Vibeship-spawner-skills quantitative-research

id: quantitative-research

install

source · Clone the upstream repo

git clone https://github.com/vibeforge1111/vibeship-spawner-skills

manifest: trading/quantitative-research/skill.yaml

The Only Backtest That Matters

Most backtests are lies. Here's how to build one that isn't:

Walk-Forward Validation (Required)

import pandas as pd
import numpy as np
from typing import List, Tuple, Dict
from dataclasses import dataclass

@dataclass
class WalkForwardResult:
    train_sharpe: float
    test_sharpe: float
    train_start: pd.Timestamp
    train_end: pd.Timestamp
    test_start: pd.Timestamp
    test_end: pd.Timestamp
    params: dict
    trades: int

def walk_forward_backtest(
    data: pd.DataFrame,
    signal_func: callable,
    train_days: int = 252 * 2,  # 2 years
    test_days: int = 63,  # 3 months
    step_days: int = 21,  # 1 month steps
    param_grid: dict = None
) -> List[WalkForwardResult]:
    """
    Walk-forward analysis with proper train/test split.

    This is the MINIMUM bar for strategy validation.
    """
    results = []

    for i in range(0, len(data) - train_days - test_days, step_days):
        train_start = i
        train_end = i + train_days
        test_start = train_end
        test_end = test_start + test_days

        if test_end > len(data):
            break

        train_data = data.iloc[train_start:train_end]
        test_data = data.iloc[test_start:test_end]

        # Optimize on training set
        if param_grid:
            best_params, train_sharpe = optimize_params(
                train_data, signal_func, param_grid
            )
        else:
            best_params = {}
            train_sharpe = calculate_sharpe(
                run_strategy(train_data, signal_func, {})
            )

        # Test on out-of-sample
        test_returns = run_strategy(test_data, signal_func, best_params)
        test_sharpe = calculate_sharpe(test_returns)

        results.append(WalkForwardResult(
            train_sharpe=train_sharpe,
            test_sharpe=test_sharpe,
            train_start=data.index[train_start],
            train_end=data.index[train_end],
            test_start=data.index[test_start],
            test_end=data.index[test_end],
            params=best_params,
            trades=len(test_returns[test_returns != 0])
        ))

    return results

def analyze_walk_forward(results: List[WalkForwardResult]) -> dict:
    """Analyze walk-forward results for strategy viability."""
    train_sharpes = [r.train_sharpe for r in results]
    test_sharpes = [r.test_sharpe for r in results]

    return {
        'avg_train_sharpe': np.mean(train_sharpes),
        'avg_test_sharpe': np.mean(test_sharpes),
        'sharpe_degradation': 1 - np.mean(test_sharpes) / np.mean(train_sharpes),
        'test_sharpe_std': np.std(test_sharpes),
        'pct_profitable_periods': sum(1 for s in test_sharpes if s > 0) / len(test_sharpes),
        'worst_test_sharpe': min(test_sharpes),
        'total_periods': len(results),
        'is_viable': (
            np.mean(test_sharpes) > 0.5 and  # Minimum threshold
            np.mean(test_sharpes) / np.mean(train_sharpes) > 0.5  # <50% degradation
        )
    }

Red Flags in Backtest Results

Red Flag	What It Means
Sharpe > 3	Almost certainly overfit
Train >> Test Sharpe	Overfit to training data
Few trades	Not statistically significant
Perfect Sharpe curve	You're using future data
Works on all assets	Probably fitting to noise
success_rate: "Strategies that pass WF: 60% survive live (vs 5% for simple backtest)"

name: Alpha Signal Research description: Systematic approach to finding and validating alpha signals detection: "alpha|signal|predict|edge" guidance: |

Alpha Signal Research Protocol

The goal: Find signals that predict returns AFTER costs.

Information Coefficient Framework

import pandas as pd
import numpy as np
from scipy import stats

def calculate_information_coefficient(
    signal: pd.Series,
    forward_returns: pd.Series,
    method: str = 'spearman'
) -> dict:
    """
    Calculate IC between signal and forward returns.

    IC is the correlation between your signal today and
    returns tomorrow. This is your edge.
    """
    # Align and drop NaN
    aligned = pd.concat([signal, forward_returns], axis=1).dropna()
    signal_clean = aligned.iloc[:, 0]
    returns_clean = aligned.iloc[:, 1]

    if method == 'spearman':
        ic, p_value = stats.spearmanr(signal_clean, returns_clean)
    else:
        ic, p_value = stats.pearsonr(signal_clean, returns_clean)

    # Calculate IC by time period
    ic_by_period = signal_clean.groupby(signal_clean.index.to_period('M')).apply(
        lambda x: stats.spearmanr(
            x, returns_clean.loc[x.index]
        )[0] if len(x) > 10 else np.nan
    )

    return {
        'ic': ic,
        'p_value': p_value,
        'ic_mean': ic_by_period.mean(),
        'ic_std': ic_by_period.std(),
        'ir': ic_by_period.mean() / ic_by_period.std(),  # Information Ratio
        't_stat': ic_by_period.mean() / (ic_by_period.std() / np.sqrt(len(ic_by_period))),
        'pct_positive': (ic_by_period > 0).mean(),
        'is_significant': abs(ic / ic_by_period.std()) > 2.0  # t > 2
    }

def alpha_decay_analysis(
    signal: pd.Series,
    returns: pd.DataFrame,
    max_horizon: int = 20
) -> pd.DataFrame:
    """
    Analyze how quickly alpha decays over holding periods.

    Critical for understanding optimal holding period.
    """
    results = []

    for horizon in range(1, max_horizon + 1):
        forward_ret = returns.shift(-horizon).rolling(horizon).sum()
        ic_result = calculate_information_coefficient(signal, forward_ret)

        results.append({
            'horizon': horizon,
            'ic': ic_result['ic'],
            't_stat': ic_result['t_stat'],
            'is_significant': ic_result['is_significant']
        })

    return pd.DataFrame(results)

# Example: Test a momentum signal
def momentum_signal(prices: pd.DataFrame, lookback: int = 20) -> pd.Series:
    """Simple momentum: past returns predict future returns."""
    return prices.pct_change(lookback)

# Usage
signal = momentum_signal(prices, lookback=20)
forward_returns = prices.pct_change().shift(-1)  # Next day returns

ic_results = calculate_information_coefficient(signal, forward_returns)
print(f"IC: {ic_results['ic']:.4f}")
print(f"t-stat: {ic_results['t_stat']:.2f}")
print(f"IR: {ic_results['ir']:.2f}")

# Minimum bars:
# IC > 0.02 (or < -0.02)
# t-stat > 2 (or < -2)
# IR > 0.5

Signal Combination (Multi-Factor)

def combine_signals(
    signals: Dict[str, pd.Series],
    method: str = 'equal',
    ic_weights: dict = None
) -> pd.Series:
    """
    Combine multiple alpha signals into composite signal.
    """
    df = pd.DataFrame(signals)

    # Z-score normalize each signal
    df_zscore = (df - df.mean()) / df.std()

    if method == 'equal':
        return df_zscore.mean(axis=1)

    elif method == 'ic_weighted':
        # Weight by IC (stronger signals get more weight)
        weights = pd.Series(ic_weights)
        weights = weights / weights.abs().sum()  # Normalize
        return (df_zscore * weights).sum(axis=1)

    elif method == 'decay_weighted':
        # Recent signals matter more
        weights = np.array([0.5 ** i for i in range(len(signals))])[::-1]
        weights = weights / weights.sum()
        return (df_zscore * weights).sum(axis=1)

    return df_zscore.mean(axis=1)

success_rate: "Signals with IC > 0.03 and IR > 0.7 historically profitable"

name: Statistical Arbitrage description: Pairs trading and mean reversion with proper statistical grounding detection: "pairs|cointegration|mean.*reversion|stat.*arb" guidance: |

Statistical Arbitrage Framework

Stat arb is about finding price relationships that revert to equilibrium.

Cointegration Testing

import numpy as np
import pandas as pd
from statsmodels.tsa.stattools import coint, adfuller
from statsmodels.regression.linear_model import OLS
import statsmodels.api as sm

def find_cointegrated_pairs(
    prices: pd.DataFrame,
    significance: float = 0.05
) -> list:
    """
    Find pairs with statistically significant cointegration.
    """
    n = len(prices.columns)
    pairs = []

    for i in range(n):
        for j in range(i+1, n):
            asset1 = prices.columns[i]
            asset2 = prices.columns[j]

            # Cointegration test
            score, p_value, _ = coint(prices[asset1], prices[asset2])

            if p_value < significance:
                # Calculate hedge ratio
                model = OLS(prices[asset1], sm.add_constant(prices[asset2]))
                results = model.fit()
                hedge_ratio = results.params[1]

                # Calculate spread statistics
                spread = prices[asset1] - hedge_ratio * prices[asset2]
                half_life = calculate_half_life(spread)

                pairs.append({
                    'asset1': asset1,
                    'asset2': asset2,
                    'p_value': p_value,
                    'hedge_ratio': hedge_ratio,
                    'half_life_days': half_life,
                    'spread_mean': spread.mean(),
                    'spread_std': spread.std()
                })

    return sorted(pairs, key=lambda x: x['p_value'])

def calculate_half_life(spread: pd.Series) -> float:
    """
    Calculate mean reversion half-life using OLS.

    Half-life tells you how long to hold a pairs trade.
    """
    spread_lag = spread.shift(1).dropna()
    spread_diff = spread.diff().dropna()
    spread_lag = spread_lag.iloc[1:]

    model = OLS(spread_diff, sm.add_constant(spread_lag))
    results = model.fit()

    lambda_param = results.params[1]

    if lambda_param >= 0:
        return np.inf  # Not mean reverting

    half_life = -np.log(2) / lambda_param
    return half_life

def pairs_trading_signals(
    prices: pd.DataFrame,
    pair: dict,
    entry_z: float = 2.0,
    exit_z: float = 0.5,
    stop_z: float = 4.0
) -> pd.DataFrame:
    """
    Generate pairs trading signals with proper risk management.
    """
    asset1 = prices[pair['asset1']]
    asset2 = prices[pair['asset2']]
    hedge_ratio = pair['hedge_ratio']

    # Calculate spread
    spread = asset1 - hedge_ratio * asset2

    # Rolling z-score (use lookback appropriate to half-life)
    lookback = max(20, int(pair['half_life_days'] * 2))
    z_score = (spread - spread.rolling(lookback).mean()) / spread.rolling(lookback).std()

    # Generate signals
    signals = pd.DataFrame(index=prices.index)
    signals['z_score'] = z_score
    signals['position'] = 0

    # Long spread (long asset1, short asset2) when z < -entry
    signals.loc[z_score < -entry_z, 'position'] = 1
    # Short spread when z > entry
    signals.loc[z_score > entry_z, 'position'] = -1
    # Exit when z crosses 0
    signals.loc[abs(z_score) < exit_z, 'position'] = 0
    # Stop out at extreme z
    signals.loc[abs(z_score) > stop_z, 'position'] = 0

    # Forward fill positions
    signals['position'] = signals['position'].replace(0, np.nan).ffill().fillna(0)

    return signals

Critical Stat Arb Checks

Check	Threshold	Why
Cointegration p-value	< 0.05	Statistical significance
Half-life	5-60 days	Too short = noise, too long = risk
Spread stationarity (ADF)	p < 0.05	Must revert
Out-of-sample coint	Still < 0.05	Not just in-sample
success_rate: "Pairs with half-life 10-40 days and OOS coint historically best"

Factor Model Framework

Separate alpha from beta - most "alpha" is just hidden factor exposure.

Factor Exposure Analysis

import pandas as pd
import numpy as np
from sklearn.linear_model import LinearRegression
import statsmodels.api as sm

def calculate_factor_exposures(
    returns: pd.Series,
    factors: pd.DataFrame
) -> dict:
    """
    Calculate exposure to common factors.

    If your 'alpha' is just factor exposure, you're paying
    2/20 for beta.
    """
    # Align data
    aligned = pd.concat([returns, factors], axis=1).dropna()
    y = aligned.iloc[:, 0]
    X = aligned.iloc[:, 1:]

    # Regression
    X_const = sm.add_constant(X)
    model = sm.OLS(y, X_const).fit()

    # Extract results
    exposures = {}
    for i, col in enumerate(X.columns):
        exposures[col] = {
            'beta': model.params[col],
            't_stat': model.tvalues[col],
            'p_value': model.pvalues[col],
            'significant': model.pvalues[col] < 0.05
        }

    # Calculate true alpha (intercept)
    alpha_annual = model.params['const'] * 252
    alpha_t_stat = model.tvalues['const']

    return {
        'factor_exposures': exposures,
        'alpha_annual': alpha_annual,
        'alpha_t_stat': alpha_t_stat,
        'alpha_significant': abs(alpha_t_stat) > 2,
        'r_squared': model.rsquared,
        'unexplained_variance': 1 - model.rsquared
    }

def get_fama_french_factors() -> pd.DataFrame:
    """
    Load Fama-French factors (market, size, value, momentum).
    """
    # In practice, use Ken French's data library
    # or commercial provider like Quandl

    # Minimum factors to test against:
    # - Market (RMRF)
    # - Size (SMB)
    # - Value (HML)
    # - Momentum (UMD)
    # - Quality (QMJ)
    # - Low Volatility (BAB)
    pass

def decompose_strategy_returns(
    strategy_returns: pd.Series,
    factors: pd.DataFrame
) -> dict:
    """
    Decompose strategy returns into factor and alpha components.

    This tells you if you have real alpha or just smart beta.
    """
    analysis = calculate_factor_exposures(strategy_returns, factors)

    # Calculate factor contribution
    factor_contrib = {}
    for factor, exp in analysis['factor_exposures'].items():
        if exp['significant']:
            # Annual contribution = beta * factor return
            factor_contrib[factor] = exp['beta'] * factors[factor].mean() * 252

    total_return = strategy_returns.mean() * 252
    factor_return = sum(factor_contrib.values())
    true_alpha = total_return - factor_return

    return {
        'total_return': total_return,
        'factor_contributions': factor_contrib,
        'total_factor_return': factor_return,
        'true_alpha': true_alpha,
        'alpha_pct_of_return': true_alpha / total_return if total_return != 0 else 0,
        'is_true_alpha': analysis['alpha_significant'] and true_alpha > 0.02
    }

Factor Model Reality Check

Your "Alpha"	After Factor Adjustment	Reality
+15% annual	Market beta 1.2	You had +3% alpha
+20% annual	Long momentum, short value	Zero alpha
+10% annual	No factor exposure	Real alpha!
success_rate: "Only ~5% of strategies have true alpha after factor adjustment"

name: Regime Detection description: Identify market regimes for adaptive strategy allocation detection: "regime|market.*state|trend.*ranging|volatility.*cluster" guidance: |

Regime Detection Framework

Markets have states. Strategies that work in one regime fail in another.

Hidden Markov Model Regime Detection

import numpy as np
import pandas as pd
from hmmlearn import hmm

def detect_regimes_hmm(
    returns: pd.Series,
    n_regimes: int = 3
) -> pd.DataFrame:
    """
    Detect market regimes using Hidden Markov Model.

    Common regimes:
    - Bull (low vol, positive returns)
    - Bear (high vol, negative returns)
    - Chop (high vol, no trend)
    """
    # Prepare features
    features = pd.DataFrame({
        'returns': returns,
        'volatility': returns.rolling(20).std() * np.sqrt(252),
        'momentum': returns.rolling(60).mean() * 252
    }).dropna()

    # Fit HMM
    model = hmm.GaussianHMM(
        n_components=n_regimes,
        covariance_type='full',
        n_iter=1000,
        random_state=42
    )

    X = features.values
    model.fit(X)

    # Predict regimes
    regimes = model.predict(X)

    # Analyze each regime
    results = pd.DataFrame(index=features.index)
    results['regime'] = regimes

    regime_stats = {}
    for r in range(n_regimes):
        mask = results['regime'] == r
        regime_stats[r] = {
            'avg_return': features.loc[mask, 'returns'].mean() * 252,
            'volatility': features.loc[mask, 'volatility'].mean(),
            'pct_time': mask.mean(),
            'count': mask.sum()
        }

    # Label regimes by characteristics
    regime_labels = {}
    for r, stats in regime_stats.items():
        if stats['avg_return'] > 0.1 and stats['volatility'] < 0.2:
            regime_labels[r] = 'bull'
        elif stats['avg_return'] < -0.1:
            regime_labels[r] = 'bear'
        else:
            regime_labels[r] = 'chop'

    results['regime_label'] = results['regime'].map(regime_labels)

    return results, regime_stats

def regime_aware_allocation(
    regimes: pd.Series,
    strategy_returns: Dict[str, pd.Series]
) -> pd.DataFrame:
    """
    Allocate to strategies based on detected regime.
    """
    # Analyze strategy performance by regime
    performance_by_regime = {}

    for strategy, returns in strategy_returns.items():
        aligned = pd.concat([returns, regimes], axis=1).dropna()

        by_regime = aligned.groupby('regime_label')['returns'].agg([
            ('sharpe', lambda x: x.mean() / x.std() * np.sqrt(252)),
            ('avg_return', lambda x: x.mean() * 252)
        ])

        performance_by_regime[strategy] = by_regime

    # Create optimal allocation per regime
    allocations = {}
    for regime in regimes.unique():
        if pd.isna(regime):
            continue

        best_strategies = sorted(
            strategy_returns.keys(),
            key=lambda s: performance_by_regime[s].loc[regime, 'sharpe'],
            reverse=True
        )

        allocations[regime] = {
            'primary': best_strategies[0],
            'secondary': best_strategies[1] if len(best_strategies) > 1 else None,
            'allocation': [0.6, 0.4] if len(best_strategies) > 1 else [1.0]
        }

    return allocations

Simple Regime Indicators

def simple_regime_detection(prices: pd.Series) -> pd.Series:
    """
    Simple regime detection without ML.

    Sometimes simple beats complex.
    """
    sma_50 = prices.rolling(50).mean()
    sma_200 = prices.rolling(200).mean()
    volatility = prices.pct_change().rolling(20).std() * np.sqrt(252)
    avg_vol = volatility.rolling(252).mean()

    regime = pd.Series(index=prices.index, dtype=str)

    # Bull: Price > 50 SMA > 200 SMA, low vol
    bull_mask = (prices > sma_50) & (sma_50 > sma_200) & (volatility < avg_vol)
    regime[bull_mask] = 'bull'

    # Bear: Price < 50 SMA < 200 SMA
    bear_mask = (prices < sma_50) & (sma_50 < sma_200)
    regime[bear_mask] = 'bear'

    # Chop: Everything else
    regime[regime.isna()] = 'chop'

    return regime

success_rate: "Regime-aware strategies reduce drawdowns 30-40% historically"

name: Transaction Cost Modeling description: Accurate cost modeling - the silent killer of backtests detection: "transaction.*cost|slippage|commission|market.*impact" guidance: |

Transaction Cost Reality

The gap between backtest and live is usually costs.

Complete Cost Model

import numpy as np
import pandas as pd

def estimate_transaction_costs(
    trade_value: float,
    trade_side: str,  # 'buy' or 'sell'
    asset_class: str,
    avg_daily_volume: float,
    volatility: float,
    is_market_order: bool = True
) -> dict:
    """
    Estimate total transaction costs for a trade.
    """
    # 1. Commission (usually smallest component)
    commission_rates = {
        'us_equity': 0.0005,  # $0.50 per $1000
        'crypto': 0.001,      # 10 bps
        'futures': 0.00001,   # Negligible
        'forex': 0.00002      # 0.2 bps
    }
    commission = trade_value * commission_rates.get(asset_class, 0.001)

    # 2. Spread cost (for market orders)
    spread_estimates = {
        'us_equity': 0.0003,  # 3 bps for liquid
        'crypto': 0.001,      # 10 bps
        'futures': 0.0001,    # 1 bp
        'forex': 0.0001       # 1 bp
    }
    spread = spread_estimates.get(asset_class, 0.001)
    if not is_market_order:
        spread = 0  # Limit orders avoid spread
    spread_cost = trade_value * spread

    # 3. Market impact (the killer)
    # Square root model: impact = σ * sqrt(V_trade / V_daily)
    participation_rate = trade_value / (avg_daily_volume * 1)  # Assuming 1 day to execute
    market_impact = volatility * np.sqrt(participation_rate) * trade_value

    # 4. Timing risk (for multi-day execution)
    # Price might move while you're executing
    execution_days = max(1, trade_value / (avg_daily_volume * 0.1))  # 10% participation
    timing_risk = volatility * np.sqrt(execution_days / 252) * trade_value

    total_cost = commission + spread_cost + market_impact

    return {
        'commission': commission,
        'spread': spread_cost,
        'market_impact': market_impact,
        'timing_risk': timing_risk,
        'total_cost': total_cost,
        'cost_bps': (total_cost / trade_value) * 10000,
        'execution_days': execution_days,
        'participation_rate': participation_rate
    }

def adjust_backtest_for_costs(
    returns: pd.Series,
    trades: pd.DataFrame,  # Must have 'value', 'side' columns
    asset_info: dict
) -> pd.Series:
    """
    Apply realistic transaction costs to backtest returns.
    """
    costs = []

    for idx, trade in trades.iterrows():
        cost = estimate_transaction_costs(
            trade_value=trade['value'],
            trade_side=trade['side'],
            asset_class=asset_info['class'],
            avg_daily_volume=asset_info['adv'],
            volatility=asset_info['volatility']
        )
        costs.append({
            'date': idx,
            'cost': cost['total_cost'],
            'cost_bps': cost['cost_bps']
        })

    costs_df = pd.DataFrame(costs).set_index('date')

    # Subtract costs from returns
    adjusted_returns = returns.copy()
    for idx, row in costs_df.iterrows():
        if idx in adjusted_returns.index:
            adjusted_returns[idx] -= row['cost']

    return adjusted_returns

Cost Reality Table

Asset	Commission	Spread	Impact (1% ADV)	Total
SPY	0.5 bps	1 bp	2 bps	3.5 bps
Small Cap	0.5 bps	10 bps	20 bps	30.5 bps
Crypto	10 bps	20 bps	50 bps	80 bps
Micro Cap	0.5 bps	50 bps	100 bps	150.5 bps

A strategy turning over 12x/year (monthly) in crypto:

12 * 2 (buy+sell) * 80 bps = 19.2% annual cost drag! success_rate: "Realistic cost modeling improves backtest-to-live correlation from 30% to 70%"

anti_patterns:

name: In-Sample Optimization description: Optimizing parameters on the same data you validate on detection: "optimize|best.*param|grid.*search" why_harmful: | You're fitting to noise. Your 3.0 Sharpe is measuring how well you memorized the data, not how well you'll predict the future. what_to_do: | Always split: train on 70%, validate on 30%. Better yet, use walk-forward analysis where you repeatedly train/test on rolling windows. If you optimize parameters, you MUST have a separate holdout set you never touch until final validation.
name: Survivorship Bias description: Testing only on assets that still exist today detection: "download|yfinance|historical" why_harmful: | You're only seeing winners. The stocks that went bankrupt, got delisted, or merged aren't in your data. This inflates returns by 1-2% annually. what_to_do: | Use a data provider with point-in-time constituents and delisted securities. If testing on crypto, include dead coins. Minimum: understand which assets are missing from your universe.
name: Look-Ahead Bias description: Using information that wasn't available at trade time detection: "future|next|forward" why_harmful: | The most dangerous bug. Using Friday's data on Thursday's trades shows perfect results but zero real edge. Often hidden in data alignment or indicator calculations. what_to_do: | Audit every data point: "Could I have known this at trade time?" Shift data properly. When in doubt, add extra lag. Your backtest should simulate having LESS information than reality.
name: Ignoring Capacity description: Assuming you can trade unlimited size at backtest prices detection: "position|trade|execute" why_harmful: | A strategy that works at $1M might fail at $10M. Market impact is nonlinear. Your 2 Sharpe at small size becomes 0.5 Sharpe at scale. what_to_do: | Model market impact explicitly. Cap position size at % of ADV. Understand your strategy's capacity BEFORE deploying capital. If capacity is $1M, don't raise $100M.
name: Data Mining Multiple Hypotheses description: Testing hundreds of strategies and reporting the best one detection: "test.*strategy|multiple.*backtest|parameter.*sweep" why_harmful: | If you test 100 strategies, 5 will look good by chance at 5% significance. This is NOT the same as finding 5 real edges. It's multiple hypothesis testing. what_to_do: | Apply Bonferroni correction: divide significance threshold by number of tests. Or use FDR control. Track ALL strategies you tested, not just winners. Pre-register hypotheses.
name: Short Backtest Period description: Validating on 2-3 years of data detection: "2.*year|3.*year|recent" why_harmful: | 2-3 years might be one market regime. Your momentum strategy "works" because the entire period was trending. You have no idea how it performs in a range or crisis. what_to_do: | Minimum 10 years of data, ideally 20+. MUST include: 2008 crisis, 2020 COVID crash, 2022 bear market. If your strategy can't be tested on long history, increase skepticism.

handoffs:

trigger: "risk|position size|drawdown" to: risk-management-trading context: "Strategy validated, needs risk framework" provides:
- Backtest statistics (Sharpe, drawdown, win rate)
- Strategy capacity estimate
- Recommended position sizing parameters
trigger: "execute|implement|live trading" to: execution-algorithms context: "Strategy ready for execution optimization" provides:
- Trading signals with expected holding period
- Turnover and capacity estimates
- Slippage assumptions used in backtest
trigger: "sentiment|alternative data|social" to: sentiment-analysis-trading context: "Need sentiment signals for alpha research" expects:
- Processed sentiment scores
- Historical sentiment data
- Sentiment-price lead/lag analysis
trigger: "chart|technical|pattern" to: technical-analysis context: "Need discretionary signals for combination" expects:
- Technical signal definitions
- Historical signal data
- Signal performance by market regime