From Forecast to Position — The Signal Pipeline

A forecast says "JPY rate will be 156.10 in 30 days, 95% confidence." A trade signal has to answer something harder: should I take this position right now, and how much? The four gates below run in order — any one of them can drop the trade with a logged reason. Most days, every pair gets dropped at gate 1 (regime).

forecast(pair) → trade signal pipeline

      ┌─────────────────────────────────────────────────────┐
      │ GATE 1 · regime_detector.py                         │
      │   ADX(14d) ≥ 18 ?  ─── NO ──► SKIP (ranging market) │
      └────────────────────────────┬────────────────────────┘
                                   ▼
      ┌─────────────────────────────────────────────────────┐
      │ GATE 2 · forecast-range gate                        │
      │   |30d_change| ≥ 2.0% ?  ─── NO ──► SKIP (no edge)  │
      └────────────────────────────┬────────────────────────┘
                                   ▼
      ┌─────────────────────────────────────────────────────┐
      │ GATE 3 · adaptive confidence threshold              │
      │   confidence ≥ adapt(ADX) ?  ─── NO ──► SKIP        │
      └────────────────────────────┬────────────────────────┘
                                   ▼
      ┌─────────────────────────────────────────────────────┐
      │ GATE 4 · half-Kelly sizing (cold-start safe)        │
      │   size = balance × min(0.5×kelly, 0.20)             │
      └────────────────────────────┬────────────────────────┘
                                   ▼
                         OPEN POSITION → portfolio_state.json
                         Slack notify  → "BUY SGD @ 1.2855 ..."

The single highest-leverage decision in the pipeline. Even a great forecast model is wrong in ranging markets, where price oscillates around a mean and any signal is noise. The Average Directional Index (ADX) measures trend strength — high ADX = trending, low ADX = ranging. Built from scratch in source.trading.regime_detector.

Two cheap checks that prevent low-edge trades. Both are configurable per pair — JPY has a wider 30-day range than SGD, so the thresholds aren't shared. The principle: if the edge is small, the transaction cost eats it.

Once a trade passes the first three gates, the question is how much. Full Kelly is too aggressive (any historical-win-rate error gets amplified to bankruptcy risk). Half-Kelly with a cold-start clamp is the production rule.

# source.trading.position_sizer

def size_position(balance, history):
    # COLD START — <5 trades, or no wins, or no losses
    if len(history) < 5 or no_wins(history) or no_losses(history):
        return 1000.0           # fixed size, builds the win/loss sample

    # FULL KELLY = (p_win × avg_win − p_loss × avg_loss) / avg_win
    p_win    = wins / total
    avg_win  = mean([t.pnl for t in history if t.pnl > 0])
    avg_loss = mean([t.pnl for t in history if t.pnl < 0])
    kelly    = (p_win * avg_win − (1 − p_win) * abs(avg_loss)) / avg_win

    # HALF-KELLY with 20% per-trade cap
    return balance * min(kelly * 0.5, 0.20)

Every daily run does two things in order: close eligible positions first, then open new ones. Closing first means a stale position can't block a new signal on the same pair. State lives in portfolio_state.json + the trades SQLite table.

# Pseudo-code — the daily execution loop

def daily_run():
    # 1. ALWAYS close before opening
    for position in open_positions:
        if position.days_held >= position.target_exit_day:
            close(position, reason='time_expiry')
        elif position.current_rate hits target:
            close(position, reason='target_reached')
        elif stop_loss_triggered(position):
            close(position, reason='stop_loss')

    # 2. Score every pair, run gates, open if eligible
    for pair in ['JPY', 'SGD']:
        if pair has open position:
            continue                          # one-at-a-time per pair

        forecast = ensemble_forecast(pair)
        signal   = generate_signal(forecast)  # gates 1-3
        if signal is None:
            log(f"{pair}: skipped — {reason}")
            continue

        size = size_position(balance, history)  # gate 4
        open(pair, signal, size)
        slack_notify(f"{signal.action} {pair} @ {signal.entry_rate}, "
                     f"target {signal.target_exit_rate}, Sharpe {signal.sharpe}")

    # 3. Health log
    pipeline_health.log(success=True, n_signals=len(opened))

Numbers as of the last successful run. Both positions opened in late March; both are paper trades, not real money. The intent was to validate the signal pipeline against real out-of-sample price action.

Every trade entry and exit pings a Slack webhook. Two reasons: (1) it forces visibility — if the system silently breaks, I notice within a day; (2) it's a discipline aid — paper trades are easy to ignore, named ones aren't.