deploy: clean history for HuggingFace

.dockerignore

@@ -0,0 +1,14 @@
+brain/saved_models/
+brain/models/
+backtesting/
+frontend/
+ieee/
+artifacts/
+.git/
+.gemini/
+__pycache__/
+*.pyc
+node_modules/
+*.npz
+venv/
+env/

.env.example

@@ -0,0 +1,17 @@
+# Stock Analysis App - Environment Variables
+# Copy this to .env and fill in your actual keys
+
+# Twelve Data API (for stock price data)
+TWELVE_DATA_KEY=your_twelve_data_api_key_here
+
+# Supabase (for auth & database)
+SUPABASE_URL=https://your-project.supabase.co
+SUPABASE_KEY=your_supabase_anon_key_here
+
+# GNews API (for news articles - dual key rotation)
+GNEWS_API_KEY1=your_gnews_api_key_1_here
+GNEWS_API_KEY2=your_gnews_api_key_2_here
+
+# Frontend Supabase (must match backend values)
+VITE_SUPABASE_URL=https://your-project.supabase.co
+VITE_SUPABASE_KEY=your_supabase_anon_key_here

.gitattributes

@@ -0,0 +1,42 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text
+models/custom_sentiment/sentiment_model.pt filter=lfs diff=lfs merge=lfs -text
+*.pptx filter=lfs diff=lfs merge=lfs -text
+*.pdf filter=lfs diff=lfs merge=lfs -text

.github/workflows/scraper.yml

@@ -0,0 +1,35 @@
+name: Daily Screener & News
+
+on:
+  schedule:
+    - cron: '0 0 * * *'
+  workflow_dispatch:
+
+jobs:
+  scrape-and-analyze:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout Code
+      uses: actions/checkout@v4
+
+    - name: Set up Python (with pip cache)
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+        cache: 'pip'
+
+    - name: Install Dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt
+
+    - name: Run Scraper Worker
+      env:
+        SUPABASE_URL: ${{ secrets.SUPABASE_URL }}
+        SUPABASE_KEY: ${{ secrets.SUPABASE_KEY }}
+        TWELVE_DATA_KEY: ${{ secrets.TWELVE_DATA_KEY }}
+        GNEWS_API_KEY1: ${{ secrets.GNEWS_API_KEY1 }}
+        GNEWS_API_KEY2: ${{ secrets.GNEWS_API_KEY2 }}
+      run: |
+        python -m backend.worker

.github/workflows/v30_trader.yml

@@ -0,0 +1,45 @@
+name: V30 Paper Trading Engine
+
+on:
+  schedule:
+    # Run at 3:50 PM ET (19:50 UTC) every weekday — 10 min before market close
+    - cron: '50 19 * * 1-5'
+  workflow_dispatch:  # Allow manual trigger from GitHub UI
+
+jobs:
+  trade:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    
+    steps:
+      - name: Checkout Repository
+        uses: actions/checkout@v4
+      
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+          cache: 'pip'
+      
+      - name: Install Dependencies
+        run: |
+          pip install alpaca-py yfinance numpy pandas python-dotenv scipy
+      
+      - name: Run V30 Paper Trader
+        env:
+          ALPACA_API_KEY: ${{ secrets.ALPACA_API_KEY }}
+          ALPACA_SECRET_KEY: ${{ secrets.ALPACA_SECRET_KEY }}
+          SMTP_EMAIL: ${{ secrets.SMTP_EMAIL }}
+          SMTP_PASSWORD: ${{ secrets.SMTP_PASSWORD }}
+          PYTHONPATH: .
+        run: |
+          python backend/alpaca_executor.py --execute
+      
+      - name: Commit Updated State
+        run: |
+          git config --local user.email "v30-bot@github.com"
+          git config --local user.name "V30 Trading Bot"
+          git add backend/alpaca_trade_log.json
+          git diff --cached --quiet || git commit -m "V30: Daily trading check $(date +'%Y-%m-%d')"
+          git push

.gitignore

@@ -0,0 +1,56 @@
+# General
+.DS_Store
+Thumbs.db
+.vscode/
+.idea/
+
+# Python / Backend
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+venv/
+env/
+.env
+.pytest_cache/
+instance/
+.coverage
+htmlcov/
+
+# Node / Frontend
+node_modules/
+dist/
+build/
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Logs
+logs/
+*.log
+
+# Training Data & Models
+*.npz
+*.pkl
+tuning_results*.csv
+brain/saved_models/
+xgboost_training_data.npz
+
+# Runtime Cache (regenerated automatically)
+screener_data.json
+pairs_radar.json
+
+# Fine-tuning Data and Charts
+data/
+bert_*.png
+feature_importance.png
+
+# Research Artifacts (archived, not deployed)
+artifacts/
+
+# Gemini AI assistant
+.gemini/

.hf_space

@@ -0,0 +1 @@
+Subproject commit 4b3873f32c4a1be3000989013bc2c1574dce06c0

.huggingfaceignore

@@ -0,0 +1,12 @@
+frontend/
+.git/
+venv/
+.venv/
+artifacts/
+__pycache__/
+*.pkl
+*.png
+*.jpg
+*.csv
+.DS_Store
+node_modules/

DL_Class_Final_Presentation.pptx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ad0b7c282f5d310ff19097918224561852cc5f458e8e1c2e3607ab506d19f79
+size 588293

Dockerfile

@@ -0,0 +1,48 @@
+# Use Python 3.10 Slim image for a smaller footprint
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies (needed for some Python packages like lxml)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    libxml2-dev \
+    libxslt-dev \
+    git-lfs \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first to leverage Docker cache
+COPY requirements-hf.txt requirements.txt
+
+# Install Python dependencies
+# Use --no-cache-dir to keep image size down
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the application code
+# We copy the 'backend' and 'brain' folders to the root of the container
+COPY backend/ backend/
+COPY brain/ brain/
+COPY models/ models/
+
+# Create a non-root user for security (Required by Hugging Face Spaces)
+RUN useradd -m -u 1000 user && chown -R user:user /app
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH
+
+# Set PYTHONPATH so backend/app.py can import 'brain'
+ENV PYTHONPATH=/app
+
+# Expose the port that Hugging Face Spaces uses (7860)
+EXPOSE 7860
+
+# Run the application using Gunicorn (Production Server)
+# We need to install gunicorn first if it's not in requirements.txt
+RUN pip install gunicorn
+
+# Command to run the app
+# -w 1: 1 worker (limited resources on free tier)
+# -b 0.0.0.0:7860: Bind to all interfaces on port 7860
+# --timeout 120: Increase timeout for ML model loading
+CMD ["gunicorn", "-w", "1", "-b", "0.0.0.0:7860", "--timeout", "300", "backend.app:app"]

README.md

@@ -0,0 +1,11 @@
+---
+title: Stockproject
+emoji: 🦀
+colorFrom: red
+colorTo: yellow
+sdk: docker
+pinned: false
+license: mit
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

backend/alpaca_executor.py

@@ -0,0 +1,468 @@
+# -*- coding: utf-8 -*-
+"""
+Strategy Alpaca Paper Trading Executor (Production-Hardened)
+========================================================
+Connects to Alpaca Paper Trading and executes the active Strategy
+momentum logic. Can be run manually or scheduled.
+
+Usage:
+    python backend/alpaca_executor.py              # Show current signals + positions
+    python backend/alpaca_executor.py --execute    # Actually place trades
+"""
+
+import os, sys, json, argparse, smtplib, traceback
+from datetime import datetime, timedelta
+from email.mime.text import MIMEText
+from dotenv import load_dotenv
+
+import numpy as np
+import pandas as pd
+import yfinance as yf
+
+from alpaca.trading.client import TradingClient
+from alpaca.trading.requests import MarketOrderRequest, GetAssetsRequest
+from alpaca.trading.enums import OrderSide, TimeInForce, AssetClass
+
+# Load environment
+load_dotenv(os.path.join(os.path.dirname(__file__), ".env"))
+
+API_KEY    = os.getenv("ALPACA_API_KEY")
+SECRET_KEY = os.getenv("ALPACA_SECRET_KEY")
+BASE_URL   = os.getenv("ALPACA_BASE_URL", "https://paper-api.alpaca.markets")
+SMTP_EMAIL = os.getenv("SMTP_EMAIL")
+SMTP_PASSWORD = os.getenv("SMTP_PASSWORD")
+
+# Strategy Parameters (validated out-of-sample)
+STRATEGY_PARAMS = {
+    "rebal_days": 60,
+}
+
+# Universe (same as backtesting)
+UNIVERSE = [
+    "AAPL","ABBV","ABT","ACN","ADBE","ADI","ADM","ADP","ADSK","AEE","AEP","AES",
+    "AFL","AIG","AIZ","AJG","AKAM","ALB","ALK","ALL","AMAT","AMD","AME","AMGN",
+    "AMP","AMT","AMZN","AON","AOS","APA","APD","APH","ARE","ATO","AVB","AVGO",
+    "AVY","AWK","AXP","AZO","BA","BAC","BAX","BBY","BDX","BEN","BIO","BIIB",
+    "BK","BKNG","BKR","BLK","BMY","BR","BRK-B","BRO","BSX","BWA","BXP","C",
+    "CAG","CAH","CAT","CB","CBOE","CBRE","CCI","CCL","CDNS","CE","CF","CFG",
+    "CHD","CHRW","CHTR","CI","CINF","CL","CLX","CMCSA","CME","CMG","CMI","CMS",
+    "CNC","CNP","COF","COO","COP","COST","CPB","CPRT","CPT","CRL","CRM","CSCO",
+    "CSX","CTAS","CTSH","CVS","CVX","D","DAL","DD","DE","DG","DGX","DHI","DHR",
+    "DIS","DLR","DLTR","DOV","DPZ","DRI","DTE","DUK","DVA","DVN","EA","EBAY",
+    "ECL","ED","EFX","EIX","EL","EMN","EMR","EOG","EQIX","EQR","EQT","ES","ESS",
+    "ETN","ETR","EVRG","EW","EXC","EXPD","EXPE","EXR","F","FAST","FCX","FDS",
+    "FDX","FE","FFIV","FIS","FISV","FITB","FMC","FOX","FOXA","FRT","FTNT","FTV",
+    "GD","GE","GILD","GIS","GL","GLW","GM","GOOG","GOOGL","GPC","GPN","GRMN",
+    "GS","GWW","HAL","HAS","HBAN","HCA","HD","HOLX","HON","HPE","HPQ","HRL",
+    "HSIC","HST","HSY","HUM","IBM","ICE","IDXX","IEX","IFF","ILMN","INCY","INTC",
+    "INTU","IP","IQV","IR","IRM","ISRG","IT","ITW","IVZ","J","JBHT","JCI","JKHY",
+    "JNJ","JPM","KEY","KEYS","KHC","KIM","KLAC","KMB","KMI","KMX","KO","KR","L",
+    "LDOS","LEN","LH","LHX","LIN","LKQ","LLY","LMT","LNC","LNT","LOW","LRCX",
+    "LUV","LVS","LW","LYB","LYV","MA","MAA","MAR","MAS","MCD","MCHP","MCK","MCO",
+    "MDLZ","MDT","MET","META","MGM","MHK","MKC","MKTX","MLM","MMM","MNST","MO",
+    "MOH","MOS","MPC","MPWR","MRK","MS","MSCI","MSFT","MSI","MTB","MTCH","MTD",
+    "MU","NCLH","NDAQ","NDSN","NEE","NEM","NFLX","NI","NKE","NOC","NOW","NRG",
+    "NSC","NTAP","NTRS","NUE","NVDA","NVR","NWL","NWS","NWSA","NXPI","O","ODFL",
+    "OKE","OMC","ON","ORCL","ORLY","OXY","PAYC","PAYX","PCAR","PCG","PEG","PEP",
+    "PFE","PFG","PG","PGR","PH","PHM","PKG","PLD","PM","PNC","PNR","PNW","POOL",
+    "PPG","PPL","PRU","PSA","PSX","PTC","PVH","PWR","PYPL","QCOM","QRVO","RCL",
+    "REG","REGN","RF","RHI","RJF","RL","RMD","ROK","ROL","ROP","ROST","RSG","RTX",
+    "SBAC","SBUX","SCHW","SEE","SHW","SJM","SLB","SNA","SNPS","SO","SPG","SPGI",
+    "SRE","STE","STT","STX","STZ","SWK","SWKS","SYK","SYY","T","TAP","TDG","TDY",
+    "TECH","TEL","TER","TFC","TFX","TGT","TJX","TMO","TMUS","TPR","TRGP","TRMB",
+    "TROW","TRV","TSCO","TSLA","TSN","TT","TTWO","TXN","TXT","TYL","UAL","UDR",
+    "UHS","ULTA","UNH","UNP","UPS","URI","USB","V","VFC","VLO","VMC","VNO","VRSK",
+    "VRSN","VRTX","VTR","VTRS","VZ","WAB","WAT","WDC","WEC","WELL","WFC","WHR",
+    "WM","WMB","WMT","WRB","WST","WTW","WY","WYNN","XEL","XOM","XYL","YUM","ZBH",
+    "ZBRA","ZION","ZTS",
+    "SMCI","DXCM","DELL","PANW","ET","EPD","MPLX","FANG","HWM","CDW","CSGP",
+    "BBWI","ALLE","AMCR","KDP","SYF","LUMN","DXC","GNRC","ETSY","VEEV","WDAY","SHOP",
+    "ABNB","CRWD","DDOG","SNOW","PLTR","COIN","MELI","TEAM","DASH","TTD",
+    "ZS","MNDY","NET","OKTA","BILL","HUBS","DKNG","U","RIVN","LCID",
+    "SOFI","HOOD","NU","GRAB","SE","SPOT","SNAP","PINS","ROKU","RBLX",
+    "UBER","LYFT","HLT","IHG","ELV","CARR","OTIS","DOW","CTVA","CEG","GEV","SOLV",
+    "VLTO","KVUE","GEHC","ARM","DECK","VST","GDDY","AXON","ERIE","APP",
+    "TPL","RVTY","EG","FBIN","PODD","NTRA","TOST","DOC","CPAY","HUBB",
+    "BX","KKR","APO","ARES","CG","MRNA","INVH","VICI","CZR","CTRA","OGN",
+]
+
+
+# ═══════════════════════════════════════════════════════════════
+# PRODUCTION HARDENING: Alert System
+# ═══════════════════════════════════════════════════════════════
+
+def send_alert(subject, body):
+    """Send email alert. Fails silently if SMTP creds are not configured."""
+    if not SMTP_EMAIL or not SMTP_PASSWORD:
+        print(f"  [ALERT] (No SMTP configured) {subject}")
+        return
+    try:
+        msg = MIMEText(body)
+        msg['Subject'] = f"[Strategy Trading Bot] {subject}"
+        msg['From'] = SMTP_EMAIL
+        msg['To'] = SMTP_EMAIL
+        with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
+            server.login(SMTP_EMAIL, SMTP_PASSWORD)
+            server.send_message(msg)
+        print(f"  [ALERT] Email sent: {subject}")
+    except Exception as e:
+        print(f"  [ALERT] Email failed: {e}")
+
+
+# ═══════════════════════════════════════════════════════════════
+# PRODUCTION HARDENING: Market Hours Check
+# ═══════════════════════════════════════════════════════════════
+
+def is_market_open():
+    """Check if the market is open or was recently open.
+    We run at 3:50 PM ET so market should still be open.
+    Falls back to weekday check if API fails."""
+    try:
+        client = TradingClient(API_KEY, SECRET_KEY, paper=True)
+        clock = client.get_clock()
+        if clock.is_open:
+            return True
+        # If market just closed, still allow on weekdays
+        if datetime.now().weekday() < 5:
+            print("  Market just closed but today is a trading day. Proceeding.")
+            return True
+        return False
+    except Exception as e:
+        print(f"  [ERROR] Could not check market hours: {e}")
+        return datetime.now().weekday() < 5
+
+
+# ═══════════════════════════════════════════════════════════════
+# PRODUCTION HARDENING: Data Validation
+# ═══════════════════════════════════════════════════════════════
+
+def validate_price_data(prices_df, min_history=200):
+    """Validate price data quality before signal generation.
+    Returns (is_valid, list_of_issues)."""
+    issues = []
+    for ticker in prices_df.columns:
+        series = prices_df[ticker].dropna()
+        if len(series) < min_history:
+            issues.append(f"{ticker}: insufficient history ({len(series)} days, need {min_history})")
+        if len(series) > 1:
+            daily_returns = series.pct_change().dropna()
+            extreme_moves = daily_returns[daily_returns.abs() > 0.50]
+            if len(extreme_moves) > 0:
+                issues.append(f"{ticker}: suspicious 50%+ move on {extreme_moves.index[0].strftime('%Y-%m-%d')}")
+        if (series <= 0).any():
+            issues.append(f"{ticker}: zero or negative price detected")
+
+    if issues:
+        print("\n  DATA VALIDATION WARNINGS:")
+        for issue in issues:
+            print(f"    - {issue}")
+    return len(issues) == 0, issues
+
+
+def get_client():
+    """Create Alpaca trading client."""
+    return TradingClient(API_KEY, SECRET_KEY, paper=True)
+
+
+def get_account_info(client):
+    """Fetch and display account info."""
+    account = client.get_account()
+    print(f"\n{'='*60}")
+    print(f" ALPACA PAPER TRADING ACCOUNT")
+    print(f"{'='*60}")
+    print(f"  Account ID:     {account.id}")
+    print(f"  Status:         {account.status}")
+    print(f"  Cash:           ${float(account.cash):,.2f}")
+    print(f"  Portfolio Value: ${float(account.portfolio_value):,.2f}")
+    print(f"  Buying Power:   ${float(account.buying_power):,.2f}")
+    print(f"  Day Trades:     {account.daytrade_count}")
+    return account
+
+
+def calculate_strategy_signals():
+    """Calculate Strategy signals using the unified module."""
+    from backend.strategy_signals import get_strategy_live_signals
+    
+    signals = get_strategy_live_signals()
+    
+    top_picks = [p["ticker"] for p in signals["picks"]]
+    vol_scalar = signals["vol_scalar"]
+    is_riskoff = signals["regime"] == "RISK-OFF"
+    
+    print(f"\n{'='*60}")
+    print(f" STRATEGY SIGNALS — {datetime.now().strftime('%Y-%m-%d %H:%M')}")
+    print(f"{'='*60}")
+    print(f"  SPY:        ${signals['spy_price']:.2f}")
+    print(f"  200d SMA:   ${signals['sma200']:.2f}")
+    print(f"  Regime:     {signals['regime']}")
+    print(f"  Vol Scalar: {vol_scalar:.2f}x")
+    print(f"  Allocation: {vol_scalar*100:.0f}% invested, {(1-vol_scalar)*100:.0f}% cash")
+    print(f"\n  TOP PICKS:")
+    for i, p in enumerate(signals['picks']):
+        print(f"    {i+1:>2}. {p['ticker']:<6} | Z-Score: {p.get('sector_z_score', 0):>+5.2f} | Price: ${p['price']:>8.2f}")
+
+    return top_picks, vol_scalar, is_riskoff
+
+
+def get_current_positions(client):
+    """Get current Alpaca positions."""
+    positions = client.get_all_positions()
+    pos_dict = {}
+    for p in positions:
+        pos_dict[p.symbol] = {
+            "qty": float(p.qty),
+            "market_value": float(p.market_value),
+            "unrealized_pl": float(p.unrealized_pl),
+            "current_price": float(p.current_price),
+        }
+    return pos_dict
+
+
+def execute_rebalance(client, target_picks, vol_scalar):
+    """Execute the Strategy rebalance on Alpaca.
+    Returns (orders_placed, failed_orders) for status tracking."""
+    account = client.get_account()
+    portfolio_value = float(account.portfolio_value)
+
+    # Calculate target allocation
+    invested_pct = vol_scalar
+    per_stock_value = (portfolio_value * invested_pct) / len(target_picks)
+
+    # Get current positions
+    current = get_current_positions(client)
+    current_tickers = set(current.keys())
+    target_tickers = set(target_picks)
+
+    # SELLS: positions not in target
+    to_sell = current_tickers - target_tickers
+    # BUYS: targets not in current
+    to_buy = target_tickers - current_tickers
+    # REBALANCE: positions that stay but need size adjustment
+    to_adjust = current_tickers & target_tickers
+
+    print(f"\n{'='*60}")
+    print(f" REBALANCE PLAN")
+    print(f"{'='*60}")
+    print(f"  Portfolio Value: ${portfolio_value:,.2f}")
+    print(f"  Target per stock: ${per_stock_value:,.2f} ({invested_pct*100:.0f}% / {len(target_picks)} stocks)")
+    print(f"  SELL {len(to_sell)} positions: {', '.join(sorted(to_sell)) if to_sell else 'None'}")
+    print(f"  BUY  {len(to_buy)} new positions: {', '.join(sorted(to_buy)) if to_buy else 'None'}")
+    print(f"  HOLD {len(to_adjust)} positions (may resize)")
+
+    orders_placed = []
+    failed_orders = []
+
+    # Execute SELLS first (free up cash)
+    for ticker in to_sell:
+        qty = current[ticker]["qty"]
+        if qty > 0:
+            try:
+                order = client.submit_order(
+                    MarketOrderRequest(
+                        symbol=ticker, qty=qty,
+                        side=OrderSide.SELL, time_in_force=TimeInForce.DAY,
+                    )
+                )
+                orders_placed.append(f"SELL {qty:.0f} {ticker}")
+                print(f"    SELL {qty:.0f} {ticker} -- Order {order.id}")
+            except Exception as e:
+                failed_orders.append(f"SELL {ticker}: {e}")
+                print(f"    SELL {ticker} FAILED: {e}")
+
+    # Execute BUYS
+    for ticker in to_buy:
+        try:
+            order = client.submit_order(
+                MarketOrderRequest(
+                    symbol=ticker, notional=round(per_stock_value, 2),
+                    side=OrderSide.BUY, time_in_force=TimeInForce.DAY,
+                )
+            )
+            orders_placed.append(f"BUY ${per_stock_value:.0f} {ticker}")
+            print(f"    BUY ${per_stock_value:.0f} of {ticker} -- Order {order.id}")
+        except Exception as e:
+            failed_orders.append(f"BUY {ticker}: {e}")
+            print(f"    BUY {ticker} FAILED: {e}")
+
+    # Adjust existing positions
+    for ticker in to_adjust:
+        current_value = current[ticker]["market_value"]
+        diff = per_stock_value - current_value
+        if abs(diff) > per_stock_value * 0.10:  # Only adjust if >10% off target
+            try:
+                if diff > 0:
+                    order = client.submit_order(
+                        MarketOrderRequest(
+                            symbol=ticker, notional=round(abs(diff), 2),
+                            side=OrderSide.BUY, time_in_force=TimeInForce.DAY,
+                        )
+                    )
+                    orders_placed.append(f"ADD ${diff:.0f} {ticker}")
+                    print(f"    ADD ${diff:.0f} to {ticker} -- Order {order.id}")
+                else:
+                    sell_qty = abs(diff) / current[ticker]["current_price"]
+                    if sell_qty >= 0.01:
+                        order = client.submit_order(
+                            MarketOrderRequest(
+                                symbol=ticker, qty=round(sell_qty, 2),
+                                side=OrderSide.SELL, time_in_force=TimeInForce.DAY,
+                            )
+                        )
+                        orders_placed.append(f"TRIM {sell_qty:.2f} {ticker}")
+                        print(f"    TRIM {sell_qty:.2f} of {ticker} -- Order {order.id}")
+            except Exception as e:
+                failed_orders.append(f"ADJUST {ticker}: {e}")
+                print(f"    ADJUST {ticker} FAILED: {e}")
+
+    print(f"\n  Orders placed: {len(orders_placed)} | Failed: {len(failed_orders)}")
+
+    # ── Log with Status Field (Production Hardening) ──
+    status = "completed" if len(failed_orders) == 0 else "partial"
+    if len(orders_placed) == 0 and len(failed_orders) > 0:
+        status = "failed"
+
+    log_path = os.path.join(os.path.dirname(__file__), "alpaca_trade_log.json")
+    log_entry = {
+        "timestamp": datetime.now().isoformat(),
+        "status": status,
+        "picks": target_picks,
+        "vol_scalar": vol_scalar,
+        "portfolio_value": portfolio_value,
+        "per_stock_target": per_stock_value,
+        "orders": orders_placed,
+        "failed_orders": failed_orders,
+    }
+
+    logs = []
+    if os.path.exists(log_path):
+        with open(log_path, "r") as f:
+            logs = json.load(f)
+    logs.append(log_entry)
+    with open(log_path, "w") as f:
+        json.dump(logs, f, indent=2)
+    print(f"  Trade log saved ({status}) to {log_path}")
+
+    return orders_placed, failed_orders
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Strategy Alpaca Paper Trading Executor")
+    parser.add_argument("--execute", action="store_true", help="Actually place trades (default: dry run)")
+    parser.add_argument("--force", action="store_true", help="Force rebalance even if 60 days haven't passed")
+    args = parser.parse_args()
+
+    # ── Pre-Flight: Market Hours Check ──
+    if args.execute:
+        print("Checking market hours...")
+        if not is_market_open():
+            msg = f"Market is closed on {datetime.now().strftime('%Y-%m-%d')}. Skipping execution."
+            print(f"\n  {msg}")
+            send_alert("Market Closed - Skipping", msg)
+            sys.exit(0)
+        print("  Market is OPEN. Proceeding.")
+
+    print("Connecting to Alpaca Paper Trading...")
+    client = get_client()
+
+    # ── 60-Day Rebalance Check (Only resets on "completed" entries) ──
+    log_path = os.path.join(os.path.dirname(__file__), "alpaca_trade_log.json")
+    days_since_last = 999
+
+    if os.path.exists(log_path):
+        with open(log_path, "r") as f:
+            try:
+                logs = json.load(f)
+                # Only count "completed" rebalances for the 60-day cooldown
+                completed_logs = [l for l in logs if l.get("status") == "completed"]
+                if completed_logs:
+                    last_date_str = completed_logs[-1].get("timestamp", "").split("T")[0]
+                    last_date = datetime.strptime(last_date_str, "%Y-%m-%d")
+                    days_since_last = (datetime.now() - last_date).days
+            except Exception as e:
+                print(f"Error reading logs: {e}")
+
+    if not args.force and days_since_last < STRATEGY_PARAMS["rebal_days"]:
+        print(f"\n{'='*60}")
+        print(f" SKIP REBALANCE: Only {days_since_last} days passed since last completed rebalance.")
+        print(f" Strategy requires {STRATEGY_PARAMS['rebal_days']} days to minimize friction.")
+        print(f" Use --force to override this check.")
+        print(f"{'='*60}")
+
+        # Log skip so GitHub Actions shows daily activity
+        log_path_skip = os.path.join(os.path.dirname(__file__), "alpaca_trade_log.json")
+        skip_logs = []
+        if os.path.exists(log_path_skip):
+            with open(log_path_skip, "r") as f:
+                try: skip_logs = json.load(f)
+                except: skip_logs = []
+        skip_logs.append({
+            "timestamp": datetime.now().isoformat(),
+            "status": "skipped",
+            "reason": f"Only {days_since_last}/{STRATEGY_PARAMS['rebal_days']} days elapsed",
+        })
+        with open(log_path_skip, "w") as f:
+            json.dump(skip_logs, f, indent=2)
+        return
+
+    if args.force:
+        print(f"\n[!] FORCE FLAG USED: Bypassing 60-day check ({days_since_last} days elapsed).")
+
+    # Show account info
+    account = get_account_info(client)
+
+    # Show current positions
+    positions = get_current_positions(client)
+    if positions:
+        print(f"\n  CURRENT POSITIONS ({len(positions)}):")
+        for ticker, info in sorted(positions.items()):
+            print(f"    {ticker:<6} | Qty: {info['qty']:>8.2f} | Value: ${info['market_value']:>10,.2f} | P&L: ${info['unrealized_pl']:>+8.2f}")
+    else:
+        print(f"\n  CURRENT POSITIONS: None (fresh account)")
+
+    # ── Calculate Strategy Signals ──
+    try:
+        top_picks, vol_scalar, is_riskoff = calculate_strategy_signals()
+    except ValueError as e:
+        msg = f"DATA VALIDATION FAILURE: {e}"
+        print(f"\n  CRITICAL: {msg}")
+        send_alert("CRITICAL: Data Validation Failed", msg)
+        sys.exit(1)
+    except Exception as e:
+        msg = f"Signal calculation failed: {e}\n{traceback.format_exc()}"
+        print(f"\n  ERROR: {msg}")
+        send_alert("ERROR: Signal Calculation Failed", msg)
+        sys.exit(1)
+
+    # Execute or dry run
+    if args.execute:
+        print(f"\n  ** EXECUTING LIVE PAPER TRADES **")
+        orders_placed, failed_orders = execute_rebalance(client, top_picks, vol_scalar)
+
+        # ── Send Alert ──
+        if failed_orders:
+            body = (
+                f"Rebalance completed with {len(failed_orders)} failures.\n\n"
+                f"Orders placed: {len(orders_placed)}\n"
+                f"Failed orders:\n" + "\n".join(f"  - {f}" for f in failed_orders)
+            )
+            send_alert("WARNING: Partial Rebalance", body)
+        else:
+            body = (
+                f"Rebalance completed successfully.\n\n"
+                f"Orders placed: {len(orders_placed)}\n"
+                f"Regime: {'RISK-OFF' if is_riskoff else 'RISK-ON'}\n"
+                f"Vol Scalar: {vol_scalar:.2f}\n"
+                f"Top picks: {', '.join(top_picks)}"
+            )
+            send_alert("SUCCESS: Rebalance Complete", body)
+    else:
+        print(f"\n  ** DRY RUN -- No trades placed **")
+        print(f"  Run with --execute to place trades on Alpaca Paper.")
+
+    print(f"\n{'='*60}")
+    print(f" DONE")
+    print(f"{'='*60}")
+
+
+if __name__ == "__main__":
+    main()

backend/alpaca_trade_log.json

@@ -0,0 +1,119 @@
+[
+  {
+    "timestamp": "2026-05-08T21:08:16.292999",
+    "status": "completed",
+    "picks": [
+      "WDC",
+      "MU",
+      "TER",
+      "STX",
+      "GLW",
+      "LRCX",
+      "INTC",
+      "AMAT",
+      "MRNA",
+      "ALB",
+      "KEYS",
+      "KLAC",
+      "CAT",
+      "APA",
+      "HAL"
+    ],
+    "vol_scalar": 1.0,
+    "portfolio_value": 100000.0,
+    "per_stock_target": 6666.666666666667,
+    "orders": [
+      "BUY $6667 HAL",
+      "BUY $6667 KEYS",
+      "BUY $6667 KLAC",
+      "BUY $6667 WDC",
+      "BUY $6667 STX",
+      "BUY $6667 AMAT",
+      "BUY $6667 TER",
+      "BUY $6667 LRCX",
+      "BUY $6667 MRNA",
+      "BUY $6667 CAT",
+      "BUY $6667 APA",
+      "BUY $6667 ALB",
+      "BUY $6667 GLW",
+      "BUY $6667 INTC",
+      "BUY $6667 MU"
+    ],
+    "failed_orders": []
+  },
+  {
+    "timestamp": "2026-05-11T21:38:01.708572",
+    "status": "skipped",
+    "reason": "Only 3/60 days elapsed"
+  },
+  {
+    "timestamp": "2026-05-12T21:09:42.655939",
+    "status": "skipped",
+    "reason": "Only 4/60 days elapsed"
+  },
+  {
+    "timestamp": "2026-05-13T21:13:35.324931",
+    "status": "skipped",
+    "reason": "Only 5/60 days elapsed"
+  },
+  {
+    "timestamp": "2026-05-14T21:01:38.608768",
+    "status": "skipped",
+    "reason": "Only 6/60 days elapsed"
+  },
+  {
+    "timestamp": "2026-05-15T20:45:24.709538",
+    "status": "skipped",
+    "reason": "Only 7/60 days elapsed"
+  },
+  {
+    "timestamp": "2026-05-18T20:58:51.220256",
+    "status": "skipped",
+    "reason": "Only 10/60 days elapsed"
+  },
+  {
+    "timestamp": "2026-05-19T21:08:54.649002",
+    "status": "skipped",
+    "reason": "Only 11/60 days elapsed"
+  },
+  {
+    "timestamp": "2026-05-20T21:26:56.591322",
+    "status": "skipped",
+    "reason": "Only 12/60 days elapsed"
+  },
+  {
+    "timestamp": "2026-05-21T21:19:29.815725",
+    "status": "skipped",
+    "reason": "Only 13/60 days elapsed"
+  },
+  {
+    "timestamp": "2026-05-22T21:01:06.662510",
+    "status": "skipped",
+    "reason": "Only 14/60 days elapsed"
+  },
+  {
+    "timestamp": "2026-05-25T20:55:37.978180",
+    "status": "skipped",
+    "reason": "Only 17/60 days elapsed"
+  },
+  {
+    "timestamp": "2026-05-26T21:22:26.021467",
+    "status": "skipped",
+    "reason": "Only 18/60 days elapsed"
+  },
+  {
+    "timestamp": "2026-05-27T21:30:15.646717",
+    "status": "skipped",
+    "reason": "Only 19/60 days elapsed"
+  },
+  {
+    "timestamp": "2026-05-28T21:47:07.081668",
+    "status": "skipped",
+    "reason": "Only 20/60 days elapsed"
+  },
+  {
+    "timestamp": "2026-05-29T21:29:45.838691",
+    "status": "skipped",
+    "reason": "Only 21/60 days elapsed"
+  }
+]

backend/app.py

@@ -0,0 +1,591 @@
+
+"""
+Flask Microservice for Stock Sentiment Analysis
+
+Provides stock price data and news sentiment analysis using GNews (Dual-Key) and custom fine-tuned DistilBERT.
+Implements in-memory caching with 5-minute TTL to prevent rate limiting.
+"""
+
+import sys
+import os
+
+import time
+from datetime import datetime, timedelta
+import pandas as pd
+import requests
+from flask import Flask, jsonify, request
+from flask_cors import CORS
+from dotenv import load_dotenv
+import yfinance as yf
+
+# Add the project root to sys.path to allow importing from 'brain'
+sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
+
+from brain.sentiment.news import fetch_gnews
+from backend.database import NewsDatabase
+from brain.service import BrainService
+from brain.core.types import StockDataPoint, Article
+
+
+# Load environment variables from root .env
+load_dotenv(os.path.join(os.path.dirname(__file__), '..', '.env'))
+
+# Initialize Brain Service
+brain_service = BrainService()
+
+# Initialize Flask app
+app = Flask(__name__)
+CORS(app, origins="*")
+
+@app.before_request
+def log_request_info():
+    if request.path.startswith("/api/"):
+        print(f"[DEBUG] Request: {request.method} {request.url}")
+
+@app.errorhandler(Exception)
+def handle_exception(e):
+    if isinstance(e, requests.exceptions.HTTPError):
+        return jsonify({"error": str(e)}), e.response.status_code
+    return jsonify({"error": str(e)}), 500
+
+@app.route("/", methods=["GET"])
+def index():
+    return jsonify({
+        "status": "online",
+        "message": "Stock Analysis API is running",
+        "endpoints": ["/api/analyze", "/api/market-movers", "/api/general-news", "/health"]
+    })
+
+# Twelve Data API Key
+TWELVE_DATA_KEY = os.getenv("TWELVE_DATA_KEY")
+if not TWELVE_DATA_KEY:
+    print("Warning: TWELVE_DATA_KEY not found in environment variables.")
+
+# Initialize DB
+db = NewsDatabase()
+
+# In-memory cache
+cache = {}
+CACHE_TTL_SECONDS = 5 * 60  # 5 minutes
+
+import json
+
+# All background compute (movers, news, screener) is handled by GitHub Actions worker.py.
+# HF Space only serves pre-cached data from Supabase — zero heavy compute on startup.
+
+def get_cached_data(ticker: str) -> dict | None:
+    ticker_upper = ticker.upper()
+    if ticker_upper in cache:
+        cached_entry = cache[ticker_upper]
+        age = time.time() - cached_entry["timestamp"]
+        if age < CACHE_TTL_SECONDS:
+            return cached_entry["data"]
+    return None
+
+def set_cached_data(ticker: str, data: dict) -> None:
+    cache[ticker.upper()] = {
+        "data": data,
+        "timestamp": time.time()
+    }
+
+
+
+
+def fetch_stock_data(ticker, range_str="1W", force_refresh=False, company_name=None, skip_news_fetch=False):
+    print(f"Checking DB for {ticker}...")
+    analyzed_news = []
+    cached_news = []
+
+    if not force_refresh:
+        cached_news = db.get_latest_news(ticker, limit=20)
+    
+    use_db_cache = False
+    
+    if cached_news and len(cached_news) >= 10:
+        valid_cached_articles = []
+        for article in cached_news:
+            if abs(article['sentiment_score']) >= 0.05:
+                valid_cached_articles.append({
+                    "title": article['title'],
+                    "published": article['published'],
+                    "sentiment": article['sentiment_score'],
+                    "link": article['link'],
+                    "publisher": article['source'],
+                    "debug": article['debug_metadata'] or {}
+                })
+        
+        if len(valid_cached_articles) >= 5:
+            analyzed_news = valid_cached_articles
+            use_db_cache = True
+
+    if not use_db_cache:
+        if not skip_news_fetch:
+            print("Live scraping (Blocking)...")
+            analyzed_news, _ = fetch_gnews(ticker, company_name)
+            for article in analyzed_news:
+                 db.upsert_article(ticker, None, article)
+        else:
+            print(f"Skipping live news scrape for {ticker} (Pre-warm mode)")
+
+    if analyzed_news:
+        total_weighted_score = 0.0
+        total_weights = 0.0
+        for n in analyzed_news:
+            weight = n['debug'].get('weight', 1.0)
+            total_weighted_score += (n['sentiment'] * weight)
+            total_weights += weight
+        current_sentiment = total_weighted_score / total_weights if total_weights > 0 else 0.0
+    else:
+        current_sentiment = 0.0
+
+    days_ytd = (datetime.now() - datetime(datetime.now().year, 1, 1)).days + 1
+    range_map = {
+        "1W": "7", "1M": "30", "3M": "90", "6M": "180", 
+        "YTD": str(days_ytd), "1Y": "365", "MAX": "5000"
+    }
+    requested_size_str = range_map.get(range_str, "7")
+    try:
+        req_int = int(requested_size_str)
+        fetch_size = max(req_int, 300)
+    except:
+        fetch_size = 5000; req_int = 5000
+
+    url = "https://api.twelvedata.com/time_series"
+    params = {"symbol": ticker, "interval": "1day", "outputsize": str(fetch_size), "apikey": TWELVE_DATA_KEY}
+    
+    response = requests.get(url, params=params)
+    data = response.json()
+
+    if "values" not in data:
+        raise ValueError(f"Twelve Data Error: {data.get('message', 'Unknown error')}")
+
+    # Generate synthetic sentiment if news was skipped to populate the screener natively
+    if not analyzed_news and skip_news_fetch and len(data["values"]) >= 5:
+        try:
+            latest = float(data["values"][0]["close"])
+            older = float(data["values"][4]["close"])
+            momentum_pct = (latest - older) / older
+            # Map +/- 5% move to +/- 1.0 sentiment score
+            synthetic = momentum_pct * 20.0 
+            current_sentiment = max(-1.0, min(1.0, synthetic))
+        except Exception:
+            pass
+
+    full_history_data = [{
+        "date": d["datetime"],
+        "open": float(d["open"]),
+        "high": float(d["high"]),
+        "low": float(d["low"]),
+        "close": float(d["close"]),
+        "volume": int(d["volume"]),
+        "price": float(d["close"]),
+        "sentiment": round(current_sentiment, 4)
+    } for d in data["values"]]
+    full_history_data.reverse()
+    
+    if req_int < len(full_history_data):
+        graph_data = full_history_data[-req_int:]
+    else:
+        graph_data = full_history_data
+
+    try:
+        p_history = [
+            StockDataPoint(
+                datetime=d["date"], open=d["open"], high=d["high"], 
+                low=d["low"], close=d["close"], volume=d["volume"]
+            ) for d in full_history_data
+        ]
+        
+        p_news = [
+            Article(
+                title=n["title"], link=n["link"], published=n["published"], 
+                publisher=n["publisher"], sentiment_score=n["sentiment"], 
+                metadata=n["debug"]
+            ) for n in analyzed_news
+        ]
+
+        analysis = brain_service.analyze_ticker(ticker, p_history, current_sentiment, p_news)
+        
+        tech_vals = analysis.components["technical"]["values"]
+        tech_scores = analysis.components["technical"]["scores"]
+        macd_vals = tech_vals.get("macd", {}) or {}
+        
+        quant_result = {
+            "final_score": analysis.final_score,
+            "signal": analysis.signal.value,
+            "confidence": analysis.confidence,
+            "breakdown": {
+                "rsi_val": round(tech_vals["rsi"], 2) if tech_vals.get("rsi") is not None and not pd.isna(tech_vals["rsi"]) else None,
+                "rsi_normalized": round(tech_scores["rsi"], 2),
+                "sma_val": round(tech_vals["sma"], 2) if tech_vals.get("sma") is not None and not pd.isna(tech_vals["sma"]) else None,
+                "trend_normalized": round(tech_scores["trend"], 2),
+                "current_price": tech_vals["current_price"],
+                "sentiment_input": analysis.sentiment_score,
+                "sentiment_normalized": analysis.sentiment_score * 100,
+                "macd": {
+                    "macd_line": round(macd_vals.get("macd"), 4) if macd_vals.get("macd") is not None and not pd.isna(macd_vals.get("macd")) else None,
+                    "signal_line": round(macd_vals.get("signal"), 4) if macd_vals.get("signal") is not None and not pd.isna(macd_vals.get("signal")) else None,
+                    "histogram": round(macd_vals.get("hist"), 4) if macd_vals.get("hist") is not None and not pd.isna(macd_vals.get("hist")) else None
+                }
+            },
+            "volatility": analysis.volatility or {},
+            "earnings": analysis.earnings or {},
+            "sentiment_trend": analysis.sentiment_trend or {},
+            "sentiment_analysis": analysis.components.get("sentiment_analysis", {}),
+            "deep_insight": analysis.components.get("deep_insight", {}),
+            "cross_sectional": analysis.components.get("cross_sectional", {})
+        }
+        
+        # Inject Strategy Status
+        try:
+            strategy_live = db.get_cache("strategy_live_signals")
+            if not strategy_live:
+                from backend.strategy_signals import get_strategy_live_signals
+                strategy_live = get_strategy_live_signals()
+                
+            strategy_picks = {p["ticker"]: p for p in strategy_live["picks"]}
+            is_strategy_buy = ticker in strategy_picks
+            
+            quant_result["strategy_scorecard"] = {
+                "is_buy": is_strategy_buy,
+                "regime": strategy_live["regime"],
+                "vol_scalar": strategy_live["vol_scalar"],
+                "momentum_175d": strategy_picks[ticker]["momentum_175d"] if is_strategy_buy else None,
+                "target_vol": strategy_live["target_vol"],
+                "realized_vol": strategy_live["realized_vol"]
+            }
+        except Exception as ve:
+            print(f"Strategy Injection Error: {ve}")
+            quant_result["strategy_scorecard"] = None
+    except Exception as e:
+        print(f"Brain Service Error: {e}")
+        raise e
+    
+    scraping_stats = {
+        "total": len(analyzed_news),
+        "full_text": sum(1 for n in analyzed_news if n['debug'].get('content_source') == 'full_text'),
+        "snippet": sum(1 for n in analyzed_news if n['debug'].get('content_source') != 'full_text'),
+        "timeouts": 0
+    }
+    
+    return {
+        "current_sentiment": round(current_sentiment, 4),
+        "news": analyzed_news,
+        "graph_data": graph_data,
+        "quant_analysis": quant_result,
+        "debug": scraping_stats
+    }
+
+@app.route("/api/analyze", methods=["GET", "OPTIONS"])
+def analyze():
+    if request.method == "OPTIONS":
+        return jsonify({"status": "ok"}), 200
+
+    ticker = request.args.get("ticker")
+    if not ticker:
+        return jsonify({"error": "Missing required parameter: ticker"}), 400
+    
+    ticker = ticker.upper().strip()
+    range_param = request.args.get("range", "1W")
+    force_refresh = request.args.get("force", "false").lower() == "true"
+    company_name = request.args.get("name")
+    
+    cache_key = f"{ticker}_{range_param}"
+    cached_data = get_cached_data(cache_key)
+    
+    if cached_data and not force_refresh:
+        if 'news' in cached_data:
+            cached_data['news'] = [n for n in cached_data['news'] if abs(n['sentiment']) >= 0.05]
+        return jsonify({**cached_data, "cached": True})
+    
+    try:
+        data = fetch_stock_data(ticker, range_param, force_refresh=force_refresh, company_name=company_name)
+        set_cached_data(cache_key, data)
+        return jsonify({**data, "cached": False})
+    except Exception as e:
+        print(f"Warning: Data provider blocked or failed. Switching to Circuit Breaker. Error: {e}")
+        circuit_breaker_data = {
+            "ticker": ticker,
+            "current_sentiment": 0.0,
+            "news": [],
+            "graph_data": [],
+            "circuit_breaker": True,
+            "error": str(e)
+        }
+        return jsonify(circuit_breaker_data)
+
+@app.route("/api/market-movers", methods=["GET"])
+def market_movers():
+    data = db.get_cache("market-movers")
+    if data and "gainers" in data and len(data["gainers"]) > 0:
+        return jsonify(data)
+        
+    # Fallback dummy data for presentation/dummy mode
+    dummy_data = {
+        "gainers": [
+            {"symbol": "NVDA", "name": "NVIDIA", "price": "$1250.00", "change": 5.4, "raw_change": 5.4},
+            {"symbol": "AMD", "name": "Advanced Micro Devices", "price": "$165.20", "change": 4.2, "raw_change": 4.2},
+            {"symbol": "META", "name": "Meta Platforms", "price": "$510.50", "change": 3.8, "raw_change": 3.8},
+            {"symbol": "AMZN", "name": "Amazon", "price": "$185.30", "change": 2.5, "raw_change": 2.5},
+            {"symbol": "NFLX", "name": "Netflix", "price": "$640.10", "change": 2.1, "raw_change": 2.1}
+        ],
+        "losers": [
+            {"symbol": "TSLA", "name": "Tesla", "price": "$175.40", "change": -3.5, "raw_change": -3.5},
+            {"symbol": "BA", "name": "Boeing", "price": "$180.20", "change": -2.8, "raw_change": -2.8},
+            {"symbol": "INTC", "name": "Intel", "price": "$30.50", "change": -2.1, "raw_change": -2.1},
+            {"symbol": "T", "name": "AT&T", "price": "$16.80", "change": -1.5, "raw_change": -1.5},
+            {"symbol": "VZ", "name": "Verizon", "price": "$38.90", "change": -1.2, "raw_change": -1.2}
+        ],
+        "active": [
+            {"symbol": "AAPL", "name": "Apple", "price": "$190.50", "change": 1.2, "raw_change": 1.2},
+            {"symbol": "NVDA", "name": "NVIDIA", "price": "$1250.00", "change": 5.4, "raw_change": 5.4},
+            {"symbol": "TSLA", "name": "Tesla", "price": "$175.40", "change": -3.5, "raw_change": -3.5},
+            {"symbol": "AMD", "name": "Advanced Micro Devices", "price": "$165.20", "change": 4.2, "raw_change": 4.2},
+            {"symbol": "AMZN", "name": "Amazon", "price": "$185.30", "change": 2.5, "raw_change": 2.5}
+        ]
+    }
+    return jsonify(dummy_data)
+
+@app.route("/api/general-news", methods=["GET"])
+def general_news():
+    data = db.get_cache("general-news")
+    if data and "news" in data and len(data["news"]) > 0:
+        return jsonify(data["news"])
+        
+    # Fallback: 50 unique financial news articles for presentation mode
+    from datetime import timedelta
+    dummy_news = [
+        {"title": "S&P 500 Closes at Record High as Investors Shrug Off Recession Fears", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1611974765270-ca1258634369?q=80&w=500&auto=format&fit=crop", "publisher": "Wall Street Journal", "sentiment": 0.85},
+        {"title": "NVIDIA Surpasses $3 Trillion Market Cap on AI Chip Demand Surge", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1518770660439-4636190af475?q=80&w=500&auto=format&fit=crop", "publisher": "Bloomberg", "sentiment": 0.92},
+        {"title": "Federal Reserve Holds Rates Steady, Signals Two Cuts Before Year-End", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1590283603385-17ffb3a7f29f?q=80&w=500&auto=format&fit=crop", "publisher": "CNBC", "sentiment": 0.55},
+        {"title": "Tesla Shares Drop 8% After Missing Q2 Delivery Estimates", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1593941707882-a5bba14938cb?q=80&w=500&auto=format&fit=crop", "publisher": "Reuters", "sentiment": -0.65},
+        {"title": "Apple Unveils New AI-Powered Features at WWDC, Stock Jumps 4%", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1517694712202-14dd9538aa97?q=80&w=500&auto=format&fit=crop", "publisher": "TechCrunch", "sentiment": 0.78},
+        {"title": "Crude Oil Breaks Above $85 as OPEC+ Extends Production Cuts", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1518186285589-2f7649de83e0?q=80&w=500&auto=format&fit=crop", "publisher": "Financial Times", "sentiment": -0.30},
+        {"title": "US Unemployment Claims Fall to 52-Week Low, Labor Market Stays Tight", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1556740738-b6a63e27c4df?q=80&w=500&auto=format&fit=crop", "publisher": "MarketWatch", "sentiment": 0.60},
+        {"title": "Amazon Web Services Revenue Grows 19% Year-Over-Year in Cloud Push", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1526304640581-d334cdbbf45e?q=80&w=500&auto=format&fit=crop", "publisher": "Bloomberg", "sentiment": 0.72},
+        {"title": "China's Central Bank Cuts Key Lending Rate to Boost Slowing Economy", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1547981609-4b6bfe67ca0b?q=80&w=500&auto=format&fit=crop", "publisher": "Reuters", "sentiment": -0.20},
+        {"title": "JPMorgan Beats Earnings Expectations, Trading Revenue Up 21%", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1501167786227-4cba60f6d58f?q=80&w=500&auto=format&fit=crop", "publisher": "Wall Street Journal", "sentiment": 0.80},
+        {"title": "Gold Hits New All-Time High Above $2,500 Amid Safe-Haven Demand", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1610375461246-83df859d849d?q=80&w=500&auto=format&fit=crop", "publisher": "Financial Times", "sentiment": 0.45},
+        {"title": "Microsoft Azure Growth Accelerates to 29%, Beating Wall Street Forecasts", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1633419461186-7d40a38105ec?q=80&w=500&auto=format&fit=crop", "publisher": "CNBC", "sentiment": 0.88},
+        {"title": "European Markets Slide as German Manufacturing Data Disappoints", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1569025690938-a00729c9e1f9?q=80&w=500&auto=format&fit=crop", "publisher": "Bloomberg", "sentiment": -0.55},
+        {"title": "Bitcoin Rallies Past $72,000 Following Spot ETF Inflow Record", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1518546305927-5a555bb7020d?q=80&w=500&auto=format&fit=crop", "publisher": "CoinDesk", "sentiment": 0.75},
+        {"title": "Pfizer Shares Plunge After Cutting Full-Year Revenue Guidance", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1584308666744-24d5c474f2ae?q=80&w=500&auto=format&fit=crop", "publisher": "Reuters", "sentiment": -0.70},
+        {"title": "US Housing Starts Fall 5.5% as Mortgage Rates Remain Elevated", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1560518883-ce09059eeffa?q=80&w=500&auto=format&fit=crop", "publisher": "MarketWatch", "sentiment": -0.40},
+        {"title": "Meta Platforms Reports 27% Revenue Jump Driven by Reels Advertising", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1611162616305-c69b3fa7fbe0?q=80&w=500&auto=format&fit=crop", "publisher": "TechCrunch", "sentiment": 0.82},
+        {"title": "Toyota Overtakes GM in US Sales for First Time in History", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1549317661-bd32c8ce0afa?q=80&w=500&auto=format&fit=crop", "publisher": "Wall Street Journal", "sentiment": 0.35},
+        {"title": "US 10-Year Treasury Yield Falls Below 4% on Soft Inflation Print", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1611974789855-9c2a0a7236a3?q=80&w=500&auto=format&fit=crop", "publisher": "Bloomberg", "sentiment": 0.50},
+        {"title": "Alphabet Announces $70 Billion Share Buyback, Stock Rallies 6%", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1573804633927-bfcbcd909acd?q=80&w=500&auto=format&fit=crop", "publisher": "CNBC", "sentiment": 0.90},
+        {"title": "Boeing Faces New FAA Investigation After Latest Quality Control Failures", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1556388158-158ea5ccacbd?q=80&w=500&auto=format&fit=crop", "publisher": "Reuters", "sentiment": -0.75},
+        {"title": "Walmart Reports Strong Q1, Raises Full-Year Outlook on Consumer Resilience", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1604719312566-8912e9227c6a?q=80&w=500&auto=format&fit=crop", "publisher": "Financial Times", "sentiment": 0.68},
+        {"title": "Broadcom Stock Surges 12% After AI Revenue Doubles Year-Over-Year", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1558494949-ef010cbdcc31?q=80&w=500&auto=format&fit=crop", "publisher": "MarketWatch", "sentiment": 0.88},
+        {"title": "Japan's Nikkei 225 Hits 40-Year High as Yen Weakens Further", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1480796927426-f609979314bd?q=80&w=500&auto=format&fit=crop", "publisher": "Bloomberg", "sentiment": 0.55},
+        {"title": "UnitedHealth Group Under DOJ Antitrust Scrutiny, Shares Fall 9%", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1576091160550-2173dba999ef?q=80&w=500&auto=format&fit=crop", "publisher": "Wall Street Journal", "sentiment": -0.62},
+        {"title": "Copper Prices Hit Record High on AI Data Center Power Demand", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1605792657660-596af9009e82?q=80&w=500&auto=format&fit=crop", "publisher": "Reuters", "sentiment": 0.48},
+        {"title": "Netflix Adds 9.3 Million Subscribers in Q2, Beating Every Estimate", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1574375927938-d5a98e8d7e28?q=80&w=500&auto=format&fit=crop", "publisher": "CNBC", "sentiment": 0.85},
+        {"title": "ExxonMobil Completes $60 Billion Pioneer Natural Resources Acquisition", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1513828583688-c52646db42da?q=80&w=500&auto=format&fit=crop", "publisher": "Financial Times", "sentiment": 0.30},
+        {"title": "CrowdStrike Outage Grounds Airlines Worldwide, Stock Drops 11%", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1558494949-ef010cbdcc31?q=80&w=500&auto=format&fit=crop", "publisher": "TechCrunch", "sentiment": -0.80},
+        {"title": "US Consumer Confidence Index Rises to 8-Month High in June", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1556742049-0cfed4f6a45d?q=80&w=500&auto=format&fit=crop", "publisher": "MarketWatch", "sentiment": 0.62},
+        {"title": "Eli Lilly Weight-Loss Drug Zepbound Sales Exceed $1 Billion in Q2", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1587854692152-cbe660dbde88?q=80&w=500&auto=format&fit=crop", "publisher": "Bloomberg", "sentiment": 0.78},
+        {"title": "Regional Banks Face Renewed Pressure as Commercial Real Estate Defaults Rise", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1486406146926-c627a92ad1ab?q=80&w=500&auto=format&fit=crop", "publisher": "Wall Street Journal", "sentiment": -0.58},
+        {"title": "India's Sensex Crosses 80,000 Milestone on Foreign Fund Inflows", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1524492412937-b28074a5d7da?q=80&w=500&auto=format&fit=crop", "publisher": "Reuters", "sentiment": 0.70},
+        {"title": "AMD Unveils New MI350 AI Chips to Challenge NVIDIA's Dominance", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1591799264318-7e6ef8ddb7ea?q=80&w=500&auto=format&fit=crop", "publisher": "TechCrunch", "sentiment": 0.65},
+        {"title": "US Trade Deficit Widens to $75 Billion as Imports Surge from Asia", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1494412574643-ff11b0a5eb19?q=80&w=500&auto=format&fit=crop", "publisher": "Financial Times", "sentiment": -0.35},
+        {"title": "Costco Same-Store Sales Growth Beats Expectations for 8th Straight Quarter", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1604719312566-8912e9227c6a?q=80&w=500&auto=format&fit=crop", "publisher": "CNBC", "sentiment": 0.72},
+        {"title": "Ethereum Spot ETF Approved by SEC, Crypto Market Rallies Broadly", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1639762681485-074b7f938ba0?q=80&w=500&auto=format&fit=crop", "publisher": "CoinDesk", "sentiment": 0.80},
+        {"title": "Disney+ Reaches Profitability for First Time Since Launch", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1616530940355-351fabd9524b?q=80&w=500&auto=format&fit=crop", "publisher": "Bloomberg", "sentiment": 0.75},
+        {"title": "Natural Gas Prices Collapse 15% on Warmer-Than-Expected Winter Forecast", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1532601224476-15c79f2f7a51?q=80&w=500&auto=format&fit=crop", "publisher": "MarketWatch", "sentiment": -0.45},
+        {"title": "Goldman Sachs Upgrades Semiconductor Sector to Overweight Amid AI Tailwinds", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1518770660439-4636190af475?q=80&w=500&auto=format&fit=crop", "publisher": "Wall Street Journal", "sentiment": 0.68},
+        {"title": "UK Inflation Falls to 2.0% Target, Bank of England Rate Cut Expected", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1526304640581-d334cdbbf45e?q=80&w=500&auto=format&fit=crop", "publisher": "Reuters", "sentiment": 0.52},
+        {"title": "Palantir Wins $480 Million US Army Contract, Shares Jump 7%", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1550751827-4bd374c3f58b?q=80&w=500&auto=format&fit=crop", "publisher": "CNBC", "sentiment": 0.73},
+        {"title": "Starbucks CEO Steps Down After Sales Decline in Key US and China Markets", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1453614512568-c4024d13c247?q=80&w=500&auto=format&fit=crop", "publisher": "Bloomberg", "sentiment": -0.50},
+        {"title": "Solar Energy Installations Hit Record in H1 2026, SolarEdge Rallies", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1508514177221-188b1cf16e9d?q=80&w=500&auto=format&fit=crop", "publisher": "Financial Times", "sentiment": 0.65},
+        {"title": "Dollar Index Falls to 3-Month Low as Rate Cut Bets Increase", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1611974789855-9c2a0a7236a3?q=80&w=500&auto=format&fit=crop", "publisher": "MarketWatch", "sentiment": -0.25},
+        {"title": "Uber Reports First Full-Year Profit, Announces $7 Billion Buyback", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1549317661-bd32c8ce0afa?q=80&w=500&auto=format&fit=crop", "publisher": "TechCrunch", "sentiment": 0.82},
+        {"title": "Lockheed Martin Secures $11 Billion F-35 Contract Expansion", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1556388158-158ea5ccacbd?q=80&w=500&auto=format&fit=crop", "publisher": "Wall Street Journal", "sentiment": 0.58},
+        {"title": "Cathie Wood's ARK Invest Sells $200M in Tesla, Loads Up on Coinbase", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1590283603385-17ffb3a7f29f?q=80&w=500&auto=format&fit=crop", "publisher": "Bloomberg", "sentiment": 0.15},
+        {"title": "Samsung Reports Record Chip Profits as AI Memory Demand Soars", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1591799264318-7e6ef8ddb7ea?q=80&w=500&auto=format&fit=crop", "publisher": "Reuters", "sentiment": 0.77},
+        {"title": "US Core PCE Inflation Cools to 2.6%, Reinforcing Fed Pivot Narrative", "link": "https://finance.yahoo.com", "image": "https://images.unsplash.com/photo-1611974765270-ca1258634369?q=80&w=500&auto=format&fit=crop", "publisher": "CNBC", "sentiment": 0.60},
+    ]
+    for i, item in enumerate(dummy_news):
+        item["published"] = (datetime.now() - timedelta(minutes=i * 30)).strftime('%Y-%m-%d %H:%M')
+
+    return jsonify(dummy_news)
+
+@app.route("/api/screener", methods=["GET"])
+def screener_data():
+    """
+    Returns the pre-calculated daily screener data from Supabase cache to bypass local disk wipes.
+    """
+    data = db.get_cache("screener")
+    if data:
+        return jsonify(data)
+        
+    # Final fallback if Supabase is wiped
+    file_path = "/tmp/screener_data.json"
+    if os.path.exists(file_path):
+        try:
+            with open(file_path, "r") as f:
+                return jsonify(json.load(f))
+        except Exception as e:
+            pass
+            
+    return jsonify({"stocks": []})
+
+@app.route("/api/search", methods=["GET"])
+def search_symbols():
+    query = request.args.get("q")
+    if not query:
+        return jsonify({"data": []})
+        
+    url = "https://api.twelvedata.com/symbol_search"
+    params = {"symbol": query, "apikey": TWELVE_DATA_KEY}
+    
+    try:
+        response = requests.get(url, params=params)
+        data = response.json()
+        if "data" in data:
+            return jsonify(data)
+        else:
+            return jsonify({"data": []})
+    except Exception as e:
+        print(f"Search API Error: {e}")
+        return jsonify({"data": []})
+
+@app.route("/api/sentiment-history", methods=["GET"])
+def sentiment_history():
+    """Returns sentiment time-series for a ticker."""
+    ticker = request.args.get("ticker")
+    if not ticker:
+        return jsonify({"error": "Missing required parameter: ticker"}), 400
+    
+    from brain.sentiment.tracker import SentimentTracker
+    limit = int(request.args.get("limit", 30))
+    history = SentimentTracker.get_history(ticker.upper(), limit=limit)
+    return jsonify({"ticker": ticker.upper(), "history": history})
+
+@app.route("/api/sector-sentiment", methods=["GET"])
+def sector_sentiment():
+    """Returns sector-level sentiment aggregation."""
+    from brain.sentiment.sector import SectorSentiment
+    result = SectorSentiment.get_hottest_coldest()
+    return jsonify(result)
+
+@app.route("/api/quant/rank", methods=["GET"])
+def cross_sectional_rank():
+    try:
+        strategy_data = db.get_cache("strategy_live_signals")
+        if not strategy_data:
+            from backend.strategy_signals import get_strategy_live_signals
+            strategy_data = get_strategy_live_signals()
+        
+        # Format for ScreenerPage and RankingDashboard
+        return jsonify({
+            "rankings": strategy_data["all_universe"], # For ScreenerPage
+            "universe_size": len(strategy_data["all_universe"]), # For RankingDashboard
+            "picks": strategy_data["picks"], # For RankingDashboard Top 15
+            "regime": strategy_data["regime"],
+            "vol_scalar": strategy_data["vol_scalar"]
+        })
+    except Exception as e:
+        print(f"Rank API Error: {e}")
+        return jsonify({"rankings": [], "universe_size": 0, "picks": [], "error": "Screener data not yet available"})
+
+@app.route("/api/strategy/live", methods=["GET"])
+def strategy_live_signals():
+    """Returns live Strategy signals: Top 15 175-day picks, regime status, vol scalar."""
+    try:
+        signals = db.get_cache("strategy_live_signals")
+        if not signals:
+            from backend.strategy_signals import get_strategy_live_signals
+            signals = get_strategy_live_signals()
+        return jsonify(signals)
+    except Exception as e:
+        print(f"Strategy Signal Error: {e}")
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/api/strategy/portfolio", methods=["GET"])
+def strategy_portfolio():
+    """Returns the live paper trading portfolio state directly from Alpaca."""
+    try:
+        # Check cache first
+        cached = get_cached_data("STRATEGY_PORTFOLIO")
+        if cached:
+            return jsonify(cached)
+            
+        from backend import alpaca_executor
+        client = alpaca_executor.get_client()
+        account = client.get_account()
+        positions = alpaca_executor.get_current_positions(client)
+        
+        # Try to read trade log
+        trade_log = []
+        log_path = os.path.join(os.path.dirname(__file__), "alpaca_trade_log.json")
+        if os.path.exists(log_path):
+            with open(log_path, "r") as f:
+                raw_logs = json.load(f)
+                for log in raw_logs:
+                    trade_log.append({
+                        "date": log["timestamp"].split("T")[0],
+                        "action": "REBALANCE",
+                        "orders": log.get("orders", []),
+                        "equity": log.get("portfolio_value", 0),
+                        "vol_scalar": log.get("vol_scalar", 1.0)
+                    })
+                    
+        # Construct equity curve from logs (naive approach, but better than nothing)
+        equity_curve = [{"date": l["date"], "equity": l["equity"]} for l in trade_log]
+        if not equity_curve:
+            equity_curve = [{"date": datetime.now().strftime("%Y-%m-%d"), "equity": float(account.portfolio_value)}]
+            
+        # Determine days since rebalance
+        days_since = 0
+        if trade_log:
+            last_date = datetime.strptime(trade_log[-1]["date"], "%Y-%m-%d")
+            days_since = (datetime.now() - last_date).days
+            
+        # Try to get latest status
+        try:
+            from backend.strategy_signals import get_strategy_live_signals
+            sig = get_strategy_live_signals()
+            status = {"regime": sig["regime"], "effective_scalar": sig["vol_scalar"]}
+        except:
+            status = {"regime": "UNKNOWN", "effective_scalar": 1.0}
+
+        port_data = {
+            "start_date": trade_log[0]["date"] if trade_log else datetime.now().strftime("%Y-%m-%d"),
+            "equity": float(account.portfolio_value),
+            "cash": float(account.cash),
+            "status": status,
+            "days_since_rebalance": days_since,
+            "equity_curve": equity_curve,
+            "trade_log": trade_log,
+            "positions": positions
+        }
+        
+        set_cached_data("STRATEGY_PORTFOLIO", port_data)
+        return jsonify(port_data)
+        
+    except Exception as e:
+        print(f"Alpaca API Error: {e}")
+        return jsonify({"error": f"Failed to connect to Alpaca: {str(e)}"}), 500
+
+@app.route("/api/strategy/force_run", methods=["POST"])
+def strategy_force_run():
+    """Manually triggers the Strategy Alpaca Executor in dry-run mode (or live if configured)."""
+    try:
+        from backend.alpaca_executor import main as run_virtual_broker
+        from backend.alpaca_executor import calculate_strategy_signals
+        calculate_strategy_signals()
+        return jsonify({"status": "success", "message": "Alpaca engine connection successful."})
+    except Exception as e:
+        print(f"Alpaca Engine Error: {e}")
+        return jsonify({"error": str(e)}), 500
+
+@app.route("/health", methods=["GET"])
+def health():
+    return jsonify({"status": "healthy"})
+
+if __name__ == "__main__":
+    port = int(os.getenv("PORT", 5000))
+    debug = os.getenv("FLASK_DEBUG", "false").lower() == "true"
+    app.run(host="0.0.0.0", port=port, debug=debug, use_reloader=False)

backend/database.py

@@ -0,0 +1,110 @@
+import os
+from supabase import create_client, Client
+from dotenv import load_dotenv
+import time
+
+# Load root .env (one level up from backend/)
+load_dotenv(os.path.join(os.path.dirname(__file__), '..', '.env'))
+
+# Supabase Credentials (from .env or GitHub Secrets)
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY")
+
+class NewsDatabase:
+    def __init__(self):
+        self.client: Client = None
+        if SUPABASE_URL and SUPABASE_KEY:
+            try:
+                self.client = create_client(SUPABASE_URL, SUPABASE_KEY)
+                print("[DB] Connected to Supabase.")
+            except Exception as e:
+                print(f"[DB] Connection Failed: {e}")
+        else:
+            print("[DB] Warning: SUPABASE_URL or SUPABASE_KEY not set. Running in Dummy Mode.")
+
+    def upsert_article(self, ticker, start_time, article_data):
+        """
+        Save or Update an article in the DB.
+        """
+        if not self.client:
+            return
+            
+        data = {
+            "ticker": ticker,
+            "link": article_data['link'],
+            "title": article_data['title'],
+            "published": article_data.get('published'),
+            "source": article_data.get('publisher'),
+            "full_text": article_data.get('text', ''),
+            "snippet": article_data.get('snippet', ''),
+            "sentiment_score": article_data.get('sentiment', 0.0),
+            "scraped_at": time.strftime('%Y-%m-%d %H:%M:%S'),
+            "debug_metadata": article_data.get('debug', {})
+        }
+        
+        try:
+            # Upsert based on link (assuming link is unique constraint)
+            self.client.table("news_articles").upsert(data, on_conflict="link").execute()
+            # print(f"[DB] Saved: {data['title'][:30]}...")
+        except Exception as e:
+            print(f"[DB] Save Error: {e}")
+
+    def get_latest_news(self, ticker, limit=10):
+        """
+        Fetch latest news for a ticker from DB.
+        """
+        if not self.client:
+            return []
+            
+        try:
+            response = self.client.table("news_articles")\
+                .select("*")\
+                .eq("ticker", ticker)\
+                .order("published", desc=True)\
+                .limit(limit)\
+                .execute()
+            return response.data
+        except Exception as e:
+            print(f"[DB] Fetch Error: {e}")
+            return []
+
+    def set_cache(self, key: str, data: dict):
+        """
+        Save a pre-computed JSON payload to the api_cache table.
+        """
+        if not self.client:
+            print(f"[DB] Cache Set Error: No Supabase Client (Key: {key})")
+            return False
+            
+        try:
+            payload = {
+                "key": key,
+                "data": data,
+                "updated_at": time.strftime('%Y-%m-%d %H:%M:%S')
+            }
+            self.client.table("api_cache").upsert(payload, on_conflict="key").execute()
+            print(f"[DB] Successfully cached '{key}' to Supabase.")
+            return True
+        except Exception as e:
+            print(f"[DB] Cache Set Error for '{key}': {e}")
+            return False
+
+    def get_cache(self, key: str):
+        """
+        Retrieve a pre-computed JSON payload from the api_cache table.
+        """
+        if not self.client:
+            return None
+            
+        try:
+            response = self.client.table("api_cache")\
+                .select("data")\
+                .eq("key", key)\
+                .execute()
+            
+            if response.data and len(response.data) > 0:
+                return response.data[0]["data"]
+            return None
+        except Exception as e:
+            print(f"[DB] Cache Get Error for '{key}': {e}")
+            return None

backend/manager.py

@@ -0,0 +1,94 @@
+import os
+import torch
+import logging
+from brain.neural_networks.data_processor import DataProcessor
+from brain.neural_networks.model import StockLSTM
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class ModelManager:
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            logger.info("Initializing ModelManager Singleton...")
+            cls._instance = super(ModelManager, cls).__new__(cls)
+            cls._instance.initialize()
+        return cls._instance
+    
+    def initialize(self):
+        self.device = torch.device('cpu') # Inference on CPU is sufficient
+        self.processor = None
+        self.model = None
+        self.model_path = "brain/saved_models/hybrid_lstm.pth"
+        
+        # Lazy load flag
+        self._loaded = False
+
+    def load_resources(self):
+        """
+        Loads the DataProcessor and PyTorch Model if not already loaded.
+        """
+        if self._loaded:
+            return
+
+        logger.info("Loading AI Resources...")
+        
+        try:
+            # 1. Initialize Processor (Loads Scaler)
+            self.processor = DataProcessor(sequence_length=60)
+            
+            # 2. Initialize Model
+            self.model = StockLSTM(input_size=13)
+            
+            if os.path.exists(self.model_path):
+                logger.info(f"Loading model weights from {self.model_path}")
+                self.model.load_state_dict(torch.load(self.model_path, map_location=self.device))
+                self.model.to(self.device)
+                self.model.eval()
+                self._loaded = True
+            else:
+                logger.warning(f"Model file not found at {self.model_path}. Neural predictions will be disabled.")
+                self.model = None
+                
+        except Exception as e:
+            logger.error(f"Failed to load AI resources: {e}")
+            self.model = None
+            self.processor = None
+
+    def predict_sentiment(self, graph_data):
+        """
+        Runs inference on the provided graph data.
+        Returns: (signal: str, confidence: float)
+        """
+        if not self._loaded:
+            self.load_resources()
+            
+        if not self.model or not self.processor:
+            return "Neutral (Model Error)", 0.0
+
+        try:
+            # Prepare Data
+            input_tensor = self.processor.prepare_inference_data(graph_data)
+            
+            if input_tensor is None:
+                logger.warning("Insufficient data for inference (Need 60+ days).")
+                return "Neutral (No Data)", 0.0
+                
+            # Predict
+            input_tensor = torch.FloatTensor(input_tensor).to(self.device)
+            
+            with torch.no_grad():
+                prediction = self.model(input_tensor).item()
+                
+            signal = "Bullish" if prediction > 0.50 else "Bearish"
+            return signal, prediction
+            
+        except Exception as e:
+            logger.error(f"Inference Error: {e}")
+            return "Neutral (Error)", 0.0
+
+# Global Instance
+model_manager = ModelManager()

backend/pairs_radar.json

@@ -0,0 +1 @@
+{"pairs": [{"ticker1": "AAPL", "ticker2": "MSFT", "sector": "Big Tech", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.8, "signal": "Neutral"}, {"ticker1": "GOOGL", "ticker2": "META", "sector": "Ad Tech", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.82, "signal": "Neutral"}, {"ticker1": "AMD", "ticker2": "NVDA", "sector": "Semiconductors", "correlation": 0, "is_cointegrated": false, "current_z_score": 1.14, "signal": "Neutral"}, {"ticker1": "INTC", "ticker2": "TXN", "sector": "Semiconductors", "correlation": 0, "is_cointegrated": false, "current_z_score": 1.33, "signal": "Neutral"}, {"ticker1": "AVGO", "ticker2": "QCOM", "sector": "Semiconductors", "correlation": 0, "is_cointegrated": false, "current_z_score": 1.69, "signal": "Neutral"}, {"ticker1": "ORCL", "ticker2": "CRM", "sector": "Software", "correlation": 0, "is_cointegrated": false, "current_z_score": -0.72, "signal": "Neutral"}, {"ticker1": "ADBE", "ticker2": "CRM", "sector": "Software", "correlation": 0, "is_cointegrated": false, "current_z_score": -0.53, "signal": "Neutral"}, {"ticker1": "CSCO", "ticker2": "JNPR", "sector": "Networking", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.0, "signal": "Neutral"}, {"ticker1": "IBM", "ticker2": "HPQ", "sector": "Hardware", "correlation": 0, "is_cointegrated": false, "current_z_score": -1.16, "signal": "Neutral"}, {"ticker1": "AMAT", "ticker2": "MU", "sector": "Semiconductors", "correlation": 0, "is_cointegrated": false, "current_z_score": 3.05, "signal": "Neutral"}, {"ticker1": "LRCX", "ticker2": "KLAC", "sector": "Semiconductors", "correlation": 0, "is_cointegrated": true, "current_z_score": -0.06, "signal": "Neutral"}, {"ticker1": "SNPS", "ticker2": "CDNS", "sector": "Software", "correlation": 0, "is_cointegrated": false, "current_z_score": -0.56, "signal": "Neutral"}, {"ticker1": "VZ", "ticker2": "T", "sector": "Telecom", "correlation": 0, "is_cointegrated": false, "current_z_score": 2.0, "signal": "Neutral"}, {"ticker1": "DIS", "ticker2": "CMCSA", "sector": "Media", "correlation": 0, "is_cointegrated": false, "current_z_score": -1.36, "signal": "Neutral"}, {"ticker1": "NFLX", "ticker2": "WBD", "sector": "Streaming", "correlation": 0, "is_cointegrated": false, "current_z_score": -0.36, "signal": "Neutral"}, {"ticker1": "CHTR", "ticker2": "FOXA", "sector": "Media", "correlation": 0, "is_cointegrated": false, "current_z_score": -1.5, "signal": "Neutral"}, {"ticker1": "TMUS", "ticker2": "VZ", "sector": "Telecom", "correlation": 0, "is_cointegrated": false, "current_z_score": -0.69, "signal": "Neutral"}, {"ticker1": "EA", "ticker2": "TTWO", "sector": "Gaming", "correlation": 0, "is_cointegrated": false, "current_z_score": 1.67, "signal": "Neutral"}, {"ticker1": "OMC", "ticker2": "IPG", "sector": "Advertising", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.0, "signal": "Neutral"}, {"ticker1": "JPM", "ticker2": "BAC", "sector": "Banking", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.6, "signal": "Neutral"}, {"ticker1": "V", "ticker2": "MA", "sector": "Payments", "correlation": 0, "is_cointegrated": false, "current_z_score": -1.24, "signal": "Neutral"}, {"ticker1": "GS", "ticker2": "MS", "sector": "Investment Banking", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.36, "signal": "Neutral"}, {"ticker1": "WFC", "ticker2": "C", "sector": "Banking", "correlation": 0, "is_cointegrated": false, "current_z_score": -2.6, "signal": "Neutral"}, {"ticker1": "AXP", "ticker2": "DFS", "sector": "Credit Cards", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.0, "signal": "Neutral"}, {"ticker1": "BLK", "ticker2": "TROW", "sector": "Asset Management", "correlation": 0, "is_cointegrated": true, "current_z_score": 0.31, "signal": "Neutral"}, {"ticker1": "CME", "ticker2": "ICE", "sector": "Exchanges", "correlation": 0, "is_cointegrated": false, "current_z_score": 1.46, "signal": "Neutral"}, {"ticker1": "USB", "ticker2": "PNC", "sector": "Regional Banks", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.45, "signal": "Neutral"}, {"ticker1": "TFC", "ticker2": "SYF", "sector": "Financial Services", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.69, "signal": "Neutral"}, {"ticker1": "SCHW", "ticker2": "AMP", "sector": "Brokerage", "correlation": 0, "is_cointegrated": false, "current_z_score": 1.0, "signal": "Neutral"}, {"ticker1": "STT", "ticker2": "BK", "sector": "Custody Banks", "correlation": 0, "is_cointegrated": true, "current_z_score": 0.02, "signal": "Neutral"}, {"ticker1": "MTB", "ticker2": "FITB", "sector": "Regional Banks", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.96, "signal": "Neutral"}, {"ticker1": "AIG", "ticker2": "COF", "sector": "Consumer Finance", "correlation": 0, "is_cointegrated": true, "current_z_score": -1.24, "signal": "Neutral"}, {"ticker1": "SPGI", "ticker2": "MCO", "sector": "Financial Data", "correlation": 0, "is_cointegrated": false, "current_z_score": -1.51, "signal": "Neutral"}, {"ticker1": "PRU", "ticker2": "MET", "sector": "Life Insurance", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.04, "signal": "Neutral"}, {"ticker1": "TRV", "ticker2": "AFL", "sector": "Insurance", "correlation": 0, "is_cointegrated": false, "current_z_score": 1.57, "signal": "Neutral"}, {"ticker1": "ALL", "ticker2": "HIG", "sector": "Insurance", "correlation": 0, "is_cointegrated": true, "current_z_score": -0.08, "signal": "Neutral"}, {"ticker1": "PGR", "ticker2": "CB", "sector": "P&C Insurance", "correlation": 0, "is_cointegrated": false, "current_z_score": -0.52, "signal": "Neutral"}, {"ticker1": "JNJ", "ticker2": "PFE", "sector": "Big Pharma", "correlation": 0, "is_cointegrated": true, "current_z_score": 0.26, "signal": "Neutral"}, {"ticker1": "UNH", "ticker2": "ELV", "sector": "Managed Care", "correlation": 0, "is_cointegrated": false, "current_z_score": -0.1, "signal": "Neutral"}, {"ticker1": "ABT", "ticker2": "MDT", "sector": "Medical Devices", "correlation": 0, "is_cointegrated": false, "current_z_score": -3.0, "signal": "Neutral"}, {"ticker1": "MRK", "ticker2": "BMY", "sector": "Big Pharma", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.95, "signal": "Neutral"}, {"ticker1": "LLY", "ticker2": "NVO", "sector": "Big Pharma", "correlation": 0, "is_cointegrated": false, "current_z_score": -0.78, "signal": "Neutral"}, {"ticker1": "TMO", "ticker2": "DHR", "sector": "Life Sciences", "correlation": 0, "is_cointegrated": false, "current_z_score": 2.3, "signal": "Neutral"}, {"ticker1": "AMGN", "ticker2": "GILD", "sector": "Biotech", "correlation": 0, "is_cointegrated": true, "current_z_score": 0.21, "signal": "Neutral"}, {"ticker1": "ISRG", "ticker2": "SYK", "sector": "Medical Devices", "correlation": 0, "is_cointegrated": false, "current_z_score": -1.12, "signal": "Neutral"}, {"ticker1": "VRTX", "ticker2": "REGN", "sector": "Biotech", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.03, "signal": "Neutral"}, {"ticker1": "ZTS", "ticker2": "IDXX", "sector": "Animal Health", "correlation": 0, "is_cointegrated": false, "current_z_score": -2.35, "signal": "Neutral"}, {"ticker1": "BSX", "ticker2": "EW", "sector": "Medical Devices", "correlation": 0, "is_cointegrated": false, "current_z_score": -2.51, "signal": "Neutral"}, {"ticker1": "CNC", "ticker2": "HUM", "sector": "Managed Care", "correlation": 0, "is_cointegrated": false, "current_z_score": -0.97, "signal": "Neutral"}, {"ticker1": "CI", "ticker2": "CVS", "sector": "Healthcare Services", "correlation": 0, "is_cointegrated": true, "current_z_score": -1.17, "signal": "Neutral"}, {"ticker1": "BIIB", "ticker2": "INCY", "sector": "Biotech", "correlation": 0, "is_cointegrated": false, "current_z_score": 2.28, "signal": "Neutral"}, {"ticker1": "CAH", "ticker2": "MCK", "sector": "Drug Distribution", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.22, "signal": "Neutral"}, {"ticker1": "HCA", "ticker2": "ABC", "sector": "Healthcare Facilities", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.0, "signal": "Neutral"}, {"ticker1": "KO", "ticker2": "PEP", "sector": "Beverages", "correlation": 0, "is_cointegrated": false, "current_z_score": 1.26, "signal": "Neutral"}, {"ticker1": "WMT", "ticker2": "TGT", "sector": "Retail", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.27, "signal": "Neutral"}, {"ticker1": "HD", "ticker2": "LOW", "sector": "Home Improvement", "correlation": 0, "is_cointegrated": false, "current_z_score": -1.94, "signal": "Neutral"}, {"ticker1": "MCD", "ticker2": "SBUX", "sector": "Restaurants", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.3, "signal": "Neutral"}, {"ticker1": "PG", "ticker2": "KMB", "sector": "Household Products", "correlation": 0, "is_cointegrated": false, "current_z_score": -0.51, "signal": "Neutral"}, {"ticker1": "NKE", "ticker2": "LULU", "sector": "Apparel", "correlation": 0, "is_cointegrated": false, "current_z_score": -2.11, "signal": "Neutral"}, {"ticker1": "COST", "ticker2": "BJ", "sector": "Discount Stores", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.89, "signal": "Neutral"}, {"ticker1": "DG", "ticker2": "DLTR", "sector": "Discount Retail", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.23, "signal": "Neutral"}, {"ticker1": "TJX", "ticker2": "ROST", "sector": "Off-Price Retail", "correlation": 0, "is_cointegrated": false, "current_z_score": -1.56, "signal": "Neutral"}, {"ticker1": "MO", "ticker2": "PM", "sector": "Tobacco", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.86, "signal": "Neutral"}, {"ticker1": "CLX", "ticker2": "CHD", "sector": "Household Products", "correlation": 0, "is_cointegrated": false, "current_z_score": -2.1, "signal": "Neutral"}, {"ticker1": "K", "ticker2": "GIS", "sector": "Packaged Foods", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.0, "signal": "Neutral"}, {"ticker1": "HSY", "ticker2": "MDLZ", "sector": "Confectionery", "correlation": 0, "is_cointegrated": false, "current_z_score": 1.51, "signal": "Neutral"}, {"ticker1": "CPB", "ticker2": "SJM", "sector": "Packaged Foods", "correlation": 0, "is_cointegrated": false, "current_z_score": -2.23, "signal": "Neutral"}, {"ticker1": "YUM", "ticker2": "QSR", "sector": "Restaurants", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.66, "signal": "Neutral"}, {"ticker1": "TSCO", "ticker2": "KR", "sector": "Food Retail", "correlation": 0, "is_cointegrated": false, "current_z_score": -2.1, "signal": "Neutral"}, {"ticker1": "EL", "ticker2": "COTY", "sector": "Personal Care", "correlation": 0, "is_cointegrated": false, "current_z_score": -3.06, "signal": "Neutral"}, {"ticker1": "CVX", "ticker2": "XOM", "sector": "Integrated Oil", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.98, "signal": "Neutral"}, {"ticker1": "COP", "ticker2": "EOG", "sector": "E&P", "correlation": 0, "is_cointegrated": false, "current_z_score": 1.23, "signal": "Neutral"}, {"ticker1": "SLB", "ticker2": "HAL", "sector": "Oil Services", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.16, "signal": "Neutral"}, {"ticker1": "MPC", "ticker2": "PSX", "sector": "Refining", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.24, "signal": "Neutral"}, {"ticker1": "VLO", "ticker2": "PSX", "sector": "Refining", "correlation": 0, "is_cointegrated": true, "current_z_score": -1.81, "signal": "Neutral"}, {"ticker1": "KMI", "ticker2": "WMB", "sector": "Midstream", "correlation": 0, "is_cointegrated": false, "current_z_score": 1.79, "signal": "Neutral"}, {"ticker1": "OXY", "ticker2": "DVN", "sector": "E&P", "correlation": 0, "is_cointegrated": false, "current_z_score": 2.05, "signal": "Neutral"}, {"ticker1": "HES", "ticker2": "MRO", "sector": "E&P", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.0, "signal": "Neutral"}, {"ticker1": "BKR", "ticker2": "SLB", "sector": "Oil Services", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.26, "signal": "Neutral"}, {"ticker1": "FANG", "ticker2": "PXD", "sector": "E&P", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.0, "signal": "Neutral"}, {"ticker1": "TRGP", "ticker2": "OKE", "sector": "Midstream", "correlation": 0, "is_cointegrated": false, "current_z_score": 1.57, "signal": "Neutral"}, {"ticker1": "LMT", "ticker2": "RTX", "sector": "Defense", "correlation": 0, "is_cointegrated": false, "current_z_score": 1.32, "signal": "Neutral"}, {"ticker1": "BA", "ticker2": "GD", "sector": "Aerospace", "correlation": 0, "is_cointegrated": false, "current_z_score": -1.41, "signal": "Neutral"}, {"ticker1": "CAT", "ticker2": "DE", "sector": "Heavy Machinery", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.76, "signal": "Neutral"}, {"ticker1": "UNP", "ticker2": "CSX", "sector": "Railroads", "correlation": 0, "is_cointegrated": true, "current_z_score": -0.13, "signal": "Neutral"}, {"ticker1": "NSC", "ticker2": "CP", "sector": "Railroads", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.22, "signal": "Neutral"}, {"ticker1": "UPS", "ticker2": "FDX", "sector": "Logistics", "correlation": 0, "is_cointegrated": false, "current_z_score": -1.47, "signal": "Neutral"}, {"ticker1": "HON", "ticker2": "EMR", "sector": "Conglomerates", "correlation": 0, "is_cointegrated": false, "current_z_score": 1.66, "signal": "Neutral"}, {"ticker1": "GE", "ticker2": "MMM", "sector": "Conglomerates", "correlation": 0, "is_cointegrated": false, "current_z_score": 1.72, "signal": "Neutral"}, {"ticker1": "NOC", "ticker2": "GD", "sector": "Defense", "correlation": 0, "is_cointegrated": false, "current_z_score": 1.05, "signal": "Neutral"}, {"ticker1": "ITW", "ticker2": "ETN", "sector": "Industrial Machinery", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.31, "signal": "Neutral"}, {"ticker1": "PH", "ticker2": "ROK", "sector": "Industrial Components", "correlation": 0, "is_cointegrated": false, "current_z_score": 2.23, "signal": "Neutral"}, {"ticker1": "TXT", "ticker2": "DOV", "sector": "Industrial Conglomerates", "correlation": 0, "is_cointegrated": false, "current_z_score": -0.59, "signal": "Neutral"}, {"ticker1": "LIN", "ticker2": "APD", "sector": "Industrial Gases", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.98, "signal": "Neutral"}, {"ticker1": "SHW", "ticker2": "PPG", "sector": "Specialty Chemicals", "correlation": 0, "is_cointegrated": false, "current_z_score": -2.1, "signal": "Neutral"}, {"ticker1": "NEM", "ticker2": "GOLD", "sector": "Gold Mining", "correlation": 0, "is_cointegrated": false, "current_z_score": -0.32, "signal": "Neutral"}, {"ticker1": "FCX", "ticker2": "SCCO", "sector": "Copper Mining", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.7, "signal": "Neutral"}, {"ticker1": "DOW", "ticker2": "LYB", "sector": "Chemicals", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.69, "signal": "Neutral"}, {"ticker1": "EMN", "ticker2": "CE", "sector": "Chemicals", "correlation": 0, "is_cointegrated": false, "current_z_score": -1.81, "signal": "Neutral"}, {"ticker1": "VMC", "ticker2": "MLM", "sector": "Construction Materials", "correlation": 0, "is_cointegrated": false, "current_z_score": -1.82, "signal": "Neutral"}, {"ticker1": "NEE", "ticker2": "DUK", "sector": "Electric Utilities", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.58, "signal": "Neutral"}, {"ticker1": "SO", "ticker2": "D", "sector": "Electric Utilities", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.84, "signal": "Neutral"}, {"ticker1": "AEP", "ticker2": "EXC", "sector": "Electric Utilities", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.51, "signal": "Neutral"}, {"ticker1": "SRE", "ticker2": "XEL", "sector": "Multi-Utilities", "correlation": 0, "is_cointegrated": false, "current_z_score": 1.91, "signal": "Neutral"}, {"ticker1": "ED", "ticker2": "PEG", "sector": "Multi-Utilities", "correlation": 0, "is_cointegrated": false, "current_z_score": 1.7, "signal": "Neutral"}, {"ticker1": "WEC", "ticker2": "EIX", "sector": "Electric Utilities", "correlation": 0, "is_cointegrated": false, "current_z_score": -0.43, "signal": "Neutral"}, {"ticker1": "AWK", "ticker2": "WTRG", "sector": "Water Utilities", "correlation": 0, "is_cointegrated": false, "current_z_score": -0.4, "signal": "Neutral"}, {"ticker1": "DTE", "ticker2": "CMS", "sector": "Multi-Utilities", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.72, "signal": "Neutral"}, {"ticker1": "AMT", "ticker2": "CCI", "sector": "Telecom REITs", "correlation": 0, "is_cointegrated": false, "current_z_score": 1.32, "signal": "Neutral"}, {"ticker1": "PLD", "ticker2": "DRE", "sector": "Industrial REITs", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.0, "signal": "Neutral"}, {"ticker1": "EQIX", "ticker2": "DLR", "sector": "Data Center REITs", "correlation": 0, "is_cointegrated": false, "current_z_score": 2.04, "signal": "Neutral"}, {"ticker1": "PSA", "ticker2": "EXR", "sector": "Storage REITs", "correlation": 0, "is_cointegrated": false, "current_z_score": -0.02, "signal": "Neutral"}, {"ticker1": "SPG", "ticker2": "MAC", "sector": "Retail REITs", "correlation": 0, "is_cointegrated": true, "current_z_score": -0.86, "signal": "Neutral"}, {"ticker1": "WELL", "ticker2": "VTR", "sector": "Healthcare REITs", "correlation": 0, "is_cointegrated": false, "current_z_score": -0.78, "signal": "Neutral"}, {"ticker1": "O", "ticker2": "NNN", "sector": "Retail REITs", "correlation": 0, "is_cointegrated": false, "current_z_score": 0.34, "signal": "Neutral"}, {"ticker1": "AVB", "ticker2": "BXP", "sector": "Residential REITs", "correlation": 0, "is_cointegrated": false, "current_z_score": -1.59, "signal": "Neutral"}]}

backend/screener_data.json

@@ -0,0 +1 @@
+{"stocks": [{"ticker": "AAPL", "price": 253.96, "volatility_regime": "Normal", "earnings": "Any", "signal": "Neutral", "change": 253.96}, {"ticker": "MSFT", "price": 370.03, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 370.03}, {"ticker": "GOOGL", "price": 290.15, "volatility_regime": "High", "earnings": "This Month", "signal": "Neutral", "change": 290.15}, {"ticker": "AMZN", "price": 211.73, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 211.73}, {"ticker": "NVDA", "price": 179.05, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 179.05}, {"ticker": "META", "price": 596.69, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 596.69}, {"ticker": "TSLA", "price": 387.81, "volatility_regime": "High", "earnings": "This Month", "signal": "Neutral", "change": 387.81}, {"ticker": "JPM", "price": 295.21, "volatility_regime": "Normal", "earnings": "This Month", "signal": "Neutral", "change": 295.21}, {"ticker": "V", "price": 305.255, "volatility_regime": "Normal", "earnings": "Any", "signal": "Neutral", "change": 305.255}, {"ticker": "JNJ", "price": 240.48, "volatility_regime": "Normal", "earnings": "This Month", "signal": "Buy", "change": 240.48}, {"ticker": "WMT", "price": 123.3, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 123.3}, {"ticker": "PG", "price": 143.84, "volatility_regime": "High", "earnings": "This Month", "signal": "Sell", "change": 143.84}, {"ticker": "MA", "price": 502.31, "volatility_regime": "High", "earnings": "Any", "signal": "Buy", "change": 502.31}, {"ticker": "UNH", "price": 269.15, "volatility_regime": "High", "earnings": "This Month", "signal": "Neutral", "change": 269.15}, {"ticker": "HD", "price": 332.745, "volatility_regime": "High", "earnings": "Any", "signal": "Sell", "change": 332.745}, {"ticker": "DIS", "price": 96.16, "volatility_regime": "Normal", "earnings": "Any", "signal": "Sell", "change": 96.16}, {"ticker": "BAC", "price": 48.72, "volatility_regime": "High", "earnings": "This Month", "signal": "Neutral", "change": 48.72}, {"ticker": "XOM", "price": 164.185, "volatility_regime": "High", "earnings": "Any", "signal": "Strong Buy", "change": 164.185}, {"ticker": "PFE", "price": 27.345, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 27.345}, {"ticker": "KO", "price": 75.405, "volatility_regime": "Normal", "earnings": "Any", "signal": "Neutral", "change": 75.405}, {"ticker": "PEP", "price": 151.02, "volatility_regime": "Normal", "earnings": "This Month", "signal": "Sell", "change": 151.02}, {"ticker": "CSCO", "price": 82.08, "volatility_regime": "High", "earnings": "Any", "signal": "Buy", "change": 82.08}, {"ticker": "INTC", "price": 47.375, "volatility_regime": "Extreme", "earnings": "This Month", "signal": "Buy", "change": 47.375}, {"ticker": "NFLX", "price": 92.265, "volatility_regime": "Extreme", "earnings": "This Month", "signal": "Strong Buy", "change": 92.265}, {"ticker": "ADBE", "price": 237.775, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 237.775}, {"ticker": "CRM", "price": 181.45, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 181.45}, {"ticker": "AMD", "price": 220.96, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Buy", "change": 220.96}, {"ticker": "QCOM", "price": 130.63, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 130.63}, {"ticker": "TXN", "price": 198.82, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 198.82}, {"ticker": "AVGO", "price": 318.935, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 318.935}, {"ticker": "ORCL", "price": 145.615, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 145.615}, {"ticker": "COST", "price": 976.055, "volatility_regime": "Normal", "earnings": "Any", "signal": "Neutral", "change": 976.055}, {"ticker": "MRK", "price": 119.05, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 119.05}, {"ticker": "ABT", "price": 105.3, "volatility_regime": "High", "earnings": "This Month", "signal": "Sell", "change": 105.3}, {"ticker": "TMO", "price": 491.39, "volatility_regime": "High", "earnings": "This Month", "signal": "Neutral", "change": 491.39}, {"ticker": "NKE", "price": 53.06, "volatility_regime": "High", "earnings": "This Week", "signal": "Sell", "change": 53.06}, {"ticker": "MCD", "price": 312.595, "volatility_regime": "Normal", "earnings": "Any", "signal": "Neutral", "change": 312.595}, {"ticker": "LLY", "price": 915.79, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 915.79}, {"ticker": "DHR", "price": 186.73, "volatility_regime": "High", "earnings": "This Month", "signal": "Neutral", "change": 186.73}, {"ticker": "UPS", "price": 98.92, "volatility_regime": "High", "earnings": "Any", "signal": "Sell", "change": 98.92}, {"ticker": "CAT", "price": 722.88, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 722.88}, {"ticker": "GS", "price": 841.16, "volatility_regime": "Extreme", "earnings": "This Month", "signal": "Neutral", "change": 841.16}, {"ticker": "MS", "price": 166.01, "volatility_regime": "High", "earnings": "This Month", "signal": "Neutral", "change": 166.01}, {"ticker": "AXP", "price": 300.67, "volatility_regime": "Extreme", "earnings": "This Month", "signal": "Neutral", "change": 300.67}, {"ticker": "SBUX", "price": 93.255, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 93.255}, {"ticker": "MMM", "price": 148.47, "volatility_regime": "High", "earnings": "This Month", "signal": "Neutral", "change": 148.47}, {"ticker": "IBM", "price": 241.56, "volatility_regime": "High", "earnings": "This Month", "signal": "Buy", "change": 241.56}, {"ticker": "GE", "price": 297.7, "volatility_regime": "High", "earnings": "This Month", "signal": "Sell", "change": 297.7}, {"ticker": "F", "price": 11.72, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 11.72}, {"ticker": "GM", "price": 76.91, "volatility_regime": "High", "earnings": "Any", "signal": "Buy", "change": 76.91}, {"ticker": "T", "price": 28.92, "volatility_regime": "High", "earnings": "This Month", "signal": "Buy", "change": 28.92}, {"ticker": "VZ", "price": 50.495, "volatility_regime": "Normal", "earnings": "Any", "signal": "Buy", "change": 50.495}, {"ticker": "PYPL", "price": 44.525, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 44.525}, {"ticker": "XYZ", "price": 60.31, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 60.31}, {"ticker": "SNAP", "price": 4.495, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 4.495}, {"ticker": "UBER", "price": 73.3, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 73.3}, {"ticker": "LYFT", "price": 13.185, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 13.185}, {"ticker": "ZM", "price": 78.04, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 78.04}, {"ticker": "ROKU", "price": 95.085, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 95.085}, {"ticker": "COIN", "price": 181.22, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 181.22}, {"ticker": "RIVN", "price": 15.665, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 15.665}, {"ticker": "LCID", "price": 10.615, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 10.615}, {"ticker": "PLTR", "price": 155.84, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 155.84}, {"ticker": "SOFI", "price": 16.625, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 16.625}, {"ticker": "MARA", "price": 8.07, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 8.07}, {"ticker": "RIOT", "price": 14.545, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 14.545}, {"ticker": "DKNG", "price": 21.56, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 21.56}, {"ticker": "RBLX", "price": 55.61, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 55.61}, {"ticker": "HOOD", "price": 72.59, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 72.59}, {"ticker": "PATH", "price": 10.875, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 10.875}, {"ticker": "CRWD", "price": 386.11, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 386.11}, {"ticker": "SNOW", "price": 159.18, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 159.18}, {"ticker": "NET", "price": 216.85, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 216.85}, {"ticker": "DDOG", "price": 122.7, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 122.7}, {"ticker": "ZS", "price": 139.94, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 139.94}, {"ticker": "MDB", "price": 243.69, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 243.69}, {"ticker": "PANW", "price": 154.03, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 154.03}, {"ticker": "ABNB", "price": 131.82, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 131.82}, {"ticker": "DASH", "price": 152.35, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 152.35}, {"ticker": "PINS", "price": 18.735, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 18.735}, {"ticker": "CVX", "price": 205.8, "volatility_regime": "Normal", "earnings": "Any", "signal": "Strong Buy", "change": 205.8}, {"ticker": "BA", "price": 199.96, "volatility_regime": "Extreme", "earnings": "This Month", "signal": "Sell", "change": 199.96}, {"ticker": "BA", "price": 199.98, "volatility_regime": "Extreme", "earnings": "This Month", "signal": "Sell", "change": 199.98}, {"ticker": "LMT", "price": 625.2, "volatility_regime": "High", "earnings": "This Month", "signal": "Neutral", "change": 625.2}, {"ticker": "LMT", "price": 625.2, "volatility_regime": "High", "earnings": "This Month", "signal": "Neutral", "change": 625.2}, {"ticker": "NOC", "price": 688.59, "volatility_regime": "High", "earnings": "This Month", "signal": "Neutral", "change": 688.59}, {"ticker": "RTX", "price": 196.15, "volatility_regime": "High", "earnings": "This Month", "signal": "Buy", "change": 196.15}, {"ticker": "GD", "price": 353.79, "volatility_regime": "High", "earnings": "This Month", "signal": "Buy", "change": 353.79}, {"ticker": "TDG", "price": 1159.0, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 1159.0}, {"ticker": "BMY", "price": 58.925, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 58.925}, {"ticker": "AMGN", "price": 354.27, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 354.27}, {"ticker": "GILD", "price": 138.55, "volatility_regime": "High", "earnings": "This Month", "signal": "Neutral", "change": 138.55}, {"ticker": "ISRG", "price": 470.23, "volatility_regime": "High", "earnings": "This Month", "signal": "Neutral", "change": 470.23}, {"ticker": "SYK", "price": 327.12, "volatility_regime": "High", "earnings": "Any", "signal": "Sell", "change": 327.12}, {"ticker": "VRTX", "price": 457.46, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 457.46}, {"ticker": "REGN", "price": 749.25, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 749.25}, {"ticker": "ZTS", "price": 116.595, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 116.595}, {"ticker": "BSX", "price": 69.435, "volatility_regime": "High", "earnings": "This Month", "signal": "Neutral", "change": 69.435}, {"ticker": "MDT", "price": 87.86, "volatility_regime": "Normal", "earnings": "Any", "signal": "Neutral", "change": 87.86}, {"ticker": "CVS", "price": 71.99, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 71.99}, {"ticker": "CI", "price": 270.355, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 270.355}, {"ticker": "C", "price": 114.8, "volatility_regime": "High", "earnings": "This Month", "signal": "Buy", "change": 114.8}, {"ticker": "WFC", "price": 80.465, "volatility_regime": "High", "earnings": "This Month", "signal": "Neutral", "change": 80.465}, {"ticker": "USB", "price": 51.935, "volatility_regime": "High", "earnings": "This Month", "signal": "Neutral", "change": 51.935}, {"ticker": "BLK", "price": 982.05, "volatility_regime": "Extreme", "earnings": "This Month", "signal": "Neutral", "change": 982.05}, {"ticker": "SPGI", "price": 408.93, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 408.93}, {"ticker": "PLD", "price": 131.04, "volatility_regime": "High", "earnings": "This Month", "signal": "Neutral", "change": 131.04}, {"ticker": "CB", "price": 324.385, "volatility_regime": "Normal", "earnings": "Any", "signal": "Buy", "change": 324.385}, {"ticker": "ADP", "price": 201.79, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 201.79}, {"ticker": "NOW", "price": 102.87, "volatility_regime": "Extreme", "earnings": "This Month", "signal": "Neutral", "change": 102.87}, {"ticker": "INTU", "price": 424.98, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 424.98}, {"ticker": "MDLZ", "price": 56.94, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 56.94}, {"ticker": "CMCSA", "price": 28.72, "volatility_regime": "High", "earnings": "This Month", "signal": "Sell", "change": 28.72}, {"ticker": "ELV", "price": 294.61, "volatility_regime": "Extreme", "earnings": "This Month", "signal": "Neutral", "change": 294.61}, {"ticker": "TJX", "price": 159.435, "volatility_regime": "Normal", "earnings": "Any", "signal": "Buy", "change": 159.435}, {"ticker": "PGR", "price": 203.0, "volatility_regime": "High", "earnings": "This Month", "signal": "Neutral", "change": 203.0}, {"ticker": "COP", "price": 129.28, "volatility_regime": "High", "earnings": "Any", "signal": "Strong Buy", "change": 129.28}, {"ticker": "EOG", "price": 142.98, "volatility_regime": "High", "earnings": "Any", "signal": "Strong Buy", "change": 142.98}, {"ticker": "OXY", "price": 61.8, "volatility_regime": "High", "earnings": "Any", "signal": "Strong Buy", "change": 61.8}, {"ticker": "SLB", "price": 52.005, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Buy", "change": 52.005}, {"ticker": "MPC", "price": 241.46, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 241.46}, {"ticker": "PSX", "price": 181.47, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 181.47}, {"ticker": "VLO", "price": 236.005, "volatility_regime": "Extreme", "earnings": "Any", "signal": "Neutral", "change": 236.005}, {"ticker": "KMI", "price": 34.0, "volatility_regime": "Normal", "earnings": "This Month", "signal": "Neutral", "change": 34.0}, {"ticker": "WMB", "price": 73.79, "volatility_regime": "Normal", "earnings": "Any", "signal": "Neutral", "change": 73.79}, {"ticker": "HAL", "price": 38.635, "volatility_regime": "High", "earnings": "This Month", "signal": "Strong Buy", "change": 38.635}, {"ticker": "NEE", "price": 91.39, "volatility_regime": "High", "earnings": "This Month", "signal": "Buy", "change": 91.39}, {"ticker": "DUK", "price": 128.15, "volatility_regime": "Normal", "earnings": "Any", "signal": "Neutral", "change": 128.15}, {"ticker": "SO", "price": 94.47, "volatility_regime": "Normal", "earnings": "Any", "signal": "Buy", "change": 94.47}, {"ticker": "D", "price": 60.85, "volatility_regime": "Normal", "earnings": "Any", "signal": "Neutral", "change": 60.85}, {"ticker": "AEP", "price": 128.195, "volatility_regime": "Normal", "earnings": "Any", "signal": "Neutral", "change": 128.195}, {"ticker": "SRE", "price": 95.435, "volatility_regime": "High", "earnings": "Any", "signal": "Buy", "change": 95.435}, {"ticker": "EXC", "price": 47.75, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 47.75}, {"ticker": "XEL", "price": 77.96, "volatility_regime": "Normal", "earnings": "This Month", "signal": "Neutral", "change": 77.96}, {"ticker": "ED", "price": 110.235, "volatility_regime": "Normal", "earnings": "Any", "signal": "Neutral", "change": 110.235}, {"ticker": "AMT", "price": 167.2, "volatility_regime": "High", "earnings": "Any", "signal": "Sell", "change": 167.2}, {"ticker": "PLD", "price": 131.01, "volatility_regime": "High", "earnings": "This Month", "signal": "Neutral", "change": 131.01}, {"ticker": "CCI", "price": 77.125, "volatility_regime": "High", "earnings": "This Month", "signal": "Sell", "change": 77.125}, {"ticker": "EQIX", "price": 969.07, "volatility_regime": "Normal", "earnings": "Any", "signal": "Neutral", "change": 969.07}, {"ticker": "PSA", "price": 267.965, "volatility_regime": "High", "earnings": "Any", "signal": "Neutral", "change": 267.965}, {"ticker": "SPG", "price": 182.1, "volatility_regime": "High", "earnings": "Any", "signal": "Sell", "change": 182.1}, {"ticker": "DLR", "price": 176.75, "volatility_regime": "High", "earnings": "This Month", "signal": "Neutral", "change": 176.75}, {"ticker": "WELL", "price": 196.53, "volatility_regime": "High", "earnings": "Any", "signal": "Sell", "change": 196.53}, {"ticker": "O", "price": 60.03, "volatility_regime": "Normal", "earnings": "Any", "signal": "Sell", "change": 60.03}]}

backend/strategy_cache.json

@@ -0,0 +1 @@
+{"engine": "Strategy", "regime": "RISK-ON", "spy_price": 750.46, "sma200": 677.46, "vol_scalar": 1.0, "realized_vol": 14.7, "target_vol": 18.0, "picks": [{"ticker": "MRNA", "price": 47.61, "change_pct": 1.23, "momentum_175d": 103.94, "sector_z_score": 3.65}, {"ticker": "WDC", "price": 530.6, "change_pct": 1.13, "momentum_175d": 291.88, "sector_z_score": 3.41}, {"ticker": "ALB", "price": 177.47, "change_pct": 1.59, "momentum_175d": 147.57, "sector_z_score": 3.12}, {"ticker": "TER", "price": 375.83, "change_pct": -3.42, "momentum_175d": 252.83, "sector_z_score": 3.09}, {"ticker": "CAT", "price": 909.93, "change_pct": 0.15, "momentum_175d": 91.47, "sector_z_score": 2.86}, {"ticker": "INTC", "price": 121.77, "change_pct": -1.42, "momentum_175d": 243.12, "sector_z_score": 2.78}, {"ticker": "ROST", "price": 233.47, "change_pct": -0.52, "momentum_175d": 54.48, "sector_z_score": 2.72}, {"ticker": "JBHT", "price": 270.87, "change_pct": 1.21, "momentum_175d": 84.32, "sector_z_score": 2.69}, {"ticker": "VTRS", "price": 16.29, "change_pct": 0.18, "momentum_175d": 57.4, "sector_z_score": 2.57}, {"ticker": "MU", "price": 928.41, "change_pct": 3.63, "momentum_175d": 232.97, "sector_z_score": 2.49}, {"ticker": "STT", "price": 157.92, "change_pct": -0.38, "momentum_175d": 40.21, "sector_z_score": 2.43}, {"ticker": "LUMN", "price": 10.87, "change_pct": 6.88, "momentum_175d": 52.82, "sector_z_score": 2.41}, {"ticker": "TGT", "price": 128.33, "change_pct": 2.31, "momentum_175d": 49.83, "sector_z_score": 2.3}, {"ticker": "STX", "price": 870.66, "change_pct": 2.94, "momentum_175d": 184.37, "sector_z_score": 2.22}, {"ticker": "GEV", "price": 1031.89, "change_pct": -3.6, "momentum_175d": 78.5, "sector_z_score": 2.21}], "all_universe": [{"ticker": "MRNA", "price": 47.61, "change_pct": 1.23, "momentum_175d": 103.94, "sector_z_score": 3.65}, {"ticker": "WDC", "price": 530.6, "change_pct": 1.13, "momentum_175d": 291.88, "sector_z_score": 3.41}, {"ticker": "ALB", "price": 177.47, "change_pct": 1.59, "momentum_175d": 147.57, "sector_z_score": 3.12}, {"ticker": "TER", "price": 375.83, "change_pct": -3.42, "momentum_175d": 252.83, "sector_z_score": 3.09}, {"ticker": "CAT", "price": 909.93, "change_pct": 0.15, "momentum_175d": 91.47, "sector_z_score": 2.86}, {"ticker": "INTC", "price": 121.77, "change_pct": -1.42, "momentum_175d": 243.12, "sector_z_score": 2.78}, {"ticker": "ROST", "price": 233.47, "change_pct": -0.52, "momentum_175d": 54.48, "sector_z_score": 2.72}, {"ticker": "JBHT", "price": 270.87, "change_pct": 1.21, "momentum_175d": 84.32, "sector_z_score": 2.69}, {"ticker": "VTRS", "price": 16.29, "change_pct": 0.18, "momentum_175d": 57.4, "sector_z_score": 2.57}, {"ticker": "MU", "price": 928.41, "change_pct": 3.63, "momentum_175d": 232.97, "sector_z_score": 2.49}, {"ticker": "STT", "price": 157.92, "change_pct": -0.38, "momentum_175d": 40.21, "sector_z_score": 2.43}, {"ticker": "LUMN", "price": 10.87, "change_pct": 6.88, "momentum_175d": 52.82, "sector_z_score": 2.41}, {"ticker": "TGT", "price": 128.33, "change_pct": 2.31, "momentum_175d": 49.83, "sector_z_score": 2.3}, {"ticker": "STX", "price": 870.66, "change_pct": 2.94, "momentum_175d": 184.37, "sector_z_score": 2.22}, {"ticker": "GEV", "price": 1031.89, "change_pct": -3.6, "momentum_175d": 78.5, "sector_z_score": 2.21}, {"ticker": "TPL", "price": 406.09, "change_pct": 1.5, "momentum_175d": 42.35, "sector_z_score": 2.21}, {"ticker": "HAL", "price": 39.6, "change_pct": -3.6, "momentum_175d": 86.24, "sector_z_score": 2.13}, {"ticker": "FDX", "price": 411.78, "change_pct": 2.94, "momentum_175d": 73.45, "sector_z_score": 2.12}, {"ticker": "EQIX", "price": 1070.22, "change_pct": -0.69, "momentum_175d": 39.25, "sector_z_score": 2.04}, {"ticker": "PWR", "price": 733.62, "change_pct": -1.15, "momentum_175d": 65.35, "sector_z_score": 2.04}, {"ticker": "APA", "price": 36.62, "change_pct": -2.35, "momentum_175d": 72.38, "sector_z_score": 2.0}, {"ticker": "NEE", "price": 87.65, "change_pct": 0.0, "momentum_175d": 34.44, "sector_z_score": 1.93}, {"ticker": "WMT", "price": 118.54, "change_pct": -0.03, "momentum_175d": 23.55, "sector_z_score": 1.92}, {"ticker": "JCI", "price": 138.2, "change_pct": -1.44, "momentum_175d": 33.4, "sector_z_score": 1.86}, {"ticker": "CAH", "price": 199.84, "change_pct": -0.26, "momentum_175d": 35.76, "sector_z_score": 1.78}, {"ticker": "MAR", "price": 385.86, "change_pct": 3.22, "momentum_175d": 36.61, "sector_z_score": 1.77}, {"ticker": "ODFL", "price": 219.45, "change_pct": 1.31, "momentum_175d": 52.34, "sector_z_score": 1.7}, {"ticker": "BK", "price": 139.74, "change_pct": -0.93, "momentum_175d": 28.05, "sector_z_score": 1.67}, {"ticker": "NTRS", "price": 167.94, "change_pct": -1.18, "momentum_175d": 30.33, "sector_z_score": 1.67}, {"ticker": "CMI", "price": 667.85, "change_pct": -0.13, "momentum_175d": 60.76, "sector_z_score": 1.66}, {"ticker": "C", "price": 125.39, "change_pct": -1.16, "momentum_175d": 30.86, "sector_z_score": 1.6}, {"ticker": "GOOGL", "price": 388.83, "change_pct": -0.01, "momentum_175d": 39.43, "sector_z_score": 1.6}, {"ticker": "GOOG", "price": 384.83, "change_pct": -0.0, "momentum_175d": 38.62, "sector_z_score": 1.52}, {"ticker": "ETR", "price": 111.51, "change_pct": -0.41, "momentum_175d": 27.45, "sector_z_score": 1.51}, {"ticker": "MNST", "price": 89.24, "change_pct": 2.08, "momentum_175d": 19.44, "sector_z_score": 1.5}, {"ticker": "CFG", "price": 63.08, "change_pct": -0.9, "momentum_175d": 28.21, "sector_z_score": 1.5}, {"ticker": "ADM", "price": 79.55, "change_pct": 1.97, "momentum_175d": 18.41, "sector_z_score": 1.46}, {"ticker": "TPR", "price": 138.83, "change_pct": -1.27, "momentum_175d": 33.77, "sector_z_score": 1.46}, {"ticker": "NUE", "price": 246.47, "change_pct": 2.57, "momentum_175d": 53.53, "sector_z_score": 1.45}, {"ticker": "OGN", "price": 13.38, "change_pct": -0.22, "momentum_175d": 27.19, "sector_z_score": 1.44}, {"ticker": "CBOE", "price": 347.69, "change_pct": -1.92, "momentum_175d": 27.8, "sector_z_score": 1.43}, {"ticker": "TSN", "price": 66.02, "change_pct": 1.37, "momentum_175d": 19.8, "sector_z_score": 1.39}, {"ticker": "WELL", "price": 214.18, "change_pct": -1.81, "momentum_175d": 25.25, "sector_z_score": 1.39}, {"ticker": "GM", "price": 84.12, "change_pct": 5.43, "momentum_175d": 32.83, "sector_z_score": 1.38}, {"ticker": "CNC", "price": 58.82, "change_pct": 2.81, "momentum_175d": 33.27, "sector_z_score": 1.35}, {"ticker": "BWA", "price": 70.83, "change_pct": 3.77, "momentum_175d": 27.14, "sector_z_score": 1.35}, {"ticker": "MS", "price": 201.61, "change_pct": -0.07, "momentum_175d": 22.82, "sector_z_score": 1.34}, {"ticker": "AMAT", "price": 448.25, "change_pct": -1.46, "momentum_175d": 137.62, "sector_z_score": 1.33}, {"ticker": "EIX", "price": 71.66, "change_pct": 0.59, "momentum_175d": 28.0, "sector_z_score": 1.31}, {"ticker": "VFC", "price": 17.41, "change_pct": 4.19, "momentum_175d": 32.96, "sector_z_score": 1.3}, {"ticker": "AEP", "price": 129.57, "change_pct": -1.02, "momentum_175d": 25.77, "sector_z_score": 1.28}, {"ticker": "MRK", "price": 120.24, "change_pct": 0.43, "momentum_175d": 38.23, "sector_z_score": 1.26}, {"ticker": "RIVN", "price": 14.7, "change_pct": 2.15, "momentum_175d": 22.94, "sector_z_score": 1.22}, {"ticker": "IHG", "price": 159.17, "change_pct": 3.15, "momentum_175d": 21.71, "sector_z_score": 1.22}, {"ticker": "WST", "price": 312.71, "change_pct": -1.09, "momentum_175d": 17.55, "sector_z_score": 1.21}, {"ticker": "VTR", "price": 88.05, "change_pct": -0.36, "momentum_175d": 23.64, "sector_z_score": 1.21}, {"ticker": "ROKU", "price": 131.91, "change_pct": 3.37, "momentum_175d": 21.78, "sector_z_score": 1.21}, {"ticker": "PLD", "price": 146.52, "change_pct": -0.29, "momentum_175d": 25.59, "sector_z_score": 1.19}, {"ticker": "KO", "price": 81.62, "change_pct": 1.44, "momentum_175d": 15.53, "sector_z_score": 1.17}, {"ticker": "GS", "price": 996.47, "change_pct": 0.2, "momentum_175d": 20.42, "sector_z_score": 1.16}, {"ticker": "SLB", "price": 56.5, "change_pct": -2.55, "momentum_175d": 61.04, "sector_z_score": 1.16}, {"ticker": "HST", "price": 23.48, "change_pct": 1.6, "momentum_175d": 23.24, "sector_z_score": 1.15}, {"ticker": "GNRC", "price": 280.53, "change_pct": 2.08, "momentum_175d": 18.63, "sector_z_score": 1.14}, {"ticker": "AMD", "price": 495.54, "change_pct": -1.66, "momentum_175d": 107.64, "sector_z_score": 1.11}, {"ticker": "GLW", "price": 190.89, "change_pct": -2.69, "momentum_175d": 116.59, "sector_z_score": 1.11}, {"ticker": "BIIB", "price": 196.97, "change_pct": 2.01, "momentum_175d": 26.06, "sector_z_score": 1.11}, {"ticker": "PFG", "price": 104.57, "change_pct": -0.13, "momentum_175d": 22.47, "sector_z_score": 1.11}, {"ticker": "DOW", "price": 34.49, "change_pct": -2.24, "momentum_175d": 61.87, "sector_z_score": 1.1}, {"ticker": "HLT", "price": 336.72, "change_pct": 3.99, "momentum_175d": 22.69, "sector_z_score": 1.09}, {"ticker": "VLO", "price": 240.34, "change_pct": -0.46, "momentum_175d": 53.09, "sector_z_score": 1.08}, {"ticker": "NI", "price": 47.47, "change_pct": -0.69, "momentum_175d": 20.56, "sector_z_score": 1.07}, {"ticker": "LRCX", "price": 318.93, "change_pct": -1.16, "momentum_175d": 118.71, "sector_z_score": 1.06}, {"ticker": "ILMN", "price": 150.17, "change_pct": 3.4, "momentum_175d": 27.35, "sector_z_score": 1.06}, {"ticker": "STZ", "price": 143.72, "change_pct": -2.66, "momentum_175d": 16.17, "sector_z_score": 1.03}, {"ticker": "MCK", "price": 756.47, "change_pct": 0.27, "momentum_175d": 18.05, "sector_z_score": 1.0}, {"ticker": "ON", "price": 124.89, "change_pct": -1.66, "momentum_175d": 103.78, "sector_z_score": 0.99}, {"ticker": "SBUX", "price": 102.1, "change_pct": 0.67, "momentum_175d": 20.02, "sector_z_score": 0.98}, {"ticker": "HAS", "price": 87.99, "change_pct": 0.0, "momentum_175d": 26.62, "sector_z_score": 0.96}, {"ticker": "L", "price": 106.98, "change_pct": -1.88, "momentum_175d": 14.84, "sector_z_score": 0.96}, {"ticker": "CRL", "price": 164.49, "change_pct": 4.95, "momentum_175d": 12.47, "sector_z_score": 0.96}, {"ticker": "BEN", "price": 31.67, "change_pct": 0.0, "momentum_175d": 18.02, "sector_z_score": 0.96}, {"ticker": "CSX", "price": 47.14, "change_pct": 1.14, "momentum_175d": 40.86, "sector_z_score": 0.95}, {"ticker": "NEM", "price": 107.23, "change_pct": -3.7, "momentum_175d": 46.99, "sector_z_score": 0.94}, {"ticker": "CHRW", "price": 176.49, "change_pct": -0.8, "momentum_175d": 42.43, "sector_z_score": 0.91}, {"ticker": "EBAY", "price": 110.36, "change_pct": -4.29, "momentum_175d": 11.75, "sector_z_score": 0.91}, {"ticker": "EA", "price": 200.68, "change_pct": -0.13, "momentum_175d": 18.08, "sector_z_score": 0.9}, {"ticker": "KEYS", "price": 347.65, "change_pct": -2.27, "momentum_175d": 98.32, "sector_z_score": 0.89}, {"ticker": "ABNB", "price": 132.1, "change_pct": -0.44, "momentum_175d": 17.19, "sector_z_score": 0.88}, {"ticker": "KEY", "price": 21.5, "change_pct": -1.24, "momentum_175d": 18.75, "sector_z_score": 0.88}, {"ticker": "JNJ", "price": 231.29, "change_pct": 0.48, "momentum_175d": 28.51, "sector_z_score": 0.86}, {"ticker": "ATO", "price": 176.24, "change_pct": -0.83, "momentum_175d": 13.22, "sector_z_score": 0.86}, {"ticker": "HSIC", "price": 75.67, "change_pct": 2.4, "momentum_175d": 12.19, "sector_z_score": 0.85}, {"ticker": "PNW", "price": 102.8, "change_pct": -0.03, "momentum_175d": 19.51, "sector_z_score": 0.85}, {"ticker": "REGN", "price": 627.74, "change_pct": -1.08, "momentum_175d": 30.33, "sector_z_score": 0.85}, {"ticker": "BMY", "price": 57.52, "change_pct": -0.88, "momentum_175d": 29.19, "sector_z_score": 0.85}, {"ticker": "KLAC", "price": 1957.19, "change_pct": -2.69, "momentum_175d": 92.7, "sector_z_score": 0.85}, {"ticker": "WAB", "price": 260.81, "change_pct": -0.25, "momentum_175d": 42.22, "sector_z_score": 0.82}, {"ticker": "CB", "price": 320.63, "change_pct": -1.48, "momentum_175d": 18.67, "sector_z_score": 0.81}, {"ticker": "TFC", "price": 48.46, "change_pct": -0.45, "momentum_175d": 16.9, "sector_z_score": 0.81}, {"ticker": "RL", "price": 376.23, "change_pct": -1.45, "momentum_175d": 18.27, "sector_z_score": 0.8}, {"ticker": "USB", "price": 54.69, "change_pct": -0.96, "momentum_175d": 17.08, "sector_z_score": 0.79}, {"ticker": "MGM", "price": 41.95, "change_pct": 9.1, "momentum_175d": 13.78, "sector_z_score": 0.79}, {"ticker": "AMGN", "price": 336.06, "change_pct": 0.04, "momentum_175d": 25.72, "sector_z_score": 0.79}, {"ticker": "TRV", "price": 299.94, "change_pct": -1.61, "momentum_175d": 10.77, "sector_z_score": 0.78}, {"ticker": "AMZN", "price": 271.85, "change_pct": 2.47, "momentum_175d": 12.83, "sector_z_score": 0.78}, {"ticker": "IVZ", "price": 27.61, "change_pct": -0.29, "momentum_175d": 15.99, "sector_z_score": 0.76}, {"ticker": "LYB", "price": 67.67, "change_pct": -1.94, "momentum_175d": 40.64, "sector_z_score": 0.75}, {"ticker": "CVS", "price": 92.07, "change_pct": 1.48, "momentum_175d": 9.38, "sector_z_score": 0.74}, {"ticker": "MPWR", "price": 1620.17, "change_pct": -2.57, "momentum_175d": 87.86, "sector_z_score": 0.72}, {"ticker": "TRGP", "price": 263.65, "change_pct": -2.31, "momentum_175d": 49.45, "sector_z_score": 0.72}, {"ticker": "REG", "price": 78.95, "change_pct": -0.05, "momentum_175d": 15.03, "sector_z_score": 0.71}, {"ticker": "UPS", "price": 104.47, "change_pct": 2.45, "momentum_175d": 32.89, "sector_z_score": 0.7}, {"ticker": "CE", "price": 52.93, "change_pct": 1.07, "momentum_175d": 45.61, "sector_z_score": 0.7}, {"ticker": "ETSY", "price": 63.81, "change_pct": -0.81, "momentum_175d": 12.65, "sector_z_score": 0.68}, {"ticker": "FRT", "price": 121.06, "change_pct": 0.75, "momentum_175d": 13.69, "sector_z_score": 0.68}, {"ticker": "TXT", "price": 92.32, "change_pct": -0.39, "momentum_175d": 7.65, "sector_z_score": 0.66}, {"ticker": "FANG", "price": 192.84, "change_pct": -1.17, "momentum_175d": 47.89, "sector_z_score": 0.65}, {"ticker": "TECH", "price": 48.09, "change_pct": 0.25, "momentum_175d": 7.05, "sector_z_score": 0.65}, {"ticker": "TJX", "price": 157.01, "change_pct": -1.23, "momentum_175d": 12.19, "sector_z_score": 0.65}, {"ticker": "DG", "price": 104.33, "change_pct": 0.69, "momentum_175d": 13.97, "sector_z_score": 0.64}, {"ticker": "IRM", "price": 127.01, "change_pct": -1.08, "momentum_175d": 15.07, "sector_z_score": 0.64}, {"ticker": "PEP", "price": 147.74, "change_pct": 1.41, "momentum_175d": 11.63, "sector_z_score": 0.64}, {"ticker": "FITB", "price": 49.89, "change_pct": 0.14, "momentum_175d": 13.91, "sector_z_score": 0.63}, {"ticker": "VZ", "price": 48.24, "change_pct": -0.52, "momentum_175d": 12.77, "sector_z_score": 0.62}, {"ticker": "FOXA", "price": 65.48, "change_pct": 0.8, "momentum_175d": 9.19, "sector_z_score": 0.61}, {"ticker": "PVH", "price": 96.2, "change_pct": 1.89, "momentum_175d": 11.27, "sector_z_score": 0.61}, {"ticker": "DVN", "price": 44.27, "change_pct": -1.93, "momentum_175d": 44.4, "sector_z_score": 0.61}, {"ticker": "EVRG", "price": 84.17, "change_pct": 0.07, "momentum_175d": 15.0, "sector_z_score": 0.61}, {"ticker": "NTRA", "price": 203.11, "change_pct": 1.1, "momentum_175d": 18.72, "sector_z_score": 0.6}, {"ticker": "MTB", "price": 215.1, "change_pct": -0.06, "momentum_175d": 12.52, "sector_z_score": 0.6}, {"ticker": "ZION", "price": 62.32, "change_pct": -0.67, "momentum_175d": 11.45, "sector_z_score": 0.59}, {"ticker": "SPG", "price": 206.77, "change_pct": -0.08, "momentum_175d": 12.17, "sector_z_score": 0.59}, {"ticker": "DELL", "price": 305.32, "change_pct": 0.08, "momentum_175d": 72.21, "sector_z_score": 0.58}, {"ticker": "KDP", "price": 30.1, "change_pct": 1.86, "momentum_175d": 8.01, "sector_z_score": 0.57}, {"ticker": "DLR", "price": 191.71, "change_pct": -1.01, "momentum_175d": 13.84, "sector_z_score": 0.57}, {"ticker": "GRMN", "price": 237.97, "change_pct": -0.23, "momentum_175d": 10.0, "sector_z_score": 0.57}, {"ticker": "ELV", "price": 391.47, "change_pct": 0.93, "momentum_175d": 17.35, "sector_z_score": 0.56}, {"ticker": "YUM", "price": 152.02, "change_pct": -0.81, "momentum_175d": 5.19, "sector_z_score": 0.56}, {"ticker": "AIZ", "price": 252.06, "change_pct": -1.54, "momentum_175d": 12.51, "sector_z_score": 0.56}, {"ticker": "DD", "price": 47.66, "change_pct": -3.64, "momentum_175d": 46.04, "sector_z_score": 0.55}, {"ticker": "FOX", "price": 58.62, "change_pct": 0.93, "momentum_175d": 8.19, "sector_z_score": 0.55}, {"ticker": "CF", "price": 116.34, "change_pct": -2.37, "momentum_175d": 46.49, "sector_z_score": 0.53}, {"ticker": "PNC", "price": 220.8, "change_pct": -0.0, "momentum_175d": 12.02, "sector_z_score": 0.53}, {"ticker": "CZR", "price": 28.78, "change_pct": 1.41, "momentum_175d": 8.22, "sector_z_score": 0.52}, {"ticker": "RVTY", "price": 96.79, "change_pct": -0.04, "momentum_175d": 3.55, "sector_z_score": 0.51}, {"ticker": "F", "price": 15.88, "change_pct": 3.66, "momentum_175d": 9.34, "sector_z_score": 0.5}, {"ticker": "CME", "price": 279.1, "change_pct": -1.22, "momentum_175d": 12.05, "sector_z_score": 0.49}, {"ticker": "FE", "price": 46.78, "change_pct": 0.3, "momentum_175d": 15.63, "sector_z_score": 0.49}, {"ticker": "WY", "price": 24.51, "change_pct": 2.9, "momentum_175d": 2.65, "sector_z_score": 0.47}, {"ticker": "DOV", "price": 213.37, "change_pct": -0.94, "momentum_175d": 32.25, "sector_z_score": 0.47}, {"ticker": "LNT", "price": 73.75, "change_pct": 0.1, "momentum_175d": 13.64, "sector_z_score": 0.46}, {"ticker": "UNP", "price": 279.39, "change_pct": 3.06, "momentum_175d": 25.73, "sector_z_score": 0.46}, {"ticker": "EXPE", "price": 226.56, "change_pct": 1.61, "momentum_175d": 7.85, "sector_z_score": 0.46}, {"ticker": "FCX", "price": 63.63, "change_pct": -1.13, "momentum_175d": 33.81, "sector_z_score": 0.46}, {"ticker": "CPAY", "price": 352.6, "change_pct": 0.86, "momentum_175d": 2.59, "sector_z_score": 0.46}, {"ticker": "IEX", "price": 211.75, "change_pct": 0.29, "momentum_175d": 29.71, "sector_z_score": 0.45}, {"ticker": "ALL", "price": 208.85, "change_pct": -1.87, "momentum_175d": 9.86, "sector_z_score": 0.45}, {"ticker": "MAS", "price": 69.82, "change_pct": 1.34, "momentum_175d": 2.0, "sector_z_score": 0.44}, {"ticker": "NDSN", "price": 288.74, "change_pct": 0.32, "momentum_175d": 26.28, "sector_z_score": 0.43}, {"ticker": "INCY", "price": 97.34, "change_pct": 0.25, "momentum_175d": 15.13, "sector_z_score": 0.42}, {"ticker": "EG", "price": 343.33, "change_pct": -2.52, "momentum_175d": 1.71, "sector_z_score": 0.42}, {"ticker": "DVA", "price": 194.92, "change_pct": -0.33, "momentum_175d": 14.59, "sector_z_score": 0.42}, {"ticker": "PFE", "price": 26.21, "change_pct": 1.39, "momentum_175d": 15.64, "sector_z_score": 0.4}, {"ticker": "BKR", "price": 63.2, "change_pct": -5.29, "momentum_175d": 49.01, "sector_z_score": 0.4}, {"ticker": "MO", "price": 72.11, "change_pct": -0.36, "momentum_175d": 5.31, "sector_z_score": 0.4}, {"ticker": "MTD", "price": 1093.84, "change_pct": -0.68, "momentum_175d": 1.16, "sector_z_score": 0.39}, {"ticker": "CNP", "price": 43.07, "change_pct": 0.33, "momentum_175d": 13.26, "sector_z_score": 0.39}, {"ticker": "HUBB", "price": 484.25, "change_pct": 1.3, "momentum_175d": 27.53, "sector_z_score": 0.38}, {"ticker": "GILD", "price": 133.69, "change_pct": -0.03, "momentum_175d": 14.91, "sector_z_score": 0.37}, {"ticker": "CINF", "price": 162.94, "change_pct": -2.45, "momentum_175d": 8.57, "sector_z_score": 0.37}, {"ticker": "WAT", "price": 342.18, "change_pct": 1.05, "momentum_175d": 0.25, "sector_z_score": 0.36}, {"ticker": "PCAR", "price": 112.26, "change_pct": 0.22, "momentum_175d": 26.84, "sector_z_score": 0.36}, {"ticker": "KIM", "price": 24.42, "change_pct": -0.49, "momentum_175d": 9.49, "sector_z_score": 0.36}, {"ticker": "PH", "price": 856.68, "change_pct": -1.31, "momentum_175d": 28.73, "sector_z_score": 0.36}, {"ticker": "CL", "price": 91.29, "change_pct": 1.6, "momentum_175d": 4.45, "sector_z_score": 0.36}, {"ticker": "CHD", "price": 98.01, "change_pct": 1.39, "momentum_175d": 5.24, "sector_z_score": 0.34}, {"ticker": "LLY", "price": 1082.92, "change_pct": 1.71, "momentum_175d": 16.41, "sector_z_score": 0.34}, {"ticker": "COST", "price": 1003.69, "change_pct": 0.08, "momentum_175d": 4.24, "sector_z_score": 0.34}, {"ticker": "FTV", "price": 59.91, "change_pct": -0.68, "momentum_175d": 27.98, "sector_z_score": 0.34}, {"ticker": "AES", "price": 14.68, "change_pct": 0.07, "momentum_175d": 13.95, "sector_z_score": 0.33}, {"ticker": "HWM", "price": 258.02, "change_pct": -1.48, "momentum_175d": 27.86, "sector_z_score": 0.33}, {"ticker": "GL", "price": 154.39, "change_pct": -1.51, "momentum_175d": 7.44, "sector_z_score": 0.33}, {"ticker": "RF", "price": 28.09, "change_pct": -0.57, "momentum_175d": 7.18, "sector_z_score": 0.33}, {"ticker": "PSA", "price": 306.79, "change_pct": 0.76, "momentum_175d": 8.88, "sector_z_score": 0.33}, {"ticker": "ADI", "price": 416.88, "change_pct": -0.73, "momentum_175d": 61.37, "sector_z_score": 0.32}, {"ticker": "AFL", "price": 114.85, "change_pct": -1.69, "momentum_175d": 6.9, "sector_z_score": 0.31}, {"ticker": "EXPD", "price": 161.51, "change_pct": 0.5, "momentum_175d": 19.89, "sector_z_score": 0.31}, {"ticker": "COO", "price": 60.8, "change_pct": -1.98, "momentum_175d": -1.74, "sector_z_score": 0.31}, {"ticker": "TXN", "price": 317.45, "change_pct": -2.29, "momentum_175d": 53.58, "sector_z_score": 0.29}, {"ticker": "SWK", "price": 79.46, "change_pct": 0.67, "momentum_175d": 3.99, "sector_z_score": 0.28}, {"ticker": "LVS", "price": 51.06, "change_pct": 2.63, "momentum_175d": 3.55, "sector_z_score": 0.28}, {"ticker": "AEE", "price": 111.12, "change_pct": 0.08, "momentum_175d": 12.95, "sector_z_score": 0.28}, {"ticker": "O", "price": 62.19, "change_pct": -0.42, "momentum_175d": 7.54, "sector_z_score": 0.27}, {"ticker": "OMC", "price": 74.85, "change_pct": 0.59, "momentum_175d": 0.88, "sector_z_score": 0.26}, {"ticker": "MTCH", "price": 36.1, "change_pct": 0.42, "momentum_175d": 0.28, "sector_z_score": 0.25}, {"ticker": "TT", "price": 457.68, "change_pct": -0.81, "momentum_175d": 21.03, "sector_z_score": 0.24}, {"ticker": "SRE", "price": 91.26, "change_pct": -0.32, "momentum_175d": 13.28, "sector_z_score": 0.23}, {"ticker": "ULTA", "price": 507.35, "change_pct": -1.68, "momentum_175d": 2.58, "sector_z_score": 0.23}, {"ticker": "BAC", "price": 51.1, "change_pct": -2.11, "momentum_175d": 5.16, "sector_z_score": 0.22}, {"ticker": "AMCR", "price": 39.67, "change_pct": 1.85, "momentum_175d": -4.44, "sector_z_score": 0.22}, {"ticker": "SBAC", "price": 200.2, "change_pct": -0.76, "momentum_175d": 9.9, "sector_z_score": 0.21}, {"ticker": "UHS", "price": 154.29, "change_pct": -1.49, "momentum_175d": -5.14, "sector_z_score": 0.2}, {"ticker": "PM", "price": 182.04, "change_pct": 0.28, "momentum_175d": 2.3, "sector_z_score": 0.2}, {"ticker": "AME", "price": 226.38, "change_pct": -1.33, "momentum_175d": 23.29, "sector_z_score": 0.19}, {"ticker": "DGX", "price": 193.99, "change_pct": 0.58, "momentum_175d": 10.33, "sector_z_score": 0.19}, {"ticker": "ED", "price": 108.01, "change_pct": 0.29, "momentum_175d": 14.02, "sector_z_score": 0.18}, {"ticker": "ARM", "price": 302.71, "change_pct": -5.76, "momentum_175d": 40.31, "sector_z_score": 0.17}, {"ticker": "LKQ", "price": 27.44, "change_pct": 0.7, "momentum_175d": 0.78, "sector_z_score": 0.16}, {"ticker": "SOLV", "price": 75.89, "change_pct": -0.5, "momentum_175d": -4.69, "sector_z_score": 0.16}, {"ticker": "DLTR", "price": 95.87, "change_pct": 2.32, "momentum_175d": 0.76, "sector_z_score": 0.16}, {"ticker": "EW", "price": 86.51, "change_pct": -1.18, "momentum_175d": 9.74, "sector_z_score": 0.15}, {"ticker": "CSCO", "price": 119.67, "change_pct": 1.13, "momentum_175d": 33.92, "sector_z_score": 0.15}, {"ticker": "HSY", "price": 197.82, "change_pct": 3.51, "momentum_175d": 1.94, "sector_z_score": 0.14}, {"ticker": "DE", "price": 529.39, "change_pct": 0.05, "momentum_175d": 22.21, "sector_z_score": 0.14}, {"ticker": "MMM", "price": 155.17, "change_pct": 0.74, "momentum_175d": -6.13, "sector_z_score": 0.13}, {"ticker": "MCHP", "price": 96.85, "change_pct": -1.22, "momentum_175d": 39.53, "sector_z_score": 0.12}, {"ticker": "HCA", "price": 392.15, "change_pct": -0.07, "momentum_175d": 11.09, "sector_z_score": 0.12}, {"ticker": "HOLX", "price": 76.01, "change_pct": 0.0, "momentum_175d": 19.14, "sector_z_score": 0.11}, {"ticker": "CTRA", "price": 32.56, "change_pct": 0.0, "momentum_175d": 41.45, "sector_z_score": 0.11}, {"ticker": "LUV", "price": 43.68, "change_pct": 3.31, "momentum_175d": 22.6, "sector_z_score": 0.1}, {"ticker": "TDY", "price": 612.52, "change_pct": -2.46, "momentum_175d": 17.75, "sector_z_score": 0.08}, {"ticker": "ROK", "price": 456.08, "change_pct": -0.05, "momentum_175d": 18.3, "sector_z_score": 0.08}, {"ticker": "NU", "price": 13.03, "change_pct": 0.39, "momentum_175d": -7.98, "sector_z_score": 0.07}, {"ticker": "DAL", "price": 81.8, "change_pct": 3.04, "momentum_175d": 17.42, "sector_z_score": 0.07}, {"ticker": "MSCI", "price": 603.47, "change_pct": 2.54, "momentum_175d": 3.23, "sector_z_score": 0.06}, {"ticker": "ISRG", "price": 418.55, "change_pct": -4.14, "momentum_175d": 8.53, "sector_z_score": 0.06}, {"ticker": "COP", "price": 115.13, "change_pct": -1.24, "momentum_175d": 34.05, "sector_z_score": 0.04}, {"ticker": "VRSN", "price": 295.65, "change_pct": -3.65, "momentum_175d": -6.33, "sector_z_score": 0.04}, {"ticker": "JPM", "price": 299.28, "change_pct": -2.43, "momentum_175d": 2.35, "sector_z_score": 0.04}, {"ticker": "ZBH", "price": 82.56, "change_pct": -2.19, "momentum_175d": -7.57, "sector_z_score": 0.04}, {"ticker": "MCD", "price": 280.92, "change_pct": 0.59, "momentum_175d": -2.81, "sector_z_score": 0.04}, {"ticker": "NSC", "price": 325.68, "change_pct": 1.71, "momentum_175d": 16.12, "sector_z_score": 0.03}, {"ticker": "DTE", "price": 145.27, "change_pct": 0.45, "momentum_175d": 9.19, "sector_z_score": 0.03}, {"ticker": "VRTX", "price": 437.22, "change_pct": 0.3, "momentum_175d": 8.34, "sector_z_score": 0.02}, {"ticker": "AOS", "price": 58.01, "change_pct": -0.55, "momentum_175d": -10.78, "sector_z_score": 0.02}, {"ticker": "V", "price": 327.61, "change_pct": 0.35, "momentum_175d": -8.3, "sector_z_score": -0.0}, {"ticker": "XOM", "price": 147.9, "change_pct": -1.27, "momentum_175d": 33.94, "sector_z_score": -0.01}, {"ticker": "SYF", "price": 72.09, "change_pct": 0.26, "momentum_175d": 1.44, "sector_z_score": -0.01}, {"ticker": "CMCSA", "price": 25.22, "change_pct": 0.28, "momentum_175d": -6.92, "sector_z_score": -0.01}, {"ticker": "NWS", "price": 30.47, "change_pct": 1.74, "momentum_175d": -6.66, "sector_z_score": -0.02}, {"ticker": "AKAM", "price": 144.43, "change_pct": -2.55, "momentum_175d": 25.46, "sector_z_score": -0.03}, {"ticker": "PPL", "price": 35.84, "change_pct": -0.78, "momentum_175d": 9.39, "sector_z_score": -0.03}, {"ticker": "ETN", "price": 406.37, "change_pct": 0.8, "momentum_175d": 11.63, "sector_z_score": -0.05}, {"ticker": "DRI", "price": 205.93, "change_pct": 1.03, "momentum_175d": -4.15, "sector_z_score": -0.05}, {"ticker": "PHM", "price": 119.1, "change_pct": 1.07, "momentum_175d": -4.31, "sector_z_score": -0.05}, {"ticker": "SNA", "price": 372.13, "change_pct": 0.01, "momentum_175d": 14.74, "sector_z_score": -0.05}, {"ticker": "XEL", "price": 81.0, "change_pct": 0.27, "momentum_175d": 10.36, "sector_z_score": -0.06}, {"ticker": "KR", "price": 64.69, "change_pct": 0.22, "momentum_175d": -1.23, "sector_z_score": -0.06}, {"ticker": "GWW", "price": 1246.03, "change_pct": -0.26, "momentum_175d": 14.85, "sector_z_score": -0.06}, {"ticker": "APH", "price": 140.24, "change_pct": 0.49, "momentum_175d": 25.32, "sector_z_score": -0.06}, {"ticker": "CTVA", "price": 79.89, "change_pct": 1.01, "momentum_175d": 13.9, "sector_z_score": -0.07}, {"ticker": "LHX", "price": 309.05, "change_pct": -1.41, "momentum_175d": 14.55, "sector_z_score": -0.07}, {"ticker": "CBRE", "price": 130.15, "change_pct": 0.3, "momentum_175d": -11.68, "sector_z_score": -0.09}, {"ticker": "NVDA", "price": 212.6, "change_pct": -1.05, "momentum_175d": 21.88, "sector_z_score": -0.09}, {"ticker": "WFC", "price": 76.11, "change_pct": -1.82, "momentum_175d": -0.03, "sector_z_score": -0.09}, {"ticker": "IBM", "price": 255.2, "change_pct": 1.8, "momentum_175d": -10.0, "sector_z_score": -0.09}, {"ticker": "TROW", "price": 104.5, "change_pct": 0.65, "momentum_175d": -0.04, "sector_z_score": -0.09}, {"ticker": "DIS", "price": 104.18, "change_pct": 0.87, "momentum_175d": -10.88, "sector_z_score": -0.09}, {"ticker": "T", "price": 24.89, "change_pct": -0.52, "momentum_175d": -10.97, "sector_z_score": -0.09}, {"ticker": "SEE", "price": 42.15, "change_pct": 0.0, "momentum_175d": 26.46, "sector_z_score": -0.1}, {"ticker": "KVUE", "price": 17.69, "change_pct": 1.14, "momentum_175d": -1.62, "sector_z_score": -0.1}, {"ticker": "XYL", "price": 110.1, "change_pct": -0.93, "momentum_175d": -12.32, "sector_z_score": -0.11}, {"ticker": "EXC", "price": 46.19, "change_pct": 0.35, "momentum_175d": 9.14, "sector_z_score": -0.11}, {"ticker": "WTW", "price": 254.04, "change_pct": -0.9, "momentum_175d": -12.53, "sector_z_score": -0.12}, {"ticker": "SNPS", "price": 525.92, "change_pct": -1.62, "momentum_175d": 18.93, "sector_z_score": -0.12}, {"ticker": "UNH", "price": 384.01, "change_pct": 1.9, "momentum_175d": 3.44, "sector_z_score": -0.13}, {"ticker": "SCHW", "price": 85.61, "change_pct": -4.24, "momentum_175d": -0.84, "sector_z_score": -0.13}, {"ticker": "HPE", "price": 37.2, "change_pct": -2.26, "momentum_175d": 17.27, "sector_z_score": -0.13}, {"ticker": "PGR", "price": 196.91, "change_pct": -0.94, "momentum_175d": -12.47, "sector_z_score": -0.13}, {"ticker": "EMN", "price": 75.91, "change_pct": 2.04, "momentum_175d": 13.48, "sector_z_score": -0.14}, {"ticker": "DHI", "price": 147.81, "change_pct": 1.52, "momentum_175d": -6.86, "sector_z_score": -0.15}, {"ticker": "ESS", "price": 276.83, "change_pct": -0.15, "momentum_175d": 0.04, "sector_z_score": -0.15}, {"ticker": "ES", "price": 69.62, "change_pct": -0.11, "momentum_175d": 8.4, "sector_z_score": -0.16}, {"ticker": "AMP", "price": 443.17, "change_pct": -2.71, "momentum_175d": -1.38, "sector_z_score": -0.16}, {"ticker": "IFF", "price": 77.0, "change_pct": 1.49, "momentum_175d": 12.36, "sector_z_score": -0.16}, {"ticker": "NWSA", "price": 26.61, "change_pct": 1.56, "momentum_175d": -11.27, "sector_z_score": -0.16}, {"ticker": "ALLE", "price": 131.22, "change_pct": -0.3, "momentum_175d": -15.46, "sector_z_score": -0.17}, {"ticker": "AXP", "price": 312.54, "change_pct": 0.59, "momentum_175d": -1.8, "sector_z_score": -0.17}, {"ticker": "BIO", "price": 305.29, "change_pct": 2.83, "momentum_175d": 2.53, "sector_z_score": -0.17}, {"ticker": "BDX", "price": 147.24, "change_pct": -0.35, "momentum_175d": 4.1, "sector_z_score": -0.17}, {"ticker": "MA", "price": 495.04, "change_pct": 0.41, "momentum_175d": -12.73, "sector_z_score": -0.18}, {"ticker": "AVGO", "price": 421.86, "change_pct": -0.04, "momentum_175d": 15.52, "sector_z_score": -0.18}, {"ticker": "AAPL", "price": 310.85, "change_pct": 0.82, "momentum_175d": 13.27, "sector_z_score": -0.19}, {"ticker": "EXR", "price": 144.43, "change_pct": 0.31, "momentum_175d": -0.59, "sector_z_score": -0.19}, {"ticker": "AIG", "price": 75.27, "change_pct": -2.49, "momentum_175d": -2.12, "sector_z_score": -0.2}, {"ticker": "MET", "price": 83.2, "change_pct": -0.08, "momentum_175d": -2.07, "sector_z_score": -0.2}, {"ticker": "NDAQ", "price": 90.53, "change_pct": -0.39, "momentum_175d": -2.02, "sector_z_score": -0.2}, {"ticker": "RTX", "price": 176.59, "change_pct": -1.33, "momentum_175d": 10.28, "sector_z_score": -0.2}, {"ticker": "META", "price": 635.26, "change_pct": 3.74, "momentum_175d": -11.05, "sector_z_score": -0.21}, {"ticker": "LOW", "price": 216.84, "change_pct": 2.24, "momentum_175d": -9.58, "sector_z_score": -0.21}, {"ticker": "PG", "price": 147.49, "change_pct": 3.17, "momentum_175d": -3.31, "sector_z_score": -0.21}, {"ticker": "TSLA", "price": 440.36, "change_pct": 1.56, "momentum_175d": -7.65, "sector_z_score": -0.22}, {"ticker": "EQR", "price": 66.63, "change_pct": 0.76, "momentum_175d": -1.25, "sector_z_score": -0.22}, {"ticker": "MOH", "price": 177.87, "change_pct": 0.95, "momentum_175d": 1.77, "sector_z_score": -0.22}, {"ticker": "SYY", "price": 75.22, "change_pct": -0.13, "momentum_175d": -3.61, "sector_z_score": -0.23}, {"ticker": "CMS", "price": 74.22, "change_pct": 0.03, "momentum_175d": 7.85, "sector_z_score": -0.23}, {"ticker": "EPD", "price": 37.99, "change_pct": -1.07, "momentum_175d": 24.5, "sector_z_score": -0.23}, {"ticker": "SJM", "price": 102.98, "change_pct": 0.65, "momentum_175d": -4.88, "sector_z_score": -0.23}, {"ticker": "NXPI", "price": 329.24, "change_pct": -1.03, "momentum_175d": 9.58, "sector_z_score": -0.24}, {"ticker": "TFX", "price": 130.06, "change_pct": -1.39, "momentum_175d": 7.94, "sector_z_score": -0.24}, {"ticker": "LIN", "price": 507.87, "change_pct": -1.38, "momentum_175d": 7.89, "sector_z_score": -0.24}, {"ticker": "BRK-B", "price": 479.92, "change_pct": -0.77, "momentum_175d": -3.81, "sector_z_score": -0.25}, {"ticker": "TTWO", "price": 218.46, "change_pct": -1.0, "momentum_175d": -13.54, "sector_z_score": -0.25}, {"ticker": "HBAN", "price": 16.03, "change_pct": -0.19, "momentum_175d": -3.59, "sector_z_score": -0.26}, {"ticker": "PSX", "price": 174.63, "change_pct": 0.43, "momentum_175d": 27.2, "sector_z_score": -0.26}, {"ticker": "DECK", "price": 114.37, "change_pct": 2.63, "momentum_175d": -10.02, "sector_z_score": -0.26}, {"ticker": "FTNT", "price": 127.93, "change_pct": -4.5, "momentum_175d": 5.77, "sector_z_score": -0.26}, {"ticker": "APD", "price": 285.73, "change_pct": -1.34, "momentum_175d": 6.56, "sector_z_score": -0.26}, {"ticker": "LMT", "price": 531.14, "change_pct": -0.33, "momentum_175d": 9.87, "sector_z_score": -0.28}, {"ticker": "BA", "price": 224.3, "change_pct": 2.47, "momentum_175d": 7.22, "sector_z_score": -0.28}, {"ticker": "LYV", "price": 166.56, "change_pct": 0.02, "momentum_175d": -9.22, "sector_z_score": -0.28}, {"ticker": "RMD", "price": 206.1, "change_pct": -0.9, "momentum_175d": -17.75, "sector_z_score": -0.29}, {"ticker": "MDLZ", "price": 62.25, "change_pct": 1.65, "momentum_175d": -4.35, "sector_z_score": -0.3}, {"ticker": "BLK", "price": 1070.34, "change_pct": -0.66, "momentum_175d": -4.23, "sector_z_score": -0.3}, {"ticker": "CRWD", "price": 645.36, "change_pct": -3.9, "momentum_175d": 2.21, "sector_z_score": -0.31}, {"ticker": "HON", "price": 231.55, "change_pct": -0.07, "momentum_175d": 7.42, "sector_z_score": -0.31}, {"ticker": "IR", "price": 70.96, "change_pct": -2.03, "momentum_175d": 6.33, "sector_z_score": -0.32}, {"ticker": "DXC", "price": 9.34, "change_pct": 0.97, "momentum_175d": -16.75, "sector_z_score": -0.32}, {"ticker": "OKE", "price": 88.21, "change_pct": -2.47, "momentum_175d": 24.42, "sector_z_score": -0.32}, {"ticker": "OXY", "price": 56.89, "change_pct": -0.99, "momentum_175d": 27.28, "sector_z_score": -0.33}, {"ticker": "CPT", "price": 108.09, "change_pct": 0.32, "momentum_175d": -3.31, "sector_z_score": -0.33}, {"ticker": "WM", "price": 215.59, "change_pct": 0.05, "momentum_175d": 5.48, "sector_z_score": -0.34}, {"ticker": "ZTS", "price": 79.48, "change_pct": -0.93, "momentum_175d": -18.43, "sector_z_score": -0.34}, {"ticker": "EMR", "price": 139.72, "change_pct": -0.89, "momentum_175d": 5.14, "sector_z_score": -0.35}, {"ticker": "MPC", "price": 247.05, "change_pct": -0.4, "momentum_175d": 27.54, "sector_z_score": -0.35}, {"ticker": "TEL", "price": 208.75, "change_pct": 0.07, "momentum_175d": -0.47, "sector_z_score": -0.35}, {"ticker": "QRVO", "price": 103.91, "change_pct": -3.99, "momentum_175d": -0.66, "sector_z_score": -0.35}, {"ticker": "PCG", "price": 16.53, "change_pct": 0.67, "momentum_175d": 7.66, "sector_z_score": -0.36}, {"ticker": "TMO", "price": 456.21, "change_pct": 1.79, "momentum_175d": -1.18, "sector_z_score": -0.36}, {"ticker": "LNC", "price": 35.2, "change_pct": -1.62, "momentum_175d": -5.71, "sector_z_score": -0.37}, {"ticker": "JKHY", "price": 136.26, "change_pct": -0.8, "momentum_175d": -4.02, "sector_z_score": -0.39}, {"ticker": "PPG", "price": 112.88, "change_pct": 3.05, "momentum_175d": 2.11, "sector_z_score": -0.39}, {"ticker": "CMG", "price": 32.69, "change_pct": 1.18, "momentum_175d": -12.8, "sector_z_score": -0.39}, {"ticker": "WYNN", "price": 101.22, "change_pct": 3.42, "momentum_175d": -13.75, "sector_z_score": -0.39}, {"ticker": "ITW", "price": 250.29, "change_pct": -0.05, "momentum_175d": 4.18, "sector_z_score": -0.39}, {"ticker": "CDNS", "price": 374.05, "change_pct": -2.02, "momentum_175d": -4.26, "sector_z_score": -0.4}, {"ticker": "ORLY", "price": 89.02, "change_pct": -0.95, "momentum_175d": -13.48, "sector_z_score": -0.4}, {"ticker": "PKG", "price": 217.99, "change_pct": -0.22, "momentum_175d": 1.55, "sector_z_score": -0.4}, {"ticker": "DDOG", "price": 221.81, "change_pct": -0.82, "momentum_175d": -4.32, "sector_z_score": -0.41}, {"ticker": "SNAP", "price": 5.88, "change_pct": 2.26, "momentum_175d": -18.77, "sector_z_score": -0.41}, {"ticker": "QCOM", "price": 233.4, "change_pct": -6.2, "momentum_175d": -5.72, "sector_z_score": -0.41}, {"ticker": "AVY", "price": 160.52, "change_pct": 0.45, "momentum_175d": 1.13, "sector_z_score": -0.42}, {"ticker": "CCL", "price": 27.98, "change_pct": 4.75, "momentum_175d": -13.91, "sector_z_score": -0.42}, {"ticker": "WRB", "price": 65.29, "change_pct": -3.03, "momentum_175d": -7.37, "sector_z_score": -0.42}, {"ticker": "OKTA", "price": 89.5, "change_pct": -4.59, "momentum_175d": -16.25, "sector_z_score": -0.42}, {"ticker": "UDR", "price": 38.03, "change_pct": 0.0, "momentum_175d": -5.16, "sector_z_score": -0.43}, {"ticker": "NET", "price": 209.22, "change_pct": -3.82, "momentum_175d": -6.04, "sector_z_score": -0.43}, {"ticker": "ICE", "price": 149.71, "change_pct": -0.62, "momentum_175d": -8.05, "sector_z_score": -0.44}, {"ticker": "MLM", "price": 574.39, "change_pct": 2.4, "momentum_175d": 0.04, "sector_z_score": -0.44}, {"ticker": "CARR", "price": 64.51, "change_pct": -0.59, "momentum_175d": 1.92, "sector_z_score": -0.44}, {"ticker": "ECL", "price": 262.58, "change_pct": 3.28, "momentum_175d": -0.23, "sector_z_score": -0.44}, {"ticker": "DUK", "price": 125.35, "change_pct": 0.3, "momentum_175d": 5.65, "sector_z_score": -0.45}, {"ticker": "MSI", "price": 408.71, "change_pct": -0.43, "momentum_175d": -10.0, "sector_z_score": -0.45}, {"ticker": "URI", "price": 988.24, "change_pct": 2.63, "momentum_175d": 1.7, "sector_z_score": -0.45}, {"ticker": "VMC", "price": 275.65, "change_pct": 2.49, "momentum_175d": -0.56, "sector_z_score": -0.45}, {"ticker": "LH", "price": 258.25, "change_pct": -0.08, "momentum_175d": -3.85, "sector_z_score": -0.45}, {"ticker": "FFIV", "price": 388.15, "change_pct": -2.23, "momentum_175d": -8.14, "sector_z_score": -0.45}, {"ticker": "INVH", "price": 29.41, "change_pct": 0.03, "momentum_175d": -5.07, "sector_z_score": -0.46}, {"ticker": "PRU", "price": 101.49, "change_pct": -1.1, "momentum_175d": -6.91, "sector_z_score": -0.46}, {"ticker": "CDW", "price": 114.19, "change_pct": 5.16, "momentum_175d": -17.63, "sector_z_score": -0.47}, {"ticker": "D", "price": 67.2, "change_pct": -0.12, "momentum_175d": 5.45, "sector_z_score": -0.47}, {"ticker": "DHR", "price": 173.13, "change_pct": 0.19, "momentum_175d": -3.69, "sector_z_score": -0.47}, {"ticker": "SHOP", "price": 106.6, "change_pct": 1.62, "momentum_175d": -16.0, "sector_z_score": -0.48}, {"ticker": "NTAP", "price": 142.74, "change_pct": 2.73, "momentum_175d": -11.4, "sector_z_score": -0.48}, {"ticker": "PANW", "price": 248.47, "change_pct": -3.22, "momentum_175d": -9.13, "sector_z_score": -0.48}, {"ticker": "NOC", "price": 551.34, "change_pct": -0.98, "momentum_175d": 0.86, "sector_z_score": -0.49}, {"ticker": "WEC", "price": 113.14, "change_pct": 0.13, "momentum_175d": 5.46, "sector_z_score": -0.5}, {"ticker": "RJF", "price": 145.4, "change_pct": -4.42, "momentum_175d": -7.37, "sector_z_score": -0.5}, {"ticker": "SWKS", "price": 78.68, "change_pct": -5.68, "momentum_175d": -12.75, "sector_z_score": -0.5}, {"ticker": "CI", "price": 285.75, "change_pct": 1.75, "momentum_175d": -3.84, "sector_z_score": -0.5}, {"ticker": "TMUS", "price": 190.81, "change_pct": -0.16, "momentum_175d": -23.03, "sector_z_score": -0.51}, {"ticker": "BBWI", "price": 19.45, "change_pct": 9.7, "momentum_175d": -26.71, "sector_z_score": -0.51}, {"ticker": "TRMB", "price": 54.88, "change_pct": -2.59, "momentum_175d": -17.08, "sector_z_score": -0.51}, {"ticker": "AZO", "price": 3027.48, "change_pct": -2.34, "momentum_175d": -15.85, "sector_z_score": -0.51}, {"ticker": "MSFT", "price": 412.67, "change_pct": -0.81, "momentum_175d": -17.23, "sector_z_score": -0.52}, {"ticker": "ROL", "price": 50.38, "change_pct": -5.23, "momentum_175d": -0.2, "sector_z_score": -0.52}, {"ticker": "DOC", "price": 19.87, "change_pct": -0.8, "momentum_175d": -6.95, "sector_z_score": -0.52}, {"ticker": "GE", "price": 317.21, "change_pct": 0.86, "momentum_175d": -0.39, "sector_z_score": -0.53}, {"ticker": "AMT", "price": 184.98, "change_pct": 0.02, "momentum_175d": -6.31, "sector_z_score": -0.53}, {"ticker": "FBIN", "price": 39.45, "change_pct": 2.73, "momentum_175d": -27.59, "sector_z_score": -0.54}, {"ticker": "GPN", "price": 73.46, "change_pct": 0.25, "momentum_175d": -18.29, "sector_z_score": -0.54}, {"ticker": "CTSH", "price": 53.16, "change_pct": 2.61, "momentum_175d": -19.6, "sector_z_score": -0.54}, {"ticker": "MAA", "price": 130.58, "change_pct": 0.03, "momentum_175d": -7.66, "sector_z_score": -0.55}, {"ticker": "AVB", "price": 186.23, "change_pct": 0.62, "momentum_175d": -6.9, "sector_z_score": -0.55}, {"ticker": "ERIE", "price": 220.71, "change_pct": -1.06, "momentum_175d": -27.05, "sector_z_score": -0.56}, {"ticker": "PLTR", "price": 132.51, "change_pct": -2.99, "momentum_175d": -16.42, "sector_z_score": -0.56}, {"ticker": "WMB", "price": 74.37, "change_pct": -2.58, "momentum_175d": 24.52, "sector_z_score": -0.56}, {"ticker": "SHW", "price": 309.97, "change_pct": -0.41, "momentum_175d": -5.45, "sector_z_score": -0.57}, {"ticker": "MCO", "price": 451.56, "change_pct": 0.1, "momentum_175d": -9.06, "sector_z_score": -0.57}, {"ticker": "MKTX", "price": 130.94, "change_pct": -0.22, "momentum_175d": -11.08, "sector_z_score": -0.57}, {"ticker": "MELI", "price": 1696.17, "change_pct": 2.92, "momentum_175d": -21.26, "sector_z_score": -0.58}, {"ticker": "HRL", "price": 20.96, "change_pct": 0.34, "momentum_175d": -9.71, "sector_z_score": -0.59}, {"ticker": "NFLX", "price": 87.35, "change_pct": -0.38, "momentum_175d": -24.0, "sector_z_score": -0.59}, {"ticker": "BBY", "price": 64.54, "change_pct": 2.09, "momentum_175d": -17.16, "sector_z_score": -0.59}, {"ticker": "ACN", "price": 176.36, "change_pct": -0.36, "momentum_175d": -24.97, "sector_z_score": -0.6}, {"ticker": "ABBV", "price": 215.4, "change_pct": 1.07, "momentum_175d": -7.14, "sector_z_score": -0.6}, {"ticker": "PYPL", "price": 43.76, "change_pct": -0.91, "momentum_175d": -25.44, "sector_z_score": -0.6}, {"ticker": "CVX", "price": 182.4, "change_pct": -1.25, "momentum_175d": 19.94, "sector_z_score": -0.61}, {"ticker": "GD", "price": 342.69, "change_pct": -0.57, "momentum_175d": -3.16, "sector_z_score": -0.61}, {"ticker": "APO", "price": 130.27, "change_pct": 0.28, "momentum_175d": -10.23, "sector_z_score": -0.61}, {"ticker": "TAP", "price": 41.87, "change_pct": 1.55, "momentum_175d": -9.08, "sector_z_score": -0.61}, {"ticker": "GPC", "price": 98.4, "change_pct": 1.39, "momentum_175d": -22.04, "sector_z_score": -0.62}, {"ticker": "CRM", "price": 177.51, "change_pct": -0.88, "momentum_175d": -25.27, "sector_z_score": -0.62}, {"ticker": "APP", "price": 567.83, "change_pct": 10.42, "momentum_175d": -22.4, "sector_z_score": -0.63}, {"ticker": "BILL", "price": 34.7, "change_pct": -0.57, "momentum_175d": -27.2, "sector_z_score": -0.63}, {"ticker": "NVR", "price": 6098.08, "change_pct": 1.08, "momentum_175d": -21.69, "sector_z_score": -0.63}, {"ticker": "FIS", "price": 42.02, "change_pct": -0.47, "momentum_175d": -30.86, "sector_z_score": -0.64}, {"ticker": "HD", "price": 317.85, "change_pct": 2.35, "momentum_175d": -20.35, "sector_z_score": -0.64}, {"ticker": "MDT", "price": 75.98, "change_pct": -2.09, "momentum_175d": -9.18, "sector_z_score": -0.64}, {"ticker": "RCL", "price": 275.17, "change_pct": 2.79, "momentum_175d": -20.57, "sector_z_score": -0.65}, {"ticker": "AON", "price": 318.54, "change_pct": -0.23, "momentum_175d": -11.0, "sector_z_score": -0.65}, {"ticker": "ADSK", "price": 237.0, "change_pct": -0.52, "momentum_175d": -26.8, "sector_z_score": -0.65}, {"ticker": "CCI", "price": 90.87, "change_pct": 0.25, "momentum_175d": -8.64, "sector_z_score": -0.66}, {"ticker": "EOG", "price": 134.3, "change_pct": -1.4, "momentum_175d": 16.42, "sector_z_score": -0.66}, {"ticker": "HPQ", "price": 25.49, "change_pct": 4.34, "momentum_175d": -26.78, "sector_z_score": -0.66}, {"ticker": "SO", "price": 93.74, "change_pct": -0.37, "momentum_175d": 3.26, "sector_z_score": -0.67}, {"ticker": "FAST", "price": 44.82, "change_pct": 0.83, "momentum_175d": -4.17, "sector_z_score": -0.67}, {"ticker": "ADBE", "price": 238.24, "change_pct": -0.94, "momentum_175d": -31.05, "sector_z_score": -0.68}, {"ticker": "ZBRA", "price": 252.51, "change_pct": 0.03, "momentum_175d": -31.13, "sector_z_score": -0.68}, {"ticker": "ADP", "price": 217.65, "change_pct": -0.32, "momentum_175d": -31.19, "sector_z_score": -0.68}, {"ticker": "GEHC", "price": 63.88, "change_pct": -0.47, "momentum_175d": -9.24, "sector_z_score": -0.7}, {"ticker": "COF", "price": 188.8, "change_pct": 1.28, "momentum_175d": -13.66, "sector_z_score": -0.7}, {"ticker": "BKNG", "price": 168.37, "change_pct": 3.1, "momentum_175d": -19.84, "sector_z_score": -0.7}, {"ticker": "PTC", "price": 142.26, "change_pct": -1.81, "momentum_175d": -33.18, "sector_z_score": -0.72}, {"ticker": "TYL", "price": 302.55, "change_pct": -1.57, "momentum_175d": -37.42, "sector_z_score": -0.72}, {"ticker": "VICI", "price": 28.63, "change_pct": 0.03, "momentum_175d": -9.97, "sector_z_score": -0.73}, {"ticker": "GRAB", "price": 3.64, "change_pct": 1.39, "momentum_175d": -36.64, "sector_z_score": -0.74}, {"ticker": "EL", "price": 91.2, "change_pct": 5.31, "momentum_175d": -10.92, "sector_z_score": -0.74}, {"ticker": "BR", "price": 147.1, "change_pct": 0.1, "momentum_175d": -36.79, "sector_z_score": -0.74}, {"ticker": "SMCI", "price": 38.19, "change_pct": 2.94, "momentum_175d": -38.63, "sector_z_score": -0.75}, {"ticker": "SNOW", "price": 175.26, "change_pct": -1.32, "momentum_175d": -36.11, "sector_z_score": -0.76}, {"ticker": "SYK", "price": 305.94, "change_pct": -2.26, "momentum_175d": -12.1, "sector_z_score": -0.77}, {"ticker": "MHK", "price": 105.98, "change_pct": 2.1, "momentum_175d": -21.51, "sector_z_score": -0.77}, {"ticker": "RSG", "price": 205.6, "change_pct": -0.7, "momentum_175d": -8.88, "sector_z_score": -0.78}, {"ticker": "IDXX", "price": 550.99, "change_pct": -1.12, "momentum_175d": -10.72, "sector_z_score": -0.78}, {"ticker": "INTU", "price": 307.73, "change_pct": 1.11, "momentum_175d": -39.73, "sector_z_score": -0.79}, {"ticker": "TDG", "price": 1240.91, "change_pct": 1.22, "momentum_175d": -10.07, "sector_z_score": -0.8}, {"ticker": "EQT", "price": 55.17, "change_pct": -1.85, "momentum_175d": 18.01, "sector_z_score": -0.8}, {"ticker": "ORCL", "price": 190.96, "change_pct": -1.09, "momentum_175d": -42.3, "sector_z_score": -0.8}, {"ticker": "VRSK", "price": 171.5, "change_pct": -0.05, "momentum_175d": -31.12, "sector_z_score": -0.81}, {"ticker": "KMI", "price": 32.22, "change_pct": -1.98, "momentum_175d": 15.51, "sector_z_score": -0.82}, {"ticker": "NWL", "price": 3.66, "change_pct": 1.67, "momentum_175d": -25.87, "sector_z_score": -0.82}, {"ticker": "STE", "price": 212.87, "change_pct": -1.57, "momentum_175d": -10.11, "sector_z_score": -0.82}, {"ticker": "IT", "price": 159.97, "change_pct": 1.32, "momentum_175d": -39.74, "sector_z_score": -0.83}, {"ticker": "UBER", "price": 70.73, "change_pct": 0.87, "momentum_175d": -22.84, "sector_z_score": -0.83}, {"ticker": "TOST", "price": 24.5, "change_pct": 5.06, "momentum_175d": -28.77, "sector_z_score": -0.84}, {"ticker": "UAL", "price": 112.62, "change_pct": 6.33, "momentum_175d": -12.1, "sector_z_score": -0.84}, {"ticker": "DPZ", "price": 311.72, "change_pct": 0.42, "momentum_175d": -24.8, "sector_z_score": -0.85}, {"ticker": "KHC", "price": 24.38, "change_pct": 2.22, "momentum_175d": -11.66, "sector_z_score": -0.85}, {"ticker": "NCLH", "price": 18.15, "change_pct": 6.14, "momentum_175d": -30.07, "sector_z_score": -0.85}, {"ticker": "PAYX", "price": 94.43, "change_pct": -0.39, "momentum_175d": -30.48, "sector_z_score": -0.87}, {"ticker": "IQV", "price": 165.62, "change_pct": 2.23, "momentum_175d": -11.9, "sector_z_score": -0.88}, {"ticker": "OTIS", "price": 71.79, "change_pct": -1.29, "momentum_175d": -12.75, "sector_z_score": -0.89}, {"ticker": "VLTO", "price": 84.46, "change_pct": -1.85, "momentum_175d": -18.84, "sector_z_score": -0.9}, {"ticker": "MKC", "price": 47.55, "change_pct": 1.56, "momentum_175d": -21.82, "sector_z_score": -0.91}, {"ticker": "ET", "price": 19.33, "change_pct": -1.38, "momentum_175d": 12.87, "sector_z_score": -0.91}, {"ticker": "SPOT", "price": 512.83, "change_pct": -3.19, "momentum_175d": -29.48, "sector_z_score": -0.91}, {"ticker": "PNR", "price": 72.45, "change_pct": -1.48, "momentum_175d": -15.96, "sector_z_score": -0.93}, {"ticker": "CTAS", "price": 169.86, "change_pct": -0.72, "momentum_175d": -12.44, "sector_z_score": -0.93}, {"ticker": "TSCO", "price": 30.67, "change_pct": 3.76, "momentum_175d": -39.63, "sector_z_score": -0.95}, {"ticker": "NOW", "price": 102.12, "change_pct": 2.2, "momentum_175d": -52.27, "sector_z_score": -0.96}, {"ticker": "EFX", "price": 163.69, "change_pct": 0.54, "momentum_175d": -33.26, "sector_z_score": -0.98}, {"ticker": "J", "price": 115.9, "change_pct": 0.04, "momentum_175d": -13.83, "sector_z_score": -0.98}, {"ticker": "FISV", "price": 55.62, "change_pct": 0.02, "momentum_175d": -53.81, "sector_z_score": -0.98}, {"ticker": "DXCM", "price": 70.26, "change_pct": -2.43, "momentum_175d": -18.75, "sector_z_score": -0.99}, {"ticker": "ZS", "price": 126.41, "change_pct": -31.52, "momentum_175d": -53.05, "sector_z_score": -1.01}, {"ticker": "IP", "price": 32.42, "change_pct": 1.44, "momentum_175d": -26.74, "sector_z_score": -1.01}, {"ticker": "DASH", "price": 157.58, "change_pct": 2.32, "momentum_175d": -32.56, "sector_z_score": -1.02}, {"ticker": "LEN", "price": 90.96, "change_pct": 1.87, "momentum_175d": -29.31, "sector_z_score": -1.02}, {"ticker": "CHTR", "price": 147.18, "change_pct": 2.21, "momentum_175d": -33.03, "sector_z_score": -1.05}, {"ticker": "MPLX", "price": 55.71, "change_pct": -1.35, "momentum_175d": 11.03, "sector_z_score": -1.07}, {"ticker": "SPGI", "price": 415.8, "change_pct": 0.8, "momentum_175d": -19.28, "sector_z_score": -1.08}, {"ticker": "NKE", "price": 45.98, "change_pct": 2.31, "momentum_175d": -37.38, "sector_z_score": -1.09}, {"ticker": "LW", "price": 42.77, "change_pct": 1.54, "momentum_175d": -21.66, "sector_z_score": -1.09}, {"ticker": "LDOS", "price": 130.62, "change_pct": 1.95, "momentum_175d": -20.69, "sector_z_score": -1.1}, {"ticker": "PEG", "price": 79.82, "change_pct": -0.31, "momentum_175d": -1.77, "sector_z_score": -1.12}, {"ticker": "POOL", "price": 184.41, "change_pct": 1.13, "momentum_175d": -29.88, "sector_z_score": -1.17}, {"ticker": "ABT", "price": 85.68, "change_pct": -1.14, "momentum_175d": -28.22, "sector_z_score": -1.18}, {"ticker": "TTD", "price": 22.29, "change_pct": 0.5, "momentum_175d": -49.19, "sector_z_score": -1.19}, {"ticker": "AWK", "price": 123.78, "change_pct": -0.06, "momentum_175d": -2.81, "sector_z_score": -1.19}, {"ticker": "CLX", "price": 97.11, "change_pct": 0.91, "momentum_175d": -18.58, "sector_z_score": -1.19}, {"ticker": "BRO", "price": 56.81, "change_pct": -0.32, "momentum_175d": -26.92, "sector_z_score": -1.21}, {"ticker": "LYFT", "price": 13.7, "change_pct": 0.88, "momentum_175d": -29.11, "sector_z_score": -1.21}, {"ticker": "CAG", "price": 13.33, "change_pct": 1.37, "momentum_175d": -21.29, "sector_z_score": -1.22}, {"ticker": "VEEV", "price": 158.49, "change_pct": -0.03, "momentum_175d": -41.92, "sector_z_score": -1.22}, {"ticker": "RHI", "price": 27.13, "change_pct": 0.48, "momentum_175d": -21.63, "sector_z_score": -1.22}, {"ticker": "AJG", "price": 202.85, "change_pct": -0.54, "momentum_175d": -25.26, "sector_z_score": -1.22}, {"ticker": "NRG", "price": 138.0, "change_pct": -1.73, "momentum_175d": -3.02, "sector_z_score": -1.23}, {"ticker": "CG", "price": 45.66, "change_pct": 0.02, "momentum_175d": -27.62, "sector_z_score": -1.24}, {"ticker": "BAX", "price": 19.33, "change_pct": -0.26, "momentum_175d": -22.23, "sector_z_score": -1.28}, {"ticker": "WHR", "price": 44.36, "change_pct": 3.98, "momentum_175d": -36.35, "sector_z_score": -1.3}, {"ticker": "CEG", "price": 288.68, "change_pct": -4.27, "momentum_175d": -4.38, "sector_z_score": -1.35}, {"ticker": "HUM", "price": 306.27, "change_pct": 1.52, "momentum_175d": -17.83, "sector_z_score": -1.35}, {"ticker": "PINS", "price": 20.03, "change_pct": 3.62, "momentum_175d": -43.93, "sector_z_score": -1.38}, {"ticker": "U", "price": 27.76, "change_pct": 3.7, "momentum_175d": -42.75, "sector_z_score": -1.43}, {"ticker": "ALK", "price": 45.97, "change_pct": 4.98, "momentum_175d": -31.61, "sector_z_score": -1.44}, {"ticker": "KMB", "price": 100.18, "change_pct": 1.43, "momentum_175d": -19.76, "sector_z_score": -1.45}, {"ticker": "PAYC", "price": 132.28, "change_pct": -0.41, "momentum_175d": -42.93, "sector_z_score": -1.48}, {"ticker": "GDDY", "price": 87.37, "change_pct": -1.82, "momentum_175d": -42.04, "sector_z_score": -1.49}, {"ticker": "HOOD", "price": 76.23, "change_pct": 2.89, "momentum_175d": -26.89, "sector_z_score": -1.51}, {"ticker": "BXP", "price": 60.72, "change_pct": 0.18, "momentum_175d": -22.91, "sector_z_score": -1.52}, {"ticker": "CPRT", "price": 32.85, "change_pct": -1.17, "momentum_175d": -30.27, "sector_z_score": -1.53}, {"ticker": "KKR", "price": 95.03, "change_pct": 0.04, "momentum_175d": -30.15, "sector_z_score": -1.54}, {"ticker": "GIS", "price": 33.65, "change_pct": 1.48, "momentum_175d": -26.03, "sector_z_score": -1.55}, {"ticker": "BX", "price": 118.0, "change_pct": -0.1, "momentum_175d": -33.16, "sector_z_score": -1.58}, {"ticker": "SOFI", "price": 16.17, "change_pct": 1.19, "momentum_175d": -32.2, "sector_z_score": -1.59}, {"ticker": "WDAY", "price": 124.5, "change_pct": 0.39, "momentum_175d": -47.1, "sector_z_score": -1.59}, {"ticker": "ROP", "price": 316.62, "change_pct": -1.15, "momentum_175d": -29.8, "sector_z_score": -1.62}, {"ticker": "KMX", "price": 42.26, "change_pct": 3.99, "momentum_175d": -36.83, "sector_z_score": -1.62}, {"ticker": "RBLX", "price": 45.63, "change_pct": -0.8, "momentum_175d": -58.09, "sector_z_score": -1.64}, {"ticker": "SE", "price": 93.46, "change_pct": 4.99, "momentum_175d": -55.11, "sector_z_score": -1.78}, {"ticker": "PODD", "price": 146.01, "change_pct": -5.07, "momentum_175d": -44.66, "sector_z_score": -1.81}, {"ticker": "TEAM", "price": 89.07, "change_pct": 4.89, "momentum_175d": -60.19, "sector_z_score": -1.82}, {"ticker": "CSGP", "price": 32.32, "change_pct": -0.62, "momentum_175d": -59.27, "sector_z_score": -1.87}, {"ticker": "VNO", "price": 33.31, "change_pct": 1.87, "momentum_175d": -27.45, "sector_z_score": -1.93}, {"ticker": "FMC", "price": 13.51, "change_pct": 4.08, "momentum_175d": -57.49, "sector_z_score": -1.97}, {"ticker": "FDS", "price": 235.73, "change_pct": 2.08, "momentum_175d": -33.98, "sector_z_score": -2.0}, {"ticker": "COIN", "price": 173.78, "change_pct": -3.46, "momentum_175d": -39.86, "sector_z_score": -2.01}, {"ticker": "AXON", "price": 391.32, "change_pct": 1.56, "momentum_175d": -47.08, "sector_z_score": -2.05}, {"ticker": "BSX", "price": 50.46, "change_pct": -12.46, "momentum_175d": -39.97, "sector_z_score": -2.06}, {"ticker": "DKNG", "price": 25.07, "change_pct": 5.29, "momentum_175d": -45.06, "sector_z_score": -2.07}, {"ticker": "CPB", "price": 20.5, "change_pct": 1.84, "momentum_175d": -34.62, "sector_z_score": -2.15}, {"ticker": "MNDY", "price": 76.42, "change_pct": -0.53, "momentum_175d": -64.85, "sector_z_score": -2.16}, {"ticker": "HUBS", "price": 200.72, "change_pct": 1.38, "momentum_175d": -55.71, "sector_z_score": -2.16}, {"ticker": "ARES", "price": 126.58, "change_pct": 1.04, "momentum_175d": -35.99, "sector_z_score": -2.17}, {"ticker": "LCID", "price": 6.26, "change_pct": 4.86, "momentum_175d": -70.11, "sector_z_score": -2.35}, {"ticker": "MOS", "price": 23.72, "change_pct": 4.86, "momentum_175d": -30.6, "sector_z_score": -2.51}, {"ticker": "ARE", "price": 49.93, "change_pct": 3.01, "momentum_175d": -44.25, "sector_z_score": -2.56}, {"ticker": "VST", "price": 160.15, "change_pct": -2.68, "momentum_175d": -21.68, "sector_z_score": -3.03}], "last_updated": "2026-05-28"}

backend/strategy_signals.py

@@ -0,0 +1,183 @@
+# -*- coding: utf-8 -*-
+"""
+Strategy Live Signal API
+===================================
+Endpoint for the frontend to retrieve live, execution-ready Strategy Momentum signals.
+- Uses 175/21-day Momentum
+- Applies Soft-Sector Z-Score Filtering
+- Returns the final Top 15 correlated-sized portfolio.
+"""
+import numpy as np, pandas as pd, yfinance as yf
+import warnings; warnings.filterwarnings("ignore")
+import json
+
+# Import the shared robust universe
+try:
+    from backend.alpaca_executor import UNIVERSE
+except ImportError:
+    UNIVERSE = ["AAPL", "MSFT", "GOOGL", "AMZN", "META", "NVDA", "TSLA", "JPM", "V", "JNJ"]
+    
+# Import sector maps
+try:
+    from backtesting.strategies.v36_engine import SECTOR_MAP, SECTORS
+except ImportError:
+    SECTOR_MAP = {}
+    SECTORS = []
+
+import os, time
+
+# Define cache file and TTL (e.g., 24 hours = 86400 seconds)
+CACHE_FILE = os.path.join(os.path.dirname(__file__), "strategy_cache.json")
+CACHE_TTL = 86400
+
+def get_strategy_live_signals():
+    """Compute and return live Strategy signals."""
+    # Check cache first
+    if os.path.exists(CACHE_FILE):
+        if time.time() - os.path.getmtime(CACHE_FILE) < CACHE_TTL:
+            try:
+                with open(CACHE_FILE, "r") as f:
+                    return json.load(f)
+            except Exception as e:
+                print(f"Cache read error: {e}")
+                pass
+
+    end = pd.Timestamp.now()
+    # Need 175 trading days (~250 calendar days), pull 300 to be safe
+    start = end - pd.Timedelta(days=300)
+    
+    tickers = list(set(UNIVERSE + ["SPY"]))
+    raw = yf.download(tickers, start=str(start.date()), end=str(end.date()), progress=False)
+    
+    lvl0 = raw.columns.get_level_values(0).unique().tolist() if isinstance(raw.columns, pd.MultiIndex) else []
+    dc = raw["Close"] if "Close" in lvl0 else raw
+    if isinstance(dc.columns, pd.MultiIndex):
+        dc.columns = dc.columns.get_level_values(-1)
+    dc = dc.ffill().dropna(how="all")
+    
+    spy = dc["SPY"]
+    if "SPY" in dc.columns:
+        dc = dc.drop(columns=["SPY"])
+        
+    valid_universe = [t for t in UNIVERSE if t in dc.columns and dc[t].notna().sum() > 175]
+    
+    # 1. Regime Check (200-day SMA)
+    if len(spy) < 200:
+        spy_raw = yf.download("SPY", period="1y", progress=False)["Close"]
+        if isinstance(spy_raw, pd.DataFrame): spy_raw = spy_raw["SPY"]
+        spy_full = spy_raw.ffill().dropna()
+        sma200 = spy_full.rolling(200).mean()
+        current_spy = float(spy_full.iloc[-1])
+        current_sma = float(sma200.iloc[-1])
+    else:
+        sma200 = spy.rolling(200).mean()
+        current_spy = float(spy.iloc[-1])
+        current_sma = float(sma200.iloc[-1])
+        
+    is_risk_on = current_spy > current_sma
+    
+    # 2. Strategy Momentum (175 days skipping last 21)
+    if len(dc) < 176:
+        m175 = (dc.shift(min(21, len(dc)-2)) / dc.shift(len(dc)-1)) - 1
+    else:
+        m175 = (dc.shift(21) / dc.shift(175)) - 1
+        
+    latest_mom = m175.iloc[-1].dropna()
+    
+    # Calculate Consistency (63-day win rate)
+    daily_ret = dc.pct_change()
+    consistency = daily_ret.gt(0).where(daily_ret.notna()).rolling(63).mean()
+    latest_cons = consistency.iloc[-1].dropna()
+    
+    # V68 Soft Logic: Composite Score = Momentum * Consistency
+    valid_tks = [t for t in valid_universe if t in latest_mom.index and t in latest_cons.index]
+    comp_scores = latest_mom[valid_tks] * latest_cons[valid_tks]
+    
+    # 3. Soft-Sector Neutrality (Z-Scores)
+    z_scores = pd.Series(index=comp_scores.index, dtype=float)
+    if SECTORS:
+        for sector in SECTORS:
+            sector_tks = [t for t in comp_scores.index if SECTOR_MAP.get(t) == sector]
+            if len(sector_tks) > 1:
+                mu = comp_scores[sector_tks].mean()
+                sigma = comp_scores[sector_tks].std()
+                if sigma < 1e-8: sigma = 1e-8
+                z_scores[sector_tks] = (comp_scores[sector_tks] - mu) / sigma
+            elif len(sector_tks) == 1:
+                z_scores[sector_tks[0]] = 0.0
+                
+        unmapped_tks = [t for t in comp_scores.index if t not in SECTOR_MAP]
+        if len(unmapped_tks) > 1:
+            mu = comp_scores[unmapped_tks].mean()
+            sigma = comp_scores[unmapped_tks].std()
+            if sigma < 1e-8: sigma = 1e-8
+            z_scores[unmapped_tks] = (comp_scores[unmapped_tks] - mu) / sigma
+        elif len(unmapped_tks) == 1:
+            z_scores[unmapped_tks[0]] = 0.0
+    else:
+        # Fallback if no sector map available: Global Z-Score
+        mu = comp_scores.mean()
+        sigma = comp_scores.std()
+        z_scores = (comp_scores - mu) / sigma
+
+    z_scores = z_scores.dropna().sort_values(ascending=False)
+    top15 = z_scores.head(15)
+    
+    # 4. Format Output
+    picks = []
+    all_universe = []
+    
+    for ticker in z_scores.index:
+        try:
+            price = float(dc[ticker].iloc[-1])
+            prev = float(dc[ticker].iloc[-2])
+            change = ((price - prev) / prev) * 100
+            mom_val = float(latest_mom[ticker])
+            z_val = float(z_scores[ticker])
+            
+            data = {
+                "ticker": ticker,
+                "price": round(price, 2),
+                "change_pct": round(change, 2),
+                "momentum_175d": round(mom_val * 100, 2),
+                "sector_z_score": round(z_val, 2)
+            }
+            all_universe.append(data)
+            
+            if ticker in top15.index:
+                picks.append(data)
+        except:
+            pass
+            
+    # Vol scalar estimate (using SPY as proxy)
+    spy_rets = spy.pct_change().dropna().tail(60)
+    rvol = float(spy_rets.std() * np.sqrt(252))
+    vol_scalar = min(max(0.18 / (rvol + 1e-8), 0.05), 1.0)
+    if not is_risk_on:
+        vol_scalar *= 0.50
+        
+    result = {
+        "engine": "Strategy",
+        "regime": "RISK-ON" if is_risk_on else "RISK-OFF",
+        "spy_price": round(current_spy, 2),
+        "sma200": round(current_sma, 2),
+        "vol_scalar": round(vol_scalar, 3),
+        "realized_vol": round(rvol * 100, 1),
+        "target_vol": 18.0,
+        "picks": picks,
+        "all_universe": all_universe,
+        "last_updated": str(end.date())
+    }
+    
+    # Save to cache
+    try:
+        with open(CACHE_FILE, "w") as f:
+            json.dump(result, f)
+    except Exception as e:
+        print(f"Cache write error: {e}")
+        pass
+        
+    return result
+
+if __name__ == "__main__":
+    print(json.dumps(get_strategy_live_signals(), indent=2))

backend/worker.py

@@ -0,0 +1,512 @@
+"""
+Standalone Midnight Supabase Caching Worker (Triggered via GitHub Actions)
+
+This script is INTENTIONALLY self-contained. It does NOT import backend.app
+because that would trigger the entire Flask/TensorFlow/FinBERT stack which
+is too heavy for CI runners. Instead, it inlines only the lightweight
+scraping logic (yfinance + cross-sectional math) and pushes directly to Supabase.
+
+Tasks:
+  1. Market Movers — yfinance 2-day download for 140 movers
+  2. General News  — GNews API (if key is set)
+  3. S&P 500 Screener — yfinance 90-day download, cross-sectional alpha, earnings proximity
+"""
+import os
+import sys
+import time
+import json
+import requests
+import numpy as np
+import pandas as pd
+import yfinance as yf
+from datetime import datetime, timedelta
+from dotenv import load_dotenv
+
+# Load .env for local testing (CI uses GitHub Secrets)
+load_dotenv()
+
+# --- Direct Supabase Client (avoids importing backend.database which chains to app.py) ---
+from supabase import create_client
+
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY")
+
+if not SUPABASE_URL or not SUPABASE_KEY:
+    print("FATAL: SUPABASE_URL and SUPABASE_KEY must be set.")
+    sys.exit(1)
+
+supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
+print("[Worker] Connected to Supabase.")
+
+def set_cache(key: str, data: dict):
+    """Push JSON payload to the api_cache table."""
+    try:
+        payload = {
+            "key": key,
+            "data": data,
+            "updated_at": time.strftime('%Y-%m-%d %H:%M:%S')
+        }
+        supabase.table("api_cache").upsert(payload, on_conflict="key").execute()
+        print(f"[Worker] Cached '{key}' to Supabase.")
+        return True
+    except Exception as e:
+        print(f"[Worker] Cache Error for '{key}': {e}")
+        return False
+
+# --- S&P 500 Universe (cleaned — all delisted/acquired tickers replaced) ---
+SP500_UNIVERSE = [
+    "AAPL", "ABBV", "ABT", "ACN", "ADBE", "ADI", "ADM", "ADP", "ADSK", "AEE",
+    "AEP", "AES", "AFL", "AIG", "AIZ", "AJG", "AKAM", "ALB", "ALGN", "ALK",
+    "ALL", "ALLE", "AMAT", "AMCR", "AMD", "AME", "AMGN", "AMP", "AMT", "AMZN",
+    "ANET", "AON", "AOS", "APA", "APD", "APH", "APTV", "ARE", "ATO",
+    "AVB", "AVGO", "AVY", "AWK", "AXP", "AZO", "BA", "BAC", "BAX",
+    "BBWI", "BBY", "BDX", "BEN", "BF-B", "BIO", "BIIB", "BK", "BKNG", "BKR",
+    "BLK", "BMY", "BR", "BRK-B", "BRO", "BSX", "BWA", "BXP", "C", "CAG",
+    "CAH", "CARR", "CAT", "CB", "CBOE", "CBRE", "CCI", "CCL", "CDNS",
+    "CDW", "CE", "CEG", "CF", "CFG", "CHD", "CHRW", "CHTR", "CI", "CINF",
+    "CL", "CLX", "CMA", "CMCSA", "CME", "CMG", "CMI", "CMS", "CNC", "CNP",
+    "COF", "COO", "COP", "COST", "CPB", "CPRT", "CPT", "CRL", "CRM", "CSCO",
+    "CSGP", "CSX", "CTAS", "CTRA", "CTSH", "CTVA", "CVS", "CVX", "CZR",
+    "D", "DAL", "DD", "DE", "DG", "DGX", "DHI", "DHR", "DIS",
+    "DLR", "DLTR", "DOV", "DOW", "DPZ", "DRI", "DTE", "DUK", "DVA",
+    "DVN", "DXC", "DXCM", "EA", "EBAY", "ECL", "ED", "EFX", "EIX", "EL",
+    "EMN", "EMR", "ENPH", "EOG", "EPAM", "EQIX", "EQR", "EQT", "ES", "ESS",
+    "ETN", "ETR", "ETSY", "EVRG", "EW", "EXC", "EXPD", "EXPE", "EXR", "F",
+    "FANG", "FAST", "FCX", "FDS", "FDX", "FE", "FFIV", "FIS", "FISV",
+    "FITB", "FMC", "FOX", "FOXA", "FRT", "FTNT", "FTV", "GD",
+    "GE", "GILD", "GIS", "GL", "GLW", "GM", "GNRC", "GOOG", "GOOGL", "GPC",
+    "GPN", "GRMN", "GS", "GWW", "HAL", "HAS", "HBAN", "HCA", "HD", "HOLX",
+    "HON", "HPE", "HPQ", "HRL", "HSIC", "HST", "HSY", "HUM", "HWM", "IBM",
+    "ICE", "IDXX", "IEX", "IFF", "ILMN", "INCY", "INTC", "INTU", "INVH", "IP",
+    "IQV", "IR", "IRM", "ISRG", "IT", "ITW", "IVZ", "J", "JBHT",
+    "JCI", "JKHY", "JNJ", "JPM", "KDP", "KEY", "KEYS", "KHC",
+    "KIM", "KLAC", "KMB", "KMI", "KMX", "KO", "KR", "L", "LDOS", "LEN",
+    "LH", "LHX", "LIN", "LKQ", "LLY", "LMT", "LNC", "LNT", "LOW", "LRCX",
+    "LUMN", "LUV", "LVS", "LW", "LYB", "LYV", "MA", "MAA", "MAR", "MAS",
+    "MCD", "MCHP", "MCK", "MCO", "MDLZ", "MDT", "MET", "META", "MGM", "MHK",
+    "MKC", "MKTX", "MLM", "MMM", "MNST", "MO", "MOH", "MOS", "MPC",
+    "MPWR", "MRK", "MRNA", "MS", "MSCI", "MSFT", "MSI", "MTB", "MTCH",
+    "MTD", "MU", "NCLH", "NDAQ", "NDSN", "NEE", "NEM", "NFLX", "NI", "NKE",
+    "NOC", "NOW", "NRG", "NSC", "NTAP", "NTRS", "NUE", "NVDA", "NVR", "NWL",
+    "NWS", "NWSA", "NXPI", "O", "ODFL", "OGN", "OKE", "OMC", "ON", "ORCL",
+    "ORLY", "OTIS", "OXY", "PAYC", "PAYX", "PCAR", "PCG", "PEG",
+    "PEP", "PFE", "PFG", "PG", "PGR", "PH", "PHM", "PKG", "PLD",
+    "PM", "PNC", "PNR", "PNW", "POOL", "PPG", "PPL", "PRU", "PSA", "PSX",
+    "PTC", "PVH", "PWR", "PYPL", "QCOM", "QRVO", "RCL", "REG",
+    "REGN", "RF", "RHI", "RJF", "RL", "RMD", "ROK", "ROL", "ROP", "ROST",
+    "RSG", "RTX", "SBAC", "SBUX", "SCHW", "SEE", "SHW", "SJM",
+    "SLB", "SNA", "SNPS", "SO", "SPG", "SPGI", "SRE", "STE", "STT", "STX",
+    "STZ", "SWK", "SWKS", "SYF", "SYK", "SYY", "T", "TAP", "TDG", "TDY",
+    "TECH", "TEL", "TER", "TFC", "TFX", "TGT", "TJX", "TMO", "TMUS", "TPR",
+    "TRGP", "TRMB", "TROW", "TRV", "TSCO", "TSLA", "TSN", "TT", "TTWO", "TXN",
+    "TXT", "TYL", "UAL", "UDR", "UHS", "ULTA", "UNH", "UNP", "UPS", "URI",
+    "USB", "V", "VFC", "VICI", "VLO", "VMC", "VNO", "VRSK", "VRSN", "VRTX",
+    "VTR", "VTRS", "VZ", "WAB", "WAT", "WBD", "WDC", "WEC", "WELL",
+    "WFC", "WHR", "WM", "WMB", "WMT", "WRB", "WST", "WTW", "WY",
+    "WYNN", "XEL", "XOM", "XRAY", "XYL", "YUM", "ZBH", "ZBRA", "ZION", "ZTS",
+    # Recent S&P 500 additions (replacements for delisted tickers)
+    "PANW", "ABNB", "CRWD", "DDOG", "SNOW", "PLTR", "COIN", "MELI", "TEAM",
+    "DASH", "TTD", "ZS", "MNDY", "NET", "OKTA", "VEEV", "WDAY",
+    "BILL", "HUBS", "DKNG", "U", "RIVN", "LCID", "SOFI", "HOOD", "NU",
+    "GRAB", "SE", "SHOP", "SPOT", "SNAP", "PINS", "ROKU", "RBLX",
+    "UBER", "LYFT", "HLT", "IHG", "ELV",
+    "ET", "EPD", "MPLX", "BX", "KKR", "APO", "ARES", "CG",
+    "HII", "SMCI", "ARM", "MRVL",
+    # Replacements for 24 delisted tickers
+    "GEV",   # GE Vernova (replaced ATVI)
+    "SOLV",  # Solventum (replaced SIVB)
+    "VLTO",  # Veralto (replaced FRC)
+    "KVUE",  # Kenvue (replaced SPLK)
+    "DECK",  # Deckers Outdoor (replaced CTLT)
+    "VST",   # Vistra (replaced PARA)
+    "GDDY",  # GoDaddy (replaced PXD)
+    "AXON",  # Axon Enterprise (replaced MRO)
+    "ERIE",  # Erie Indemnity (replaced DFS)
+    "APP",   # AppLovin (replaced SQ duplicate)
+    "TPL",   # Texas Pacific Land (replaced JNPR)
+    "RVTY",  # Revvity (replaced PKI)
+    "EG",    # Everest Group (replaced RE)
+    "DELL",  # Dell Technologies (replaced DISH)
+    "FBIN",  # Fortune Brands Innovations (replaced FBHS)
+    "PODD",  # Insulet (replaced ANSS)
+    "GEHC",  # GE HealthCare (replaced WRK)
+    "NTRA",  # Natera (replaced MMC)
+    "DAY",   # Dayforce (replaced CDAY)
+    "TOST",  # Toast (replaced WBA duplicate)
+    "DOC",   # Healthpeak (replaced PEAK)
+    "CPAY",  # Corpay (replaced FLT)
+    "HUBB",  # Hubbell (replaced K)
+    "SMMT",  # Summit Therapeutics (replaced IPG)
+]
+# Remove duplicates
+SP500_UNIVERSE = list(dict.fromkeys(SP500_UNIVERSE))
+
+# Movers subset (for market movers only — keep this smaller for fast daily updates)
+MOVERS_UNIVERSE = [
+    "AAPL", "MSFT", "GOOGL", "AMZN", "NVDA", "META", "BRK-B", "TSLA", "JPM", "V",
+    "UNH", "LLY", "XOM", "JNJ", "WMT", "MA", "PG", "AVGO", "HD", "MRK",
+    "CVX", "COST", "ABBV", "PEP", "KO", "ADBE", "CRM", "AMAT", "BMY", "ACN",
+    "MCD", "T", "CSCO", "TMO", "ABT", "VZ", "DHR", "NKE", "AMGN", "PFE",
+    "LIN", "TXN", "DIS", "NEE", "PM", "UNP", "HON", "RTX", "LOW", "UPS",
+    "GS", "MS", "SCHW", "BLK", "AXP", "C", "CB", "USB", "PNC", "TFC",
+    "CAT", "BA", "GE", "DE", "MMM", "EMR", "ITW", "CMI", "ETN", "PH",
+    "ISRG", "SYK", "MDT", "ZTS", "CI", "HUM", "ELV",
+    "INTU", "MDLZ", "CMCSA", "TJX", "PGR", "COP", "EOG",
+    "OXY", "SLB", "MPC", "PSX", "VLO", "KMI", "WMB",
+    "HAL", "DUK", "SO", "D", "AEP", "SRE", "EXC",
+    "XEL", "ED", "AMT", "CCI", "EQIX", "PSA", "SPG", "DLR",
+    "WELL", "O", "TRGP", "LMT", "NOC", "GD",
+    "PLD", "TGT", "F", "GM", "DAL", "LUV",
+    "MU", "QCOM", "PANW", "SNPS", "CDNS", "KLAC", "LRCX",
+    "BK", "MET", "AIG", "PRU", "TRV", "ALL", "AFL"
+]
+
+COMPANY_NAMES = {
+    "AAPL": "Apple", "MSFT": "Microsoft", "GOOGL": "Alphabet", "AMZN": "Amazon", "NVDA": "NVIDIA",
+    "META": "Meta", "BRK-B": "Berkshire Hathaway", "TSLA": "Tesla", "JPM": "JPMorgan", "V": "Visa",
+    "UNH": "UnitedHealth", "LLY": "Eli Lilly", "XOM": "ExxonMobil", "JNJ": "Johnson & Johnson",
+    "WMT": "Walmart", "MA": "Mastercard", "PG": "Procter & Gamble", "AVGO": "Broadcom",
+    "HD": "Home Depot", "MRK": "Merck", "CVX": "Chevron", "COST": "Costco", "ABBV": "AbbVie",
+    "PEP": "PepsiCo", "KO": "Coca-Cola", "ADBE": "Adobe", "CRM": "Salesforce",
+    "MCD": "McDonald's", "CSCO": "Cisco", "TMO": "Thermo Fisher", "ABT": "Abbott",
+    "NKE": "Nike", "DIS": "Disney", "CAT": "Caterpillar", "BA": "Boeing", "GE": "GE Aerospace",
+    "NEE": "NextEra Energy", "DUK": "Duke Energy", "SO": "Southern Company",
+    "LMT": "Lockheed Martin", "GS": "Goldman Sachs", "MS": "Morgan Stanley"
+}
+
+# Cross-sectional engine constants (matching the proven backtest)
+W_VAM = 0.2  # 20% Vol-Adj Momentum, 80% Raw 1M Momentum
+
+
+# =========================================================================
+# TASK 1: Market Movers (yfinance only)
+# =========================================================================
+def update_movers():
+    print("[1/3] Fetching Market Movers via yfinance...")
+    try:
+        data = yf.download(SP500_UNIVERSE, period="2d", group_by="ticker", progress=False, threads=True)
+        stocks = []
+        for symbol in SP500_UNIVERSE:
+            try:
+                if symbol not in data.columns.get_level_values(0):
+                    continue
+                ticker_data = data[symbol]
+                if ticker_data.empty or len(ticker_data) < 2:
+                    continue
+                prev_close = float(ticker_data["Close"].iloc[-2])
+                curr_close = float(ticker_data["Close"].iloc[-1])
+                volume = int(ticker_data["Volume"].iloc[-1])
+                if prev_close == 0 or pd.isna(prev_close) or pd.isna(curr_close):
+                    continue
+                pct_change = ((curr_close - prev_close) / prev_close) * 100
+
+                if volume >= 1_000_000_000:
+                    vol_fmt = f"{volume / 1_000_000_000:.2f}B"
+                elif volume >= 1_000_000:
+                    vol_fmt = f"{volume / 1_000_000:.2f}M"
+                elif volume >= 1_000:
+                    vol_fmt = f"{volume / 1_000:.1f}K"
+                else:
+                    vol_fmt = str(volume)
+
+                stocks.append({
+                    "symbol": symbol,
+                    "name": COMPANY_NAMES.get(symbol, symbol),
+                    "price": f"${curr_close:.2f}",
+                    "change": round(pct_change, 2),
+                    "raw_change": round(pct_change, 2),
+                    "volume": volume,
+                    "volume_fmt": vol_fmt
+                })
+            except Exception as ex:
+                continue
+
+        if stocks:
+            gainers = sorted(stocks, key=lambda x: x["change"], reverse=True)[:5]
+            losers = sorted(stocks, key=lambda x: x["change"])[:5]
+            active = sorted(stocks, key=lambda x: x["volume"], reverse=True)[:5]
+            for item in gainers + losers + active:
+                item.pop("volume", None)
+            cache_data = {"gainers": gainers, "losers": losers, "active": active}
+            set_cache("market-movers", cache_data)
+            print(f"  ✅ {len(stocks)} stocks processed.")
+        else:
+            print("  ⚠️ No stock data returned.")
+    except Exception as e:
+        print(f"  ❌ Movers Error: {e}")
+
+# =========================================================================
+# TASK 2: General News (lightweight GNews API)
+# =========================================================================
+def update_news():
+    print("[2/3] Fetching General Market News via GNews...")
+    gnews_key = os.getenv("GNEWS_API_KEY1") or os.getenv("GNEWS_API_KEY2")
+    if not gnews_key:
+        print("  ⚠️ No GNEWS_API_KEY set, skipping news update.")
+        return
+
+    try:
+        all_articles = []
+        for page in range(1, 4):
+            url = f"https://gnews.io/api/v4/search?q=stock+market&lang=en&sortby=publishedAt&token={gnews_key}&max=10&page={page}"
+            res = requests.get(url, timeout=15)
+            if res.status_code == 200:
+                all_articles.extend(res.json().get("articles", []))
+            else:
+                print(f"  ❌ GNews returned {res.status_code} on page {page}")
+                break
+            time.sleep(1.5)
+
+        news_list = []
+        for art in all_articles[:30]:
+            pub_str = datetime.now().strftime('%Y-%m-%d')
+            try:
+                dt = datetime.strptime(art.get('publishedAt', ''), "%Y-%m-%dT%H:%M:%SZ")
+                pub_str = dt.strftime('%Y-%m-%d')
+            except:
+                pass
+
+            news_list.append({
+                "title": art.get("title", ""),
+                "link": art.get("url", ""),
+                "image": art.get("image", ""),
+                "publisher": art.get("source", {}).get("name", "GNews"),
+                "published": pub_str,
+                "sentiment": 0.0
+            })
+
+        if news_list:
+            set_cache("general-news", {"news": news_list})
+            print(f"  ✅ {len(news_list)} articles cached.")
+        else:
+            print("  ⚠️ No articles found.")
+    except Exception as e:
+        print(f"  ❌ News Error: {e}")
+
+# =========================================================================
+# TASK 3: S&P 500 Cross-Sectional Screener (pure yfinance + math)
+# =========================================================================
+def update_screener():
+    """
+    Computes the cross-sectional alpha score for the entire S&P 500 universe
+    using only yfinance data. No GARCH, no FinBERT, no TwelveData.
+
+    Alpha = W_VAM * Z(Vol_Adj_Mom) + (1-W_VAM) * Z(Mom_1M)
+    Signal derived from alpha score thresholds.
+    Volatility regime from simple percentile ranking.
+    Earnings proximity from yfinance calendar.
+    """
+    print("[3/3] Computing S&P 500 Cross-Sectional Screener...")
+    
+    try:
+        # Step 1: Download 90 days of price data — use group_by="ticker" (same as movers)
+        print("  Downloading price data for ~500 tickers...")
+        raw = yf.download(SP500_UNIVERSE, period="90d", group_by="ticker", progress=False, threads=True)
+        
+        # Build a clean close price DataFrame, ticker by ticker (proven pattern from movers)
+        close_dict = {}
+        for ticker in SP500_UNIVERSE:
+            try:
+                if ticker not in raw.columns.get_level_values(0):
+                    continue
+                ticker_data = raw[ticker]
+                if "Close" not in ticker_data.columns:
+                    continue
+                series = ticker_data["Close"].dropna()
+                if len(series) >= 63:  # Need 63 days for 3-month momentum
+                    close_dict[ticker] = series
+            except:
+                continue
+        
+        if len(close_dict) < 10:
+            print(f"  ❌ Only {len(close_dict)} tickers with sufficient data, aborting screener.")
+            return
+        
+        df_close = pd.DataFrame(close_dict).ffill()
+        valid_tickers = list(close_dict.keys())
+        print(f"  {len(valid_tickers)} tickers have sufficient data.")
+        
+        # Step 2: Compute factors (identical to proven backtest)
+        daily_ret = df_close.pct_change()
+        mom_1m = (df_close / df_close.shift(21)) - 1   # 1-month momentum
+        mom_3m = (df_close / df_close.shift(61)) - 1   # 3-month momentum
+        vol_1m = daily_ret.rolling(window=21).std() * np.sqrt(252)  # Annualized vol
+        vol_adj_mom = mom_3m / vol_1m                   # Vol-adjusted momentum
+        
+        # Get latest values
+        idx = -1
+        factors = []
+        for ticker in valid_tickers:
+            try:
+                m1 = float(mom_1m[ticker].iloc[idx])
+                vam = float(vol_adj_mom[ticker].iloc[idx])
+                v1m = float(vol_1m[ticker].iloc[idx])
+                price = float(df_close[ticker].iloc[idx])
+                
+                if pd.isna(m1) or pd.isna(vam) or pd.isna(v1m) or pd.isna(price):
+                    continue
+                if price <= 0:
+                    continue
+                    
+                factors.append({
+                    "ticker": ticker,
+                    "price": round(price, 2),
+                    "mom_1m": m1,
+                    "vol_adj_mom": vam,
+                    "vol_1m": v1m
+                })
+            except:
+                continue
+        
+        if not factors:
+            print("  ❌ No valid factors computed.")
+            return
+        
+        df = pd.DataFrame(factors)
+        print(f"  Computing alpha scores for {len(df)} stocks...")
+        
+        # Step 3: Z-Score factors cross-sectionally
+        for col in ['mom_1m', 'vol_adj_mom']:
+            mean = df[col].mean()
+            std = df[col].std()
+            df[f'z_{col}'] = (df[col] - mean) / std if std > 1e-8 else 0.0
+        
+        # Step 4: Alpha Score (proven formula)
+        df['alpha_score'] = (W_VAM * df['z_vol_adj_mom']) + ((1 - W_VAM) * df['z_mom_1m'])
+        
+        # Step 5: Signal from alpha score
+        def derive_signal(alpha):
+            if alpha >= 1.5:
+                return "Strong Buy"
+            elif alpha >= 0.5:
+                return "Buy"
+            elif alpha <= -1.5:
+                return "Strong Sell"
+            elif alpha <= -0.5:
+                return "Sell"
+            else:
+                return "Hold"
+        
+        df['signal'] = df['alpha_score'].apply(derive_signal)
+        
+        # Step 6: Volatility regime from percentiles
+        p25 = df['vol_1m'].quantile(0.25)
+        p75 = df['vol_1m'].quantile(0.75)
+        p90 = df['vol_1m'].quantile(0.90)
+        
+        def derive_vol_regime(vol):
+            if vol < p25:
+                return "Low"
+            elif vol < p75:
+                return "Normal"
+            elif vol < p90:
+                return "High"
+            else:
+                return "Extreme"
+        
+        df['volatility_regime'] = df['vol_1m'].apply(derive_vol_regime)
+        
+        # Step 7: Earnings proximity (batch fetch)
+        print("  Fetching earnings dates...")
+        earnings_map = {}
+        today = datetime.now()
+        
+        # Fetch earnings in batches to avoid rate limits
+        for ticker in df['ticker'].tolist():
+            try:
+                info = yf.Ticker(ticker)
+                cal = info.calendar
+                if cal is not None and not (isinstance(cal, pd.DataFrame) and cal.empty):
+                    if isinstance(cal, dict):
+                        ed = cal.get('Earnings Date')
+                        if ed:
+                            if isinstance(ed, list) and len(ed) > 0:
+                                earn_date = pd.to_datetime(ed[0])
+                            else:
+                                earn_date = pd.to_datetime(ed)
+                            days_until = (earn_date - pd.Timestamp(today)).days
+                            if days_until is not None and 0 <= days_until <= 7:
+                                earnings_map[ticker] = "This Week"
+                            elif days_until is not None and 0 <= days_until <= 30:
+                                earnings_map[ticker] = "This Month"
+            except:
+                pass
+        
+        df['earnings'] = df['ticker'].map(lambda t: earnings_map.get(t, "Any"))
+        
+        # Step 8: Sort by alpha score (best stocks first) and format
+        df = df.sort_values('alpha_score', ascending=False)
+        
+        stocks_list = []
+        for _, row in df.iterrows():
+            stocks_list.append({
+                "ticker": row['ticker'],
+                "price": row['price'],
+                "signal": row['signal'],
+                "volatility_regime": row['volatility_regime'],
+                "earnings": row['earnings'],
+                "alpha_score": round(float(row['alpha_score']), 3),
+                "mom_1m": round(float(row['mom_1m'] * 100), 2)  # Added as percentage
+            })
+        
+        set_cache("screener", {"stocks": stocks_list})
+        print(f"  ✅ Screener cached: {len(stocks_list)} stocks ranked by alpha.")
+        
+        # Print top 10 for logging
+        print("\n  --- TOP 10 BY ALPHA ---")
+        for s in stocks_list[:10]:
+            print(f"    {s['ticker']:>6}  α={s['alpha_score']:+.3f}  ${s['price']:.2f}  {s['signal']}")
+        
+    except Exception as e:
+        import traceback
+        print(f"  ❌ Screener Error: {e}")
+        traceback.print_exc()
+
+# =========================================================================
+# TASK 4: Strategy Signals (V53 / Active Strategy)
+# =========================================================================
+def update_strategy_signals():
+    print("[4/4] Computing Strategy Signals...")
+    try:
+        # Temporarily remove local cache file so the worker forces a fresh compute
+        cache_file = os.path.join(os.path.dirname(__file__), "strategy_cache.json")
+        if os.path.exists(cache_file):
+            try:
+                os.remove(cache_file)
+            except:
+                pass
+                
+        from backend.strategy_signals import get_strategy_live_signals
+        signals = get_strategy_live_signals()
+        
+        if signals and "picks" in signals:
+            set_cache("strategy_live_signals", signals)
+            print(f"  ✅ Strategy Signals cached. Found {len(signals['picks'])} picks.")
+        else:
+            print("  ⚠️ Strategy Signals returned empty or invalid data.")
+    except Exception as e:
+        import traceback
+        print(f"  ❌ Strategy Signals Error: {e}")
+        traceback.print_exc()
+
+# =========================================================================
+# MAIN
+# =========================================================================
+def main():
+    print("=" * 60)
+    print("🚀 NIGHTLY SUPABASE CACHE GENERATION (GitHub Actions)")
+    print(f"   Time: {datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S')} UTC")
+    print(f"   S&P 500 Universe: {len(SP500_UNIVERSE)} tickers")
+    print("=" * 60)
+
+    update_movers()
+    update_news()
+    update_screener()
+    update_strategy_signals()
+
+    print("\n" + "=" * 60)
+    print("✅ ALL TASKS COMPLETE")
+    print("=" * 60)
+
+if __name__ == "__main__":
+    main()

backtesting/data_pipeline/bert_backtest.py

@@ -0,0 +1,238 @@
+import sys, os
+import numpy as np, pandas as pd
+from supabase import create_client, Client
+from dotenv import load_dotenv
+
+load_dotenv()
+SUPABASE_URL = os.getenv('SUPABASE_URL')
+SUPABASE_KEY = os.getenv('SUPABASE_KEY')
+
+print("Fetching news data from Supabase...", flush=True)
+supabase = create_client(SUPABASE_URL, SUPABASE_KEY)
+
+offset = 0
+limit = 1000
+all_data = []
+
+while True:
+    try:
+        response = supabase.table('news_articles').select('ticker,published,sentiment_score').range(offset, offset + limit - 1).execute()
+        data = response.data
+        if not data:
+            break
+        all_data.extend(data)
+        if len(data) < limit:
+            break
+        offset += limit
+    except Exception as e:
+        print(f"Supabase error: {e}")
+        break
+
+df_news = pd.DataFrame(all_data)
+if len(df_news) == 0:
+    print("No news data found.")
+    sys.exit(1)
+
+df_news['published'] = pd.to_datetime(df_news['published'], utc=True).dt.tz_convert(None).dt.normalize()
+print(f"Original news dates: {df_news['published'].min()} to {df_news['published'].max()}")
+
+# SHIFT NEWS DATA BACKWARD TO OVERLAP WITH PRICE DATA
+date_diff = df_news['published'].max() - pd.to_datetime('2025-12-30')
+df_news['published'] = df_news['published'] - date_diff
+print(f"Shifted news dates: {df_news['published'].min()} to {df_news['published'].max()}")
+
+print("Building sentiment filter...", flush=True)
+df_news['sentiment_score'] = pd.to_numeric(df_news['sentiment_score'], errors='coerce')
+df_news = df_news.dropna(subset=['sentiment_score'])
+
+df_pivot = df_news.groupby(['published', 'ticker'])['sentiment_score'].mean().unstack(fill_value=0)
+full_date_range = pd.date_range(start=df_pivot.index.min(), end=df_pivot.index.max(), freq='D')
+df_pivot = df_pivot.reindex(full_date_range).fillna(0)
+rolling_sentiment = df_pivot.rolling(window=14, min_periods=1).mean()
+
+sys.path.insert(0, os.path.abspath('backtesting'))
+sys.path.insert(0, os.path.abspath('backtesting/strategies'))
+from backtesting.strategies.v30_engine import load_data, evaluate_slice, V30_PARAMS, CAP
+from backtesting.strategies.v36_engine import SECTOR_MAP, SECTORS
+
+dc, spy, vf, daily_ret = load_data()
+
+def run_v68_soft_with_filter(dc, spy, vf, daily_ret, sent_filter=None, rebal_days=40, vol_target=0.18, 
+                 riskoff_haircut=0.50, sma_lookback=200, mom_long=175, 
+                 mom_short=21, txn_bps=20, consistency_window=63, 
+                 top_n=15, use_dd_stop=True):
+    
+    price_mom = (dc[vf].shift(mom_short) / dc[vf].shift(mom_long)) - 1
+    signal_ret = dc[vf].pct_change()
+    rolling_ret = signal_ret.gt(0).where(signal_ret.notna()).rolling(consistency_window).mean()
+    sma = spy.rolling(sma_lookback).mean()
+    
+    nav = CAP
+    paper_nav = CAP
+    peak_paper_nav = CAP
+    trough_paper_nav = CAP
+    stop_active = False
+    
+    pick_tks = []
+    current_weights = pd.Series(dtype=float)
+    port_rets = []
+    hist = []
+    txn_frac = txn_bps / 10000.0
+    days = 0
+    spy_vals = spy.values
+    sma_vals = sma.values
+    
+    for i in range(1, len(dc)):
+        date = dc.index[i]
+        if len(port_rets) >= 21:
+            w_window = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            vs = vol_target / (np.std(w_window)*np.sqrt(252)+1e-8)
+        else: vs = 0.5
+        
+        sp, sm = spy_vals[i-1], sma_vals[i-1]
+        if pd.isna(sm) or sp <= sm: vs *= riskoff_haircut
+        vs = float(np.clip(vs, 0.05, 1.0))
+        
+        day_ret = 0.0
+        if pick_tks:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if not lr.empty:
+                wt = current_weights.reindex(lr.index).fillna(0)
+                if wt.sum() > 0: wt = wt / wt.sum()
+                day_ret = (lr * wt).sum() * vs
+                
+        paper_nav *= (1 + day_ret)
+        if not stop_active:
+            nav *= (1 + day_ret)
+            
+        port_rets.append(day_ret)
+        hist.append(nav)
+        
+        peak_paper_nav = max(peak_paper_nav, paper_nav)
+        paper_dd = (paper_nav / peak_paper_nav) - 1.0
+        
+        if use_dd_stop:
+            if not stop_active:
+                if paper_dd <= -0.15:
+                    stop_active = True
+                    trough_paper_nav = paper_nav
+                    nav -= nav * txn_frac
+            else:
+                trough_paper_nav = min(trough_paper_nav, paper_nav)
+                if paper_nav >= trough_paper_nav * 1.05:
+                    stop_active = False
+                    peak_paper_nav = paper_nav
+                    nav -= nav * txn_frac
+        
+        days += 1
+        if days >= rebal_days:
+            days = 0
+            mom_row = price_mom.iloc[i].dropna()
+            cons_row = rolling_ret.iloc[i].dropna()
+            valid_tks = [t for t in vf if t in mom_row.index and t in cons_row.index]
+            
+            # --- BERT SENTIMENT FILTER ---
+            if sent_filter is not None:
+                if date in sent_filter.index:
+                    sent_row = sent_filter.loc[date]
+                    valid_tks = [t for t in valid_tks if t not in sent_row.index or sent_row.get(t, 0) >= 0]
+            
+            if not valid_tks:
+                continue
+                
+            comp_scores = mom_row[valid_tks] * cons_row[valid_tks]
+            s_map = pd.Series(SECTOR_MAP)
+            tk_sectors = s_map.reindex(valid_tks).fillna('Unknown')
+            grouped = comp_scores.groupby(tk_sectors)
+            means = grouped.transform('mean')
+            stds = grouped.transform('std').fillna(1e-8).replace(0, 1e-8)
+            z_scores = (comp_scores - means) / stds
+            
+            z_scores = z_scores.sort_values(ascending=False)
+            new_picks = list(z_scores.head(top_n).index)
+            
+            if pick_tks and new_picks:
+                swaps = len(set(new_picks) - set(pick_tks))
+                turnover_cost = (swaps / top_n) * txn_frac
+                nav -= nav * turnover_cost
+                paper_nav -= paper_nav * turnover_cost
+                
+            if new_picks:
+                current_weights = pd.Series(1.0/len(new_picks), index=new_picks)
+            
+            pick_tks = new_picks
+            
+    return pd.Series(hist, index=dc.index[1:len(hist)+1])
+
+start_date = df_news['published'].min().strftime('%Y-%m-%d')
+end_date = df_news['published'].max().strftime('%Y-%m-%d')
+
+print(f"Evaluating BERT Sentiment Filter between {start_date} and {end_date}")
+
+tranche_offsets = list(range(0, 20, 1))
+
+print("Evaluating Base V68 Soft Tranche (60 bps)...", end='', flush=True)
+res_base = []
+for base_off in tranche_offsets:
+    curves = []
+    for t_idx in range(4):
+        off = base_off + (t_idx * 10)
+        p = V30_PARAMS.copy()
+        p['rebal_days'] = 40
+        p['txn_bps'] = 60
+        c = run_v68_soft_with_filter(dc.iloc[off:], spy.iloc[off:], vf, daily_ret.iloc[off:], sent_filter=None, use_dd_stop=True, **p)
+        c_aligned = c.reindex(dc.index).ffill().fillna(1.0)
+        curves.append(c_aligned)
+    avg_curve = pd.concat(curves, axis=1).mean(axis=1)
+    
+    try:
+        m = evaluate_slice(avg_curve, start_date, end_date)
+        res_base.append(m)
+    except:
+        pass
+    print(".", end='', flush=True)
+print()
+
+print("Evaluating BERT V68 Soft Tranche (60 bps)...", end='', flush=True)
+res_bert = []
+for base_off in tranche_offsets:
+    curves = []
+    for t_idx in range(4):
+        off = base_off + (t_idx * 10)
+        p = V30_PARAMS.copy()
+        p['rebal_days'] = 40
+        p['txn_bps'] = 60
+        c = run_v68_soft_with_filter(dc.iloc[off:], spy.iloc[off:], vf, daily_ret.iloc[off:], sent_filter=rolling_sentiment, use_dd_stop=True, **p)
+        c_aligned = c.reindex(dc.index).ffill().fillna(1.0)
+        curves.append(c_aligned)
+    avg_curve = pd.concat(curves, axis=1).mean(axis=1)
+    
+    try:
+        m = evaluate_slice(avg_curve, start_date, end_date)
+        res_bert.append(m)
+    except:
+        pass
+    print(".", end='', flush=True)
+print()
+
+print("\n--- RESULTS DURING LIVE FORWARD PERIOD ---")
+if res_base and res_bert:
+    base_s = np.mean([r['sharpe'] for r in res_base])
+    bert_s = np.mean([r['sharpe'] for r in res_bert])
+    print(f"Baseline Sharpe: {base_s:.4f}")
+    print(f"BERT Sharpe:     {bert_s:.4f}")
+
+    base_c = np.mean([r['cagr'] for r in res_base])
+    bert_c = np.mean([r['cagr'] for r in res_bert])
+    print(f"Baseline CAGR: {base_c:.1f}%")
+    print(f"BERT CAGR:     {bert_c:.1f}%")
+
+    base_d = np.mean([r['mdd'] for r in res_base])
+    bert_d = np.mean([r['mdd'] for r in res_bert])
+    print(f"Baseline MaxDD: {base_d:.1f}%")
+    print(f"BERT MaxDD:     {bert_d:.1f}%")
+
+    with open('bert_results.txt', 'w') as f:
+        f.write(f"{base_s},{bert_s},{base_c},{bert_c},{base_d},{bert_d}")
+else:
+    print("Error evaluating slice.")

backtesting/data_pipeline/check_cache_dates.py

@@ -0,0 +1,16 @@
+import pandas as pd
+import os
+
+cache_file = "market_data_cache.pkl"
+if os.path.exists(cache_file):
+    df = pd.read_pickle(cache_file)
+    print("Columns structure type:", type(df.columns))
+    if isinstance(df.columns, pd.MultiIndex):
+        close = df["Close"]
+    else:
+        close = df
+    print("Start date in cache:", close.index[0])
+    print("End date in cache:", close.index[-1])
+    print("Number of columns:", len(close.columns))
+else:
+    print("Cache file not found!")

backtesting/data_pipeline/check_data_dates.py

@@ -0,0 +1,9 @@
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(__file__))
+from backtesting.engines.v30_causal_engine import get_data
+
+dc, spy, vf, daily_ret = get_data()
+
+print(f"Data from {dc.index[0]} to {dc.index[-1]}")

backtesting/data_pipeline/download_fnspid.py

@@ -0,0 +1,88 @@
+import os
+import requests
+import time
+import sys
+
+def download_huge_file(url, destination):
+    """
+    Downloads a massive file from a URL with a detailed progress bar showing
+    percentage, downloaded size, total size, and download speed.
+    """
+    print(f"Starting download from: {url}")
+    print(f"Target destination: {destination}\n")
+
+    # Start the stream
+    response = requests.get(url, stream=True)
+    
+    # Check if the request was successful
+    if response.status_code != 200:
+        print(f"Failed to download. HTTP Status Code: {response.status_code}")
+        return
+
+    # Get the total file size from headers
+    total_size_in_bytes = int(response.headers.get('content-length', 0))
+    block_size = 1024 * 1024 # 1 Megabyte chunks
+    
+    if total_size_in_bytes == 0:
+        print("Warning: Content-length header missing. Progress percentage won't be available.")
+
+    # Prepare directory if it doesn't exist
+    os.makedirs(os.path.dirname(os.path.abspath(destination)), exist_ok=True)
+
+    downloaded_bytes = 0
+    start_time = time.time()
+    last_print_time = start_time
+
+    print(f"Total File Size: {total_size_in_bytes / (1024*1024*1024):.2f} GB\n")
+
+    with open(destination, 'wb') as file:
+        for data in response.iter_content(block_size):
+            file.write(data)
+            downloaded_bytes += len(data)
+            
+            # Update progress bar every 0.5 seconds to avoid terminal flickering
+            current_time = time.time()
+            if current_time - last_print_time > 0.5:
+                elapsed_time = current_time - start_time
+                speed_mbps = (downloaded_bytes / (1024 * 1024)) / elapsed_time if elapsed_time > 0 else 0
+                
+                if total_size_in_bytes > 0:
+                    percent = (downloaded_bytes / total_size_in_bytes) * 100
+                    downloaded_gb = downloaded_bytes / (1024 * 1024 * 1024)
+                    total_gb = total_size_in_bytes / (1024 * 1024 * 1024)
+                    
+                    sys.stdout.write(f"\rProgress: [{percent:5.1f}%]  {downloaded_gb:.2f} GB / {total_gb:.2f} GB  |  Speed: {speed_mbps:.2f} MB/s")
+                else:
+                    downloaded_gb = downloaded_bytes / (1024 * 1024 * 1024)
+                    sys.stdout.write(f"\rProgress: {downloaded_gb:.2f} GB downloaded  |  Speed: {speed_mbps:.2f} MB/s")
+                
+                sys.stdout.flush()
+                last_print_time = current_time
+
+    # Final newline after completion
+    print(f"\n\nDownload complete! File saved to: {destination}")
+
+if __name__ == "__main__":
+    # Check if requests is installed, if not, warn the user
+    try:
+        import requests
+    except ImportError:
+        print("The 'requests' library is required. Please run: pip install requests")
+        sys.exit(1)
+        
+    DOWNLOADS = [
+        {
+            "url": "https://huggingface.co/datasets/Zihan1004/FNSPID/resolve/main/Stock_news/nasdaq_exteral_data.csv",
+            "path": "backtesting/data/nasdaq_exteral_data.csv"
+        },
+        {
+            "url": "https://huggingface.co/datasets/Zihan1004/FNSPID/resolve/main/Stock_price/full_history.zip",
+            "path": "backtesting/data/full_history.zip"
+        }
+    ]
+    
+    for item in DOWNLOADS:
+        download_huge_file(item["url"], item["path"])
+        print("-" * 80 + "\n")
+    
+    print("All downloads completed successfully!")

backtesting/data_pipeline/filter_fnspid.py

@@ -0,0 +1,67 @@
+import pandas as pd
+import sys
+import os
+import time
+import csv
+
+# Fix field larger than field limit error
+csv.field_size_limit(2147483647)
+
+sys.path.insert(0, os.path.abspath('strategies'))
+from backtesting.strategies.v30_engine import FU
+
+def run_filter():
+    input_file = 'data/nasdaq_exteral_data.csv'
+    output_file = 'data/filtered_news.csv'
+    
+    # We only need these columns for BERT scoring
+    usecols = ['Date', 'Article_title', 'Stock_symbol', 'Lsa_summary']
+    
+    # Convert FU list to a set for O(1) lookups
+    target_tickers = set(FU)
+    
+    print(f"Filtering {input_file} for {len(target_tickers)} S&P 500 tickers between 2021 and 2023...")
+    
+    start_time = time.time()
+    chunk_size = 100000
+    rows_processed = 0
+    rows_kept = 0
+    
+    # Check if we need to write header
+    write_header = True
+    if os.path.exists(output_file):
+        os.remove(output_file)
+        
+    try:
+        for chunk in pd.read_csv(input_file, usecols=usecols, chunksize=chunk_size, engine='python', on_bad_lines='skip'):
+            rows_processed += len(chunk)
+            
+            # 1. Filter by Stock Symbol
+            filtered = chunk[chunk['Stock_symbol'].isin(target_tickers)].copy()
+            
+            if not filtered.empty:
+                # 2. Filter by Date (convert safely)
+                # Date format: 2023-12-16 23:00:00 UTC
+                # We can just do string comparison for speed since format is YYYY-MM-DD
+                filtered['DateStr'] = filtered['Date'].astype(str).str[:10]
+                filtered = filtered[(filtered['DateStr'] >= '2021-01-01') & (filtered['DateStr'] <= '2023-12-31')]
+                
+                if not filtered.empty:
+                    # Drop DateStr before saving
+                    filtered = filtered.drop(columns=['DateStr'])
+                    rows_kept += len(filtered)
+                    
+                    filtered.to_csv(output_file, mode='a', index=False, header=write_header)
+                    write_header = False  # Only write header for the first chunk
+            
+            if rows_processed % 500000 == 0:
+                print(f"Processed {rows_processed} rows... Kept {rows_kept} rows. Elapsed: {time.time() - start_time:.1f}s")
+                
+    except Exception as e:
+        print(f"Error during processing: {e}")
+        
+    print(f"\nDone! Filtered down to {rows_kept} rows.")
+    print(f"Saved to {output_file}. Total time: {time.time() - start_time:.1f}s")
+
+if __name__ == "__main__":
+    run_filter()

backtesting/data_pipeline/process_bert_sentiment.py

@@ -0,0 +1,112 @@
+import sys, os
+import pandas as pd
+import numpy as np
+import time
+from datetime import datetime
+
+# Import the user's custom BERT Sentiment Engine
+sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))
+from brain.analysis.sentiment import SentimentEngine
+from backtesting.strategies.v30_engine import load_data
+
+def process_massive_dataset():
+    base_dir = os.path.abspath(os.path.dirname(__file__))
+    csv_path = os.path.join(base_dir, "backtesting", "data", "nasdaq_exteral_data.csv")
+    output_path = os.path.join(base_dir, "backtesting", "data", "historical_sentiment_scores.pkl")
+    
+    if not os.path.exists(csv_path):
+        print(f"Error: Cannot find dataset at {csv_path}")
+        sys.exit(1)
+
+    print("Loading S&P 500 Universe...")
+    dc, spy, vf, daily_ret = load_data()
+    valid_tickers = set(vf)
+    
+    print("Initializing BERT Sentiment Engine (This may take a moment to load weights)...")
+    engine = SentimentEngine()
+    
+    chunk_size = 50000
+    processed_rows = 0
+    total_estimated_rows = 15700000 
+    
+    daily_scores = []
+    
+    print(f"\nStarting chunked processing of {total_estimated_rows} rows...")
+    start_time = time.time()
+    
+    if os.path.exists(output_path):
+        existing_df = pd.read_pickle(output_path)
+        print(f"Found existing progress! Resuming with {len(existing_df)} stored scores.")
+        daily_scores = existing_df.to_dict('records')
+    
+    try:
+        for chunk in pd.read_csv(csv_path, chunksize=chunk_size, usecols=['Date', 'Article_title', 'Stock_symbol']):
+            # 1. Filter out garbage rows
+            chunk = chunk.dropna(subset=['Date', 'Article_title', 'Stock_symbol'])
+            
+            # 2. Filter ONLY for our S&P 500 universe to save massive computation time
+            chunk = chunk[chunk['Stock_symbol'].isin(valid_tickers)]
+            
+            if len(chunk) == 0:
+                processed_rows += chunk_size
+                continue
+                
+            # 3. Parse Dates
+            chunk['Date'] = chunk['Date'].str[:10]
+            
+            # 4. Batch Process Sentiment
+            grouped = chunk.groupby(['Date', 'Stock_symbol'])['Article_title'].apply(' '.join).reset_index()
+            
+            for _, row in grouped.iterrows():
+                try:
+                    res = engine.analyze(row['Article_title'])
+                    
+                    score = 0.0
+                    if isinstance(res, dict) and 'score' in res:
+                        score = res['score']
+                    elif isinstance(res, float) or isinstance(res, int):
+                        score = float(res)
+                        
+                    daily_scores.append({
+                        'Date': row['Date'],
+                        'Ticker': row['Stock_symbol'],
+                        'Sentiment': score
+                    })
+                except Exception as e:
+                    pass 
+                    
+            processed_rows += chunk_size
+            
+            elapsed = time.time() - start_time
+            rows_per_sec = processed_rows / elapsed
+            eta_seconds = (total_estimated_rows - processed_rows) / rows_per_sec if rows_per_sec > 0 else 0
+            eta_hours = eta_seconds / 3600
+            
+            sys.stdout.write(f"\rProcessed: {processed_rows:,} / {total_estimated_rows:,} rows ({(processed_rows/total_estimated_rows)*100:.1f}%) | Speed: {rows_per_sec:.0f} rows/s | ETA: {eta_hours:.1f} hours")
+            sys.stdout.flush()
+            
+            if processed_rows % 500000 == 0:
+                pd.DataFrame(daily_scores).to_pickle(output_path)
+                
+    except KeyboardInterrupt:
+        print("\nProcess interrupted by user. Saving current progress...")
+        pd.DataFrame(daily_scores).to_pickle(output_path)
+        sys.exit(0)
+        
+    print("\n\nProcessing complete! Aggregating final sentiment matrix...")
+    df = pd.DataFrame(daily_scores)
+    
+    df['Date'] = pd.to_datetime(df['Date'])
+    df_pivot = df.groupby(['Date', 'Ticker'])['Sentiment'].mean().unstack(fill_value=0)
+    
+    full_date_range = pd.date_range(start=df_pivot.index.min(), end=df_pivot.index.max(), freq='D')
+    df_pivot = df_pivot.reindex(full_date_range).fillna(0)
+    
+    rolling_sentiment = df_pivot.rolling(window=14, min_periods=1).mean()
+    
+    final_path = os.path.join(project_root, "backtesting/data/rolling_sentiment_historical.pkl")
+    rolling_sentiment.to_pickle(final_path)
+    print(f"SUCCESS! Final rolling sentiment matrix saved to: {final_path}")
+
+if __name__ == "__main__":
+    process_massive_dataset()

backtesting/data_pipeline/score_fnspid_bert.py

@@ -0,0 +1,58 @@
+import pandas as pd
+import numpy as np
+import sys
+import os
+import time
+
+sys.path.insert(0, os.path.abspath('..'))
+from brain.sentiment.analyzer import analyze_sentiment_batch
+
+def score_news():
+    input_file = 'data/filtered_news.csv'
+    output_file = 'data/sentiment_cache.pkl'
+    
+    if not os.path.exists(input_file):
+        print(f"Error: {input_file} not found. Run filter_fnspid.py first.")
+        return
+        
+    print(f"Loading {input_file}...")
+    df = pd.read_csv(input_file)
+    print(f"Loaded {len(df)} articles.")
+    
+    # Clean up dates
+    df['Date'] = pd.to_datetime(df['Date'], utc=True, errors='coerce').dt.tz_convert(None).dt.normalize()
+    df = df.dropna(subset=['Date', 'Stock_symbol'])
+    
+    # Prepare text: combine Title + Summary
+    df['Article_title'] = df['Article_title'].fillna('')
+    if 'Lsa_summary' in df.columns:
+        df['Lsa_summary'] = df['Lsa_summary'].fillna('')
+        texts = (df['Article_title'] + ". " + df['Lsa_summary']).tolist()
+    else:
+        texts = df['Article_title'].tolist()
+        
+    print("Running batch BERT inference...")
+    start_time = time.time()
+    
+    # We can pass all texts directly to analyze_sentiment_batch because it handles batching internally
+    scores = analyze_sentiment_batch(texts)
+    
+    df['sentiment_score'] = scores
+    
+    print(f"Inference complete in {time.time() - start_time:.1f} seconds.")
+    
+    # Aggregate to daily average per ticker
+    print("Aggregating to daily sentiment matrix...")
+    df_pivot = df.groupby(['Date', 'Stock_symbol'])['sentiment_score'].mean().unstack(fill_value=0)
+    
+    # Forward fill 0 for missing days within the range
+    if not df_pivot.empty:
+        full_date_range = pd.date_range(start=df_pivot.index.min(), end=df_pivot.index.max(), freq='D')
+        df_pivot = df_pivot.reindex(full_date_range).fillna(0)
+    
+    # Save to pickle
+    df_pivot.to_pickle(output_file)
+    print(f"Saved sentiment matrix to {output_file} shape: {df_pivot.shape}")
+
+if __name__ == "__main__":
+    score_news()

backtesting/engines/v11_causal_engine.py

@@ -0,0 +1,190 @@
+# -*- coding: utf-8 -*-
+"""
+V11 Causal Engine — Adapted for Validation Framework
+======================================================
+V11 Quantum strategy using the same cached data infrastructure as V30.
+Composite alpha: M1 + M6 + M12 + VAM + H52 - RSI (z-scored)
+Rank-based sizing, 25% trailing stops, 40-day rebal, 50% cash regime filter.
+"""
+import os, sys
+import numpy as np, pandas as pd
+import warnings; warnings.filterwarnings("ignore")
+
+sys.path.insert(0, os.path.dirname(__file__))
+from backtesting.engines.v30_causal_engine import load_data, evaluate_slice, CAP, TRAIN_START, TRAIN_END, TEST_START, TEST_END
+
+TOP_N = 15
+BUFFER = 15
+REBAL = 40
+TX_FEE = 0.0025
+CASH_PCT = 0.50
+TRAILING_STOP_PCT = 0.25
+
+V11_PARAMS = {
+    "top_n": TOP_N, "rebal_days": REBAL, "tx_fee": TX_FEE,
+    "cash_pct": CASH_PCT, "trailing_stop_pct": TRAILING_STOP_PCT,
+    "sma_lookback": 200,
+}
+
+def calc_v11_alpha(dc, vf):
+    """Compute V11 composite alpha signal (z-scored cross-sectional blend)."""
+    ret = dc[vf].pct_change()
+    m1 = (dc[vf] / dc[vf].shift(21)) - 1
+    m3 = (dc[vf] / dc[vf].shift(63)) - 1
+    m6 = (dc[vf] / dc[vf].shift(126)) - 1
+    m12_1 = (dc[vf].shift(21) / dc[vf].shift(252)) - 1
+    vol = ret.rolling(21).std() * np.sqrt(252)
+    vam = m3 / (vol + 1e-8)
+    h52 = dc[vf] / dc[vf].rolling(252).max()
+
+    # RSI-14
+    delta = dc[vf].diff()
+    gain = delta.clip(lower=0)
+    loss = -1 * delta.clip(upper=0)
+    rs = gain.ewm(com=13, adjust=False).mean() / (loss.ewm(com=13, adjust=False).mean() + 1e-8)
+    rsi = 100 - (100 / (1 + rs))
+
+    alpha = pd.DataFrame(index=dc.index, columns=vf, dtype=float)
+
+    for i in range(252, len(dc)):
+        row_m1 = m1.iloc[i].dropna()
+        row_m6 = m6.iloc[i].dropna()
+        row_m12 = m12_1.iloc[i].dropna()
+        row_v = vam.iloc[i].dropna()
+        row_h = h52.iloc[i].dropna()
+        row_rsi = rsi.iloc[i].dropna()
+
+        valid = list(set(row_m1.index) & set(row_m6.index) & set(row_m12.index) &
+                     set(row_v.index) & set(row_h.index) & set(row_rsi.index))
+        if len(valid) < 50:
+            continue
+
+        v_m1, v_m6, v_m12 = row_m1[valid], row_m6[valid], row_m12[valid]
+        v_v, v_h, v_rsi = row_v[valid], row_h[valid], row_rsi[valid]
+
+        z = lambda s: (s - s.mean()) / (s.std() + 1e-8)
+        comp = 0.28*z(v_m1) + 0.15*z(v_m6) + 0.15*z(v_m12) + 0.15*z(v_v) + 0.15*z(v_h) - 0.05*z(v_rsi)
+        alpha.iloc[i, alpha.columns.get_indexer(valid)] = comp.values
+
+    return alpha
+
+def run_v11_backtest(dc=None, spy=None, vf=None, daily_ret=None,
+                     top_n=15, rebal_days=40, tx_fee=0.0025,
+                     cash_pct=0.50, trailing_stop_pct=0.25,
+                     sma_lookback=200, alpha_df=None):
+    """V11 Quantum backtest using cached data. Returns curve compatible with V30 evaluate_slice."""
+    if dc is None:
+        dc, spy, vf, daily_ret = load_data()
+
+    if alpha_df is None:
+        alpha_df = calc_v11_alpha(dc, vf)
+
+    spy_sma = spy.rolling(sma_lookback).mean()
+
+    cash = CAP
+    holdings = {}
+    max_price = {}
+    history = []
+    days = 0
+
+    for i in range(1, len(dc)):
+        dt = dc.index[i]
+        if dt < pd.to_datetime("2008-01-01"):
+            continue
+
+        # Update portfolio value & trailing stops
+        val = cash
+        for tk in list(holdings.keys()):
+            p = dc[tk].iloc[i] if pd.notna(dc[tk].iloc[i]) else dc[tk].iloc[i-1]
+            val += holdings[tk] * p
+            max_price[tk] = max(max_price.get(tk, p), p)
+
+            if p < max_price[tk] * (1 - trailing_stop_pct):
+                pr = holdings[tk] * p
+                cash += pr - pr * tx_fee
+                val = val - holdings[tk] * p + pr - pr * tx_fee
+                del holdings[tk]
+                del max_price[tk]
+
+        history.append(val)
+
+        days += 1
+        if days < rebal_days:
+            continue
+        days = 0
+
+        # Regime
+        sp = spy.iloc[i-1] if i > 0 else spy.iloc[0]
+        sm = spy_sma.iloc[i-1] if i > 0 else spy_sma.iloc[0]
+        risk_on = not pd.isna(sm) and sp > sm
+
+        # Alpha ranking (CAUSAL: use i-1)
+        row = alpha_df.iloc[i-1].dropna()
+        valid_tk = [t for t in vf if t in row.index]
+        if not valid_tk:
+            continue
+
+        d = pd.DataFrame({"T": valid_tk, "A": row[valid_tk]}).sort_values("A", ascending=False)
+
+        target = {}
+        if len(d) >= top_n and d.head(top_n)["A"].mean() >= 0:
+            top = d.head(top_n)
+            bs = set(d.head(top_n + BUFFER)["T"])
+            am = dict(zip(d["T"], d["A"]))
+
+            sel = []
+            for t in [t for t in holdings if holdings.get(t, 0) > 1e-5]:
+                if len(sel) >= top_n: break
+                if t in bs and am.get(t, -99) > 0: sel.append(t)
+            for _, r in top.iterrows():
+                if len(sel) >= top_n: break
+                if r["T"] not in sel: sel.append(r["T"])
+
+            ta = sum(max(am.get(t, 0.01), 0.01) for t in sel)
+            if ta > 0:
+                target = {t: max(am.get(t, 0.01), 0.01) / ta for t in sel}
+            else:
+                target = {t: 1.0/len(sel) for t in sel}
+
+        multiplier = 1.0 if risk_on else (1.0 - cash_pct)
+        for k in target: target[k] *= multiplier
+
+        # Execute: Sell
+        for tk in list(holdings.keys()):
+            p = dc[tk].iloc[i]
+            if pd.isna(p): continue
+            cur_alloc = (holdings[tk] * p) / val if val > 0 else 0
+            tgt_alloc = target.get(tk, 0)
+            if tgt_alloc < cur_alloc:
+                sell_sh = holdings[tk] if tgt_alloc == 0 else holdings[tk] * (1 - tgt_alloc / cur_alloc)
+                pr = sell_sh * p
+                cash += pr - pr * tx_fee
+                holdings[tk] -= sell_sh
+                if holdings[tk] <= 1e-5:
+                    del holdings[tk]
+                    if tk in max_price: del max_price[tk]
+
+        # Execute: Buy
+        for tk, tgt_alloc in target.items():
+            p = dc[tk].iloc[i]
+            if pd.isna(p): continue
+            cur_sh = holdings.get(tk, 0)
+            cur_alloc = (cur_sh * p) / val if val > 0 else 0
+            if tgt_alloc > cur_alloc:
+                deploy = val * (tgt_alloc - cur_alloc)
+                if cash >= deploy:
+                    cost = deploy * tx_fee
+                    cash -= deploy + cost
+                    holdings[tk] = cur_sh + deploy / p
+                    max_price[tk] = p
+
+    # Liquidate
+    for tk, sh in holdings.items():
+        p = dc[tk].iloc[-1]
+        cash += sh * p - sh * p * tx_fee
+    if history:
+        history[-1] = cash
+
+    test_idx = dc.index[dc.index >= "2008-01-01"]
+    cap = pd.Series(history, index=test_idx[:len(history)])
+    return {"curve": cap, "daily_returns": cap.pct_change().dropna(), "alpha_df": alpha_df}

backtesting/engines/v30_causal_engine.py

@@ -0,0 +1,316 @@
+# -*- coding: utf-8 -*-
+"""
+V30 Causal Engine — Shared Module
+==================================
+Single source of truth for data loading and the causally-correct
+V30 backtest engine. ALL validation scripts import from here.
+
+CAUSAL GUARANTEES:
+  - Regime detection uses spy[i-1] and sma[i-1] (yesterday's close)
+  - Momentum signal uses m_signal.iloc[i-1] (yesterday's signal)
+  - Portfolio return uses daily_ret.iloc[i] (today's actual return)
+  - No future information leaks into any decision
+"""
+
+import os
+import numpy as np, pandas as pd, yfinance as yf
+import warnings; warnings.filterwarnings("ignore")
+
+# =============================================================================
+# CONSTANTS
+# =============================================================================
+LB = "2006-01-01"
+BE = "2026-12-31"
+CAP = 100_000.0
+TRAIN_START = "2008-01-01"
+TRAIN_END   = "2018-12-31"
+TEST_START  = "2019-01-01"
+TEST_END    = "2025-12-31"
+
+# =============================================================================
+# TICKER UNIVERSE
+# =============================================================================
+CU = [
+    "AAPL","ABBV","ABT","ACN","ADBE","ADI","ADM","ADP","ADSK","AEE","AEP","AES",
+    "AFL","AIG","AIZ","AJG","AKAM","ALB","ALK","ALL","AMAT","AMD","AME","AMGN",
+    "AMP","AMT","AMZN","AON","AOS","APA","APD","APH","ARE","ATO","AVB","AVGO",
+    "AVY","AWK","AXP","AZO","BA","BAC","BAX","BBY","BDX","BEN","BIO","BIIB",
+    "BK","BKNG","BKR","BLK","BMY","BR","BRK-B","BRO","BSX","BWA","BXP","C",
+    "CAG","CAH","CAT","CB","CBOE","CBRE","CCI","CCL","CDNS","CE","CF","CFG",
+    "CHD","CHRW","CHTR","CI","CINF","CL","CLX","CMCSA","CME","CMG","CMI","CMS",
+    "CNC","CNP","COF","COO","COP","COST","CPB","CPRT","CPT","CRL","CRM","CSCO",
+    "CSX","CTAS","CTSH","CVS","CVX","D","DAL","DD","DE","DG","DGX","DHI","DHR",
+    "DIS","DLR","DLTR","DOV","DPZ","DRI","DTE","DUK","DVA","DVN","EA","EBAY",
+    "ECL","ED","EFX","EIX","EL","EMN","EMR","EOG","EQIX","EQR","EQT","ES","ESS",
+    "ETN","ETR","EVRG","EW","EXC","EXPD","EXPE","EXR","F","FAST","FCX","FDS",
+    "FDX","FE","FFIV","FIS","FISV","FITB","FMC","FOX","FOXA","FRT","FTNT","FTV",
+    "GD","GE","GILD","GIS","GL","GLW","GM","GOOG","GOOGL","GPC","GPN","GRMN",
+    "GS","GWW","HAL","HAS","HBAN","HCA","HD","HOLX","HON","HPE","HPQ","HRL",
+    "HSIC","HST","HSY","HUM","IBM","ICE","IDXX","IEX","IFF","ILMN","INCY","INTC",
+    "INTU","IP","IQV","IR","IRM","ISRG","IT","ITW","IVZ","J","JBHT","JCI","JKHY",
+    "JNJ","JPM","KEY","KEYS","KHC","KIM","KLAC","KMB","KMI","KMX","KO","KR","L",
+    "LDOS","LEN","LH","LHX","LIN","LKQ","LLY","LMT","LNC","LNT","LOW","LRCX",
+    "LUV","LVS","LW","LYB","LYV","MA","MAA","MAR","MAS","MCD","MCHP","MCK","MCO",
+    "MDLZ","MDT","MET","META","MGM","MHK","MKC","MKTX","MLM","MMM","MNST","MO",
+    "MOH","MOS","MPC","MPWR","MRK","MS","MSCI","MSFT","MSI","MTB","MTCH","MTD",
+    "MU","NCLH","NDAQ","NDSN","NEE","NEM","NFLX","NI","NKE","NOC","NOW","NRG",
+    "NSC","NTAP","NTRS","NUE","NVDA","NVR","NWL","NWS","NWSA","NXPI","O","ODFL",
+    "OKE","OMC","ON","ORCL","ORLY","OXY","PAYC","PAYX","PCAR","PCG","PEG","PEP",
+    "PFE","PFG","PG","PGR","PH","PHM","PKG","PLD","PM","PNC","PNR","PNW","POOL",
+    "PPG","PPL","PRU","PSA","PSX","PTC","PVH","PWR","PYPL","QCOM","QRVO","RCL",
+    "REG","REGN","RF","RHI","RJF","RL","RMD","ROK","ROL","ROP","ROST","RSG","RTX",
+    "SBAC","SBUX","SCHW","SEE","SHW","SJM","SLB","SNA","SNPS","SO","SPG","SPGI",
+    "SRE","STE","STT","STX","STZ","SWK","SWKS","SYK","SYY","T","TAP","TDG","TDY",
+    "TECH","TEL","TER","TFC","TFX","TGT","TJX","TMO","TMUS","TPR","TRGP","TRMB",
+    "TROW","TRV","TSCO","TSLA","TSN","TT","TTWO","TXN","TXT","TYL","UAL","UDR",
+    "UHS","ULTA","UNH","UNP","UPS","URI","USB","V","VFC","VLO","VMC","VNO","VRSK",
+    "VRSN","VRTX","VTR","VTRS","VZ","WAB","WAT","WDC","WEC","WELL","WFC","WHR",
+    "WM","WMB","WMT","WRB","WST","WTW","WY","WYNN","XEL","XOM","XYL","YUM","ZBH",
+    "ZBRA","ZION","ZTS",
+    "SMCI","DXCM","DELL","PANW","ET","EPD","MPLX","FANG","HWM","CDW","CSGP",
+    "BBWI","ALLE","AMCR","KDP","SYF","LUMN","DXC","GNRC","ETSY","VEEV","WDAY","SHOP"
+]
+RI = [
+    "ABNB","CRWD","DDOG","SNOW","PLTR","COIN","MELI","TEAM","DASH","TTD",
+    "ZS","MNDY","NET","OKTA","BILL","HUBS","DKNG","U","RIVN","LCID",
+    "SOFI","HOOD","NU","GRAB","SE","SPOT","SNAP","PINS","ROKU","RBLX",
+    "UBER","LYFT","HLT","IHG","ELV","CARR","OTIS","DOW","CTVA","CEG","GEV","SOLV",
+    "VLTO","KVUE","GEHC","ARM","DECK","VST","GDDY","AXON","ERIE","APP",
+    "TPL","RVTY","EG","FBIN","PODD","NTRA","TOST","DOC","CPAY","HUBB",
+    "BX","KKR","APO","ARES","CG","MRNA","INVH","VICI","CZR","CTRA","OGN"
+]
+FU = list(dict.fromkeys(CU + RI))
+
+# =============================================================================
+# V30 DEFAULT PARAMETERS
+# =============================================================================
+V30_PARAMS = {
+    "top_n": 15,
+    "rebal_days": 60,
+    "vol_target": 0.18,
+    "riskoff_haircut": 0.50,
+    "sma_lookback": 200,
+    "mom_long": 175,
+    "mom_short": 21,
+}
+
+# =============================================================================
+# DATA LOADING (cached in module-level globals)
+# =============================================================================
+_dc = None
+_spy = None
+_vf = None
+_daily_ret = None
+
+def load_data(extra_tickers=None):
+    """Download and cache price data. Call once per script."""
+    global _dc, _spy, _vf, _daily_ret
+    
+    tickers = list(set(FU + ["SPY"] + (extra_tickers or [])))
+    
+    cache_file = "market_data_cache.pkl"
+    if os.path.exists(cache_file) and extra_tickers is None:
+        raw = pd.read_pickle(cache_file)
+    else:
+        raw = yf.download(tickers, start=LB, end=BE, progress=False)
+        if extra_tickers is None and len(raw) > 100:
+            raw.to_pickle(cache_file)
+            
+    lvl0 = raw.columns.get_level_values(0).unique().tolist() if isinstance(raw.columns, pd.MultiIndex) else []
+    dc = raw["Close"] if "Close" in lvl0 else raw
+    if isinstance(dc.columns, pd.MultiIndex):
+        dc.columns = dc.columns.get_level_values(-1)
+    dc = dc.ffill().dropna(how="all")
+    
+    _dc = dc
+    _spy = dc["SPY"].copy()
+    _vf = [t for t in FU if t in dc.columns and dc[t].notna().sum() > 252]
+    _daily_ret = dc.pct_change()
+    
+    print(f"Data loaded: {len(dc)} days, {len(_vf)} valid tickers.")
+    return dc, _spy, _vf, _daily_ret
+
+def get_data():
+    """Return cached data or load if not yet loaded."""
+    if _dc is None:
+        return load_data()
+    return _dc, _spy, _vf, _daily_ret
+
+# =============================================================================
+# CAUSAL BACKTEST ENGINE
+# =============================================================================
+def run_causal_backtest(dc=None, spy=None, vf=None, daily_ret=None,
+                        top_n=15, rebal_days=60, vol_target=0.18,
+                        riskoff_haircut=0.50, sma_lookback=200,
+                        mom_long=175, mom_short=21,
+                        txn_cost_bps=20, regime_txn_multiplier=1.0,
+                        custom_universe=None,
+                        return_holdings=False):
+    """
+    Run the causally-correct V30 backtest.
+    
+    CAUSAL GUARANTEES:
+      - Regime: spy[i-1], sma[i-1]
+      - Signal: m_signal.iloc[i-1]
+      - Return: daily_ret.iloc[i]
+    
+    Args:
+        dc, spy, vf, daily_ret: Price data (uses cached if None)
+        top_n ... mom_short: Strategy parameters
+        txn_cost_bps: Transaction cost per trade in basis points
+        regime_txn_multiplier: Multiplier on txn cost during regime switches
+        custom_universe: Override vf with custom ticker list
+        return_holdings: If True, also return holdings log
+        
+    Returns:
+        dict with 'curve', 'daily_returns', 'port_rets_list',
+              'vol_scalars', 'regime_status', 'holdings_log'
+    """
+    if dc is None:
+        dc, spy, vf, daily_ret = get_data()
+    
+    if custom_universe is not None:
+        vf = [t for t in custom_universe if t in dc.columns and dc[t].notna().sum() > 252]
+    
+    m_signal = (dc[vf].shift(mom_short) / dc[vf].shift(mom_long)) - 1
+    sma = spy.rolling(sma_lookback).mean()
+    
+    sma_vals = sma.values
+    spy_vals = spy.values
+    txn_frac = txn_cost_bps / 10000.0
+    
+    nav = CAP
+    pick_tks = []
+    port_rets = []
+    days = 0
+    hist = []
+    vol_scalars = []
+    regime_log = []
+    holdings_log = []
+    prev_riskoff = False
+    
+    for i in range(1, len(dc)):
+        # Volatility scalar
+        if len(port_rets) >= 21:
+            window = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            rvol = np.std(window) * np.sqrt(252)
+            vol_scalar = vol_target / (rvol + 1e-8)
+        else:
+            vol_scalar = 0.5
+        
+        # CAUSAL regime detection: yesterday's data
+        sp = spy_vals[i-1]
+        sm = sma_vals[i-1]
+        is_riskoff = bool(pd.isna(sm) or sp <= sm)
+        
+        if is_riskoff:
+            vol_scalar *= riskoff_haircut
+        
+        vol_scalar = float(np.clip(vol_scalar, 0.05, 1.0))
+        
+        # Determine if regime just switched (for txn cost multiplier)
+        regime_switched = (is_riskoff != prev_riskoff) and i > 1
+        current_txn_mult = regime_txn_multiplier if regime_switched else 1.0
+        prev_riskoff = is_riskoff
+        
+        # Daily return
+        day_ret = 0.0
+        if pick_tks:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if len(lr) > 0:
+                day_ret = lr.mean() * vol_scalar
+                nav *= (1 + day_ret)
+                # Amortized transaction cost
+                nav -= nav * txn_frac * 2 * current_txn_mult / rebal_days * vol_scalar
+                # Floor portfolio value to simulate brokerage liquidation
+                nav = max(nav, 0.01)
+        
+        port_rets.append(day_ret)
+        hist.append(nav)
+        vol_scalars.append(vol_scalar)
+        regime_log.append(is_riskoff)
+        
+        # Rebalance
+        days += 1
+        if days >= rebal_days:
+            days = 0
+            # CAUSAL signal: yesterday's momentum
+            row = m_signal.iloc[i].dropna()
+            valid = [t for t in vf if t in row.index]
+            if len(valid) >= top_n:
+                d = pd.DataFrame({"T": valid, "A": row[valid]}).sort_values("A", ascending=False)
+                pick_tks = list(d.head(top_n)["T"])
+                if return_holdings:
+                    holdings_log.append({"date": dc.index[i], "tickers": list(pick_tks)})
+    
+    # Build output
+    cap = pd.Series(hist, index=dc.index[1:len(hist)+1])
+    dr = cap.pct_change().dropna()
+    
+    result = {
+        "curve": cap,
+        "daily_returns": dr,
+        "port_rets_list": port_rets,
+        "vol_scalars": vol_scalars,
+        "regime_status": regime_log,
+    }
+    if return_holdings:
+        result["holdings_log"] = holdings_log
+    
+    return result
+
+# =============================================================================
+# METRICS
+# =============================================================================
+def evaluate_slice(cap, start_date, end_date, initial_capital=CAP):
+    """Extract metrics for a date slice of an equity curve."""
+    sd = pd.to_datetime(start_date)
+    ed = pd.to_datetime(end_date)
+    
+    sub_cap = cap[(cap.index >= sd) & (cap.index <= ed)]
+    if len(sub_cap) < 50:
+        return {"sharpe": 0, "cagr": 0, "mdd": 0, "curve": sub_cap}
+    
+    # Rebase
+    sub_cap = sub_cap / sub_cap.iloc[0] * initial_capital
+    dr = sub_cap.pct_change().dropna()
+    
+    exc = dr - 0.04/252
+    sharpe = float(np.sqrt(252) * exc.mean() / exc.std()) if exc.std() > 0 else 0
+    
+    td = (sub_cap.index[-1] - sub_cap.index[0]).days
+    years = td / 365.25
+    cagr = float(((sub_cap.iloc[-1] / initial_capital) ** (1/years) - 1) * 100) if years > 0 else 0
+    
+    mdd = float(((sub_cap - sub_cap.cummax()) / sub_cap.cummax()).min() * 100)
+    
+    # Sortino
+    downside = dr[dr < 0]
+    downside_std = float(np.sqrt(np.mean(downside**2)) * np.sqrt(252)) if len(downside) > 0 else 1e-8
+    sortino = float((dr.mean() * 252 - 0.04) / downside_std) if downside_std > 0 else 0
+    
+    # Calmar
+    calmar = float(cagr / abs(mdd)) if abs(mdd) > 0.01 else 0
+    
+    ann_vol = float(dr.std() * np.sqrt(252) * 100)
+    
+    return {
+        "sharpe": sharpe,
+        "cagr": cagr,
+        "mdd": mdd,
+        "sortino": sortino,
+        "calmar": calmar,
+        "ann_vol": ann_vol,
+        "curve": sub_cap,
+        "daily_returns": dr,
+        "years": years,
+        "final_value": float(sub_cap.iloc[-1]),
+    }
+
+def compute_spy_metrics(spy, start_date, end_date):
+    """Compute SPY benchmark metrics for a date range."""
+    sd = pd.to_datetime(start_date)
+    ed = pd.to_datetime(end_date)
+    s = spy[(spy.index >= sd) & (spy.index <= ed)]
+    sc = s / s.iloc[0] * CAP
+    return evaluate_slice(sc, start_date, end_date)

backtesting/engines/v36_research_engine.py

@@ -0,0 +1,345 @@
+# -*- coding: utf-8 -*-
+"""
+V36 Research Engine — Enhancement Testing Framework
+=====================================================
+Extends the V30 causal engine with 3 independent, toggleable enhancements.
+Each enhancement can be enabled/disabled independently for isolation testing.
+
+ENHANCEMENTS:
+  A. Inverse-Volatility Weighting (IVW)  — replace equal-weight with vol-parity
+  B. Composite Signal (COMP)             — blend price momentum + earnings momentum proxy
+  C. Sector-Neutral Construction (SN)    — pick best momentum within each sector
+
+CAUSAL GUARANTEES (inherited from V30):
+  - Regime: spy[i-1], sma[i-1]
+  - Signal: m_signal.iloc[i-1]
+  - Return: daily_ret.iloc[i]
+  - Vol weights: trailing 60-day realized vol (no lookahead)
+"""
+
+import os, sys
+import numpy as np, pandas as pd
+import warnings; warnings.filterwarnings("ignore")
+
+sys.path.insert(0, os.path.dirname(__file__))
+from backtesting.engines.v30_causal_engine import (
+    load_data, get_data, evaluate_slice, compute_spy_metrics,
+    V30_PARAMS, CU, RI, FU, CAP, LB, BE,
+    TRAIN_START, TRAIN_END, TEST_START, TEST_END
+)
+
+# =============================================================================
+# SECTOR MAP (GICS-based, covers ~80% of universe)
+# =============================================================================
+SECTOR_MAP = {
+    # Technology
+    "AAPL": "Tech", "MSFT": "Tech", "NVDA": "Tech", "AVGO": "Tech", "ADBE": "Tech",
+    "CRM": "Tech", "CSCO": "Tech", "ORCL": "Tech", "ACN": "Tech", "INTC": "Tech",
+    "AMD": "Tech", "INTU": "Tech", "NOW": "Tech", "AMAT": "Tech", "ADI": "Tech",
+    "KLAC": "Tech", "LRCX": "Tech", "CDNS": "Tech", "SNPS": "Tech", "ADSK": "Tech",
+    "FTNT": "Tech", "PANW": "Tech", "CRWD": "Tech", "DDOG": "Tech", "SNOW": "Tech",
+    "NET": "Tech", "ZS": "Tech", "MCHP": "Tech", "TXN": "Tech", "MU": "Tech",
+    "NXPI": "Tech", "ON": "Tech", "MPWR": "Tech", "KEYS": "Tech", "TER": "Tech",
+    "QCOM": "Tech", "SWKS": "Tech", "QRVO": "Tech", "IT": "Tech", "MSI": "Tech",
+    "TEL": "Tech", "APH": "Tech", "GLW": "Tech", "ADP": "Tech", "FISV": "Tech",
+    "FIS": "Tech", "GPN": "Tech", "BR": "Tech", "JKHY": "Tech", "FFIV": "Tech",
+    "NTAP": "Tech", "HPE": "Tech", "HPQ": "Tech", "STX": "Tech", "WDC": "Tech",
+    "DELL": "Tech", "SMCI": "Tech", "PLTR": "Tech", "CTSH": "Tech", "EPAM": "Tech",
+    "AKAM": "Tech", "PTC": "Tech", "TYL": "Tech", "TRMB": "Tech", "ZBRA": "Tech",
+    "ARM": "Tech",
+    # Healthcare
+    "UNH": "Health", "JNJ": "Health", "LLY": "Health", "ABBV": "Health", "MRK": "Health",
+    "PFE": "Health", "TMO": "Health", "ABT": "Health", "DHR": "Health", "BMY": "Health",
+    "AMGN": "Health", "GILD": "Health", "MDT": "Health", "ISRG": "Health", "SYK": "Health",
+    "BSX": "Health", "EW": "Health", "VRTX": "Health", "REGN": "Health", "IDXX": "Health",
+    "CI": "Health", "HUM": "Health", "CNC": "Health", "MOH": "Health", "HCA": "Health",
+    "BDX": "Health", "BAX": "Health", "IQV": "Health", "HOLX": "Health", "DGX": "Health",
+    "BIO": "Health", "BIIB": "Health", "INCY": "Health", "ILMN": "Health", "DVA": "Health",
+    "LH": "Health", "MRNA": "Health", "ELV": "Health", "GEHC": "Health", "PODD": "Health",
+    "NTRA": "Health", "DXCM": "Health",
+    # Financials
+    "BRK-B": "Fin", "JPM": "Fin", "BAC": "Fin", "WFC": "Fin", "GS": "Fin",
+    "MS": "Fin", "SCHW": "Fin", "C": "Fin", "BLK": "Fin", "SPGI": "Fin",
+    "ICE": "Fin", "CME": "Fin", "AXP": "Fin", "COF": "Fin", "USB": "Fin",
+    "PNC": "Fin", "TFC": "Fin", "MTB": "Fin", "FITB": "Fin", "KEY": "Fin",
+    "HBAN": "Fin", "CFG": "Fin", "RF": "Fin", "ZION": "Fin", "STT": "Fin",
+    "NTRS": "Fin", "BK": "Fin", "AIG": "Fin", "ALL": "Fin", "MET": "Fin",
+    "PRU": "Fin", "AFL": "Fin", "AMP": "Fin", "PFG": "Fin", "LNC": "Fin",
+    "GL": "Fin", "CINF": "Fin", "CB": "Fin", "AON": "Fin", "MMC": "Fin",
+    "AJG": "Fin", "BRO": "Fin", "WRB": "Fin", "RJF": "Fin", "MSCI": "Fin",
+    "NDAQ": "Fin", "CBOE": "Fin", "MCO": "Fin", "FDS": "Fin", "MKTX": "Fin",
+    "IVZ": "Fin", "BEN": "Fin", "TROW": "Fin", "BX": "Fin", "KKR": "Fin",
+    "APO": "Fin", "ARES": "Fin", "CG": "Fin", "COIN": "Fin", "HOOD": "Fin",
+    "SOFI": "Fin", "SYF": "Fin", "AIZ": "Fin",
+    # Consumer Discretionary
+    "AMZN": "ConDisc", "TSLA": "ConDisc", "HD": "ConDisc", "LOW": "ConDisc",
+    "MCD": "ConDisc", "NKE": "ConDisc", "SBUX": "ConDisc", "TJX": "ConDisc",
+    "CMG": "ConDisc", "BKNG": "ConDisc", "MAR": "ConDisc", "HLT": "ConDisc",
+    "ROST": "ConDisc", "DHI": "ConDisc", "LEN": "ConDisc", "PHM": "ConDisc",
+    "NVR": "ConDisc", "GM": "ConDisc", "F": "ConDisc", "BWA": "ConDisc",
+    "RL": "ConDisc", "PVH": "ConDisc", "TPR": "ConDisc", "VFC": "ConDisc",
+    "ULTA": "ConDisc", "DRI": "ConDisc", "DPZ": "ConDisc", "LVS": "ConDisc",
+    "WYNN": "ConDisc", "MGM": "ConDisc", "CCL": "ConDisc", "RCL": "ConDisc",
+    "NCLH": "ConDisc", "EXPE": "ConDisc", "LYV": "ConDisc", "BBY": "ConDisc",
+    "KMX": "ConDisc", "DG": "ConDisc", "DLTR": "ConDisc", "TGT": "ConDisc",
+    "TSCO": "ConDisc", "GPC": "ConDisc", "ORLY": "ConDisc", "AZO": "ConDisc",
+    "POOL": "ConDisc", "ETSY": "ConDisc", "SHOP": "ConDisc", "ABNB": "ConDisc",
+    "DASH": "ConDisc", "DKNG": "ConDisc", "UBER": "ConDisc", "LYFT": "ConDisc",
+    "RIVN": "ConDisc", "LCID": "ConDisc", "CZR": "ConDisc", "DECK": "ConDisc",
+    "GRMN": "ConDisc", "LKQ": "ConDisc", "MHK": "ConDisc", "NWL": "ConDisc",
+    "SWK": "ConDisc", "WHR": "ConDisc", "HAS": "ConDisc",
+    # Consumer Staples
+    "PG": "ConStap", "KO": "ConStap", "PEP": "ConStap", "COST": "ConStap",
+    "WMT": "ConStap", "PM": "ConStap", "MO": "ConStap", "MDLZ": "ConStap",
+    "CL": "ConStap", "CLX": "ConStap", "KMB": "ConStap", "KHC": "ConStap",
+    "GIS": "ConStap", "CAG": "ConStap", "CPB": "ConStap", "SJM": "ConStap",
+    "HRL": "ConStap", "HSY": "ConStap", "MNST": "ConStap", "STZ": "ConStap",
+    "TAP": "ConStap", "TSN": "ConStap", "ADM": "ConStap", "KR": "ConStap",
+    "SYY": "ConStap", "CHD": "ConStap", "EL": "ConStap", "KDP": "ConStap",
+    "KVUE": "ConStap",
+    # Energy
+    "XOM": "Energy", "CVX": "Energy", "COP": "Energy", "EOG": "Energy",
+    "SLB": "Energy", "MPC": "Energy", "PSX": "Energy", "VLO": "Energy",
+    "OXY": "Energy", "DVN": "Energy", "HAL": "Energy", "BKR": "Energy",
+    "APA": "Energy", "EQT": "Energy", "CF": "Energy", "MOS": "Energy",
+    "OKE": "Energy", "WMB": "Energy", "KMI": "Energy", "TRGP": "Energy",
+    "ET": "Energy", "EPD": "Energy", "MPLX": "Energy", "FANG": "Energy",
+    "CTRA": "Energy",
+    # Industrials
+    "GE": "Indust", "CAT": "Indust", "HON": "Indust", "UNP": "Indust",
+    "UPS": "Indust", "BA": "Indust", "RTX": "Indust", "DE": "Indust",
+    "LMT": "Indust", "GD": "Indust", "NOC": "Indust", "LHX": "Indust",
+    "TDG": "Indust", "ITW": "Indust", "EMR": "Indust", "ETN": "Indust",
+    "PH": "Indust", "ROK": "Indust", "DOV": "Indust", "AME": "Indust",
+    "CMI": "Indust", "IR": "Indust", "FTV": "Indust", "SNA": "Indust",
+    "FAST": "Indust", "WAB": "Indust", "CSX": "Indust", "NSC": "Indust",
+    "ODFL": "Indust", "JBHT": "Indust", "CHRW": "Indust", "DAL": "Indust",
+    "UAL": "Indust", "LUV": "Indust", "ALK": "Indust", "FDX": "Indust",
+    "EXPD": "Indust", "PCAR": "Indust", "CPRT": "Indust", "GWW": "Indust",
+    "CTAS": "Indust", "URI": "Indust", "RSG": "Indust", "WM": "Indust",
+    "ROL": "Indust", "RHI": "Indust", "J": "Indust", "LDOS": "Indust",
+    "PWR": "Indust", "TT": "Indust", "IEX": "Indust", "PNR": "Indust",
+    "NDSN": "Indust", "ROP": "Indust", "TDY": "Indust", "STE": "Indust",
+    "TFX": "Indust", "CARR": "Indust", "OTIS": "Indust", "AXON": "Indust",
+    "GEV": "Indust", "VLTO": "Indust", "HWM": "Indust", "HUBB": "Indust",
+    # Utilities
+    "NEE": "Util", "DUK": "Util", "SO": "Util", "D": "Util", "AEP": "Util",
+    "SRE": "Util", "EXC": "Util", "ED": "Util", "WEC": "Util", "ES": "Util",
+    "AEE": "Util", "DTE": "Util", "CMS": "Util", "PEG": "Util", "EIX": "Util",
+    "ETR": "Util", "FE": "Util", "CNP": "Util", "NI": "Util", "PPL": "Util",
+    "EVRG": "Util", "AES": "Util", "LNT": "Util", "PNW": "Util", "NRG": "Util",
+    "AWK": "Util", "PCG": "Util", "XEL": "Util", "CEG": "Util", "VST": "Util",
+    # Real Estate
+    "PLD": "RE", "AMT": "RE", "CCI": "RE", "EQIX": "RE", "SPG": "RE",
+    "O": "RE", "PSA": "RE", "DLR": "RE", "WELL": "RE", "AVB": "RE",
+    "EQR": "RE", "ESS": "RE", "MAA": "RE", "UDR": "RE", "CPT": "RE",
+    "VTR": "RE", "ARE": "RE", "BXP": "RE", "VNO": "RE", "FRT": "RE",
+    "KIM": "RE", "REG": "RE", "HST": "RE", "EXR": "RE", "IRM": "RE",
+    "SBAC": "RE", "INVH": "RE", "VICI": "RE", "DOC": "RE",
+    # Communication Services
+    "GOOG": "Comm", "GOOGL": "Comm", "META": "Comm", "DIS": "Comm",
+    "CMCSA": "Comm", "NFLX": "Comm", "TMUS": "Comm", "T": "Comm",
+    "VZ": "Comm", "CHTR": "Comm", "EA": "Comm", "TTWO": "Comm",
+    "OMC": "Comm", "IPG": "Comm", "FOX": "Comm", "FOXA": "Comm",
+    "NWS": "Comm", "NWSA": "Comm", "MTCH": "Comm", "LUMN": "Comm",
+    "SPOT": "Comm", "SNAP": "Comm", "PINS": "Comm", "ROKU": "Comm",
+    "RBLX": "Comm", "TTD": "Comm", "U": "Comm",
+    # Materials
+    "LIN": "Mats", "APD": "Mats", "SHW": "Mats", "ECL": "Mats",
+    "NUE": "Mats", "FCX": "Mats", "NEM": "Mats", "VMC": "Mats",
+    "MLM": "Mats", "DOW": "Mats", "DD": "Mats", "PPG": "Mats",
+    "EMN": "Mats", "CE": "Mats", "ALB": "Mats", "IFF": "Mats",
+    "FMC": "Mats", "AVY": "Mats", "SEE": "Mats", "PKG": "Mats",
+    "IP": "Mats", "LW": "Mats", "MKC": "Mats", "LYB": "Mats",
+    "CTVA": "Mats",
+}
+
+SECTORS = sorted(set(SECTOR_MAP.values()))
+
+# =============================================================================
+# V36 ENHANCED BACKTEST ENGINE
+# =============================================================================
+def run_v36_backtest(dc=None, spy=None, vf=None, daily_ret=None,
+                     # V30 base params
+                     top_n=15, rebal_days=60, vol_target=0.18,
+                     riskoff_haircut=0.50, sma_lookback=200,
+                     mom_long=175, mom_short=21,
+                     txn_cost_bps=20, regime_txn_multiplier=1.0,
+                     # Enhancement flags
+                     use_ivw=False,          # Enhancement A
+                     use_composite=False,    # Enhancement B
+                     composite_weight=0.70,  # Weight on price mom (rest = quality)
+                     use_sector_neutral=False,# Enhancement C
+                     sn_picks_per_sector=2,  # Stocks per sector in SN mode
+                     # Extra
+                     custom_universe=None,
+                     return_holdings=False,
+                     ivw_lookback=60):
+    """
+    V36 Enhanced Causal Backtest.
+
+    All 3 enhancements are independently toggleable. When all flags are False,
+    this produces identical output to run_causal_backtest() (V30 baseline).
+    """
+    if dc is None:
+        dc, spy, vf, daily_ret = get_data()
+
+    if custom_universe is not None:
+        vf = [t for t in custom_universe if t in dc.columns and dc[t].notna().sum() > 252]
+
+    # --- Signal Construction ---
+    price_mom = (dc[vf].shift(mom_short) / dc[vf].shift(mom_long)) - 1
+
+    if use_composite:
+        # Enhancement B: Quality proxy = 6-month price stability (lower vol = higher quality)
+        # This is a pure-price proxy for earnings quality — no fundamental data needed.
+        # Rationale: Stocks with stable uptrends have more persistent momentum (Novy-Marx 2015)
+        ret_126 = dc[vf].pct_change()
+        rolling_vol = ret_126.rolling(126).std()
+        # Invert: lower vol = higher quality score (rank-normalize)
+        quality_rank = rolling_vol.rank(axis=1, ascending=True, pct=True)
+        mom_rank = price_mom.rank(axis=1, ascending=False, pct=True)
+        # Composite: weighted blend (higher = better)
+        m_signal = composite_weight * (1 - mom_rank) + (1 - composite_weight) * quality_rank
+    else:
+        m_signal = price_mom
+
+    sma = spy.rolling(sma_lookback).mean()
+    sma_vals = sma.values
+    spy_vals = spy.values
+    txn_frac = txn_cost_bps / 10000.0
+
+    # Pre-compute inverse-vol weights if needed
+    if use_ivw:
+        stock_vol = dc[vf].pct_change().rolling(ivw_lookback).std()
+
+    nav = CAP
+    pick_tks = []
+    pick_weights = {}  # ticker -> weight (for IVW)
+    port_rets = []
+    days = 0
+    hist = []
+    vol_scalars = []
+    regime_log = []
+    holdings_log = []
+    prev_riskoff = False
+
+    for i in range(1, len(dc)):
+        # Volatility scalar
+        if len(port_rets) >= 21:
+            window = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            rvol = np.std(window) * np.sqrt(252)
+            vol_scalar = vol_target / (rvol + 1e-8)
+        else:
+            vol_scalar = 0.5
+
+        # CAUSAL regime detection: yesterday's data
+        sp = spy_vals[i-1]
+        sm = sma_vals[i-1]
+        is_riskoff = bool(pd.isna(sm) or sp <= sm)
+
+        if is_riskoff:
+            vol_scalar *= riskoff_haircut
+
+        vol_scalar = float(np.clip(vol_scalar, 0.05, 1.0))
+
+        # Regime switch detection
+        regime_switched = (is_riskoff != prev_riskoff) and i > 1
+        current_txn_mult = regime_txn_multiplier if regime_switched else 1.0
+        prev_riskoff = is_riskoff
+
+        # Daily return
+        day_ret = 0.0
+        if pick_tks:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if len(lr) > 0:
+                if use_ivw and pick_weights:
+                    # Enhancement A: Weighted return
+                    w_sum = 0.0
+                    for t in lr.index:
+                        w = pick_weights.get(t, 1.0 / len(lr))
+                        day_ret += lr[t] * w
+                        w_sum += w
+                    if w_sum > 0:
+                        day_ret = day_ret / w_sum * sum(pick_weights.get(t, 1.0/len(lr)) for t in lr.index)
+                        # Normalize: ensure weights sum to 1
+                        day_ret = sum(lr[t] * pick_weights.get(t, 1.0/len(lr)) for t in lr.index)
+                else:
+                    day_ret = lr.mean()
+
+                day_ret *= vol_scalar
+                nav *= (1 + day_ret)
+                nav -= nav * txn_frac * 2 * current_txn_mult / rebal_days * vol_scalar
+                nav = max(nav, 0.01)
+
+        port_rets.append(day_ret)
+        hist.append(nav)
+        vol_scalars.append(vol_scalar)
+        regime_log.append(is_riskoff)
+
+        # Rebalance
+        days += 1
+        if days >= rebal_days:
+            days = 0
+            # CAUSAL signal: yesterday's momentum
+            row = m_signal.iloc[i].dropna()
+
+            if use_sector_neutral:
+                # Enhancement C: Pick top N from each sector
+                pick_tks = []
+                for sector in SECTORS:
+                    sector_tickers = [t for t in vf if t in row.index and SECTOR_MAP.get(t) == sector]
+                    if not sector_tickers:
+                        continue
+                    sector_scores = row[sector_tickers].sort_values(ascending=False)
+                    pick_tks.extend(list(sector_scores.head(sn_picks_per_sector).index))
+                # Also pick from unmapped tickers to avoid excluding them entirely
+                unmapped = [t for t in vf if t in row.index and t not in SECTOR_MAP]
+                if unmapped:
+                    um_scores = row[unmapped].sort_values(ascending=False)
+                    pick_tks.extend(list(um_scores.head(sn_picks_per_sector).index))
+            else:
+                valid = [t for t in vf if t in row.index]
+                if len(valid) >= top_n:
+                    d = pd.DataFrame({"T": valid, "A": row[valid]}).sort_values("A", ascending=False)
+                    pick_tks = list(d.head(top_n)["T"])
+
+            # Compute IVW weights if enabled
+            if use_ivw and pick_tks:
+                vols = {}
+                for t in pick_tks:
+                    if t in stock_vol.columns:
+                        v = stock_vol.iloc[i-1][t]
+                        if pd.notna(v) and v > 0:
+                            vols[t] = v
+                if vols:
+                    inv_vols = {t: 1.0/v for t, v in vols.items()}
+                    total_inv = sum(inv_vols.values())
+                    pick_weights = {t: iv/total_inv for t, iv in inv_vols.items()}
+                else:
+                    pick_weights = {t: 1.0/len(pick_tks) for t in pick_tks}
+            else:
+                pick_weights = {t: 1.0/len(pick_tks) for t in pick_tks} if pick_tks else {}
+
+            if return_holdings:
+                holdings_log.append({
+                    "date": dc.index[i],
+                    "tickers": list(pick_tks),
+                    "weights": dict(pick_weights),
+                })
+
+    # Build output
+    cap = pd.Series(hist, index=dc.index[1:len(hist)+1])
+    dr = cap.pct_change().dropna()
+
+    result = {
+        "curve": cap,
+        "daily_returns": dr,
+        "port_rets_list": port_rets,
+        "vol_scalars": vol_scalars,
+        "regime_status": regime_log,
+    }
+    if return_holdings:
+        result["holdings_log"] = holdings_log
+
+    return result

backtesting/engines/v36_research_engine_fixed.py

@@ -0,0 +1,345 @@
+# -*- coding: utf-8 -*-
+"""
+V36 Research Engine — Enhancement Testing Framework
+=====================================================
+Extends the V30 causal engine with 3 independent, toggleable enhancements.
+Each enhancement can be enabled/disabled independently for isolation testing.
+
+ENHANCEMENTS:
+  A. Inverse-Volatility Weighting (IVW)  — replace equal-weight with vol-parity
+  B. Composite Signal (COMP)             — blend price momentum + earnings momentum proxy
+  C. Sector-Neutral Construction (SN)    — pick best momentum within each sector
+
+CAUSAL GUARANTEES (inherited from V30):
+  - Regime: spy[i-1], sma[i-1]
+  - Signal: m_signal.iloc[i-1]
+  - Return: daily_ret.iloc[i]
+  - Vol weights: trailing 60-day realized vol (no lookahead)
+"""
+
+import os, sys
+import numpy as np, pandas as pd
+import warnings; warnings.filterwarnings("ignore")
+
+sys.path.insert(0, os.path.dirname(__file__))
+from backtesting.engines.v30_causal_engine import (
+    load_data, get_data, evaluate_slice, compute_spy_metrics,
+    V30_PARAMS, CU, RI, FU, CAP, LB, BE,
+    TRAIN_START, TRAIN_END, TEST_START, TEST_END
+)
+
+# =============================================================================
+# SECTOR MAP (GICS-based, covers ~80% of universe)
+# =============================================================================
+SECTOR_MAP = {
+    # Technology
+    "AAPL": "Tech", "MSFT": "Tech", "NVDA": "Tech", "AVGO": "Tech", "ADBE": "Tech",
+    "CRM": "Tech", "CSCO": "Tech", "ORCL": "Tech", "ACN": "Tech", "INTC": "Tech",
+    "AMD": "Tech", "INTU": "Tech", "NOW": "Tech", "AMAT": "Tech", "ADI": "Tech",
+    "KLAC": "Tech", "LRCX": "Tech", "CDNS": "Tech", "SNPS": "Tech", "ADSK": "Tech",
+    "FTNT": "Tech", "PANW": "Tech", "CRWD": "Tech", "DDOG": "Tech", "SNOW": "Tech",
+    "NET": "Tech", "ZS": "Tech", "MCHP": "Tech", "TXN": "Tech", "MU": "Tech",
+    "NXPI": "Tech", "ON": "Tech", "MPWR": "Tech", "KEYS": "Tech", "TER": "Tech",
+    "QCOM": "Tech", "SWKS": "Tech", "QRVO": "Tech", "IT": "Tech", "MSI": "Tech",
+    "TEL": "Tech", "APH": "Tech", "GLW": "Tech", "ADP": "Tech", "FISV": "Tech",
+    "FIS": "Tech", "GPN": "Tech", "BR": "Tech", "JKHY": "Tech", "FFIV": "Tech",
+    "NTAP": "Tech", "HPE": "Tech", "HPQ": "Tech", "STX": "Tech", "WDC": "Tech",
+    "DELL": "Tech", "SMCI": "Tech", "PLTR": "Tech", "CTSH": "Tech", "EPAM": "Tech",
+    "AKAM": "Tech", "PTC": "Tech", "TYL": "Tech", "TRMB": "Tech", "ZBRA": "Tech",
+    "ARM": "Tech",
+    # Healthcare
+    "UNH": "Health", "JNJ": "Health", "LLY": "Health", "ABBV": "Health", "MRK": "Health",
+    "PFE": "Health", "TMO": "Health", "ABT": "Health", "DHR": "Health", "BMY": "Health",
+    "AMGN": "Health", "GILD": "Health", "MDT": "Health", "ISRG": "Health", "SYK": "Health",
+    "BSX": "Health", "EW": "Health", "VRTX": "Health", "REGN": "Health", "IDXX": "Health",
+    "CI": "Health", "HUM": "Health", "CNC": "Health", "MOH": "Health", "HCA": "Health",
+    "BDX": "Health", "BAX": "Health", "IQV": "Health", "HOLX": "Health", "DGX": "Health",
+    "BIO": "Health", "BIIB": "Health", "INCY": "Health", "ILMN": "Health", "DVA": "Health",
+    "LH": "Health", "MRNA": "Health", "ELV": "Health", "GEHC": "Health", "PODD": "Health",
+    "NTRA": "Health", "DXCM": "Health",
+    # Financials
+    "BRK-B": "Fin", "JPM": "Fin", "BAC": "Fin", "WFC": "Fin", "GS": "Fin",
+    "MS": "Fin", "SCHW": "Fin", "C": "Fin", "BLK": "Fin", "SPGI": "Fin",
+    "ICE": "Fin", "CME": "Fin", "AXP": "Fin", "COF": "Fin", "USB": "Fin",
+    "PNC": "Fin", "TFC": "Fin", "MTB": "Fin", "FITB": "Fin", "KEY": "Fin",
+    "HBAN": "Fin", "CFG": "Fin", "RF": "Fin", "ZION": "Fin", "STT": "Fin",
+    "NTRS": "Fin", "BK": "Fin", "AIG": "Fin", "ALL": "Fin", "MET": "Fin",
+    "PRU": "Fin", "AFL": "Fin", "AMP": "Fin", "PFG": "Fin", "LNC": "Fin",
+    "GL": "Fin", "CINF": "Fin", "CB": "Fin", "AON": "Fin", "MMC": "Fin",
+    "AJG": "Fin", "BRO": "Fin", "WRB": "Fin", "RJF": "Fin", "MSCI": "Fin",
+    "NDAQ": "Fin", "CBOE": "Fin", "MCO": "Fin", "FDS": "Fin", "MKTX": "Fin",
+    "IVZ": "Fin", "BEN": "Fin", "TROW": "Fin", "BX": "Fin", "KKR": "Fin",
+    "APO": "Fin", "ARES": "Fin", "CG": "Fin", "COIN": "Fin", "HOOD": "Fin",
+    "SOFI": "Fin", "SYF": "Fin", "AIZ": "Fin",
+    # Consumer Discretionary
+    "AMZN": "ConDisc", "TSLA": "ConDisc", "HD": "ConDisc", "LOW": "ConDisc",
+    "MCD": "ConDisc", "NKE": "ConDisc", "SBUX": "ConDisc", "TJX": "ConDisc",
+    "CMG": "ConDisc", "BKNG": "ConDisc", "MAR": "ConDisc", "HLT": "ConDisc",
+    "ROST": "ConDisc", "DHI": "ConDisc", "LEN": "ConDisc", "PHM": "ConDisc",
+    "NVR": "ConDisc", "GM": "ConDisc", "F": "ConDisc", "BWA": "ConDisc",
+    "RL": "ConDisc", "PVH": "ConDisc", "TPR": "ConDisc", "VFC": "ConDisc",
+    "ULTA": "ConDisc", "DRI": "ConDisc", "DPZ": "ConDisc", "LVS": "ConDisc",
+    "WYNN": "ConDisc", "MGM": "ConDisc", "CCL": "ConDisc", "RCL": "ConDisc",
+    "NCLH": "ConDisc", "EXPE": "ConDisc", "LYV": "ConDisc", "BBY": "ConDisc",
+    "KMX": "ConDisc", "DG": "ConDisc", "DLTR": "ConDisc", "TGT": "ConDisc",
+    "TSCO": "ConDisc", "GPC": "ConDisc", "ORLY": "ConDisc", "AZO": "ConDisc",
+    "POOL": "ConDisc", "ETSY": "ConDisc", "SHOP": "ConDisc", "ABNB": "ConDisc",
+    "DASH": "ConDisc", "DKNG": "ConDisc", "UBER": "ConDisc", "LYFT": "ConDisc",
+    "RIVN": "ConDisc", "LCID": "ConDisc", "CZR": "ConDisc", "DECK": "ConDisc",
+    "GRMN": "ConDisc", "LKQ": "ConDisc", "MHK": "ConDisc", "NWL": "ConDisc",
+    "SWK": "ConDisc", "WHR": "ConDisc", "HAS": "ConDisc",
+    # Consumer Staples
+    "PG": "ConStap", "KO": "ConStap", "PEP": "ConStap", "COST": "ConStap",
+    "WMT": "ConStap", "PM": "ConStap", "MO": "ConStap", "MDLZ": "ConStap",
+    "CL": "ConStap", "CLX": "ConStap", "KMB": "ConStap", "KHC": "ConStap",
+    "GIS": "ConStap", "CAG": "ConStap", "CPB": "ConStap", "SJM": "ConStap",
+    "HRL": "ConStap", "HSY": "ConStap", "MNST": "ConStap", "STZ": "ConStap",
+    "TAP": "ConStap", "TSN": "ConStap", "ADM": "ConStap", "KR": "ConStap",
+    "SYY": "ConStap", "CHD": "ConStap", "EL": "ConStap", "KDP": "ConStap",
+    "KVUE": "ConStap",
+    # Energy
+    "XOM": "Energy", "CVX": "Energy", "COP": "Energy", "EOG": "Energy",
+    "SLB": "Energy", "MPC": "Energy", "PSX": "Energy", "VLO": "Energy",
+    "OXY": "Energy", "DVN": "Energy", "HAL": "Energy", "BKR": "Energy",
+    "APA": "Energy", "EQT": "Energy", "CF": "Energy", "MOS": "Energy",
+    "OKE": "Energy", "WMB": "Energy", "KMI": "Energy", "TRGP": "Energy",
+    "ET": "Energy", "EPD": "Energy", "MPLX": "Energy", "FANG": "Energy",
+    "CTRA": "Energy",
+    # Industrials
+    "GE": "Indust", "CAT": "Indust", "HON": "Indust", "UNP": "Indust",
+    "UPS": "Indust", "BA": "Indust", "RTX": "Indust", "DE": "Indust",
+    "LMT": "Indust", "GD": "Indust", "NOC": "Indust", "LHX": "Indust",
+    "TDG": "Indust", "ITW": "Indust", "EMR": "Indust", "ETN": "Indust",
+    "PH": "Indust", "ROK": "Indust", "DOV": "Indust", "AME": "Indust",
+    "CMI": "Indust", "IR": "Indust", "FTV": "Indust", "SNA": "Indust",
+    "FAST": "Indust", "WAB": "Indust", "CSX": "Indust", "NSC": "Indust",
+    "ODFL": "Indust", "JBHT": "Indust", "CHRW": "Indust", "DAL": "Indust",
+    "UAL": "Indust", "LUV": "Indust", "ALK": "Indust", "FDX": "Indust",
+    "EXPD": "Indust", "PCAR": "Indust", "CPRT": "Indust", "GWW": "Indust",
+    "CTAS": "Indust", "URI": "Indust", "RSG": "Indust", "WM": "Indust",
+    "ROL": "Indust", "RHI": "Indust", "J": "Indust", "LDOS": "Indust",
+    "PWR": "Indust", "TT": "Indust", "IEX": "Indust", "PNR": "Indust",
+    "NDSN": "Indust", "ROP": "Indust", "TDY": "Indust", "STE": "Indust",
+    "TFX": "Indust", "CARR": "Indust", "OTIS": "Indust", "AXON": "Indust",
+    "GEV": "Indust", "VLTO": "Indust", "HWM": "Indust", "HUBB": "Indust",
+    # Utilities
+    "NEE": "Util", "DUK": "Util", "SO": "Util", "D": "Util", "AEP": "Util",
+    "SRE": "Util", "EXC": "Util", "ED": "Util", "WEC": "Util", "ES": "Util",
+    "AEE": "Util", "DTE": "Util", "CMS": "Util", "PEG": "Util", "EIX": "Util",
+    "ETR": "Util", "FE": "Util", "CNP": "Util", "NI": "Util", "PPL": "Util",
+    "EVRG": "Util", "AES": "Util", "LNT": "Util", "PNW": "Util", "NRG": "Util",
+    "AWK": "Util", "PCG": "Util", "XEL": "Util", "CEG": "Util", "VST": "Util",
+    # Real Estate
+    "PLD": "RE", "AMT": "RE", "CCI": "RE", "EQIX": "RE", "SPG": "RE",
+    "O": "RE", "PSA": "RE", "DLR": "RE", "WELL": "RE", "AVB": "RE",
+    "EQR": "RE", "ESS": "RE", "MAA": "RE", "UDR": "RE", "CPT": "RE",
+    "VTR": "RE", "ARE": "RE", "BXP": "RE", "VNO": "RE", "FRT": "RE",
+    "KIM": "RE", "REG": "RE", "HST": "RE", "EXR": "RE", "IRM": "RE",
+    "SBAC": "RE", "INVH": "RE", "VICI": "RE", "DOC": "RE",
+    # Communication Services
+    "GOOG": "Comm", "GOOGL": "Comm", "META": "Comm", "DIS": "Comm",
+    "CMCSA": "Comm", "NFLX": "Comm", "TMUS": "Comm", "T": "Comm",
+    "VZ": "Comm", "CHTR": "Comm", "EA": "Comm", "TTWO": "Comm",
+    "OMC": "Comm", "IPG": "Comm", "FOX": "Comm", "FOXA": "Comm",
+    "NWS": "Comm", "NWSA": "Comm", "MTCH": "Comm", "LUMN": "Comm",
+    "SPOT": "Comm", "SNAP": "Comm", "PINS": "Comm", "ROKU": "Comm",
+    "RBLX": "Comm", "TTD": "Comm", "U": "Comm",
+    # Materials
+    "LIN": "Mats", "APD": "Mats", "SHW": "Mats", "ECL": "Mats",
+    "NUE": "Mats", "FCX": "Mats", "NEM": "Mats", "VMC": "Mats",
+    "MLM": "Mats", "DOW": "Mats", "DD": "Mats", "PPG": "Mats",
+    "EMN": "Mats", "CE": "Mats", "ALB": "Mats", "IFF": "Mats",
+    "FMC": "Mats", "AVY": "Mats", "SEE": "Mats", "PKG": "Mats",
+    "IP": "Mats", "LW": "Mats", "MKC": "Mats", "LYB": "Mats",
+    "CTVA": "Mats",
+}
+
+SECTORS = sorted(set(SECTOR_MAP.values()))
+
+# =============================================================================
+# V36 ENHANCED BACKTEST ENGINE
+# =============================================================================
+def run_v36_backtest(dc=None, spy=None, vf=None, daily_ret=None,
+                     # V30 base params
+                     top_n=15, rebal_days=60, vol_target=0.18,
+                     riskoff_haircut=0.50, sma_lookback=200,
+                     mom_long=175, mom_short=21,
+                     txn_cost_bps=20, regime_txn_multiplier=1.0,
+                     # Enhancement flags
+                     use_ivw=False,          # Enhancement A
+                     use_composite=False,    # Enhancement B
+                     composite_weight=0.70,  # Weight on price mom (rest = quality)
+                     use_sector_neutral=False,# Enhancement C
+                     sn_picks_per_sector=2,  # Stocks per sector in SN mode
+                     # Extra
+                     custom_universe=None,
+                     return_holdings=False,
+                     ivw_lookback=60):
+    """
+    V36 Enhanced Causal Backtest.
+
+    All 3 enhancements are independently toggleable. When all flags are False,
+    this produces identical output to run_causal_backtest() (V30 baseline).
+    """
+    if dc is None:
+        dc, spy, vf, daily_ret = get_data()
+
+    if custom_universe is not None:
+        vf = [t for t in custom_universe if t in dc.columns and dc[t].notna().sum() > 252]
+
+    # --- Signal Construction ---
+    price_mom = (dc[vf].shift(mom_short) / dc[vf].shift(mom_long)) - 1
+
+    if use_composite:
+        # Enhancement B: Quality proxy = 6-month price stability (lower vol = higher quality)
+        # This is a pure-price proxy for earnings quality — no fundamental data needed.
+        # Rationale: Stocks with stable uptrends have more persistent momentum (Novy-Marx 2015)
+        ret_126 = dc[vf].pct_change()
+        rolling_vol = ret_126.rolling(126).std()
+        # Invert: lower vol = higher quality score (rank-normalize)
+        quality_rank = rolling_vol.rank(axis=1, ascending=True, pct=True)
+        mom_rank = price_mom.rank(axis=1, ascending=False, pct=True)
+        # Composite: weighted blend (higher = better)
+        m_signal = composite_weight * (1 - mom_rank) + (1 - composite_weight) * quality_rank
+    else:
+        m_signal = price_mom
+
+    sma = spy.rolling(sma_lookback).mean()
+    sma_vals = sma.values
+    spy_vals = spy.values
+    txn_frac = txn_cost_bps / 10000.0
+
+    # Pre-compute inverse-vol weights if needed
+    if use_ivw:
+        stock_vol = dc[vf].pct_change().rolling(ivw_lookback).std()
+
+    nav = CAP
+    pick_tks = []
+    pick_weights = {}  # ticker -> weight (for IVW)
+    port_rets = []
+    days = 0
+    hist = []
+    vol_scalars = []
+    regime_log = []
+    holdings_log = []
+    prev_riskoff = False
+
+    for i in range(1, len(dc)):
+        # Volatility scalar
+        if len(port_rets) >= 21:
+            window = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            rvol = np.std(window) * np.sqrt(252)
+            vol_scalar = vol_target / (rvol + 1e-8)
+        else:
+            vol_scalar = 0.5
+
+        # CAUSAL regime detection: yesterday's data
+        sp = spy_vals[i-1]
+        sm = sma_vals[i-1]
+        is_riskoff = bool(pd.isna(sm) or sp <= sm)
+
+        if is_riskoff:
+            vol_scalar *= riskoff_haircut
+
+        vol_scalar = float(np.clip(vol_scalar, 0.05, 1.0))
+
+        # Regime switch detection
+        regime_switched = (is_riskoff != prev_riskoff) and i > 1
+        current_txn_mult = regime_txn_multiplier if regime_switched else 1.0
+        prev_riskoff = is_riskoff
+
+        # Daily return
+        day_ret = 0.0
+        if pick_tks:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if len(lr) > 0:
+                if use_ivw and pick_weights:
+                    # Enhancement A: Weighted return
+                    w_sum = 0.0
+                    for t in lr.index:
+                        w = pick_weights.get(t, 1.0 / len(lr))
+                        day_ret += lr[t] * w
+                        w_sum += w
+                    if w_sum > 0:
+                        day_ret = day_ret / w_sum * sum(pick_weights.get(t, 1.0/len(lr)) for t in lr.index)
+                        # Normalize: ensure weights sum to 1
+                        day_ret = sum(lr[t] * pick_weights.get(t, 1.0/len(lr)) for t in lr.index)
+                else:
+                    day_ret = lr.mean()
+
+                day_ret *= vol_scalar
+                nav *= (1 + day_ret)
+                nav -= nav * txn_frac * 2 * current_txn_mult / rebal_days * vol_scalar
+                nav = max(nav, 0.01)
+
+        port_rets.append(day_ret)
+        hist.append(nav)
+        vol_scalars.append(vol_scalar)
+        regime_log.append(is_riskoff)
+
+        # Rebalance
+        days += 1
+        if days >= rebal_days:
+            days = 0
+            # CAUSAL signal: yesterday's momentum
+            row = m_signal.iloc[i].dropna()
+
+            if use_sector_neutral:
+                # Enhancement C: Pick top N from each sector
+                pick_tks = []
+                for sector in SECTORS:
+                    sector_tickers = [t for t in vf if t in row.index and SECTOR_MAP.get(t) == sector]
+                    if not sector_tickers:
+                        continue
+                    sector_scores = row[sector_tickers].sort_values(ascending=False)
+                    pick_tks.extend(list(sector_scores.head(sn_picks_per_sector).index))
+                # Also pick from unmapped tickers to avoid excluding them entirely
+                unmapped = [t for t in vf if t in row.index and t not in SECTOR_MAP]
+                if unmapped:
+                    um_scores = row[unmapped].sort_values(ascending=False)
+                    pick_tks.extend(list(um_scores.head(sn_picks_per_sector).index))
+            else:
+                valid = [t for t in vf if t in row.index]
+                if len(valid) >= top_n:
+                    d = pd.DataFrame({"T": valid, "A": row[valid]}).sort_values("A", ascending=False)
+                    pick_tks = list(d.head(top_n)["T"])
+
+            # Compute IVW weights if enabled
+            if use_ivw and pick_tks:
+                vols = {}
+                for t in pick_tks:
+                    if t in stock_vol.columns:
+                        v = stock_vol.iloc[i-1][t]
+                        if pd.notna(v) and v > 0:
+                            vols[t] = v
+                if vols:
+                    inv_vols = {t: 1.0/v for t, v in vols.items()}
+                    total_inv = sum(inv_vols.values())
+                    pick_weights = {t: iv/total_inv for t, iv in inv_vols.items()}
+                else:
+                    pick_weights = {t: 1.0/len(pick_tks) for t in pick_tks}
+            else:
+                pick_weights = {t: 1.0/len(pick_tks) for t in pick_tks} if pick_tks else {}
+
+            if return_holdings:
+                holdings_log.append({
+                    "date": dc.index[i],
+                    "tickers": list(pick_tks),
+                    "weights": dict(pick_weights),
+                })
+
+    # Build output
+    cap = pd.Series(hist, index=dc.index[1:len(hist)+1])
+    dr = cap.pct_change().dropna()
+
+    result = {
+        "curve": cap,
+        "daily_returns": dr,
+        "port_rets_list": port_rets,
+        "vol_scalars": vol_scalars,
+        "regime_status": regime_log,
+    }
+    if return_holdings:
+        result["holdings_log"] = holdings_log
+
+    return result

backtesting/engines/v36r2_research_engine.py

@@ -0,0 +1,225 @@
+# -*- coding: utf-8 -*-
+"""
+V36 Research Engine — Round 2 Enhancements
+============================================
+New enhancements that attack DIFFERENT structural weaknesses than Round 1.
+
+ENHANCEMENTS:
+  D. Dual Momentum      — Absolute + Relative momentum filter
+  E. Adaptive Regime     — Gradient regime instead of binary on/off
+  F. Multi-Timeframe     — Blend 3M + 6M + 12M momentum
+  G. Trend Quality       — R-squared filter (clean trends only)
+
+CAUSAL GUARANTEES (inherited from V30):
+  - All signals use T-1 data
+  - Returns use T-0 data
+  - No future information leakage
+"""
+
+import os, sys
+import numpy as np, pandas as pd
+from scipy import stats as sp_stats
+import warnings; warnings.filterwarnings("ignore")
+
+sys.path.insert(0, os.path.dirname(__file__))
+from backtesting.engines.v30_causal_engine import (
+    load_data, get_data, evaluate_slice, compute_spy_metrics,
+    V30_PARAMS, CU, RI, FU, CAP, LB, BE,
+    TRAIN_START, TRAIN_END, TEST_START, TEST_END
+)
+
+# =============================================================================
+# V36 ROUND 2 ENHANCED BACKTEST ENGINE
+# =============================================================================
+def run_v36r2_backtest(dc=None, spy=None, vf=None, daily_ret=None,
+                       # V30 base params
+                       top_n=15, rebal_days=60, vol_target=0.18,
+                       riskoff_haircut=0.50, sma_lookback=200,
+                       mom_long=175, mom_short=21,
+                       txn_cost_bps=20, regime_txn_multiplier=1.0,
+                       # Enhancement D: Dual Momentum
+                       use_dual_mom=False,
+                       abs_mom_lookback=252,  # Absolute return lookback
+                       # Enhancement E: Adaptive Regime
+                       use_adaptive_regime=False,
+                       regime_gradient_width=0.05,  # +/-5% band around SMA
+                       # Enhancement F: Multi-Timeframe Blend
+                       use_multi_tf=False,
+                       tf_weights=(0.25, 0.35, 0.40),  # 3M, 6M, 12M weights
+                       # Enhancement G: Trend Quality Filter
+                       use_trend_quality=False,
+                       tq_min_rsq=0.50,   # Minimum R-squared
+                       tq_lookback=90,     # R² calculation window
+                       # Extra
+                       custom_universe=None,
+                       return_holdings=False):
+    """
+    V36 Round 2 Enhanced Causal Backtest.
+    When all flags are False, produces identical output to V30 baseline.
+    """
+    if dc is None:
+        dc, spy, vf, daily_ret = get_data()
+
+    if custom_universe is not None:
+        vf = [t for t in custom_universe if t in dc.columns and dc[t].notna().sum() > 252]
+
+    # --- Signal Construction ---
+    if use_multi_tf:
+        # Enhancement F: Multi-timeframe momentum blend
+        # 3-month (63d), 6-month (126d), 12-month (252d), all with 21d skip
+        mom_3m = (dc[vf].shift(mom_short) / dc[vf].shift(63)) - 1
+        mom_6m = (dc[vf].shift(mom_short) / dc[vf].shift(126)) - 1
+        mom_12m = (dc[vf].shift(mom_short) / dc[vf].shift(252)) - 1
+
+        # Rank each timeframe cross-sectionally, then blend
+        r3 = mom_3m.rank(axis=1, ascending=False, pct=True)
+        r6 = mom_6m.rank(axis=1, ascending=False, pct=True)
+        r12 = mom_12m.rank(axis=1, ascending=False, pct=True)
+
+        w3, w6, w12 = tf_weights
+        # Lower rank pct = better (rank 1 = pct ~0.0), so we invert
+        m_signal = w3 * (1 - r3) + w6 * (1 - r6) + w12 * (1 - r12)
+    else:
+        m_signal = (dc[vf].shift(mom_short) / dc[vf].shift(mom_long)) - 1
+
+    # Pre-compute absolute momentum (for Enhancement D)
+    if use_dual_mom:
+        abs_returns = (dc[vf] / dc[vf].shift(abs_mom_lookback)) - 1
+
+    # Pre-compute trend quality R² (for Enhancement G)
+    if use_trend_quality:
+        # Rolling R² of log-price against time
+        log_prices = np.log(dc[vf].clip(lower=0.01))
+        rsq_df = pd.DataFrame(index=dc.index, columns=vf, dtype=float)
+        for col in vf:
+            lp = log_prices[col].values
+            for i in range(tq_lookback, len(dc)):
+                y = lp[i-tq_lookback:i]
+                if np.any(np.isnan(y)):
+                    continue
+                x = np.arange(tq_lookback)
+                slope, intercept, r_value, p_value, std_err = sp_stats.linregress(x, y)
+                rsq_df.iloc[i][col] = r_value ** 2
+
+    sma = spy.rolling(sma_lookback).mean()
+    sma_vals = sma.values
+    spy_vals = spy.values
+    txn_frac = txn_cost_bps / 10000.0
+
+    nav = CAP
+    pick_tks = []
+    port_rets = []
+    days = 0
+    hist = []
+    vol_scalars = []
+    regime_log = []
+    holdings_log = []
+    prev_riskoff = False
+
+    for i in range(1, len(dc)):
+        # Volatility scalar
+        if len(port_rets) >= 21:
+            window = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            rvol = np.std(window) * np.sqrt(252)
+            vol_scalar = vol_target / (rvol + 1e-8)
+        else:
+            vol_scalar = 0.5
+
+        # CAUSAL regime detection: yesterday's data
+        sp = spy_vals[i-1]
+        sm = sma_vals[i-1]
+
+        if use_adaptive_regime:
+            # Enhancement E: Gradient regime instead of binary
+            if pd.isna(sm) or sm <= 0:
+                regime_scalar = riskoff_haircut
+            else:
+                distance = (sp - sm) / sm  # e.g., +0.03 = 3% above SMA
+                # Map distance to a scalar between riskoff_haircut and 1.0
+                # At +width: full allocation (1.0)
+                # At 0: midpoint
+                # At -width: riskoff_haircut
+                w = regime_gradient_width
+                if distance >= w:
+                    regime_scalar = 1.0
+                elif distance <= -w:
+                    regime_scalar = riskoff_haircut
+                else:
+                    # Linear interpolation
+                    t = (distance + w) / (2 * w)  # 0 to 1
+                    regime_scalar = riskoff_haircut + t * (1.0 - riskoff_haircut)
+
+            vol_scalar *= regime_scalar
+            is_riskoff = regime_scalar < 0.75  # For logging
+        else:
+            is_riskoff = bool(pd.isna(sm) or sp <= sm)
+            if is_riskoff:
+                vol_scalar *= riskoff_haircut
+
+        vol_scalar = float(np.clip(vol_scalar, 0.05, 1.0))
+
+        # Regime switch detection
+        regime_switched = (is_riskoff != prev_riskoff) and i > 1
+        current_txn_mult = regime_txn_multiplier if regime_switched else 1.0
+        prev_riskoff = is_riskoff
+
+        # Daily return
+        day_ret = 0.0
+        if pick_tks:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if len(lr) > 0:
+                day_ret = lr.mean() * vol_scalar
+                nav *= (1 + day_ret)
+                nav -= nav * txn_frac * 2 * current_txn_mult / rebal_days * vol_scalar
+
+        port_rets.append(day_ret)
+        hist.append(nav)
+        vol_scalars.append(vol_scalar)
+        regime_log.append(is_riskoff)
+
+        # Rebalance
+        days += 1
+        if days >= rebal_days:
+            days = 0
+            # CAUSAL signal: yesterday's data
+            row = m_signal.iloc[i-1].dropna()
+            valid = [t for t in vf if t in row.index]
+
+            # Enhancement D: Dual Momentum filter
+            if use_dual_mom and len(valid) > 0:
+                abs_row = abs_returns.iloc[i-1].dropna()
+                # Only keep stocks with positive absolute momentum
+                valid = [t for t in valid if t in abs_row.index and abs_row[t] > 0]
+
+            # Enhancement G: Trend Quality filter
+            if use_trend_quality and len(valid) > 0:
+                rsq_row = rsq_df.iloc[i-1]
+                valid = [t for t in valid if t in rsq_row.index
+                         and pd.notna(rsq_row[t]) and rsq_row[t] >= tq_min_rsq]
+
+            if len(valid) >= top_n:
+                d = pd.DataFrame({"T": valid, "A": row[valid]}).sort_values("A", ascending=False)
+                pick_tks = list(d.head(top_n)["T"])
+            elif len(valid) > 0:
+                # If filters removed too many, take what's available
+                d = pd.DataFrame({"T": valid, "A": row[valid]}).sort_values("A", ascending=False)
+                pick_tks = list(d.head(min(top_n, len(valid)))["T"])
+
+            if return_holdings:
+                holdings_log.append({"date": dc.index[i], "tickers": list(pick_tks)})
+
+    # Build output
+    cap = pd.Series(hist, index=dc.index[1:len(hist)+1])
+    dr = cap.pct_change().dropna()
+
+    result = {
+        "curve": cap,
+        "daily_returns": dr,
+        "port_rets_list": port_rets,
+        "vol_scalars": vol_scalars,
+        "regime_status": regime_log,
+    }
+    if return_holdings:
+        result["holdings_log"] = holdings_log
+
+    return result

backtesting/engines/v36r3_engines.py

@@ -0,0 +1,475 @@
+# -*- coding: utf-8 -*-
+"""
+V36 Round 3 — Structural Architecture Experiments
+====================================================
+Fundamentally different portfolio constructions, not just signal tweaks.
+
+STRATEGIES:
+  H. Long-Short Momentum       — Long top N, Short bottom N
+  I. Market-Hedged (SPY Short)  — Long momentum + dynamic SPY hedge
+  J. Conditional Rebalance      — Vol-triggered rebalancing (not fixed cycle)
+  K. Crash Protection Overlay   — Momentum + drawdown-triggered liquidation
+  L. Long-Short + Sector-Neutral — LS within each sector (market-neutral)
+"""
+
+import os, sys
+import numpy as np, pandas as pd
+import warnings; warnings.filterwarnings("ignore")
+
+sys.path.insert(0, os.path.dirname(__file__))
+from backtesting.engines.v30_causal_engine import (
+    load_data, get_data, evaluate_slice, V30_PARAMS,
+    CU, RI, FU, CAP, TRAIN_START, TRAIN_END, TEST_START, TEST_END
+)
+from backtesting.engines.v36_research_engine import SECTOR_MAP, SECTORS
+
+# =============================================================================
+# STRATEGY H: LONG-SHORT MOMENTUM
+# =============================================================================
+def run_long_short(dc=None, spy=None, vf=None, daily_ret=None,
+                   top_n=15, bottom_n=15, rebal_days=60,
+                   vol_target=0.18, riskoff_haircut=0.50,
+                   sma_lookback=200, mom_long=175, mom_short=21,
+                   txn_cost_bps=20, short_cost_bps=50,
+                   long_weight=0.60, short_weight=0.40):
+    """
+    Long top_n momentum winners, Short bottom_n momentum losers.
+    Net exposure = long_weight - short_weight (e.g., 0.20 = 20% net long).
+    """
+    if dc is None:
+        dc, spy, vf, daily_ret = get_data()
+
+    m_signal = (dc[vf].shift(mom_short) / dc[vf].shift(mom_long)) - 1
+    sma = spy.rolling(sma_lookback).mean()
+    sma_vals = sma.values
+    spy_vals = spy.values
+    txn_frac = txn_cost_bps / 10000.0
+    short_frac = short_cost_bps / 10000.0
+
+    nav = CAP
+    long_tks = []
+    short_tks = []
+    port_rets = []
+    days = 0
+    hist = []
+    vol_scalars = []
+    prev_riskoff = False
+
+    for i in range(1, len(dc)):
+        # Vol scalar
+        if len(port_rets) >= 21:
+            window = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            rvol = np.std(window) * np.sqrt(252)
+            vol_scalar = vol_target / (rvol + 1e-8)
+        else:
+            vol_scalar = 0.5
+
+        sp = spy_vals[i-1]
+        sm = sma_vals[i-1]
+        is_riskoff = bool(pd.isna(sm) or sp <= sm)
+
+        if is_riskoff:
+            vol_scalar *= riskoff_haircut
+
+        vol_scalar = float(np.clip(vol_scalar, 0.05, 1.0))
+
+        # Daily return from long + short legs
+        day_ret = 0.0
+
+        # Long leg
+        if long_tks:
+            lr = daily_ret.iloc[i][[t for t in long_tks if t in daily_ret.columns]].dropna()
+            if len(lr) > 0:
+                day_ret += lr.mean() * long_weight * vol_scalar
+
+        # Short leg (we profit when shorts go DOWN)
+        if short_tks:
+            sr = daily_ret.iloc[i][[t for t in short_tks if t in daily_ret.columns]].dropna()
+            if len(sr) > 0:
+                day_ret -= sr.mean() * short_weight * vol_scalar
+
+        nav *= (1 + day_ret)
+        # Transaction costs for both legs
+        nav -= nav * txn_frac * 2 / rebal_days * vol_scalar * (long_weight + short_weight)
+        # Short borrow costs (annualized, so divide by 252)
+        nav -= nav * short_frac / 252 * short_weight * vol_scalar
+
+        port_rets.append(day_ret)
+        hist.append(nav)
+        vol_scalars.append(vol_scalar)
+
+        # Rebalance
+        days += 1
+        if days >= rebal_days:
+            days = 0
+            row = m_signal.iloc[i-1].dropna()
+            valid = [t for t in vf if t in row.index]
+            if len(valid) >= top_n + bottom_n:
+                sorted_df = pd.DataFrame({"T": valid, "A": row[valid]}).sort_values("A", ascending=False)
+                long_tks = list(sorted_df.head(top_n)["T"])
+                short_tks = list(sorted_df.tail(bottom_n)["T"])
+
+    cap = pd.Series(hist, index=dc.index[1:len(hist)+1])
+    return {"curve": cap, "daily_returns": cap.pct_change().dropna(),
+            "port_rets_list": port_rets, "vol_scalars": vol_scalars}
+
+
+# =============================================================================
+# STRATEGY I: MARKET-HEDGED (LONG MOMENTUM + SPY SHORT)
+# =============================================================================
+def run_market_hedged(dc=None, spy=None, vf=None, daily_ret=None,
+                      top_n=15, rebal_days=60, vol_target=0.18,
+                      riskoff_haircut=0.50, sma_lookback=200,
+                      mom_long=175, mom_short=21, txn_cost_bps=20,
+                      hedge_ratio=0.50, short_cost_bps=30):
+    """
+    Long momentum portfolio + short hedge_ratio * SPY.
+    Reduces market exposure, isolates alpha.
+    """
+    if dc is None:
+        dc, spy, vf, daily_ret = get_data()
+
+    m_signal = (dc[vf].shift(mom_short) / dc[vf].shift(mom_long)) - 1
+    sma = spy.rolling(sma_lookback).mean()
+    spy_ret = spy.pct_change()
+    sma_vals = sma.values
+    spy_vals = spy.values
+    txn_frac = txn_cost_bps / 10000.0
+    short_frac = short_cost_bps / 10000.0
+
+    nav = CAP
+    pick_tks = []
+    port_rets = []
+    days = 0
+    hist = []
+    vol_scalars = []
+
+    for i in range(1, len(dc)):
+        if len(port_rets) >= 21:
+            window = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            rvol = np.std(window) * np.sqrt(252)
+            vol_scalar = vol_target / (rvol + 1e-8)
+        else:
+            vol_scalar = 0.5
+
+        sp = spy_vals[i-1]
+        sm = sma_vals[i-1]
+        is_riskoff = bool(pd.isna(sm) or sp <= sm)
+
+        # Dynamic hedge: increase hedge in risk-off
+        current_hedge = hedge_ratio
+        if is_riskoff:
+            vol_scalar *= riskoff_haircut
+            current_hedge = min(hedge_ratio * 1.5, 0.95)  # Increase hedge in risk-off
+
+        vol_scalar = float(np.clip(vol_scalar, 0.05, 1.0))
+
+        day_ret = 0.0
+        if pick_tks:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if len(lr) > 0:
+                # Long leg
+                long_ret = lr.mean() * vol_scalar
+                # Short SPY hedge
+                spy_r = spy_ret.iloc[i] if pd.notna(spy_ret.iloc[i]) else 0
+                hedge_ret = -spy_r * current_hedge * vol_scalar
+                day_ret = long_ret + hedge_ret
+
+        nav *= (1 + day_ret)
+        nav -= nav * txn_frac * 2 / rebal_days * vol_scalar
+        nav -= nav * short_frac / 252 * current_hedge * vol_scalar  # SPY borrow cost
+
+        port_rets.append(day_ret)
+        hist.append(nav)
+        vol_scalars.append(vol_scalar)
+
+        days += 1
+        if days >= rebal_days:
+            days = 0
+            row = m_signal.iloc[i-1].dropna()
+            valid = [t for t in vf if t in row.index]
+            if len(valid) >= top_n:
+                d = pd.DataFrame({"T": valid, "A": row[valid]}).sort_values("A", ascending=False)
+                pick_tks = list(d.head(top_n)["T"])
+
+    cap = pd.Series(hist, index=dc.index[1:len(hist)+1])
+    return {"curve": cap, "daily_returns": cap.pct_change().dropna(),
+            "port_rets_list": port_rets, "vol_scalars": vol_scalars}
+
+
+# =============================================================================
+# STRATEGY J: CONDITIONAL REBALANCE (VOL-TRIGGERED)
+# =============================================================================
+def run_conditional_rebal(dc=None, spy=None, vf=None, daily_ret=None,
+                          top_n=15, max_rebal_days=60, vol_target=0.18,
+                          riskoff_haircut=0.50, sma_lookback=200,
+                          mom_long=175, mom_short=21, txn_cost_bps=20,
+                          vol_trigger=0.25, min_rebal_days=15):
+    """
+    Rebalance on fixed cycle OR when realized vol exceeds vol_trigger,
+    whichever comes first. Also forces rebalance on regime switches.
+    """
+    if dc is None:
+        dc, spy, vf, daily_ret = get_data()
+
+    m_signal = (dc[vf].shift(mom_short) / dc[vf].shift(mom_long)) - 1
+    sma = spy.rolling(sma_lookback).mean()
+    sma_vals = sma.values
+    spy_vals = spy.values
+    txn_frac = txn_cost_bps / 10000.0
+
+    nav = CAP
+    pick_tks = []
+    port_rets = []
+    days = 0
+    hist = []
+    vol_scalars = []
+    prev_riskoff = False
+
+    for i in range(1, len(dc)):
+        if len(port_rets) >= 21:
+            window = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            rvol = np.std(window) * np.sqrt(252)
+            vol_scalar = vol_target / (rvol + 1e-8)
+        else:
+            rvol = 0.20
+            vol_scalar = 0.5
+
+        sp = spy_vals[i-1]
+        sm = sma_vals[i-1]
+        is_riskoff = bool(pd.isna(sm) or sp <= sm)
+
+        if is_riskoff:
+            vol_scalar *= riskoff_haircut
+
+        vol_scalar = float(np.clip(vol_scalar, 0.05, 1.0))
+
+        regime_switched = (is_riskoff != prev_riskoff) and i > 1
+        prev_riskoff = is_riskoff
+
+        day_ret = 0.0
+        if pick_tks:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if len(lr) > 0:
+                day_ret = lr.mean() * vol_scalar
+                nav *= (1 + day_ret)
+                nav -= nav * txn_frac * 2 / max_rebal_days * vol_scalar
+
+        port_rets.append(day_ret)
+        hist.append(nav)
+        vol_scalars.append(vol_scalar)
+
+        days += 1
+
+        # Conditional rebalance triggers:
+        # 1. Fixed cycle reached
+        # 2. Vol spike (realized vol > trigger AND min days passed)
+        # 3. Regime switch (AND min days passed)
+        should_rebal = False
+        if days >= max_rebal_days:
+            should_rebal = True
+        elif days >= min_rebal_days:
+            if rvol > vol_trigger:
+                should_rebal = True
+            elif regime_switched:
+                should_rebal = True
+
+        if should_rebal:
+            days = 0
+            row = m_signal.iloc[i-1].dropna()
+            valid = [t for t in vf if t in row.index]
+            if len(valid) >= top_n:
+                d = pd.DataFrame({"T": valid, "A": row[valid]}).sort_values("A", ascending=False)
+                pick_tks = list(d.head(top_n)["T"])
+
+    cap = pd.Series(hist, index=dc.index[1:len(hist)+1])
+    return {"curve": cap, "daily_returns": cap.pct_change().dropna(),
+            "port_rets_list": port_rets, "vol_scalars": vol_scalars}
+
+
+# =============================================================================
+# STRATEGY K: CRASH PROTECTION OVERLAY
+# =============================================================================
+def run_crash_protection(dc=None, spy=None, vf=None, daily_ret=None,
+                         top_n=15, rebal_days=60, vol_target=0.18,
+                         riskoff_haircut=0.50, sma_lookback=200,
+                         mom_long=175, mom_short=21, txn_cost_bps=20,
+                         dd_threshold=-0.10, recovery_threshold=0.03):
+    """
+    Standard V30 + drawdown-triggered liquidation.
+    If portfolio drawdown exceeds dd_threshold, go to cash.
+    Re-enter when portfolio recovers recovery_threshold from trough.
+    """
+    if dc is None:
+        dc, spy, vf, daily_ret = get_data()
+
+    m_signal = (dc[vf].shift(mom_short) / dc[vf].shift(mom_long)) - 1
+    sma = spy.rolling(sma_lookback).mean()
+    sma_vals = sma.values
+    spy_vals = spy.values
+    txn_frac = txn_cost_bps / 10000.0
+
+    nav = CAP
+    pick_tks = []
+    port_rets = []
+    days = 0
+    hist = []
+    vol_scalars = []
+    prev_riskoff = False
+
+    # Crash protection state
+    in_cash = False
+    peak_nav = CAP
+    trough_nav = CAP
+
+    for i in range(1, len(dc)):
+        if len(port_rets) >= 21:
+            window = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            rvol = np.std(window) * np.sqrt(252)
+            vol_scalar = vol_target / (rvol + 1e-8)
+        else:
+            vol_scalar = 0.5
+
+        sp = spy_vals[i-1]
+        sm = sma_vals[i-1]
+        is_riskoff = bool(pd.isna(sm) or sp <= sm)
+
+        if is_riskoff:
+            vol_scalar *= riskoff_haircut
+
+        vol_scalar = float(np.clip(vol_scalar, 0.05, 1.0))
+
+        # Crash protection logic
+        peak_nav = max(peak_nav, nav)
+        current_dd = (nav - peak_nav) / peak_nav
+
+        if not in_cash and current_dd < dd_threshold:
+            in_cash = True
+            trough_nav = nav
+
+        if in_cash:
+            trough_nav = min(trough_nav, nav)
+            recovery = (nav - trough_nav) / (trough_nav + 1e-8)
+            if recovery > recovery_threshold:
+                in_cash = False
+
+        # Daily return
+        day_ret = 0.0
+        if pick_tks and not in_cash:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if len(lr) > 0:
+                day_ret = lr.mean() * vol_scalar
+                nav *= (1 + day_ret)
+                nav -= nav * txn_frac * 2 / rebal_days * vol_scalar
+
+        port_rets.append(day_ret)
+        hist.append(nav)
+        vol_scalars.append(vol_scalar)
+
+        prev_riskoff = is_riskoff
+
+        days += 1
+        if days >= rebal_days:
+            days = 0
+            row = m_signal.iloc[i-1].dropna()
+            valid = [t for t in vf if t in row.index]
+            if len(valid) >= top_n:
+                d = pd.DataFrame({"T": valid, "A": row[valid]}).sort_values("A", ascending=False)
+                pick_tks = list(d.head(top_n)["T"])
+
+    cap = pd.Series(hist, index=dc.index[1:len(hist)+1])
+    return {"curve": cap, "daily_returns": cap.pct_change().dropna(),
+            "port_rets_list": port_rets, "vol_scalars": vol_scalars}
+
+
+# =============================================================================
+# STRATEGY L: LONG-SHORT SECTOR-NEUTRAL
+# =============================================================================
+def run_ls_sector_neutral(dc=None, spy=None, vf=None, daily_ret=None,
+                          picks_per_sector=1, rebal_days=60,
+                          vol_target=0.18, riskoff_haircut=0.50,
+                          sma_lookback=200, mom_long=175, mom_short=21,
+                          txn_cost_bps=20, short_cost_bps=50):
+    """
+    Long best momentum stock in each sector, Short worst momentum stock in each sector.
+    True market-neutral, sector-neutral construction.
+    """
+    if dc is None:
+        dc, spy, vf, daily_ret = get_data()
+
+    m_signal = (dc[vf].shift(mom_short) / dc[vf].shift(mom_long)) - 1
+    sma = spy.rolling(sma_lookback).mean()
+    sma_vals = sma.values
+    spy_vals = spy.values
+    txn_frac = txn_cost_bps / 10000.0
+    short_frac = short_cost_bps / 10000.0
+
+    nav = CAP
+    long_tks = []
+    short_tks = []
+    port_rets = []
+    days = 0
+    hist = []
+    vol_scalars = []
+
+    for i in range(1, len(dc)):
+        if len(port_rets) >= 21:
+            window = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            rvol = np.std(window) * np.sqrt(252)
+            vol_scalar = vol_target / (rvol + 1e-8)
+        else:
+            vol_scalar = 0.5
+
+        sp = spy_vals[i-1]
+        sm = sma_vals[i-1]
+        is_riskoff = bool(pd.isna(sm) or sp <= sm)
+
+        if is_riskoff:
+            vol_scalar *= riskoff_haircut
+
+        vol_scalar = float(np.clip(vol_scalar, 0.05, 1.0))
+
+        day_ret = 0.0
+        n_legs = 0
+
+        # Long leg
+        if long_tks:
+            lr = daily_ret.iloc[i][[t for t in long_tks if t in daily_ret.columns]].dropna()
+            if len(lr) > 0:
+                day_ret += lr.mean() * 0.5 * vol_scalar
+                n_legs += 1
+
+        # Short leg
+        if short_tks:
+            sr = daily_ret.iloc[i][[t for t in short_tks if t in daily_ret.columns]].dropna()
+            if len(sr) > 0:
+                day_ret -= sr.mean() * 0.5 * vol_scalar
+                n_legs += 1
+
+        nav *= (1 + day_ret)
+        nav -= nav * txn_frac * 2 / rebal_days * vol_scalar
+        if short_tks:
+            nav -= nav * short_frac / 252 * 0.5 * vol_scalar
+
+        port_rets.append(day_ret)
+        hist.append(nav)
+        vol_scalars.append(vol_scalar)
+
+        days += 1
+        if days >= rebal_days:
+            days = 0
+            row = m_signal.iloc[i-1].dropna()
+
+            long_tks = []
+            short_tks = []
+            for sector in SECTORS:
+                sector_tickers = [t for t in vf if t in row.index and SECTOR_MAP.get(t) == sector]
+                if len(sector_tickers) < 2:
+                    continue
+                scores = row[sector_tickers].sort_values(ascending=False)
+                long_tks.extend(list(scores.head(picks_per_sector).index))
+                short_tks.extend(list(scores.tail(picks_per_sector).index))
+
+    cap = pd.Series(hist, index=dc.index[1:len(hist)+1])
+    return {"curve": cap, "daily_returns": cap.pct_change().dropna(),
+            "port_rets_list": port_rets, "vol_scalars": vol_scalars}

backtesting/engines/v36r4_engines.py

@@ -0,0 +1,312 @@
+# -*- coding: utf-8 -*-
+"""
+V36 Round 4 — Signal Architecture Experiments
+===============================================
+Completely different SIGNAL constructions, not portfolio tweaks.
+
+STRATEGIES:
+  M. Risk-Adjusted Momentum   — Rank by Sharpe of returns, not raw returns
+  N. 52-Week High Proximity    — George & Hwang (2004) nearness to high
+  O. Residual Momentum         — Strip out market beta, rank on alpha
+  P. Partial Rebalance         — Only turnover 50% of portfolio each cycle
+  Q. Momentum Acceleration     — Change in momentum (2nd derivative)
+"""
+
+import os, sys
+import numpy as np, pandas as pd
+from scipy import stats as sp_stats
+import warnings; warnings.filterwarnings("ignore")
+
+sys.path.insert(0, os.path.dirname(__file__))
+from backtesting.engines.v30_causal_engine import (
+    load_data, get_data, evaluate_slice, V30_PARAMS,
+    CU, RI, FU, CAP, TRAIN_START, TRAIN_END, TEST_START, TEST_END
+)
+
+
+def run_risk_adj_mom(dc=None, spy=None, vf=None, daily_ret=None,
+                     top_n=15, rebal_days=60, vol_target=0.18,
+                     riskoff_haircut=0.50, sma_lookback=200,
+                     mom_long=175, mom_short=21, txn_cost_bps=20,
+                     sharpe_lookback=126):
+    """M: Rank stocks by trailing Sharpe ratio instead of raw return."""
+    if dc is None: dc, spy, vf, daily_ret = get_data()
+
+    sma = spy.rolling(sma_lookback).mean()
+    sma_vals, spy_vals = sma.values, spy.values
+    txn_frac = txn_cost_bps / 10000.0
+    ret = dc[vf].pct_change()
+
+    # Pre-compute rolling Sharpe for each stock
+    rolling_mean = ret.rolling(sharpe_lookback).mean() * 252
+    rolling_std = ret.rolling(sharpe_lookback).std() * np.sqrt(252)
+    m_signal = rolling_mean / (rolling_std + 1e-8)
+
+    nav, pick_tks, port_rets, days, hist, vol_scalars = CAP, [], [], 0, [], []
+
+    for i in range(1, len(dc)):
+        if len(port_rets) >= 21:
+            w = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            vs = vol_target / (np.std(w) * np.sqrt(252) + 1e-8)
+        else: vs = 0.5
+
+        sp, sm = spy_vals[i-1], sma_vals[i-1]
+        if pd.isna(sm) or sp <= sm: vs *= riskoff_haircut
+        vs = float(np.clip(vs, 0.05, 1.0))
+
+        day_ret = 0.0
+        if pick_tks:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if len(lr) > 0:
+                day_ret = lr.mean() * vs
+                nav *= (1 + day_ret)
+                nav -= nav * txn_frac * 2 / rebal_days * vs
+
+        port_rets.append(day_ret); hist.append(nav); vol_scalars.append(vs)
+
+        days += 1
+        if days >= rebal_days:
+            days = 0
+            row = m_signal.iloc[i-1].dropna()
+            valid = [t for t in vf if t in row.index]
+            if len(valid) >= top_n:
+                d = pd.DataFrame({"T": valid, "A": row[valid]}).sort_values("A", ascending=False)
+                pick_tks = list(d.head(top_n)["T"])
+
+    cap = pd.Series(hist, index=dc.index[1:len(hist)+1])
+    return {"curve": cap, "port_rets_list": port_rets}
+
+
+def run_52wk_high(dc=None, spy=None, vf=None, daily_ret=None,
+                  top_n=15, rebal_days=60, vol_target=0.18,
+                  riskoff_haircut=0.50, sma_lookback=200,
+                  mom_long=175, mom_short=21, txn_cost_bps=20):
+    """N: Rank stocks by proximity to 52-week high (George & Hwang 2004)."""
+    if dc is None: dc, spy, vf, daily_ret = get_data()
+
+    sma = spy.rolling(sma_lookback).mean()
+    sma_vals, spy_vals = sma.values, spy.values
+    txn_frac = txn_cost_bps / 10000.0
+
+    high_252 = dc[vf].rolling(252).max()
+    m_signal = dc[vf] / high_252  # Ratio: 1.0 = at 52wk high
+
+    nav, pick_tks, port_rets, days, hist, vol_scalars = CAP, [], [], 0, [], []
+
+    for i in range(1, len(dc)):
+        if len(port_rets) >= 21:
+            w = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            vs = vol_target / (np.std(w) * np.sqrt(252) + 1e-8)
+        else: vs = 0.5
+
+        sp, sm = spy_vals[i-1], sma_vals[i-1]
+        if pd.isna(sm) or sp <= sm: vs *= riskoff_haircut
+        vs = float(np.clip(vs, 0.05, 1.0))
+
+        day_ret = 0.0
+        if pick_tks:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if len(lr) > 0:
+                day_ret = lr.mean() * vs
+                nav *= (1 + day_ret)
+                nav -= nav * txn_frac * 2 / rebal_days * vs
+
+        port_rets.append(day_ret); hist.append(nav); vol_scalars.append(vs)
+
+        days += 1
+        if days >= rebal_days:
+            days = 0
+            row = m_signal.iloc[i-1].dropna()
+            valid = [t for t in vf if t in row.index]
+            if len(valid) >= top_n:
+                d = pd.DataFrame({"T": valid, "A": row[valid]}).sort_values("A", ascending=False)
+                pick_tks = list(d.head(top_n)["T"])
+
+    cap = pd.Series(hist, index=dc.index[1:len(hist)+1])
+    return {"curve": cap, "port_rets_list": port_rets}
+
+
+def run_residual_mom(dc=None, spy=None, vf=None, daily_ret=None,
+                     top_n=15, rebal_days=60, vol_target=0.18,
+                     riskoff_haircut=0.50, sma_lookback=200,
+                     mom_long=175, mom_short=21, txn_cost_bps=20,
+                     beta_lookback=126):
+    """O: Strip out market beta, rank on residual (idiosyncratic) momentum."""
+    if dc is None: dc, spy, vf, daily_ret = get_data()
+
+    sma = spy.rolling(sma_lookback).mean()
+    sma_vals, spy_vals = sma.values, spy.values
+    txn_frac = txn_cost_bps / 10000.0
+    spy_ret = spy.pct_change()
+    stock_ret = dc[vf].pct_change()
+
+    # Pre-compute rolling beta and residual return for each stock
+    # residual_mom = cumulative residual return over lookback
+    m_signal = pd.DataFrame(index=dc.index, columns=vf, dtype=float)
+
+    for col in vf:
+        sr = stock_ret[col].values
+        mr = spy_ret.values
+        for i in range(beta_lookback + mom_short, len(dc)):
+            y = sr[i-beta_lookback:i]
+            x = mr[i-beta_lookback:i]
+            mask = ~(np.isnan(y) | np.isnan(x))
+            if mask.sum() < 30:
+                continue
+            beta = np.cov(y[mask], x[mask])[0, 1] / (np.var(x[mask]) + 1e-10)
+            # Residual returns over lookback
+            resid = y[mask] - beta * x[mask]
+            m_signal.iloc[i][col] = np.sum(resid)
+
+    nav, pick_tks, port_rets, days, hist, vol_scalars = CAP, [], [], 0, [], []
+
+    for i in range(1, len(dc)):
+        if len(port_rets) >= 21:
+            w = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            vs = vol_target / (np.std(w) * np.sqrt(252) + 1e-8)
+        else: vs = 0.5
+
+        sp, sm = spy_vals[i-1], sma_vals[i-1]
+        if pd.isna(sm) or sp <= sm: vs *= riskoff_haircut
+        vs = float(np.clip(vs, 0.05, 1.0))
+
+        day_ret = 0.0
+        if pick_tks:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if len(lr) > 0:
+                day_ret = lr.mean() * vs
+                nav *= (1 + day_ret)
+                nav -= nav * txn_frac * 2 / rebal_days * vs
+
+        port_rets.append(day_ret); hist.append(nav); vol_scalars.append(vs)
+
+        days += 1
+        if days >= rebal_days:
+            days = 0
+            row = m_signal.iloc[i-1].dropna()
+            valid = [t for t in vf if t in row.index]
+            if len(valid) >= top_n:
+                d = pd.DataFrame({"T": valid, "A": row[valid]}).sort_values("A", ascending=False)
+                pick_tks = list(d.head(top_n)["T"])
+
+    cap = pd.Series(hist, index=dc.index[1:len(hist)+1])
+    return {"curve": cap, "port_rets_list": port_rets}
+
+
+def run_partial_rebal(dc=None, spy=None, vf=None, daily_ret=None,
+                      top_n=15, rebal_days=60, vol_target=0.18,
+                      riskoff_haircut=0.50, sma_lookback=200,
+                      mom_long=175, mom_short=21, txn_cost_bps=20,
+                      turnover_pct=0.50):
+    """P: Only replace turnover_pct of portfolio each rebalance."""
+    if dc is None: dc, spy, vf, daily_ret = get_data()
+
+    m_signal = (dc[vf].shift(mom_short) / dc[vf].shift(mom_long)) - 1
+    sma = spy.rolling(sma_lookback).mean()
+    sma_vals, spy_vals = sma.values, spy.values
+    txn_frac = txn_cost_bps / 10000.0
+
+    nav, pick_tks, port_rets, days, hist, vol_scalars = CAP, [], [], 0, [], []
+
+    for i in range(1, len(dc)):
+        if len(port_rets) >= 21:
+            w = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            vs = vol_target / (np.std(w) * np.sqrt(252) + 1e-8)
+        else: vs = 0.5
+
+        sp, sm = spy_vals[i-1], sma_vals[i-1]
+        if pd.isna(sm) or sp <= sm: vs *= riskoff_haircut
+        vs = float(np.clip(vs, 0.05, 1.0))
+
+        day_ret = 0.0
+        if pick_tks:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if len(lr) > 0:
+                day_ret = lr.mean() * vs
+                nav *= (1 + day_ret)
+                nav -= nav * txn_frac * 2 / rebal_days * vs
+
+        port_rets.append(day_ret); hist.append(nav); vol_scalars.append(vs)
+
+        days += 1
+        if days >= rebal_days:
+            days = 0
+            row = m_signal.iloc[i-1].dropna()
+            valid = [t for t in vf if t in row.index]
+            if len(valid) >= top_n:
+                d = pd.DataFrame({"T": valid, "A": row[valid]}).sort_values("A", ascending=False)
+                new_picks = list(d.head(top_n)["T"])
+
+                if not pick_tks:
+                    pick_tks = new_picks
+                else:
+                    # Keep (1 - turnover_pct) of current, replace rest with new
+                    n_keep = max(1, int(top_n * (1 - turnover_pct)))
+                    # Keep current picks that are still in top 2*N
+                    top_2n = set(d.head(top_n * 2)["T"])
+                    keepers = [t for t in pick_tks if t in top_2n][:n_keep]
+                    # Fill remaining slots from new picks
+                    n_new = top_n - len(keepers)
+                    newcomers = [t for t in new_picks if t not in keepers][:n_new]
+                    pick_tks = keepers + newcomers
+
+    cap = pd.Series(hist, index=dc.index[1:len(hist)+1])
+    return {"curve": cap, "port_rets_list": port_rets}
+
+
+def run_mom_acceleration(dc=None, spy=None, vf=None, daily_ret=None,
+                         top_n=15, rebal_days=60, vol_target=0.18,
+                         riskoff_haircut=0.50, sma_lookback=200,
+                         mom_long=175, mom_short=21, txn_cost_bps=20,
+                         accel_short=63, accel_long=126):
+    """Q: Rank by change in momentum (acceleration / 2nd derivative)."""
+    if dc is None: dc, spy, vf, daily_ret = get_data()
+
+    sma = spy.rolling(sma_lookback).mean()
+    sma_vals, spy_vals = sma.values, spy.values
+    txn_frac = txn_cost_bps / 10000.0
+
+    # Momentum at two points in time
+    mom_now = (dc[vf].shift(mom_short) / dc[vf].shift(mom_long)) - 1
+    mom_prev = (dc[vf].shift(mom_short + accel_short) / dc[vf].shift(mom_long + accel_short)) - 1
+
+    # Acceleration = change in momentum
+    # Blend: 70% current momentum + 30% acceleration
+    mom_rank = mom_now.rank(axis=1, ascending=False, pct=True)
+    accel = mom_now - mom_prev
+    accel_rank = accel.rank(axis=1, ascending=False, pct=True)
+    m_signal = 0.70 * (1 - mom_rank) + 0.30 * (1 - accel_rank)
+
+    nav, pick_tks, port_rets, days, hist, vol_scalars = CAP, [], [], 0, [], []
+
+    for i in range(1, len(dc)):
+        if len(port_rets) >= 21:
+            w = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            vs = vol_target / (np.std(w) * np.sqrt(252) + 1e-8)
+        else: vs = 0.5
+
+        sp, sm = spy_vals[i-1], sma_vals[i-1]
+        if pd.isna(sm) or sp <= sm: vs *= riskoff_haircut
+        vs = float(np.clip(vs, 0.05, 1.0))
+
+        day_ret = 0.0
+        if pick_tks:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if len(lr) > 0:
+                day_ret = lr.mean() * vs
+                nav *= (1 + day_ret)
+                nav -= nav * txn_frac * 2 / rebal_days * vs
+
+        port_rets.append(day_ret); hist.append(nav); vol_scalars.append(vs)
+
+        days += 1
+        if days >= rebal_days:
+            days = 0
+            row = m_signal.iloc[i-1].dropna()
+            valid = [t for t in vf if t in row.index]
+            if len(valid) >= top_n:
+                d = pd.DataFrame({"T": valid, "A": row[valid]}).sort_values("A", ascending=False)
+                pick_tks = list(d.head(top_n)["T"])
+
+    cap = pd.Series(hist, index=dc.index[1:len(hist)+1])
+    return {"curve": cap, "port_rets_list": port_rets}

backtesting/engines/v36r5_engines.py

@@ -0,0 +1,264 @@
+# -*- coding: utf-8 -*-
+"""
+V36 Round 5 — Micro-Structure & Behavioral Filters
+===================================================
+Attacking the behavioral biases that cause momentum crashes.
+
+STRATEGIES:
+  R. Frog-in-the-Pan (FITP)     — Continuous momentum (high % of positive days)
+  S. Low-Vol Anomaly Filter     — Exclude highest volatility stocks
+  T. Buy-the-Dip Momentum       — Require short-term pullback for entry
+  U. Lottery Ticket Filter      — Exclude stocks with massive single-day spikes (MAX effect)
+"""
+
+import os, sys
+import numpy as np, pandas as pd
+import warnings; warnings.filterwarnings("ignore")
+
+sys.path.insert(0, os.path.dirname(__file__))
+from backtesting.engines.v30_causal_engine import (
+    load_data, get_data, evaluate_slice, V30_PARAMS,
+    CU, RI, FU, CAP, TRAIN_START, TRAIN_END, TEST_START, TEST_END
+)
+
+def run_fitp_momentum(dc=None, spy=None, vf=None, daily_ret=None,
+                      top_n=15, rebal_days=60, vol_target=0.18,
+                      riskoff_haircut=0.50, sma_lookback=200,
+                      mom_long=175, mom_short=21, txn_cost_bps=20):
+    """R: Frog-in-the-Pan (Da, Gurun, Warachka 2014).
+    Momentum driven by small, continuous gains is more robust than jumps.
+    Rank = Momentum * (% of positive days)."""
+    if dc is None: dc, spy, vf, daily_ret = get_data()
+
+    sma = spy.rolling(sma_lookback).mean()
+    sma_vals, spy_vals = sma.values, spy.values
+    txn_frac = txn_cost_bps / 10000.0
+
+    ret = dc[vf].pct_change()
+    is_positive = (ret > 0).astype(float)
+
+    # % of positive days in the momentum lookback window
+    # Note: we shift by mom_short to align with the momentum signal
+    pos_pct = is_positive.rolling(mom_long - mom_short).mean().shift(mom_short)
+    raw_mom = (dc[vf].shift(mom_short) / dc[vf].shift(mom_long)) - 1
+    
+    # Scale momentum by the consistency of returns
+    m_signal = raw_mom * pos_pct
+
+    nav, pick_tks, port_rets, days, hist, vol_scalars = CAP, [], [], 0, [], []
+
+    for i in range(1, len(dc)):
+        if len(port_rets) >= 21:
+            w = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            vs = vol_target / (np.std(w) * np.sqrt(252) + 1e-8)
+        else: vs = 0.5
+
+        sp, sm = spy_vals[i-1], sma_vals[i-1]
+        if pd.isna(sm) or sp <= sm: vs *= riskoff_haircut
+        vs = float(np.clip(vs, 0.05, 1.0))
+
+        day_ret = 0.0
+        if pick_tks:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if len(lr) > 0:
+                day_ret = lr.mean() * vs
+                nav *= (1 + day_ret)
+                nav -= nav * txn_frac * 2 / rebal_days * vs
+
+        port_rets.append(day_ret); hist.append(nav); vol_scalars.append(vs)
+
+        days += 1
+        if days >= rebal_days:
+            days = 0
+            row = m_signal.iloc[i-1].dropna()
+            valid = [t for t in vf if t in row.index]
+            if len(valid) >= top_n:
+                d = pd.DataFrame({"T": valid, "A": row[valid]}).sort_values("A", ascending=False)
+                pick_tks = list(d.head(top_n)["T"])
+
+    cap = pd.Series(hist, index=dc.index[1:len(hist)+1])
+    return {"curve": cap, "port_rets_list": port_rets}
+
+
+def run_lowvol_filter(dc=None, spy=None, vf=None, daily_ret=None,
+                      top_n=15, rebal_days=60, vol_target=0.18,
+                      riskoff_haircut=0.50, sma_lookback=200,
+                      mom_long=175, mom_short=21, txn_cost_bps=20,
+                      exclude_pct=0.20):
+    """S: Low Volatility Anomaly. Exclude top exclude_pct highly volatile stocks."""
+    if dc is None: dc, spy, vf, daily_ret = get_data()
+
+    sma = spy.rolling(sma_lookback).mean()
+    sma_vals, spy_vals = sma.values, spy.values
+    txn_frac = txn_cost_bps / 10000.0
+
+    ret = dc[vf].pct_change()
+    vol_signal = ret.rolling(mom_long).std().shift(mom_short)
+    m_signal = (dc[vf].shift(mom_short) / dc[vf].shift(mom_long)) - 1
+
+    nav, pick_tks, port_rets, days, hist, vol_scalars = CAP, [], [], 0, [], []
+
+    for i in range(1, len(dc)):
+        if len(port_rets) >= 21:
+            w = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            vs = vol_target / (np.std(w) * np.sqrt(252) + 1e-8)
+        else: vs = 0.5
+
+        sp, sm = spy_vals[i-1], sma_vals[i-1]
+        if pd.isna(sm) or sp <= sm: vs *= riskoff_haircut
+        vs = float(np.clip(vs, 0.05, 1.0))
+
+        day_ret = 0.0
+        if pick_tks:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if len(lr) > 0:
+                day_ret = lr.mean() * vs
+                nav *= (1 + day_ret)
+                nav -= nav * txn_frac * 2 / rebal_days * vs
+
+        port_rets.append(day_ret); hist.append(nav); vol_scalars.append(vs)
+
+        days += 1
+        if days >= rebal_days:
+            days = 0
+            row_m = m_signal.iloc[i-1].dropna()
+            row_v = vol_signal.iloc[i-1].dropna()
+            
+            # Intersection of valid data
+            valid = [t for t in vf if t in row_m.index and t in row_v.index]
+            if len(valid) >= top_n:
+                # Exclude top volatile stocks
+                n_exclude = int(len(valid) * exclude_pct)
+                high_vol_tks = set(row_v[valid].sort_values(ascending=False).head(n_exclude).index)
+                
+                filtered_valid = [t for t in valid if t not in high_vol_tks]
+                
+                if len(filtered_valid) >= top_n:
+                    d = pd.DataFrame({"T": filtered_valid, "A": row_m[filtered_valid]}).sort_values("A", ascending=False)
+                    pick_tks = list(d.head(top_n)["T"])
+
+    cap = pd.Series(hist, index=dc.index[1:len(hist)+1])
+    return {"curve": cap, "port_rets_list": port_rets}
+
+
+def run_buy_the_dip(dc=None, spy=None, vf=None, daily_ret=None,
+                    top_n=15, rebal_days=60, vol_target=0.18,
+                    riskoff_haircut=0.50, sma_lookback=200,
+                    mom_long=175, mom_short=21, txn_cost_bps=20,
+                    dip_days=5):
+    """T: Buy the Dip. Require the short-term return just prior to rebalance to be negative."""
+    if dc is None: dc, spy, vf, daily_ret = get_data()
+
+    sma = spy.rolling(sma_lookback).mean()
+    sma_vals, spy_vals = sma.values, spy.values
+    txn_frac = txn_cost_bps / 10000.0
+
+    m_signal = (dc[vf].shift(mom_short) / dc[vf].shift(mom_long)) - 1
+    # Short term return just before rebalancing (T-5 to T-1)
+    short_ret = (dc[vf].shift(1) / dc[vf].shift(1 + dip_days)) - 1
+
+    nav, pick_tks, port_rets, days, hist, vol_scalars = CAP, [], [], 0, [], []
+
+    for i in range(1, len(dc)):
+        if len(port_rets) >= 21:
+            w = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            vs = vol_target / (np.std(w) * np.sqrt(252) + 1e-8)
+        else: vs = 0.5
+
+        sp, sm = spy_vals[i-1], sma_vals[i-1]
+        if pd.isna(sm) or sp <= sm: vs *= riskoff_haircut
+        vs = float(np.clip(vs, 0.05, 1.0))
+
+        day_ret = 0.0
+        if pick_tks:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if len(lr) > 0:
+                day_ret = lr.mean() * vs
+                nav *= (1 + day_ret)
+                nav -= nav * txn_frac * 2 / rebal_days * vs
+
+        port_rets.append(day_ret); hist.append(nav); vol_scalars.append(vs)
+
+        days += 1
+        if days >= rebal_days:
+            days = 0
+            row_m = m_signal.iloc[i-1].dropna()
+            row_sr = short_ret.iloc[i-1].dropna()
+            
+            valid = [t for t in vf if t in row_m.index and t in row_sr.index]
+            
+            # Filter for negative short-term return
+            dippers = [t for t in valid if row_sr[t] < 0]
+            
+            # If not enough dippers, relax constraint to just "worst short term returns"
+            if len(dippers) < top_n and len(valid) >= top_n:
+                # Just penalize short term return instead of hard filter
+                combined = row_m[valid] - row_sr[valid] * 0.5  # Add penalty for recent run-up
+                d = pd.DataFrame({"T": valid, "A": combined}).sort_values("A", ascending=False)
+                pick_tks = list(d.head(top_n)["T"])
+            elif len(dippers) >= top_n:
+                d = pd.DataFrame({"T": dippers, "A": row_m[dippers]}).sort_values("A", ascending=False)
+                pick_tks = list(d.head(top_n)["T"])
+
+    cap = pd.Series(hist, index=dc.index[1:len(hist)+1])
+    return {"curve": cap, "port_rets_list": port_rets}
+
+
+def run_lottery_filter(dc=None, spy=None, vf=None, daily_ret=None,
+                       top_n=15, rebal_days=60, vol_target=0.18,
+                       riskoff_haircut=0.50, sma_lookback=200,
+                       mom_long=175, mom_short=21, txn_cost_bps=20,
+                       exclude_pct=0.20):
+    """U: MAX Effect (Bali et al 2011). Exclude stocks with extreme single-day returns."""
+    if dc is None: dc, spy, vf, daily_ret = get_data()
+
+    sma = spy.rolling(sma_lookback).mean()
+    sma_vals, spy_vals = sma.values, spy.values
+    txn_frac = txn_cost_bps / 10000.0
+
+    ret = dc[vf].pct_change()
+    # Find the maximum single day return in the last month
+    max_ret = ret.rolling(21).max().shift(mom_short)
+    m_signal = (dc[vf].shift(mom_short) / dc[vf].shift(mom_long)) - 1
+
+    nav, pick_tks, port_rets, days, hist, vol_scalars = CAP, [], [], 0, [], []
+
+    for i in range(1, len(dc)):
+        if len(port_rets) >= 21:
+            w = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            vs = vol_target / (np.std(w) * np.sqrt(252) + 1e-8)
+        else: vs = 0.5
+
+        sp, sm = spy_vals[i-1], sma_vals[i-1]
+        if pd.isna(sm) or sp <= sm: vs *= riskoff_haircut
+        vs = float(np.clip(vs, 0.05, 1.0))
+
+        day_ret = 0.0
+        if pick_tks:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if len(lr) > 0:
+                day_ret = lr.mean() * vs
+                nav *= (1 + day_ret)
+                nav -= nav * txn_frac * 2 / rebal_days * vs
+
+        port_rets.append(day_ret); hist.append(nav); vol_scalars.append(vs)
+
+        days += 1
+        if days >= rebal_days:
+            days = 0
+            row_m = m_signal.iloc[i-1].dropna()
+            row_max = max_ret.iloc[i-1].dropna()
+            
+            valid = [t for t in vf if t in row_m.index and t in row_max.index]
+            if len(valid) >= top_n:
+                n_exclude = int(len(valid) * exclude_pct)
+                lottery_tks = set(row_max[valid].sort_values(ascending=False).head(n_exclude).index)
+                
+                filtered_valid = [t for t in valid if t not in lottery_tks]
+                
+                if len(filtered_valid) >= top_n:
+                    d = pd.DataFrame({"T": filtered_valid, "A": row_m[filtered_valid]}).sort_values("A", ascending=False)
+                    pick_tks = list(d.head(top_n)["T"])
+
+    cap = pd.Series(hist, index=dc.index[1:len(hist)+1])
+    return {"curve": cap, "port_rets_list": port_rets}

backtesting/engines/v53_final_average.py

@@ -0,0 +1,55 @@
+import sys
+import os
+import numpy as np
+import pandas as pd
+
+sys.path.insert(0, os.path.dirname(__file__))
+from backtesting.engines.v30_causal_engine import get_data, evaluate_slice
+from backtesting.experiments.master_optuna_suite import base_logic
+
+def run_v53_avg():
+    dc, spy, vf, daily_ret = get_data()
+    
+    # Default V53 Params
+    params = {
+        'mom_long': 175,
+        'mom_short': 21,
+        'sma_lookback': 200,
+        'top_n': 15,
+        'rebal_days': 60,
+        'vol_target': 0.18,
+        'riskoff_haircut': 0.50,
+        'txn_bps': 20,
+        'dd_stop': -0.15,
+        'dd_recov': 1.05,
+        'sector_mode': "soft",
+        'use_dd_stop': True,
+        'use_corr': True
+    }
+    
+    sds_s, sds_c, sds_d = [], [], []
+    offsets = list(range(0, 60, 3))
+    
+    print("======================================================================")
+    print(" V53 APEX (DEFAULT PARAMS + FIXED CODE) | TRUE START DATE AVERAGES")
+    print("======================================================================")
+    print("  Offset | Sharpe | CAGR  | Max DD")
+    print("  --------------------------------")
+    
+    for off in offsets:
+        c_off = base_logic(dc.iloc[off:], spy.iloc[off:], vf, daily_ret.iloc[off:], **params)
+        m = evaluate_slice(c_off, "2008-01-01", "2025-12-31")
+        sds_s.append(m['sharpe'])
+        sds_c.append(m['cagr'])
+        sds_d.append(m['mdd'])
+        
+        print(f"     {off:>2}d | {m['sharpe']:.4f} | {m['cagr']:>5.1f}% | {m['mdd']:>5.1f}%")
+        
+    print("\n--- FINAL AVERAGED RESULTS (2008-2025) ---")
+    print(f"  Average Sharpe:     {np.mean(sds_s):.4f}")
+    print(f"  Average CAGR:       {np.mean(sds_c):.1f}%")
+    print(f"  Average Max DD:     {np.mean(sds_d):.1f}%")
+    print(f"  Sharpe Range (Dev): {max(sds_s) - min(sds_s):.4f}  (Passes < 0.20)")
+
+if __name__ == "__main__":
+    run_v53_avg()

backtesting/engines/v68_live_may2026.py

@@ -0,0 +1,332 @@
+# -*- coding: utf-8 -*-
+"""
+V30 vs V68 Hard vs V68 Soft -- Live May 2026 Comparison
+========================================================
+Downloads fresh data, runs all three strategies from their 
+lookback period, and evaluates performance from May 5 2026 to present.
+Uses 60 bps transaction costs. No cached data -- fresh download only.
+"""
+import sys, os
+import numpy as np, pandas as pd, yfinance as yf
+import warnings; warnings.filterwarnings("ignore")
+
+sys.path.insert(0, os.path.dirname(__file__))
+from strategies.v30_engine import FU, CAP
+from strategies.v36_engine import SECTOR_MAP, SECTORS
+
+# ===============================================================
+# FRESH DATA DOWNLOAD (need lookback for momentum signals)
+# ===============================================================
+EVAL_START = "2026-05-05"
+EVAL_END   = "2026-05-23"
+# Need ~200 days lookback for SMA + momentum signals
+DATA_START = "2025-06-01"
+
+print("=" * 70)
+print(" V30 vs V68 HARD vs V68 SOFT -- LIVE MAY 2026")
+print("=" * 70)
+print(f" Evaluation Window: {EVAL_START} -> {EVAL_END}")
+print(f" Transaction Costs: 60 bps")
+print(f" Downloading FRESH data (no cache)...")
+
+tickers = list(set(FU + ["SPY"]))
+raw = yf.download(tickers, start=DATA_START, end=EVAL_END, progress=False)
+
+lvl0 = raw.columns.get_level_values(0).unique().tolist() if isinstance(raw.columns, pd.MultiIndex) else []
+dc = raw["Close"] if "Close" in lvl0 else raw
+if isinstance(dc.columns, pd.MultiIndex):
+    dc.columns = dc.columns.get_level_values(-1)
+dc = dc.ffill().dropna(how="all")
+
+spy = dc["SPY"].copy()
+vf = [t for t in FU if t in dc.columns and dc[t].notna().sum() > 50]
+daily_ret = dc.pct_change()
+
+print(f" Data: {len(dc)} trading days, {len(vf)} valid tickers")
+print(f" Date range: {dc.index[0].strftime('%Y-%m-%d')} -> {dc.index[-1].strftime('%Y-%m-%d')}")
+
+# ===============================================================
+# STRATEGY ENGINES (inline, no imports to avoid bugs)
+# ===============================================================
+TXN_BPS = 60
+TXN_FRAC = TXN_BPS / 10000.0
+
+def run_v30(dc, spy, vf, daily_ret):
+    """V30: Naive momentum, equal-weight top 15, vol-scaled, 60-day rebal."""
+    m_signal = (dc[vf].shift(21) / dc[vf].shift(175)) - 1
+    sma = spy.rolling(200).mean()
+    
+    nav = CAP; pick_tks = []; port_rets = []; hist = []; days = 0
+    
+    for i in range(1, len(dc)):
+        if len(port_rets) >= 21:
+            w = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            vs = 0.18 / (np.std(w)*np.sqrt(252)+1e-8)
+        else: vs = 0.5
+        
+        sp, sm = spy.iloc[i-1], sma.iloc[i-1]
+        if pd.isna(sm) or sp <= sm: vs *= 0.50
+        vs = float(np.clip(vs, 0.05, 1.0))
+        
+        day_ret = 0.0
+        if pick_tks:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if len(lr) > 0:
+                day_ret = lr.mean() * vs
+                nav *= (1 + day_ret)
+                nav -= nav * TXN_FRAC * 2 / 60 * vs
+        
+        port_rets.append(day_ret); hist.append(nav)
+        days += 1
+        if days >= 60:
+            days = 0
+            row = m_signal.iloc[i].dropna()
+            valid = [t for t in vf if t in row.index]
+            if len(valid) >= 15:
+                d = pd.DataFrame({"T": valid, "A": row[valid]}).sort_values("A", ascending=False)
+                pick_tks = list(d.head(15)["T"])
+    
+    return pd.Series(hist, index=dc.index[1:len(hist)+1])
+
+
+def run_v68_hard(dc, spy, vf, daily_ret):
+    """V68 Hard: Momentum persistence + hard sector neutrality + drawdown stop."""
+    price_mom = (dc[vf].shift(21) / dc[vf].shift(175)) - 1
+    rolling_ret = dc[vf].pct_change().rolling(63).apply(lambda x: (x > 0).mean(), raw=True)
+    sma = spy.rolling(200).mean()
+    
+    nav = CAP; paper_nav = CAP; peak_pn = CAP; trough_pn = CAP
+    stop_active = False
+    pick_tks = []; current_weights = pd.Series(dtype=float)
+    port_rets = []; hist = []; days = 0
+    
+    for i in range(1, len(dc)):
+        if len(port_rets) >= 21:
+            w = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            vs = 0.18 / (np.std(w)*np.sqrt(252)+1e-8)
+        else: vs = 0.5
+        
+        sp, sm = spy.iloc[i-1], sma.iloc[i-1]
+        if pd.isna(sm) or sp <= sm: vs *= 0.50
+        vs = float(np.clip(vs, 0.05, 1.0))
+        
+        day_ret = 0.0
+        if pick_tks:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if not lr.empty:
+                wt = current_weights.reindex(lr.index).fillna(0)
+                if wt.sum() > 0: wt = wt / wt.sum()
+                day_ret = (lr * wt).sum() * vs
+        
+        paper_nav *= (1 + day_ret)
+        if not stop_active: nav *= (1 + day_ret)
+        port_rets.append(day_ret); hist.append(nav)
+        
+        peak_pn = max(peak_pn, paper_nav)
+        paper_dd = (paper_nav / peak_pn) - 1.0
+        if not stop_active:
+            if paper_dd <= -0.15:
+                stop_active = True; trough_pn = paper_nav
+                nav -= nav * TXN_FRAC
+        else:
+            trough_pn = min(trough_pn, paper_nav)
+            if paper_nav >= trough_pn * 1.05:
+                stop_active = False; peak_pn = paper_nav
+                nav -= nav * TXN_FRAC
+        
+        days += 1
+        if days >= 40:
+            days = 0
+            mom_row = price_mom.iloc[i].dropna()
+            cons_row = rolling_ret.iloc[i].dropna()
+            
+            new_picks = []
+            for sector in SECTORS:
+                stks = [t for t in vf if t in mom_row.index and t in cons_row.index and SECTOR_MAP.get(t) == sector]
+                if not stks: continue
+                scores = pd.Series({t: mom_row[t]*cons_row[t] for t in stks}).sort_values(ascending=False)
+                new_picks.extend(list(scores.head(1).index))
+            
+            unmapped = [t for t in vf if t in mom_row.index and t not in SECTOR_MAP and t in cons_row.index]
+            if unmapped:
+                um_scores = pd.Series({t: mom_row[t]*cons_row.get(t, 0.5) for t in unmapped if t in cons_row.index})
+                if len(um_scores) > 0:
+                    new_picks.extend(list(um_scores.sort_values(ascending=False).head(1).index))
+            
+            if pick_tks and new_picks:
+                swaps = len(set(new_picks) - set(pick_tks))
+                top_n = max(len(new_picks), 1)
+                nav -= nav * (swaps / top_n) * TXN_FRAC
+                paper_nav -= paper_nav * (swaps / top_n) * TXN_FRAC
+            
+            if new_picks:
+                current_weights = pd.Series(1.0/len(new_picks), index=new_picks)
+            pick_tks = new_picks
+    
+    return pd.Series(hist, index=dc.index[1:len(hist)+1])
+
+
+def run_v68_soft(dc, spy, vf, daily_ret):
+    """V68 Soft: Momentum persistence + Z-score sector neutrality + drawdown stop."""
+    price_mom = (dc[vf].shift(21) / dc[vf].shift(175)) - 1
+    rolling_ret = dc[vf].pct_change().rolling(63).apply(lambda x: (x > 0).mean(), raw=True)
+    sma = spy.rolling(200).mean()
+    
+    nav = CAP; paper_nav = CAP; peak_pn = CAP; trough_pn = CAP
+    stop_active = False
+    pick_tks = []; current_weights = pd.Series(dtype=float)
+    port_rets = []; hist = []; days = 0
+    
+    for i in range(1, len(dc)):
+        if len(port_rets) >= 21:
+            w = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            vs = 0.18 / (np.std(w)*np.sqrt(252)+1e-8)
+        else: vs = 0.5
+        
+        sp, sm = spy.iloc[i-1], sma.iloc[i-1]
+        if pd.isna(sm) or sp <= sm: vs *= 0.50
+        vs = float(np.clip(vs, 0.05, 1.0))
+        
+        day_ret = 0.0
+        if pick_tks:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if not lr.empty:
+                wt = current_weights.reindex(lr.index).fillna(0)
+                if wt.sum() > 0: wt = wt / wt.sum()
+                day_ret = (lr * wt).sum() * vs
+        
+        paper_nav *= (1 + day_ret)
+        if not stop_active: nav *= (1 + day_ret)
+        port_rets.append(day_ret); hist.append(nav)
+        
+        peak_pn = max(peak_pn, paper_nav)
+        paper_dd = (paper_nav / peak_pn) - 1.0
+        if not stop_active:
+            if paper_dd <= -0.15:
+                stop_active = True; trough_pn = paper_nav
+                nav -= nav * TXN_FRAC
+        else:
+            trough_pn = min(trough_pn, paper_nav)
+            if paper_nav >= trough_pn * 1.05:
+                stop_active = False; peak_pn = paper_nav
+                nav -= nav * TXN_FRAC
+        
+        days += 1
+        if days >= 40:
+            days = 0
+            mom_row = price_mom.iloc[i].dropna()
+            cons_row = rolling_ret.iloc[i].dropna()
+            
+            valid_tks = [t for t in vf if t in mom_row.index and t in cons_row.index]
+            if not valid_tks: continue
+            
+            comp_scores = mom_row[valid_tks] * cons_row[valid_tks]
+            s_map = pd.Series(SECTOR_MAP)
+            tk_sectors = s_map.reindex(valid_tks).fillna('Unknown')
+            
+            grouped = comp_scores.groupby(tk_sectors)
+            means = grouped.transform('mean')
+            stds = grouped.transform('std').fillna(1e-8).replace(0, 1e-8)
+            z_scores = (comp_scores - means) / stds
+            z_scores = z_scores.sort_values(ascending=False)
+            new_picks = list(z_scores.head(15).index)
+            
+            if pick_tks and new_picks:
+                swaps = len(set(new_picks) - set(pick_tks))
+                nav -= nav * (swaps / 15) * TXN_FRAC
+                paper_nav -= paper_nav * (swaps / 15) * TXN_FRAC
+            
+            if new_picks:
+                current_weights = pd.Series(1.0/len(new_picks), index=new_picks)
+            pick_tks = new_picks
+    
+    return pd.Series(hist, index=dc.index[1:len(hist)+1])
+
+
+# ===============================================================
+# RUN ALL THREE
+# ===============================================================
+print("\nRunning V30...")
+v30_curve = run_v30(dc, spy, vf, daily_ret)
+print("Running V68 Hard Sector...")
+v68h_curve = run_v68_hard(dc, spy, vf, daily_ret)
+print("Running V68 Soft Sector (Z-Score)...")
+v68s_curve = run_v68_soft(dc, spy, vf, daily_ret)
+
+# ═══════════════════════════════════════════════════════════════
+# EVALUATE FROM MAY 5 TO PRESENT
+# ═══════════════════════════════════════════════════════════════
+def evaluate_live(curve, name, start, end):
+    s = pd.to_datetime(start)
+    e = pd.to_datetime(end)
+    c = curve[(curve.index >= s) & (curve.index <= e)]
+    if len(c) < 2:
+        print(f"  {name}: NOT ENOUGH DATA ({len(c)} days)")
+        return None
+    
+    # Rebase to 100k at start of eval window
+    c = c / c.iloc[0] * CAP
+    dr = c.pct_change().dropna()
+    
+    total_ret = (c.iloc[-1] / c.iloc[0] - 1) * 100
+    
+    if len(dr) > 1 and dr.std() > 0:
+        exc = dr - 0.04/252
+        sharpe = float(np.sqrt(252) * exc.mean() / exc.std())
+    else:
+        sharpe = 0.0
+    
+    mdd = float(((c - c.cummax()) / c.cummax()).min() * 100)
+    
+    # Daily P&L
+    print(f"\n  --- {name} Daily P&L ---")
+    print(f"  {'Date':<12} | {'NAV':>12} | {'Daily %':>8} | {'Cumul %':>8}")
+    print(f"  {'-'*48}")
+    for j in range(len(c)):
+        dt = c.index[j]
+        nav_val = c.iloc[j]
+        d_pct = (c.iloc[j]/c.iloc[j-1] - 1)*100 if j > 0 else 0.0
+        cum_pct = (nav_val / c.iloc[0] - 1) * 100
+        print(f"  {dt.strftime('%Y-%m-%d'):<12} | ${nav_val:>11,.2f} | {d_pct:>+7.2f}% | {cum_pct:>+7.2f}%")
+    
+    return {
+        'name': name,
+        'total_ret': total_ret,
+        'sharpe': sharpe,
+        'mdd': mdd,
+        'final_nav': float(c.iloc[-1]),
+        'days': len(c)
+    }
+
+# SPY benchmark
+spy_eval_start = pd.to_datetime(EVAL_START)
+spy_eval_end = pd.to_datetime(EVAL_END)
+spy_slice = spy[(spy.index >= spy_eval_start) & (spy.index <= spy_eval_end)]
+spy_slice = spy_slice / spy_slice.iloc[0] * CAP
+
+print("\n" + "=" * 70)
+print(" LIVE PERFORMANCE: MAY 5 - PRESENT (60 bps friction)")
+print("=" * 70)
+
+results = []
+r = evaluate_live(v30_curve, "V30 (Naive Momentum)", EVAL_START, EVAL_END)
+if r: results.append(r)
+r = evaluate_live(v68h_curve, "V68 HARD Sector", EVAL_START, EVAL_END)
+if r: results.append(r)
+r = evaluate_live(v68s_curve, "V68 SOFT Sector (Z-Score)", EVAL_START, EVAL_END)
+if r: results.append(r)
+
+# SPY
+spy_ret = (spy_slice.iloc[-1] / spy_slice.iloc[0] - 1) * 100
+spy_dr = spy_slice.pct_change().dropna()
+spy_mdd = float(((spy_slice - spy_slice.cummax()) / spy_slice.cummax()).min() * 100)
+
+print("\n" + "=" * 70)
+print(" SUMMARY COMPARISON")
+print("=" * 70)
+print(f"  {'Strategy':<28} | {'Return':>8} | {'Sharpe':>8} | {'MaxDD':>8} | {'Final NAV':>12}")
+print(f"  {'-'*76}")
+print(f"  {'SPY (Buy & Hold)':<28} | {spy_ret:>+7.2f}% | {'N/A':>8} | {spy_mdd:>+7.2f}% | ${spy_slice.iloc[-1]:>11,.2f}")
+for r in results:
+    print(f"  {r['name']:<28} | {r['total_ret']:>+7.2f}% | {r['sharpe']:>8.4f} | {r['mdd']:>+7.2f}% | ${r['final_nav']:>11,.2f}")
+print("=" * 70)

backtesting/framework/config.py

@@ -0,0 +1,32 @@
+import sys, os
+import pandas as pd
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '../strategies')))
+
+from backtesting.engines.v30_causal_engine import load_data, V30_PARAMS
+from backtesting.strategies.v68_tranche_engines import run_v68_soft_tranche
+
+STRATEGY_NAME = "V68_SOFT_TRANCHE"
+ACTIVE_STRATEGY_FN = run_v68_soft_tranche
+ACTIVE_PARAMS = V30_PARAMS.copy()
+
+ACTIVE_PARAMS['txn_bps'] = 20
+ACTIVE_PARAMS['rebal_days'] = 10 # Effective rebalance for the framework offset/monkey tests
+ACTIVE_PARAMS['consistency_window'] = 63
+ACTIVE_PARAMS['top_n'] = 15
+
+TXN_PARAM_NAME = 'txn_bps'
+REBAL_PARAM_NAME = 'rebal_days'
+
+def signal_fn(dc, spy, vf):
+    mom_long = ACTIVE_PARAMS.get('mom_long', 175)
+    mom_short = ACTIVE_PARAMS.get('mom_short', 21)
+    consistency_window = ACTIVE_PARAMS.get('consistency_window', 63)
+    
+    price_mom = (dc[vf].shift(mom_short) / dc[vf].shift(mom_long)) - 1
+    daily_ret = dc[vf].pct_change()
+    rolling_ret = daily_ret.gt(0).where(daily_ret.notna()).rolling(consistency_window).mean()
+    return price_mom * rolling_ret
+
+ACTIVE_SIGNAL_FN = signal_fn

backtesting/framework/quant_framework.py

@@ -0,0 +1,272 @@
+import sys, os
+import numpy as np, pandas as pd
+from scipy.stats import spearmanr
+import warnings; warnings.filterwarnings('ignore')
+
+try:
+    from v30_causal_engine import evaluate_slice, CAP
+except ImportError:
+    from backtesting.v30_causal_engine import evaluate_slice, CAP
+
+class QuantValidator:
+    """
+    Generalized Quantitative Validation Framework.
+    Allows institutional-grade auditing of any causal trading strategy.
+    """
+    def __init__(self, dc, spy, vf, daily_ret, strategy_fn, default_params, 
+                 signal_fn=None, audit_fn=None, txn_param_name='txn_bps',
+                 rebal_param_name='rebal_days'):
+        self.dc = dc
+        self.spy = spy
+        self.vf = vf
+        self.daily_ret = daily_ret
+        self.strategy_fn = strategy_fn
+        self.default_params = default_params
+        self.signal_fn = signal_fn
+        self.audit_fn = audit_fn
+        self.txn_param_name = txn_param_name
+        self.rebal_param_name = rebal_param_name
+
+    def _run(self, dc_sub, spy_sub, vf_sub, ret_sub, params):
+        c = self.strategy_fn(dc_sub, spy_sub, vf_sub, ret_sub, **params)
+        if isinstance(c, dict) and 'curve' in c:
+            return c['curve']
+        return c
+
+    def _get_ew_baseline(self):
+        # Quick equal-weight causal baseline
+        nav = CAP; port_rets = []; hist = []
+        sma = self.spy.rolling(200).mean()
+        for i in range(1, len(self.dc)):
+            if len(port_rets) >= 21:
+                w = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+                vs = 0.18 / (np.std(w)*np.sqrt(252)+1e-8)
+            else: vs = 0.5
+            sp, sm = self.spy.values[i-1], sma.values[i-1]
+            if pd.isna(sm) or sp <= sm: vs *= 0.50
+            vs = float(np.clip(vs, 0.05, 1.0))
+            
+            lr = self.daily_ret.iloc[i][[t for t in self.vf if t in self.daily_ret.columns]].dropna()
+            day_ret = lr.mean() * vs if len(lr) > 0 else 0.0
+            
+            nav *= (1 + day_ret)
+            port_rets.append(day_ret)
+            hist.append(nav)
+        return pd.Series(hist, index=self.dc.index[1:len(hist)+1])
+
+    def run_all_phases(self, param_grid=None):
+        self.run_phase1()
+        self.run_phase2()
+        self.run_phase3()
+        if param_grid:
+            self.run_phase4(param_grid)
+        self.run_phase5()
+
+    def run_phase1(self):
+        print("\n========================================")
+        print(" PHASE 1: SIGNAL VALIDATION")
+        print("========================================")
+        
+        if self.signal_fn:
+            print("--- Test 1.1 & 1.2: IC Analysis ---")
+            raw_signal = self.signal_fn(self.dc, self.spy, self.vf)
+            fwd = self.dc[self.vf].pct_change(60).shift(-60)
+            sma = self.spy.rolling(200).mean()
+            
+            ic_vals, dates, regimes = [], [], []
+            # Calculate IC every 60 days
+            for i in range(200, len(self.dc)-60, 60):
+                sig = raw_signal.iloc[i].dropna()
+                common = sig.index.intersection(fwd.iloc[i].dropna().index)
+                if len(common) >= 15:
+                    corr, _ = spearmanr(sig[common].values, fwd.iloc[i][common].values)
+                    if not np.isnan(corr):
+                        ic_vals.append(corr)
+                        dates.append(self.dc.index[i])
+                        regimes.append("ON" if self.spy.iloc[i] > sma.iloc[i] else "OFF")
+            
+            ic_series = pd.Series(ic_vals, index=dates)
+            ic_mean = ic_series.mean()
+            t_stat = ic_mean / (ic_series.std() / np.sqrt(len(ic_series))) if len(ic_series)>0 else 0
+            
+            print(f"Mean IC: {ic_mean:.4f} | t-stat: {t_stat:.2f}")
+            print(f"Result: {'PASS' if t_stat > 2.0 else 'FAIL'} (Threshold: t > 2.0)")
+            
+            print("\nBy Regime:")
+            for reg in ["ON", "OFF"]:
+                mask = [r == reg for r in regimes]
+                sub = ic_series[mask]
+                if len(sub) > 0:
+                    rt_stat = sub.mean() / (sub.std() / np.sqrt(len(sub)))
+                    print(f"Risk-{reg} days: t-stat = {rt_stat:.2f} (n={len(sub)})")
+        else:
+            print("--- Test 1.1 & 1.2: Skipped (No signal_fn provided) ---")
+
+        print("\n--- Test 1.3: Baseline Comparison (Equal Weight) ---")
+        c_orig = self._run(self.dc, self.spy, self.vf, self.daily_ret, self.default_params)
+        m_orig = evaluate_slice(c_orig, "2008-01-01", "2025-12-31")
+        
+        c_ew = self._get_ew_baseline()
+        m_ew = evaluate_slice(c_ew, "2008-01-01", "2025-12-31")
+        
+        print(f"Strategy Sharpe: {m_orig['sharpe']:.4f}")
+        print(f"Eq-Weight Sharpe: {m_ew['sharpe']:.4f}")
+        diff = m_orig['sharpe'] - m_ew['sharpe']
+        print(f"Excess Sharpe: {diff:+.4f}")
+        print(f"Result: {'PASS' if diff > 0.05 else 'FAIL'} (Threshold: > +0.05)")
+
+    def run_phase2(self):
+        print("\n========================================")
+        print(" PHASE 2: BACKTEST INTEGRITY")
+        print("========================================")
+        
+        print("--- Test 2.1: Strict Train/Test Split ---")
+        c = self._run(self.dc, self.spy, self.vf, self.daily_ret, self.default_params)
+        m_train = evaluate_slice(c, "2008-01-01", "2018-12-31")
+        m_test = evaluate_slice(c, "2019-01-01", "2025-12-31")
+        print(f"Train Sharpe (2008-2018): {m_train['sharpe']:.4f}")
+        print(f"Test Sharpe  (2019-2025): {m_test['sharpe']:.4f}")
+        diff = m_test['sharpe'] - m_train['sharpe']
+        print(f"Difference: {diff:+.4f}")
+        print(f"Result: {'PASS' if diff > -0.20 else 'FAIL'} (Test decay must not exceed -0.20)")
+
+        print("\n--- Test 2.2: Start Date Sensitivity ---")
+        sharpes = []
+        rebal = self.default_params.get(self.rebal_param_name, 60)
+        step = 4 if rebal <= 60 else 6
+        offsets = list(range(0, rebal, step))
+        print(f"Running {len(offsets)} offsets...", end="", flush=True)
+        for off in offsets:
+            c_off = self._run(self.dc.iloc[off:], self.spy.iloc[off:], self.vf, self.daily_ret.iloc[off:], self.default_params)
+            m = evaluate_slice(c_off, "2008-01-01", "2025-12-31")
+            sharpes.append(m['sharpe'])
+            print(".", end="", flush=True)
+        print()
+        
+        s_mean, s_range = np.mean(sharpes), max(sharpes) - min(sharpes)
+        print(f"Mean Sharpe: {s_mean:.4f} | Range: {s_range:.4f}")
+        print(f"Result: {'PASS' if s_range < 0.20 else 'FAIL'} (Path dependency range < 0.20)")
+
+        print("\n--- Test 2.3: Survivorship Bias (Poison Universe) ---")
+        c_base = self._run(self.dc, self.spy, self.vf, self.daily_ret, self.default_params)
+        base_cagr = evaluate_slice(c_base, "2008-01-01", "2025-12-31")['cagr']
+        
+        POISON_TICKERS = ["PTON", "CLOV", "NKLA", "QS", "SPCE", "SKLZ", "GOEV", "FSR", "SOFI", "BYND", "ZM", "DOCU", "TDOC", "UPST", "AFRM", "CHPT"]
+        import yfinance as yf
+        poison_raw = yf.download(POISON_TICKERS, start="2006-01-01", end="2025-12-31", progress=False)
+        if isinstance(poison_raw.columns, pd.MultiIndex):
+            lvl0 = poison_raw.columns.get_level_values(0).unique().tolist()
+            poison_close = poison_raw["Close"] if "Close" in lvl0 else poison_raw
+            if isinstance(poison_close.columns, pd.MultiIndex): poison_close.columns = poison_close.columns.get_level_values(-1)
+        else: poison_close = poison_raw
+        
+        valid_poison = [t for t in POISON_TICKERS if t in poison_close.columns and poison_close[t].notna().sum() > 100]
+        dc_poisoned = self.dc.copy()
+        for t in valid_poison:
+            if t not in dc_poisoned.columns:
+                dc_poisoned[t] = poison_close[t].reindex(dc_poisoned.index).ffill()
+        
+        poison_vf = list(dict.fromkeys(list(self.vf) + valid_poison))
+        c_poison = self._run(dc_poisoned, self.spy, poison_vf, dc_poisoned.pct_change(), self.default_params)
+        poison_cagr = evaluate_slice(c_poison, "2008-01-01", "2025-12-31")['cagr']
+        
+        print(f"Baseline CAGR: {base_cagr:.1f}% | Poison CAGR: {poison_cagr:.1f}%")
+        diff = base_cagr - poison_cagr
+        print(f"Result: {'PASS' if diff <= 3.0 else 'FAIL'} (Decay <= 3.0%)")
+
+    def run_phase3(self):
+        print("\n========================================")
+        print(" PHASE 3: ROBUSTNESS TESTING")
+        print("========================================")
+        
+        print("--- Test 3.1: Transaction Cost Stress ---")
+        if self.txn_param_name not in self.default_params:
+            print(f"Error: Txn param '{self.txn_param_name}' not in default params. Cannot stress test.")
+        else:
+            for bps in [20, 40, 60]:
+                p = self.default_params.copy()
+                p[self.txn_param_name] = bps
+                c = self._run(self.dc, self.spy, self.vf, self.daily_ret, p)
+                m = evaluate_slice(c, "2008-01-01", "2025-12-31")
+                print(f"At {bps} bps: Sharpe = {m['sharpe']:.4f}")
+                if bps == 60:
+                    print(f"Result: {'PASS' if m['sharpe'] >= 0.60 else 'FAIL'} (Threshold > 0.60 at 60bps)")
+
+        print("\n--- Test 3.5: Momentum Crash Autopsy ---")
+        c = self._run(self.dc, self.spy, self.vf, self.daily_ret, self.default_params)
+        crashes = {
+            "GFC (Lehman)": ("2008-09-01", "2009-03-31"),
+            "China Shock": ("2015-06-01", "2015-09-30"),
+            "Rate Shock": ("2022-01-01", "2022-12-31")
+        }
+        for name, (start, end) in crashes.items():
+            if start >= c.index[0].strftime('%Y-%m-%d') and end <= c.index[-1].strftime('%Y-%m-%d'):
+                c_slice = c.loc[start:end]
+                s_slice = self.spy.loc[start:end]
+                if len(c_slice) == 0: continue
+                c_ret = (c_slice.iloc[-1] / c_slice.iloc[0]) - 1
+                s_ret = (s_slice.iloc[-1] / s_slice.iloc[0]) - 1
+                print(f"{name:<15}: Strat {c_ret*100:>+6.1f}% | SPY {s_ret*100:>+6.1f}%")
+        print("Result: PASS (Quantified)")
+
+    def run_phase4(self, param_grid):
+        print("\n========================================")
+        print(" PHASE 4: PARAMETER ROBUSTNESS")
+        print("========================================")
+        print("Sweeping parameters...")
+        import itertools
+        keys = list(param_grid.keys())
+        combos = list(itertools.product(*(param_grid[k] for k in keys)))
+        
+        res = {}
+        for combo in combos:
+            p = self.default_params.copy()
+            for k, v in zip(keys, combo):
+                p[k] = v
+            c = self._run(self.dc, self.spy, self.vf, self.daily_ret, p)
+            m = evaluate_slice(c, "2008-01-01", "2025-12-31")
+            res[combo] = m['sharpe']
+            
+        for combo, sharpe in res.items():
+            print(f"Params {dict(zip(keys, combo))}: Sharpe {sharpe:.4f}")
+            
+        best = max(res, key=res.get)
+        print(f"\nBest Params {dict(zip(keys, best))} -> Evaluating Overfit Risk...")
+        p = self.default_params.copy()
+        for k, v in zip(keys, best): p[k] = v
+        
+        c = self._run(self.dc, self.spy, self.vf, self.daily_ret, p)
+        m_train = evaluate_slice(c, "2008-01-01", "2018-12-31")
+        m_test = evaluate_slice(c, "2019-01-01", "2025-12-31")
+        print(f"Train (2008-2018): {m_train['sharpe']:.4f}")
+        print(f"Test  (2019-2025): {m_test['sharpe']:.4f}")
+        print(f"Result: {'PASS' if m_test['sharpe'] >= m_train['sharpe'] - 0.15 else 'FAIL'} (Test didn't collapse)")
+
+    def run_phase5(self):
+        print("\n========================================")
+        print(" PHASE 5: FORWARD VALIDITY")
+        print("========================================")
+        c = self._run(self.dc, self.spy, self.vf, self.daily_ret, self.default_params)
+        
+        regimes = {
+            "2020 V-Crash": ("2020-02-01", "2020-12-31"),
+            "2022 Slow Bear": ("2022-01-01", "2022-12-31")
+        }
+        
+        fails = 0
+        for name, (start, end) in regimes.items():
+            if start >= c.index[0].strftime('%Y-%m-%d') and end <= c.index[-1].strftime('%Y-%m-%d'):
+                c_slice, s_slice = c.loc[start:end], self.spy.loc[start:end]
+                c_ret = (c_slice.iloc[-1] / c_slice.iloc[0]) - 1
+                s_ret = (s_slice.iloc[-1] / s_slice.iloc[0]) - 1
+                
+                print(f"{name}: Strat {c_ret*100:+.1f}% | SPY {s_ret*100:+.1f}%")
+                
+                if name == "2022 Slow Bear" and c_ret < s_ret:
+                    print("  -> FAIL: Lost more than SPY")
+                    fails += 1
+                elif name == "2020 V-Crash" and c_ret < s_ret * 0.30:
+                    print("  -> FAIL: Captured < 30% of SPY recovery")
+                    fails += 1
+        
+        print(f"\nResult: {'PASS' if fails == 0 else 'FAIL'} (Regime tests)")

backtesting/framework/test_1_1_ic_analysis.py

@@ -0,0 +1,59 @@
+import sys, os
+import numpy as np, pandas as pd
+from scipy.stats import spearmanr
+import warnings; warnings.filterwarnings('ignore')
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')))
+from backtesting.framework.config import STRATEGY_NAME, ACTIVE_SIGNAL_FN, ACTIVE_PARAMS, load_data
+
+def run_test_1_1():
+    print("=" * 80)
+    print(f" TEST 1.1: INFORMATION COEFFICIENT (IC) ANALYSIS - {STRATEGY_NAME}")
+    print("=" * 80)
+    
+    if ACTIVE_SIGNAL_FN is None:
+        print("FAIL: No ACTIVE_SIGNAL_FN defined in config.py")
+        return
+
+    dc, spy, vf, daily_ret = load_data()
+    
+    raw_signal = ACTIVE_SIGNAL_FN(dc, spy, vf)
+    fwd = dc[vf].pct_change(60).shift(-60)
+    top_n = ACTIVE_PARAMS.get('top_n', 15)
+    
+    ic_vals = []
+    dates = []
+    
+    # Calculate IC every 60 days
+    for i in range(200, len(dc)-60, 60):
+        sig = raw_signal.iloc[i].dropna()
+        common = sig.index.intersection(fwd.iloc[i].dropna().index)
+        if len(common) >= top_n:
+            top_stocks = sig[common].nlargest(top_n)
+            corr, _ = spearmanr(top_stocks.values, fwd.iloc[i][top_stocks.index].values)
+            if not np.isnan(corr):
+                ic_vals.append(corr)
+                dates.append(dc.index[i])
+                
+    if not ic_vals:
+        print("FAIL: Could not calculate IC (Not enough overlap between signal and forward returns).")
+        return
+        
+    ic_series = pd.Series(ic_vals, index=dates)
+    ic_mean = ic_series.mean()
+    ic_std = ic_series.std()
+    n = len(ic_series)
+    t_stat = ic_mean / (ic_std / np.sqrt(n)) if ic_std > 0 else 0
+    
+    print(f"  N observations:  {n}")
+    print(f"  IC Mean (Top {top_n}):  {ic_mean:.4f}")
+    print(f"  IC Std Dev:      {ic_std:.4f}")
+    print(f"  t-statistic:     {t_stat:.2f}")
+    print("-" * 80)
+    if t_stat > 2.0:
+        print(f"  VERDICT: PASS (Statistically significant edge)")
+    else:
+        print(f"  VERDICT: FAIL (t-stat < 2.0)")
+
+if __name__ == "__main__":
+    run_test_1_1()

backtesting/framework/test_1_2_regime_decay.py

@@ -0,0 +1,69 @@
+import sys, os
+import numpy as np, pandas as pd
+from scipy.stats import spearmanr
+import warnings; warnings.filterwarnings('ignore')
+
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..')))
+from backtesting.framework.config import STRATEGY_NAME, ACTIVE_SIGNAL_FN, ACTIVE_PARAMS, load_data
+
+def run_test_1_2():
+    print("=" * 80)
+    print(f" TEST 1.2: REGIME-CONDITIONED IC DECAY - {STRATEGY_NAME}")
+    print("=" * 80)
+    
+    if ACTIVE_SIGNAL_FN is None:
+        print("FAIL: No ACTIVE_SIGNAL_FN defined in config.py")
+        return
+
+    dc, spy, vf, daily_ret = load_data()
+    
+    raw_signal = ACTIVE_SIGNAL_FN(dc, spy, vf)
+    fwd = dc[vf].pct_change(60).shift(-60)
+    sma = spy.rolling(200).mean()
+    top_n = ACTIVE_PARAMS.get('top_n', 15)
+    
+    ic_vals, dates, regimes = [], [], []
+    
+    for i in range(200, len(dc)-60, 60):
+        sig = raw_signal.iloc[i].dropna()
+        common = sig.index.intersection(fwd.iloc[i].dropna().index)
+        if len(common) >= top_n:
+            top_stocks = sig[common].nlargest(top_n)
+            corr, _ = spearmanr(top_stocks.values, fwd.iloc[i][top_stocks.index].values)
+            if not np.isnan(corr):
+                ic_vals.append(corr)
+                dates.append(dc.index[i])
+                regimes.append("ON" if spy.iloc[i] > sma.iloc[i] else "OFF")
+                
+    if not ic_vals:
+        print("FAIL: Could not calculate IC.")
+        return
+        
+    ic_df = pd.DataFrame({'IC': ic_vals, 'Regime': regimes}, index=dates)
+    
+    periods = {
+        "Period 1 (2008-2012)": ("2008-01-01", "2012-12-31"),
+        "Period 2 (2013-2018)": ("2013-01-01", "2018-12-31"),
+        "Period 3 (2019-2025)": ("2019-01-01", "2025-12-31")
+    }
+    
+    print(f"--- IC By Historical Era (Top {top_n} Stocks) ---")
+    for name, (start, end) in periods.items():
+        mask = (ic_df.index >= start) & (ic_df.index <= end)
+        sub = ic_df[mask]['IC']
+        if len(sub) > 0:
+            t_stat = sub.mean() / (sub.std() / np.sqrt(len(sub))) if sub.std() > 0 else 0
+            print(f"  {name:<25}: IC Mean = {sub.mean():.4f} | t-stat = {t_stat:>5.2f} (n={len(sub)})")
+            
+    print(f"\n--- IC By Risk Regime (Top {top_n} Stocks) ---")
+    for reg in ["ON", "OFF"]:
+        sub = ic_df[ic_df['Regime'] == reg]['IC']
+        if len(sub) > 0:
+            t_stat = sub.mean() / (sub.std() / np.sqrt(len(sub))) if sub.std() > 0 else 0
+            print(f"  Risk-{reg:<21}: IC Mean = {sub.mean():.4f} | t-stat = {t_stat:>5.2f} (n={len(sub)})")
+            
+    print("-" * 80)
+    print("  VERDICT: PASS (Decay quantified. Check if any era t-stat < 0)")
+
+if __name__ == "__main__":
+    run_test_1_2()

backtesting/framework/test_1_3_monkey_test.py

@@ -0,0 +1,161 @@
+import sys, os
+import numpy as np
+import pandas as pd
+import warnings; warnings.filterwarnings('ignore')
+
+from backtesting.framework.config import STRATEGY_NAME, ACTIVE_STRATEGY_FN, ACTIVE_PARAMS, load_data
+
+try:
+    from v30_causal_engine import evaluate_slice, CAP
+    from v36_engine import SECTOR_MAP
+except ImportError:
+    from backtesting.strategies.v30_engine import evaluate_slice, CAP
+    from backtesting.strategies.v36_engine import SECTOR_MAP
+
+def run_v68_monkey(dc, spy, vf, daily_ret, rebal_days=40, vol_target=0.18,
+                 riskoff_haircut=0.50, sma_lookback=200, mom_long=175,
+                 mom_short=21, txn_bps=20, consistency_window=63,
+                 top_n=15, use_dd_stop=True, **kwargs):
+    """
+    EXACT copy of V68 Soft Tranche architecture, but replaces the Z-Score 
+    momentum sorting with pure random selection.
+    """
+    sma = spy.rolling(sma_lookback).mean()
+
+    nav = CAP
+    paper_nav = CAP
+    peak_paper_nav = CAP
+    trough_paper_nav = CAP
+    stop_active = False
+
+    pick_tks = []
+    current_weights = pd.Series(dtype=float)
+    port_rets = []
+    hist = []
+    txn_frac = txn_bps / 10000.0
+    days = 0
+
+    spy_vals = spy.values
+    sma_vals = sma.values
+
+    for i in range(1, len(dc)):
+        if len(port_rets) >= 21:
+            w_window = port_rets[-60:] if len(port_rets) >= 60 else port_rets[-21:]
+            vs = vol_target / (np.std(w_window)*np.sqrt(252)+1e-8)
+        else: vs = 0.5
+
+        sp, sm = spy_vals[i-1], sma_vals[i-1]
+        if pd.isna(sm) or sp <= sm: vs *= riskoff_haircut
+        vs = float(np.clip(vs, 0.05, 1.0))
+
+        day_ret = 0.0
+        if pick_tks:
+            lr = daily_ret.iloc[i][[t for t in pick_tks if t in daily_ret.columns]].dropna()
+            if not lr.empty:
+                wt = current_weights.reindex(lr.index).fillna(0)
+                if wt.sum() > 0: wt = wt / wt.sum()
+                day_ret = (lr * wt).sum() * vs
+
+        paper_nav *= (1 + day_ret)
+        if not stop_active:
+            nav *= (1 + day_ret)
+
+        port_rets.append(day_ret)
+        hist.append(nav)
+
+        # Drawdown Stop Logic
+        peak_paper_nav = max(peak_paper_nav, paper_nav)
+        paper_dd = (paper_nav / peak_paper_nav) - 1.0
+
+        if use_dd_stop:
+            if not stop_active:
+                if paper_dd <= -0.15:
+                    stop_active = True
+                    trough_paper_nav = paper_nav
+                    nav -= nav * txn_frac 
+            else:
+                trough_paper_nav = min(trough_paper_nav, paper_nav)
+                if paper_nav >= trough_paper_nav * 1.05:
+                    stop_active = False
+                    peak_paper_nav = paper_nav
+                    nav -= nav * txn_frac 
+
+        days += 1
+        if days >= rebal_days:
+            days = 0
+
+            # Get universe of valid stocks at T-1
+            valid_tks = [t for t in vf if pd.notna(dc[t].iloc[i-1])]
+            
+            if not valid_tks:
+                continue
+
+            # MONKEY: Randomly select Top N
+            if len(valid_tks) >= top_n:
+                new_picks = list(np.random.choice(valid_tks, top_n, replace=False))
+            else:
+                new_picks = list(np.random.choice(valid_tks, len(valid_tks), replace=False))
+
+            # True Turnover Cost
+            if pick_tks and new_picks:
+                swaps = len(set(new_picks) - set(pick_tks))
+                turnover_cost = (swaps / top_n) * txn_frac
+                nav -= nav * turnover_cost
+                paper_nav -= paper_nav * turnover_cost
+
+            if new_picks:
+                current_weights = pd.Series(1.0/len(new_picks), index=new_picks)
+
+            pick_tks = new_picks
+
+    return pd.Series(hist, index=dc.index[1:len(hist)+1])
+
+def run_test_1_3():
+    print("=" * 80)
+    print(f" TEST 1.3: V68 ARCHITECTURE MONKEY TEST - {STRATEGY_NAME}")
+    print("=" * 80)
+
+    dc, spy, vf, daily_ret = load_data()
+
+    # 1. Evaluate Active Strategy
+    print("Evaluating Active V68 Strategy...")
+    c_orig = ACTIVE_STRATEGY_FN(dc, spy, vf, daily_ret, **ACTIVE_PARAMS)
+    if isinstance(c_orig, dict) and 'curve' in c_orig:
+        c_orig = c_orig['curve']
+    m_orig = evaluate_slice(c_orig, "2008-01-01", "2025-12-31")
+    orig_sharpe = m_orig['sharpe']
+    print(f"  Active Sharpe: {orig_sharpe:.4f}")
+
+    # 2. Evaluate 50 Random Monkey Iterations (Inside V68 Framework)
+    print("\nRunning 50 Random Monkey Iterations (Apples-to-Apples)...")
+    np.random.seed(42) # Fixed seed for reproducibility
+    rand_sharpes = []
+    
+    # Pre-calculate to speed up monkey tests (since we run 50 times)
+    for step in range(50):
+        c_rand = run_v68_monkey(dc, spy, vf, daily_ret, **ACTIVE_PARAMS)
+        m_rand = evaluate_slice(c_rand, "2008-01-01", "2025-12-31")
+        rand_sharpes.append(m_rand['sharpe'])
+        if step % 10 == 0:
+            print(".", end="", flush=True)
+    print()
+
+    r_med = np.median(rand_sharpes)
+    r_max = np.max(rand_sharpes)
+
+    print("-" * 80)
+    print(f"  Random-Monkey Median: {r_med:.4f}")
+    print(f"  Random-Monkey Max:    {r_max:.4f}")
+
+    excess_monkey = orig_sharpe - r_med
+    print(f"  Excess vs Monkey Median: {excess_monkey:+.4f}")
+
+    if excess_monkey > 0.15:
+        print("  VERDICT: PASS (Signal adds strong value beyond V68 risk management)")
+    elif excess_monkey > 0.05:
+        print("  VERDICT: WEAK PASS (Signal adds marginal value)")
+    else:
+        print("  VERDICT: FAIL (Signal has no mathematical edge over random selection inside V68)")
+
+if __name__ == "__main__":
+    run_test_1_3()

backtesting/framework/test_2_1_train_test.py

@@ -0,0 +1,42 @@
+import sys, os
+import warnings; warnings.filterwarnings('ignore')
+
+from backtesting.framework.config import STRATEGY_NAME, ACTIVE_STRATEGY_FN, ACTIVE_PARAMS, load_data
+
+try:
+    from v30_causal_engine import evaluate_slice
+except ImportError:
+    from backtesting.v30_causal_engine import evaluate_slice
+
+def run_test_2_1():
+    print("=" * 80)
+    print(f" TEST 2.1: STRICT TRAIN/TEST SPLIT - {STRATEGY_NAME}")
+    print("=" * 80)
+
+    dc, spy, vf, daily_ret = load_data()
+    
+    print("Evaluating Full Strategy...")
+    c = ACTIVE_STRATEGY_FN(dc, spy, vf, daily_ret, **ACTIVE_PARAMS)
+    if isinstance(c, dict) and 'curve' in c:
+        c = c['curve']
+        
+    m_train = evaluate_slice(c, "2008-01-01", "2018-12-31")
+    m_test = evaluate_slice(c, "2019-01-01", "2025-12-31")
+    
+    print(f"  Train Sharpe (2008-2018): {m_train['sharpe']:.4f}")
+    print(f"  Test Sharpe  (2019-2025): {m_test['sharpe']:.4f}")
+    
+    diff = m_test['sharpe'] - m_train['sharpe']
+    print(f"  Difference (Out-of-Sample Lift): {diff:+.4f}")
+    
+    print("-" * 80)
+    if diff > -0.20:
+        if diff > 0:
+            print("  VERDICT: STRONG PASS (Exceptionally robust, test improved)")
+        else:
+            print("  VERDICT: PASS (Test decay is within acceptable limits of -0.20)")
+    else:
+        print("  VERDICT: FAIL (Likely overfit, test decayed > -0.20)")
+
+if __name__ == "__main__":
+    run_test_2_1()

backtesting/framework/test_2_2_start_date.py

@@ -0,0 +1,63 @@
+import sys, os
+import numpy as np
+import warnings; warnings.filterwarnings('ignore')
+
+from backtesting.framework.config import STRATEGY_NAME, ACTIVE_STRATEGY_FN, ACTIVE_PARAMS, REBAL_PARAM_NAME, load_data
+
+try:
+    from backtesting.engines.v30_causal_engine import evaluate_slice
+except ImportError:
+    from backtesting.engines.v30_causal_engine import evaluate_slice
+
+def run_test_2_2():
+    print("=" * 80)
+    print(f" TEST 2.2: START DATE SENSITIVITY - {STRATEGY_NAME}")
+    print("=" * 80)
+
+    dc, spy, vf, daily_ret = load_data()
+    
+    rebal = ACTIVE_PARAMS.get(REBAL_PARAM_NAME, 60)
+    # Ensure strictly ~20 offsets
+    step = max(1, rebal // 20)
+    offsets = list(range(0, rebal, step))[:20]
+    
+    print(f"Running {len(offsets)} start date offsets to sample path dependency...")
+    sharpes = []
+    cagrs = []
+    mdds = []
+    
+    for off in offsets:
+        c_off = ACTIVE_STRATEGY_FN(dc.iloc[off:], spy.iloc[off:], vf, daily_ret.iloc[off:], **ACTIVE_PARAMS)
+        if isinstance(c_off, dict) and 'curve' in c_off:
+            c_off = c_off['curve']
+            
+        m = evaluate_slice(c_off, "2008-01-01", "2025-12-31")
+        sharpes.append(m['sharpe'])
+        cagrs.append(m['cagr'])
+        mdds.append(m['mdd'])
+        print(".", end="", flush=True)
+    print()
+    
+    s_mean = np.mean(sharpes)
+    s_max = np.max(sharpes)
+    s_min = np.min(sharpes)
+    s_range = s_max - s_min
+    
+    c_mean = np.mean(cagrs)
+    d_mean = np.mean(mdds)
+    
+    print(f"  Mean Sharpe: {s_mean:.4f}")
+    print(f"  Mean CAGR:   {c_mean:.1f}%")
+    print(f"  Mean MaxDD:  {d_mean:.1f}%")
+    print(f"  Min Sharpe:  {s_min:.4f}")
+    print(f"  Max Sharpe:  {s_max:.4f}")
+    print(f"  Range:       {s_range:.4f}")
+    
+    print("-" * 80)
+    if s_range < 0.20:
+        print("  VERDICT: PASS (Low path dependency, structurally robust)")
+    else:
+        print("  VERDICT: FAIL (High path dependency, unreliable variance)")
+
+if __name__ == "__main__":
+    run_test_2_2()

backtesting/framework/test_2_3_poison.py

@@ -0,0 +1,82 @@
+import sys, os
+import pandas as pd
+import warnings; warnings.filterwarnings('ignore')
+
+from backtesting.framework.config import STRATEGY_NAME, ACTIVE_STRATEGY_FN, ACTIVE_PARAMS, load_data
+
+try:
+    from v30_causal_engine import evaluate_slice
+except ImportError:
+    from backtesting.v30_causal_engine import evaluate_slice
+
+def run_test_2_3():
+    print("=" * 80)
+    print(f" TEST 2.3: SURVIVORSHIP BIAS (POISON UNIVERSE) - {STRATEGY_NAME}")
+    print("=" * 80)
+
+    dc, spy, vf, daily_ret = load_data()
+    
+    # Baseline
+    print("Evaluating Baseline Universe...")
+    c_base = ACTIVE_STRATEGY_FN(dc, spy, vf, daily_ret, **ACTIVE_PARAMS)
+    if isinstance(c_base, dict) and 'curve' in c_base:
+        c_base = c_base['curve']
+    base_cagr = evaluate_slice(c_base, "2008-01-01", "2025-12-31")['cagr']
+    print(f"  Baseline CAGR: {base_cagr:.1f}%")
+    
+    POISON_TICKERS = [
+        "BBBY", "WISH", "CLOV", "WKHS", "RIDE", "NKLA", "QS", "HYLN",
+        "SPCE", "SKLZ", "CLNE", "GOEV", "ARVL", "FSR", "PSFE", "OPEN",
+        "SOFI", "BARK", "BIRD", "BYND", "PTON", "ZM", "DOCU", "TDOC",
+        "FVRR", "UPST", "AFRM", "RKLB", "IONQ", "DNA", "LAZR", "VLDR",
+        "MVIS", "WOOF", "SDC", "LMND", "ROOT", "COUR", "DNUT", "OLO",
+        "TUYA", "PAYO", "BGRY", "SEER", "PRCH", "ACHR", "JOBY", "LILM",
+        "EVGO", "CHPT"
+    ]
+    
+    print("\nDownloading Poison Ticker Data (Catastrophic Losers)...", end="", flush=True)
+    import yfinance as yf
+    
+    # Suppress yfinance output to keep logs clean
+    old_stdout = sys.stdout
+    sys.stdout = open(os.devnull, 'w')
+    poison_raw = yf.download(POISON_TICKERS, start="2006-01-01", end="2025-12-31", progress=False)
+    sys.stdout = old_stdout
+    
+    if isinstance(poison_raw.columns, pd.MultiIndex):
+        lvl0 = poison_raw.columns.get_level_values(0).unique().tolist()
+        poison_close = poison_raw["Close"] if "Close" in lvl0 else poison_raw
+        if isinstance(poison_close.columns, pd.MultiIndex): 
+            poison_close.columns = poison_close.columns.get_level_values(-1)
+    else: 
+        poison_close = poison_raw
+    
+    valid_poison = [t for t in POISON_TICKERS if t in poison_close.columns and poison_close[t].notna().sum() > 100]
+    print(f" {len(valid_poison)} valid poison tickers integrated.")
+    
+    dc_poisoned = dc.copy()
+    for t in valid_poison:
+        if t not in dc_poisoned.columns:
+            dc_poisoned[t] = poison_close[t].reindex(dc_poisoned.index).ffill()
+    
+    poison_vf = list(dict.fromkeys(list(vf) + valid_poison))
+    daily_ret_poisoned = dc_poisoned.pct_change()
+    
+    print("Evaluating Poisoned Universe...")
+    c_poison = ACTIVE_STRATEGY_FN(dc_poisoned, spy, poison_vf, daily_ret_poisoned, **ACTIVE_PARAMS)
+    if isinstance(c_poison, dict) and 'curve' in c_poison:
+        c_poison = c_poison['curve']
+    poison_cagr = evaluate_slice(c_poison, "2008-01-01", "2025-12-31")['cagr']
+    
+    print(f"  Poison Universe CAGR: {poison_cagr:.1f}%")
+    diff = base_cagr - poison_cagr
+    print(f"  CAGR Decay: {diff:+.1f}%")
+    
+    print("-" * 80)
+    if diff <= 3.0:
+        print("  VERDICT: PASS (Strategy naturally avoids catastrophic losers)")
+    else:
+        print("  VERDICT: FAIL (Strategy edge heavily relies on survivorship bias)")
+
+if __name__ == "__main__":
+    run_test_2_3()

backtesting/framework/test_3_1_txn_costs.py

@@ -0,0 +1,44 @@
+import sys, os
+import warnings; warnings.filterwarnings('ignore')
+
+from backtesting.framework.config import STRATEGY_NAME, ACTIVE_STRATEGY_FN, ACTIVE_PARAMS, TXN_PARAM_NAME, load_data
+
+try:
+    from v30_causal_engine import evaluate_slice
+except ImportError:
+    from backtesting.v30_causal_engine import evaluate_slice
+
+def run_test_3_1():
+    print("=" * 80)
+    print(f" TEST 3.1: TRANSACTION COST STRESS TEST - {STRATEGY_NAME}")
+    print("=" * 80)
+
+    if not TXN_PARAM_NAME:
+        print("FAIL: No TXN_PARAM_NAME defined in config.py")
+        return
+
+    dc, spy, vf, daily_ret = load_data()
+    
+    levels = [20, 40, 60]
+    results = {}
+    
+    for bps in levels:
+        params = ACTIVE_PARAMS.copy()
+        params[TXN_PARAM_NAME] = bps
+        
+        c = ACTIVE_STRATEGY_FN(dc, spy, vf, daily_ret, **params)
+        if isinstance(c, dict) and 'curve' in c:
+            c = c['curve']
+            
+        m = evaluate_slice(c, "2008-01-01", "2025-12-31")
+        results[bps] = m['sharpe']
+        print(f"  At {bps} bps: Sharpe = {m['sharpe']:.4f}")
+        
+    print("-" * 80)
+    if results[60] >= 0.60:
+        print("  VERDICT: PASS (Robust to real-world execution friction)")
+    else:
+        print("  VERDICT: FAIL (Edge is heavily friction-dependent, too fragile)")
+
+if __name__ == "__main__":
+    run_test_3_1()

backtesting/framework/test_3_5_crash_autopsy.py

@@ -0,0 +1,45 @@
+import sys, os
+import warnings; warnings.filterwarnings('ignore')
+
+from backtesting.framework.config import STRATEGY_NAME, ACTIVE_STRATEGY_FN, ACTIVE_PARAMS, load_data
+
+def run_test_3_5():
+    print("=" * 80)
+    print(f" TEST 3.5: MOMENTUM CRASH AUTOPSY - {STRATEGY_NAME}")
+    print("=" * 80)
+
+    dc, spy, vf, daily_ret = load_data()
+    
+    c = ACTIVE_STRATEGY_FN(dc, spy, vf, daily_ret, **ACTIVE_PARAMS)
+    if isinstance(c, dict) and 'curve' in c:
+        c = c['curve']
+        
+    crashes = {
+        "GFC (Lehman)": ("2008-09-01", "2009-03-31"),
+        "V-Recovery": ("2009-03-01", "2009-05-31"),
+        "China Shock": ("2015-06-01", "2015-09-30"),
+        "Vaccine Rotation": ("2020-11-01", "2020-11-30"),
+        "Rate Shock": ("2022-01-01", "2022-03-31")
+    }
+    
+    print(f"  {'Crash Period':<20} | {'Strategy Return':>15} | {'SPY Return':>15}")
+    print("  " + "-"*56)
+    
+    for name, (start, end) in crashes.items():
+        if start >= c.index[0].strftime('%Y-%m-%d') and end <= c.index[-1].strftime('%Y-%m-%d'):
+            c_slice = c.loc[start:end]
+            s_slice = spy.loc[start:end]
+            
+            if len(c_slice) == 0: 
+                continue
+                
+            c_ret = (c_slice.iloc[-1] / c_slice.iloc[0]) - 1
+            s_ret = (s_slice.iloc[-1] / s_slice.iloc[0]) - 1
+            
+            print(f"  {name:<20} | {c_ret*100:>14.1f}% | {s_ret*100:>14.1f}%")
+            
+    print("-" * 80)
+    print("  VERDICT: PASS (Drawdowns quantified)")
+
+if __name__ == "__main__":
+    run_test_3_5()

backtesting/framework/test_4_1_param_sweep.py

@@ -0,0 +1,87 @@
+import sys, os
+import itertools
+import warnings; warnings.filterwarnings('ignore')
+
+from backtesting.framework.config import STRATEGY_NAME, ACTIVE_STRATEGY_FN, ACTIVE_PARAMS, load_data
+
+try:
+    from v30_causal_engine import evaluate_slice
+except ImportError:
+    from backtesting.v30_causal_engine import evaluate_slice
+
+def run_test_4_1():
+    print("=" * 80)
+    print(f" TEST 4.1 & 4.2: PARAMETER ROBUSTNESS & OVERFIT DETECTION - {STRATEGY_NAME}")
+    print("=" * 80)
+
+    dc, spy, vf, daily_ret = load_data()
+    
+    # Define a default parameter grid to test if none is provided
+    # We will test rebalance frequency and short momentum lookback
+    param_grid = {
+        'rebal_days': [40, 60, 80],
+        'mom_short': [15, 21, 30]
+    }
+    
+    keys = list(param_grid.keys())
+    combos = list(itertools.product(*(param_grid[k] for k in keys)))
+    
+    print(f"Evaluating {len(combos)} parameter combinations...")
+    res = {}
+    
+    for combo in combos:
+        p = ACTIVE_PARAMS.copy()
+        for k, v in zip(keys, combo):
+            p[k] = v
+            
+        c = ACTIVE_STRATEGY_FN(dc, spy, vf, daily_ret, **p)
+        if isinstance(c, dict) and 'curve' in c:
+            c = c['curve']
+            
+        m = evaluate_slice(c, "2008-01-01", "2025-12-31")
+        res[combo] = m['sharpe']
+        print(f"  Params {dict(zip(keys, combo))}: Sharpe {m['sharpe']:.4f}")
+        
+    sharpes = list(res.values())
+    s_min, s_max = min(sharpes), max(sharpes)
+    
+    print("-" * 80)
+    print(f"  Surface Range: {s_min:.4f} to {s_max:.4f}")
+    if s_min >= 0.70:
+        print("  VERDICT: PASS (Smooth, robust parameter surface)")
+    else:
+        print("  VERDICT: WEAK PASS / FAIL (Surface contains weak spots or cliff edges)")
+        
+    print("\n--- Test 4.2: Single Parameter Overfit Detection ---")
+    best_combo = max(res, key=res.get)
+    best_params = dict(zip(keys, best_combo))
+    
+    print(f"  Best Params found: {best_params} -> Evaluating Overfit Risk...")
+    p_best = ACTIVE_PARAMS.copy()
+    p_best.update(best_params)
+    
+    c_best = ACTIVE_STRATEGY_FN(dc, spy, vf, daily_ret, **p_best)
+    if isinstance(c_best, dict) and 'curve' in c_best:
+        c_best = c_best['curve']
+        
+    m_train = evaluate_slice(c_best, "2008-01-01", "2018-12-31")
+    m_test = evaluate_slice(c_best, "2019-01-01", "2025-12-31")
+    
+    print(f"  Train Sharpe (2008-2018): {m_train['sharpe']:.4f}")
+    print(f"  Test Sharpe  (2019-2025): {m_test['sharpe']:.4f}")
+    
+    diff = m_test['sharpe'] - m_train['sharpe']
+    print(f"  Out-of-Sample Lift: {diff:+.4f}")
+    
+    print("-" * 80)
+    # The requirement is that Test didn't collapse massively compared to train
+    if diff >= -0.15:
+        if diff > 0:
+            print("  VERDICT: PASS (Improvement is genuine out-of-sample)")
+        else:
+            print("  VERDICT: PASS (Optimization held out-of-sample within acceptable limits)")
+    else:
+        print("  VERDICT: FAIL (Pure overfit, optimization disappeared out-of-sample)")
+
+if __name__ == "__main__":
+    run_test_4_1()