PF Probe Trendmaster Integration

// This Pine Script® code is licensed under Apache-2.0
// SPDX-License-Identifier: Apache-2.0
// © PineForge contributors 2026
//
// PF probe trendmaster-probe-integration — line projection + EMA stack + composite gate + pivot bracket
// Clean-room: written from validation goal, not from source.
//
// Purpose: composes the four surfaces isolated by `trendmaster-probe-01..04`
// into a single end-to-end trend strategy. The engine surface under test
// is the cross-surface composition:
//   - pivot detection drives both line projection AND bracket anchors,
//   - three-tier EMA stack provides regime gating AND the trend predicate,
//   - RSI + 20-bar breakout add momentum + structure filters,
//   - `strategy.exit` places pivot-anchored TP/SL once filled.
// Entries fire only when ALL gates align: stack regime matches direction,
// composite gate (trend+momentum+structure) is true, and a pivot anchor
// exists. `max_lines_count=500` keeps the drawing-object chain bounded.
//
// Validation goal: bit-exact trade list against TradingView's broker emulator
// on the reference 15-minute ETH-USDT-USDT feed. Trade list parity is the
// pass criterion; line drawings are visual-only and need not be checked.
//
// TV setup: 15m chart, ETH-USDT-USDT (Binance USDT-M Perpetual). Full window
// matching corpus/data/ohlcv_ETH-USDT-USDT_15m.csv. Strategy properties:
// leave defaults from script header. Export "List of trades" → tv_trades.csv.
//@version=6
strategy("PF probe trendmaster-probe-integration", shorttitle="PF_TMINT",
     overlay=true, initial_capital=1000000,
     commission_type=strategy.commission.percent, commission_value=0,
     slippage=0, default_qty_type=strategy.fixed, default_qty_value=1,
     pyramiding=1, process_orders_on_close=false, max_lines_count=500)

// ---- inputs --------------------------------------------------------
int   i_pivot     = input.int(5,    "Pivot strength",    minval=2,  maxval=20)
int   i_ema_fast  = input.int(21,   "EMA fast",          minval=3,  maxval=100)
int   i_ema_mid   = input.int(55,   "EMA mid",           minval=10, maxval=200)
int   i_ema_slow  = input.int(200,  "EMA slow",          minval=50, maxval=500)
int   i_rsi_len   = input.int(14,   "RSI length",        minval=2,  maxval=50)
float i_rsi_lo    = input.float(55, "RSI long threshold",  minval=50, maxval=80)
float i_rsi_hi    = input.float(45, "RSI short threshold", minval=20, maxval=50)
int   i_break_len = input.int(20,   "Breakout window",   minval=5,  maxval=200)
float i_rr        = input.float(2.0, "Reward:risk ratio", minval=0.5, maxval=10.0, step=0.5)

// ---- pivot detection + retention ----------------------------------
float ph = ta.pivothigh(high, i_pivot, i_pivot)
float pl = ta.pivotlow(low,   i_pivot, i_pivot)

var float last_ph   = na
var float last_pl   = na
var int   last_ph_x = na
var int   last_pl_x = na
var float prev_ph_y = na
var int   prev_ph_x = na
var float prev_pl_y = na
var int   prev_pl_x = na

if not na(ph)
    int cur_x = bar_index - i_pivot
    if not na(last_ph) and not na(last_ph_x)
        line.new(last_ph_x, last_ph, cur_x, ph, color=color.red)
    prev_ph_y := last_ph
    prev_ph_x := last_ph_x
    last_ph   := ph
    last_ph_x := cur_x

if not na(pl)
    int cur_x = bar_index - i_pivot
    if not na(last_pl) and not na(last_pl_x)
        line.new(last_pl_x, last_pl, cur_x, pl, color=color.green)
    prev_pl_y := last_pl
    prev_pl_x := last_pl_x
    last_pl   := pl
    last_pl_x := cur_x

// ---- EMA stack regime ---------------------------------------------
float ema_fast = ta.ema(close, i_ema_fast)
float ema_mid  = ta.ema(close, i_ema_mid)
float ema_slow = ta.ema(close, i_ema_slow)

bool stack_bull = ema_fast > ema_mid and ema_mid > ema_slow
bool stack_bear = ema_fast < ema_mid and ema_mid < ema_slow

// ---- composite gate (trend + momentum + structure) ----------------
bool trend_bull = ema_fast > ema_mid
bool trend_bear = ema_fast < ema_mid

float r = ta.rsi(close, i_rsi_len)
bool mom_bull = r > i_rsi_lo
bool mom_bear = r < i_rsi_hi

// History access on chained ta.* calls hits a transpiler limitation;
// assign to a series-float carrier first, then take [1].
float hi_now   = ta.highest(high, i_break_len)
float lo_now   = ta.lowest(low,   i_break_len)
float break_hi = hi_now[1]
float break_lo = lo_now[1]
bool struct_bull = close > break_hi
bool struct_bear = close < break_lo

bool gate_long  = trend_bull and mom_bull and struct_bull
bool gate_short = trend_bear and mom_bear and struct_bear

// ---- final entry signals (stack + gate + pivot anchor) -----------
bool go_long  = stack_bull and gate_long  and not na(last_pl)
bool go_short = stack_bear and gate_short and not na(last_ph)

if go_long and strategy.position_size <= 0
    strategy.entry("L", strategy.long, qty=1, comment="integ trend long")

if go_short and strategy.position_size >= 0
    strategy.entry("S", strategy.short, qty=1, comment="integ trend short")

// ---- pivot-anchored bracket --------------------------------------
float entry_px = strategy.position_avg_price

if strategy.position_size > 0 and not na(last_pl)
    float sl_px = last_pl
    float tp_px = entry_px + (entry_px - last_pl) * i_rr
    strategy.exit("Brk", from_entry="L", stop=sl_px, limit=tp_px)

if strategy.position_size < 0 and not na(last_ph)
    float sl_px = last_ph
    float tp_px = entry_px - (last_ph - entry_px) * i_rr
    strategy.exit("Brk", from_entry="S", stop=sl_px, limit=tp_px)