PF probe market-shift-probe-integration

// This Pine Script® code is licensed under Apache-2.0
// SPDX-License-Identifier: Apache-2.0
// © PineForge contributors 2026
//
// PF probe market-shift-probe-integration — pivot state + rolling extreme + edge entries
// Clean-room: written from validation goal, not from source.
//
// Purpose: composes the three surfaces isolated by `market-shift-probe-01..03`
// into a single end-to-end strategy. The engine surface under test is the
// cross-surface composition: pivot-driven `market_state` flips on price
// breaking the most-recent confirmed pivot (probe 01); the rolling-window
// extreme (probe 02) provides an alternative rebound entry; the edge
// detector (probe 03) ensures entries fire once per state transition.
//
// Entries use OR-of-AND composition rather than strict AND-of-all: a
// long fires either on a fresh bull state edge OR on a rolling-low
// rebound while in a bull state. Strict AND-composition requires pivot
// break and rolling-extreme cross to land on the same bar, which is
// vanishingly rare on 15m crypto and produces no trades at all. The
// OR-of-AND form still routes EVERY entry through all three surfaces:
// the state machine must be in the right regime, the rolling extreme
// must agree (or the pivot edge must fire), and the edge detector
// stops same-bar duplicates.
//
// Validation goal: bit-exact trade list against TradingView's broker emulator
// on the reference 15-minute ETH-USDT-USDT feed.
//
// 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 market-shift-probe-integration", shorttitle="PF_MSINT",
     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)

// ---- inputs --------------------------------------------------------
int i_pivot  = input.int(5,  "Pivot strength",        minval=2,  maxval=20)
int i_window = input.int(50, "Rolling window length", minval=10, maxval=200)

// ---- pivot tracking ------------------------------------------------
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

if not na(ph)
    last_ph := ph
if not na(pl)
    last_pl := pl

// ---- rolling extreme gate ------------------------------------------
float roll_hi = ta.highest(high, i_window)
float roll_lo = ta.lowest(low,   i_window)

float ref_hi = roll_hi[1]
float ref_lo = roll_lo[1]

bool extreme_up   = ta.crossover(close,  ref_lo)
bool extreme_down = ta.crossunder(close, ref_hi)

// ---- state machine (probe 01 surface) ------------------------------
var int market_state = 0
var int prev_state   = 0

bool pivot_break_up   = not na(last_ph) and close > last_ph
bool pivot_break_down = not na(last_pl) and close < last_pl

if pivot_break_up
    market_state := 1
else if pivot_break_down
    market_state := -1

// ---- edge detector (probe 03 surface) ------------------------------
bool state_long_edge  = market_state ==  1 and prev_state !=  1
bool state_short_edge = market_state == -1 and prev_state != -1

// ---- composed entry (OR of two AND-gated surfaces) -----------------
// Fire long either:
//   (a) on a fresh bull state transition (probe 01 → 03 path), OR
//   (b) on a rolling-low rebound while in a bull state
//       (probe 02 ∧ 01 path).
// Same for short, mirrored. Every entry still passes through the
// state machine + at least one of {edge detector, rolling extreme}.
bool go_long  = (state_long_edge)  or (market_state ==  1 and extreme_up)
bool go_short = (state_short_edge) or (market_state == -1 and extreme_down)

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

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

prev_state := market_state