Exit Strategies

Exit Strategies

Entries are easy, exits are everything. A mediocre entry with a disciplined exit will outperform a perfect entry with no exit plan. This skill covers systematic, rule-based exit methods for crypto and Solana token trading.

Why Exits Matter

• Entries determine _if_ you participate. Exits determine _how much_ you keep.
• Most traders spend 90% of effort on entries and 10% on exits — invert this.
• Without defined exits you rely on emotion, which guarantees inconsistency.
• Every trade should have three exits defined before entry: stop loss, take profit,

and trailing stop.

Exit Categories

1. Stop Loss — Risk Management Exits

Predefined price level where you close the position to cap downside.

ATR-based stop (recommended default):

import pandas_ta as ta

atr = df.ta.atr(length=14)
stop_loss = entry_price - (atr.iloc[-1] * 2.0)  # 2x ATR below entry

Multiplier guide:

• 1.5× — Tight. High win rate needed. Good for scalps.
• 2.0× — Standard. Balances noise filtering with risk.
• 3.0× — Wide. For swing trades in volatile conditions.

See references/stop_loss_methods.md for complete methodology.

2. Take Profit — Target Exits

Predefined levels where you lock in gains.

Fixed risk/reward targets:

risk = entry_price - stop_loss_price
tp_2r = entry_price + (risk * 2)  # 2:1 R:R
tp_3r = entry_price + (risk * 3)  # 3:1 R:R
tp_5r = entry_price + (risk * 5)  # 5:1 R:R

Scaled exit framework (recommended for meme/PumpFun tokens):

Market cap milestone exits:

For PumpFun and meme tokens where R:R ratios are less meaningful:

milestones = [
    {"mcap": 50_000,  "sell_pct": 0.25, "label": "Cover cost"},
    {"mcap": 100_000, "sell_pct": 0.25, "label": "Lock profit"},
    {"mcap": 500_000, "sell_pct": 0.25, "label": "Major profit"},
    # Hold 25% as moonbag with trailing stop
]

See references/take_profit_strategies.md for full methodology including Fibonacci extension targets and volume-based exits.

3. Trailing Stop — Trend-Following Exits

Dynamic stops that follow price upward but never move down.

Percentage trailing:

def percentage_trailing_stop(
    current_price: float,
    highest_since_entry: float,
    trail_pct: float = 0.10,
) -> tuple[float, bool]:
    """Return (stop_level, triggered)."""
    highest = max(highest_since_entry, current_price)
    stop = highest * (1 - trail_pct)
    return stop, current_price <= stop

ATR trailing (Chandelier Exit):

def chandelier_exit(
    highs: list[float],
    atr_value: float,
    multiplier: float = 2.5,
    lookback: int = 22,
) -> float:
    """Highest high over lookback minus ATR * multiplier."""
    highest_high = max(highs[-lookback:])
    return highest_high - (atr_value * multiplier)

EMA trailing:

# Exit when close < EMA for M consecutive bars
ema = df.ta.ema(length=20)
below_ema = df["close"] < ema
consecutive_below = below_ema.rolling(3).sum() == 3  # 3 bars below

Typical EMA periods: 10 (scalp), 20 (day trade), 50 (swing).

See references/trailing_stops.md for Parabolic SAR, SuperTrend, and step trailing.

4. Time-Based Exits

Exit if the trade hasn't moved in your favor within a defined window.

bars_since_entry = current_bar - entry_bar
if bars_since_entry > max_hold_bars and current_pnl <= 0:
    exit_reason = "time_stop"

Guidelines:

• Scalp: 5–15 minutes
• Day trade: 4–8 hours
• Swing: 3–5 days
• PumpFun snipe: 2–10 minutes (token-specific)

Time stops prevent capital from sitting in dead trades.

5. Signal-Based Exits

Exit when the indicator that generated the entry signal reverses.

# RSI reversal exit
rsi = df.ta.rsi(length=14)
if position == "long" and rsi.iloc[-1] > 70:
    exit_reason = "rsi_overbought"

# MACD crossover exit
macd = df.ta.macd()
if macd["MACDs_12_26_9"].iloc[-1] < macd["MACDh_12_26_9"].iloc[-1]:
    exit_reason = "macd_bearish_cross"

Signal exits work well when combined with trailing stops — the signal triggers tightening the trail rather than an immediate full exit.

6. Liquidity-Based Exits

Exit when volume or liquidity deteriorates, signaling reduced ability to exit cleanly.

recent_vol = df["volume"].rolling(10).mean().iloc[-1]
baseline_vol = df["volume"].rolling(50).mean().iloc[-1]

if recent_vol < baseline_vol * 0.3:  # Volume dropped to 30% of baseline
    exit_reason = "liquidity_deterioration"

Critical for low-cap Solana tokens where liquidity can evaporate rapidly.

PumpFun-Specific Exit Rules

PumpFun tokens have unique dynamics requiring specialized exit logic.

Pre-Graduation Exits

Tokens on the bonding curve before reaching 85 SOL fill:

bonding_fill_pct = current_fill_sol / 85.0

if bonding_fill_pct > 0.90:
    # Near graduation — decide: hold through or exit before
    # Graduation creates volatility spike, both up and down
    pass

if bonding_fill_pct < 0.50 and time_since_entry > 300:  # 5 min
    exit_reason = "stalled_bonding_curve"

Volume Decay Exits

buy_vol_1m = get_buy_volume(token, "1m")
buy_vol_5m = get_buy_volume(token, "5m") / 5  # Normalize to per-minute

if buy_vol_1m < buy_vol_5m * 0.3:
    exit_reason = "buy_volume_decay"

Time Decay for PumpFun

Most PumpFun tokens that will succeed show momentum within the first few minutes:

Combining Exit Rules

A complete exit plan layers multiple rules. Here is a recommended template:

exit_plan = {
    "hard_stop": {
        "type": "fixed_percentage",
        "value": 0.20,  # -20% max loss
        "priority": 1,   # Checked first, always honored
    },
    "atr_stop": {
        "type": "atr_trailing",
        "multiplier": 2.5,
        "atr_length": 14,
        "priority": 2,
    },
    "take_profit": {
        "type": "scaled",
        "tranches": [
            {"at_rr": 2, "sell_pct": 0.25},
            {"at_rr": 4, "sell_pct": 0.25},
            {"at_rr": 8, "sell_pct": 0.25},
        ],
        "priority": 3,
    },
    "time_stop": {
        "type": "max_bars",
        "value": 50,
        "condition": "if_not_profitable",
        "priority": 4,
    },
}

Priority hierarchy: Hard stop > ATR trailing > Take profit > Time stop.

The hard stop is always active and never overridden. The ATR trailing stop activates after the first take-profit tranche fills. The time stop only fires if the trade is not yet profitable.

Common Exit Mistakes

Integration with Other Skills

• `position-sizing` — Size the position based on the stop loss distance.

position_size = (account_risk * account_balance) / (entry - stop_loss)

• `risk-management` — Exits are the mechanism that enforces risk limits.
• `pandas-ta` — Use ATR, EMA, RSI, MACD for signal-based and trailing exits.
• `slippage-modeling` — Estimate execution cost of the exit to set realistic targets.
• `liquidity-analysis` — Verify exit liquidity before entering a position.

Files

References

• references/stop_loss_methods.md — Complete stop loss methodology and anti-patterns
• references/take_profit_strategies.md — Scaled exits, R:R targets, Fibonacci extensions
• references/trailing_stops.md — Trailing stop implementations and parameter guidance

Scripts

• scripts/exit_simulator.py — Simulate and compare exit strategies on synthetic price data
• scripts/stop_loss_calculator.py — Calculate stop levels, position sizes, and R:R targets

Stop Loss Methods — Complete Reference

Overview

A stop loss is a predefined price level at which a position is closed to limit downside. Every trade must have a stop loss defined before entry. This reference covers all major stop loss methods, when to use each, and common anti-patterns.

Fixed Percentage Stops

Exit when the position declines by a fixed percentage from entry.

Calculation:

def fixed_pct_stop(entry_price: float, stop_pct: float) -> float:
    """Calculate fixed percentage stop loss price.

    Args:
        entry_price: Price at entry.
        stop_pct: Stop percentage as decimal (0.10 = 10%).

    Returns:
        Stop loss price.
    """
    return entry_price * (1 - stop_pct)

When to use: Simple setups where volatility analysis is not available or when you need a quick, predictable risk cap.

Limitation: Not adaptive to market conditions. A 10% stop may be too tight in high-volatility environments and too wide in low-volatility ones.

ATR-Based Stops

Use Average True Range to set stops that adapt to current volatility.

Core calculation:

def atr_stop(
    entry_price: float,
    atr_value: float,
    multiplier: float = 2.0,
) -> float:
    """Calculate ATR-based stop loss.

    Args:
        entry_price: Price at entry.
        atr_value: Current ATR(14) value.
        multiplier: ATR multiplier (1.5 tight, 2.0 standard, 3.0 wide).

    Returns:
        Stop loss price.
    """
    return entry_price - (atr_value * multiplier)

Multiplier Guide

ATR Period by Timeframe

Example

Entry at $1.00, ATR(14) = $0.08:

• 1.5× ATR stop: $1.00 − ($0.08 × 1.5) = $0.88 (12% risk)
• 2.0× ATR stop: $1.00 − ($0.08 × 2.0) = $0.84 (16% risk)
• 3.0× ATR stop: $1.00 − ($0.08 × 3.0) = $0.76 (24% risk)

Volatility-Adjusted Stops

Adapt stop distance based on the _current volatility regime_ rather than a fixed multiplier.

import numpy as np

def volatility_adjusted_stop(
    entry_price: float,
    atr_value: float,
    atr_history: list[float],
    base_multiplier: float = 2.0,
) -> float:
    """Widen/tighten stop based on volatility percentile.

    High volatility → wider stop. Low volatility → tighter stop.
    """
    percentile = np.searchsorted(
        np.sort(atr_history), atr_value
    ) / len(atr_history)

    # Scale multiplier: 0.7× at low vol, 1.3× at high vol
    vol_scale = 0.7 + (percentile * 0.6)
    adjusted_mult = base_multiplier * vol_scale

    return entry_price - (atr_value * adjusted_mult)

This prevents being stopped out during volatility spikes while keeping stops tight during quiet markets.

Support-Based Stops

Place stop below the nearest significant support level.

Identification methods: 1. Swing low: Lowest low in the last N bars 2. Volume profile: Below the nearest high-volume node 3. Round numbers: Below psychological levels (with offset) 4. Previous resistance turned support: Below the flip level

def support_stop(
    swing_low: float,
    offset_pct: float = 0.02,
) -> float:
    """Place stop below swing low with offset to avoid stop hunts.

    Args:
        swing_low: Nearest swing low price.
        offset_pct: Buffer below swing low (default 2%).

    Returns:
        Stop loss price.
    """
    return swing_low * (1 - offset_pct)

Important: Always add an offset below the support level. Placing stops exactly at support is where everyone else puts them — market makers and bots target these clusters.

Time Stops

Exit if the trade has not moved favorably within a defined number of bars.

def check_time_stop(
    bars_held: int,
    max_hold: int,
    current_pnl_pct: float,
    threshold: float = 0.0,
) -> bool:
    """Return True if time stop is triggered.

    Only triggers if the trade is not meaningfully profitable.
    """
    return bars_held >= max_hold and current_pnl_pct <= threshold

Combining Stop Methods

Use a layered approach:

1. Hard stop (always active): Maximum acceptable loss — never violated. Typically 20% for crypto. 2. Indicator stop (primary): ATR-based or support-based. This is your actual stop for most trades. 3. Time stop (secondary): Eject dead trades that neither hit stop nor profit target.

def evaluate_stops(
    entry_price: float,
    current_price: float,
    hard_stop: float,
    indicator_stop: float,
    bars_held: int,
    max_hold: int,
) -> str | None:
    """Check all stop conditions in priority order."""
    if current_price <= hard_stop:
        return "hard_stop"
    if current_price <= indicator_stop:
        return "indicator_stop"
    pnl_pct = (current_price - entry_price) / entry_price
    if bars_held >= max_hold and pnl_pct <= 0:
        return "time_stop"
    return None  # No stop triggered

Stop Placement Anti-Patterns

Round Numbers

Placing stops at $1.00, $0.50, $10.00 etc. These are the most common stop levels and frequently targeted by large players.

Fix: Offset by 1–3% below the round number.

Too Tight

Stops inside the normal noise range of the asset. If ATR is 8% and your stop is 3%, you will be stopped out by random fluctuation.

Fix: Stop should be at minimum 1× ATR from entry. Ideally 1.5–2×.

Too Wide

Stops so far from entry that a single loss wipes out many winners.

Fix: If the required stop distance implies risk >5% of account, reduce position size rather than widening the stop.

Moving Stops Away from Price

Widening a stop after entry because the trade is going against you. This violates the original risk assessment.

Fix: The stop defined at entry is final. If it is hit, accept the loss.

No Stop at All

Hoping the trade recovers. In crypto, tokens can go to zero. A -50% loss requires a +100% gain to recover.

Fix: Every trade gets a stop. No exceptions.

Quick Reference

Take Profit Strategies — Complete Reference

Overview

Take profit (TP) rules define where and how you lock in gains. Without TP rules, winning trades reverse into losses. This reference covers fixed R:R targets, scaled exits, market cap milestones, Fibonacci extensions, and volume-based exits.

Fixed Risk/Reward Targets

Methodology

1. Define risk: risk = entry_price - stop_loss_price 2. Set TP: tp = entry_price + (risk × R_ratio)

def calculate_rr_targets(
    entry: float,
    stop: float,
    ratios: list[float] = [2.0, 3.0, 5.0],
) -> list[dict]:
    """Calculate take profit levels at specified R:R ratios.

    Args:
        entry: Entry price.
        stop: Stop loss price.
        ratios: List of risk/reward ratios.

    Returns:
        List of dicts with ratio, price, and gain percentage.
    """
    risk = entry - stop
    targets = []
    for r in ratios:
        tp_price = entry + (risk * r)
        gain_pct = (tp_price - entry) / entry * 100
        targets.append({
            "ratio": f"{r:.1f}:1",
            "price": round(tp_price, 6),
            "gain_pct": round(gain_pct, 2),
        })
    return targets

Recommended Ratios by Style

Break-Even Analysis

Minimum win rate needed to be profitable at each R:R (excluding fees):

This is why high R:R strategies can be profitable with low win rates.

Scaled Exit Framework

Selling the entire position at one level is suboptimal. Scaled exits capture profits progressively while keeping exposure to further upside.

Standard 4-Tranche Model

SCALED_EXIT_PLAN = [
    {
        "tranche": 1,
        "sell_pct": 0.25,
        "target_rr": 2.0,
        "label": "Cover cost + small profit",
        "post_action": "Move stop to breakeven",
    },
    {
        "tranche": 2,
        "sell_pct": 0.25,
        "target_rr": 4.0,
        "label": "Meaningful profit locked",
        "post_action": "Trail stop at 2× entry",
    },
    {
        "tranche": 3,
        "sell_pct": 0.25,
        "target_rr": 8.0,
        "label": "Major profit captured",
        "post_action": "Tighten trail to 10% from peak",
    },
    {
        "tranche": 4,
        "sell_pct": 0.25,
        "target_rr": None,
        "label": "Moonbag — trailing stop only",
        "post_action": "Trail with EMA(20) or 15% from peak",
    },
]

Why Scaled Exits Work

• Tranche 1 removes psychological pressure — you have locked in some profit.
• Moving to breakeven after Tranche 1 makes the trade risk-free.
• Tranches 2–3 capture the majority of the move.
• Tranche 4 (moonbag) captures outlier moves at zero additional risk.

Aggressive Variant (PumpFun / Meme Tokens)

For extremely volatile tokens where moves are fast and violent:

AGGRESSIVE_PLAN = [
    {"sell_pct": 0.50, "target_rr": 2.0, "label": "Half out, secure base"},
    {"sell_pct": 0.25, "target_rr": 5.0, "label": "Quarter at 5×"},
    {"sell_pct": 0.25, "target_rr": None, "label": "Trail with 20% stop"},
]

Taking 50% off early is appropriate when the median outcome is a loss and you need to capitalize aggressively on winners.

Market Cap Milestone Exits

For PumpFun and meme tokens, absolute price targets are less meaningful than market cap milestones since these tokens start from near-zero.

MCAP_MILESTONES = [
    {"mcap": 30_000,   "sell_pct": 0.25, "note": "Cover entry cost"},
    {"mcap": 100_000,  "sell_pct": 0.25, "note": "Lock solid profit"},
    {"mcap": 500_000,  "sell_pct": 0.25, "note": "Major milestone"},
    {"mcap": 1_000_000, "sell_pct": 0.25, "note": "Moonbag exit or trail"},
]

Market Cap to Price Conversion

def mcap_to_price(target_mcap: float, total_supply: float) -> float:
    """Convert market cap target to token price."""
    return target_mcap / total_supply

Ensure you use circulating supply, not total supply, for accurate mcap calculations. On PumpFun, total supply is typically 1 billion tokens.

Fibonacci Extension Targets

Use Fibonacci extensions from the initial impulse move to project take profit levels during continuation.

Key Extension Levels

Calculation

def fibonacci_extensions(
    swing_low: float,
    swing_high: float,
    pullback_low: float,
    levels: list[float] = [1.0, 1.272, 1.618, 2.618, 4.236],
) -> list[dict]:
    """Calculate Fibonacci extension levels.

    Args:
        swing_low: Start of the impulse move.
        swing_high: End of the impulse move.
        pullback_low: Low of the retracement.
        levels: Extension ratios to calculate.

    Returns:
        List of dicts with level and price.
    """
    impulse = swing_high - swing_low
    results = []
    for lvl in levels:
        price = pullback_low + (impulse * lvl)
        results.append({"level": lvl, "price": round(price, 6)})
    return results

Example

Swing low: $0.001, Swing high: $0.010, Pullback: $0.006

• 1.000 ext: $0.006 + $0.009 × 1.000 = $0.015
• 1.618 ext: $0.006 + $0.009 × 1.618 = $0.0206
• 2.618 ext: $0.006 + $0.009 × 2.618 = $0.0296

Volume-Based Exits

Exit when buying pressure fades, regardless of price level.

def check_volume_exit(
    recent_volume: float,
    baseline_volume: float,
    threshold: float = 0.3,
) -> bool:
    """Signal exit when recent volume drops below threshold of baseline.

    Args:
        recent_volume: Average volume over last N bars (e.g., 5).
        baseline_volume: Average volume over longer period (e.g., 50).
        threshold: Ratio below which volume is considered weak.

    Returns:
        True if volume exit should trigger.
    """
    if baseline_volume == 0:
        return False
    return recent_volume < (baseline_volume * threshold)

Volume exits are especially important for:

• Meme tokens where volume drives 100% of price action
• Low-float tokens where a few large sellers can crash price
• Tokens post-pump where volume naturally decays

Combining Take Profit Methods

The most robust approach combines multiple methods:

1. Primary TP: Scaled R:R exits (Tranches 1–3) 2. Moonbag TP: Trailing stop on final tranche 3. Override: Volume-based exit if volume collapses before TP is reached 4. Ceiling: Fibonacci 2.618 or 4.236 as maximum expectation

The scaled exit handles the common case. The volume exit protects against momentum death. The Fibonacci extension provides a reality check on targets.

Trailing Stops — Complete Reference

Overview

A trailing stop follows price in the favorable direction and never moves against the position. When price reverses by the trail amount, the position is closed. Trailing stops let winners run while protecting accumulated profit.

Core rule: Trailing stops only move _up_ for longs (and _down_ for shorts). They never widen.

Percentage Trailing

The simplest trailing stop. Trail a fixed percentage below the highest price since entry.

def percentage_trail(
    prices: list[float],
    entry_price: float,
    trail_pct: float = 0.10,
) -> dict:
    """Simulate a percentage trailing stop.

    Args:
        prices: List of close prices after entry.
        entry_price: Price at entry.
        trail_pct: Trail distance as decimal (0.10 = 10%).

    Returns:
        Dict with exit_bar, exit_price, peak_price, pnl_pct.
    """
    peak = entry_price
    for i, price in enumerate(prices):
        peak = max(peak, price)
        stop_level = peak * (1 - trail_pct)
        if price <= stop_level:
            pnl = (price - entry_price) / entry_price
            return {
                "exit_bar": i,
                "exit_price": price,
                "peak_price": peak,
                "pnl_pct": round(pnl * 100, 2),
            }
    pnl = (prices[-1] - entry_price) / entry_price
    return {
        "exit_bar": len(prices) - 1,
        "exit_price": prices[-1],
        "peak_price": peak,
        "pnl_pct": round(pnl * 100, 2),
    }

Recommended Trail Percentages

Tip: If the trail is tighter than 1× ATR, you will be stopped by noise.

ATR Trailing (Chandelier Exit)

Uses ATR to set a volatility-adaptive trailing distance. Named "Chandelier" because it hangs from the highest high.

def chandelier_exit(
    highs: list[float],
    closes: list[float],
    atr_values: list[float],
    multiplier: float = 2.5,
    lookback: int = 22,
) -> dict:
    """Calculate Chandelier Exit trailing stop.

    Args:
        highs: High prices.
        closes: Close prices.
        atr_values: ATR values aligned with price bars.
        multiplier: ATR multiplier.
        lookback: Period for highest high.

    Returns:
        Dict with exit info or None if not triggered.
    """
    for i in range(lookback, len(closes)):
        highest_high = max(highs[i - lookback : i + 1])
        stop = highest_high - (atr_values[i] * multiplier)
        if closes[i] <= stop:
            entry_approx = closes[lookback]
            pnl = (closes[i] - entry_approx) / entry_approx
            return {
                "exit_bar": i,
                "exit_price": closes[i],
                "stop_level": stop,
                "pnl_pct": round(pnl * 100, 2),
            }
    return None

Recommended Parameters

Why ATR trailing is superior to fixed %: A 10% trail might be tight for a token with 15% daily swings but excessively wide for a stablecoin. ATR adapts automatically.

Parabolic SAR

The Parabolic Stop and Reverse (SAR) uses an acceleration factor that tightens the stop as the trend progresses.

Parameters

Lower AF values for crypto because:

• Crypto has higher noise-to-signal ratio
• Standard parameters trigger too frequently
• The slower acceleration gives trends more room

Usage with pandas-ta

import pandas_ta as ta

# Standard parameters
sar_standard = df.ta.psar(af0=0.02, af=0.02, max_af=0.2)

# Crypto-adjusted parameters
sar_crypto = df.ta.psar(af0=0.01, af=0.01, max_af=0.15)

# Exit when price crosses below the SAR (for longs)
exit_signal = df["close"] < sar_crypto["PSARl_0.01_0.15"]

Strengths and Weaknesses

• Strength: Self-tightening — the longer the trend, the closer the stop.
• Strength: No lookback period needed.
• Weakness: Whipsaws in ranging markets.
• Weakness: Cannot be used in isolation — combine with trend filter.

EMA Trailing

Exit when price closes below an EMA for M consecutive bars.

def ema_trailing_stop(
    closes: list[float],
    ema_values: list[float],
    consecutive_required: int = 2,
) -> dict | None:
    """Exit on M consecutive closes below EMA.

    Args:
        closes: Close prices.
        ema_values: EMA values aligned with closes.
        consecutive_required: Number of consecutive closes below EMA.

    Returns:
        Exit info dict or None.
    """
    below_count = 0
    for i in range(len(closes)):
        if closes[i] < ema_values[i]:
            below_count += 1
            if below_count >= consecutive_required:
                return {
                    "exit_bar": i,
                    "exit_price": closes[i],
                    "ema_value": ema_values[i],
                }
        else:
            below_count = 0
    return None

EMA Period Selection

Requiring consecutive bars is critical. A single close below the EMA in a strong uptrend is normal — requiring 2–3 confirms the trend has actually changed.

SuperTrend as Trailing Stop

SuperTrend combines ATR with a directional component. It stays below price in uptrends and above price in downtrends.

Calculation

def supertrend(
    highs: list[float],
    lows: list[float],
    closes: list[float],
    atr_values: list[float],
    multiplier: float = 3.0,
) -> list[float]:
    """Calculate SuperTrend values.

    Args:
        highs, lows, closes: OHLC data.
        atr_values: ATR values.
        multiplier: ATR multiplier.

    Returns:
        List of SuperTrend stop levels.
    """
    st = [0.0] * len(closes)
    for i in range(1, len(closes)):
        mid = (highs[i] + lows[i]) / 2
        upper = mid + (atr_values[i] * multiplier)
        lower = mid - (atr_values[i] * multiplier)

        # Lower band only moves up
        if closes[i - 1] > st[i - 1]:
            st[i] = max(lower, st[i - 1]) if closes[i] > lower else upper
        else:
            st[i] = min(upper, st[i - 1]) if closes[i] < upper else lower
    return st

Recommended Parameters

Step Trailing (Ratchet Stop)

Move the stop up in discrete steps as the trade hits milestones.

RATCHET_LEVELS = [
    {"trigger_rr": 2.0, "stop_to": "breakeven"},
    {"trigger_rr": 3.0, "stop_to": "1r_profit"},
    {"trigger_rr": 5.0, "stop_to": "3r_profit"},
    {"trigger_rr": 10.0, "stop_to": "7r_profit"},
]

Advantage: Simple mental model. You always know exactly where your stop is. Disadvantage: Leaves more on the table than smooth trailing in strong trends.

Implementation Notes

• Check on bar close, not intra-bar. Wicks frequently violate stop levels

then recover. Use closing price to avoid false triggers.

• Activation delay. Wait until 1R profit before enabling the trail. This

prevents being stopped by initial noise after entry.

• Combine fast + slow trails. Use a fast trail (8% or ATR×1.5) for partial

exit (50%) and a slow trail (20% or ATR×3.0) for the moonbag remainder.