GOM KOLA SIDO Full Integration

//@version=6
indicator("GOM KOLA SIDO — Full Integration", shorttitle="GOM SIDO", overlay=true,
     max_lines_count=500, max_labels_count=200, max_boxes_count=580)

// ═══════════════════════════════════════════════════════════════
// VISUAL IDENTITY — GHOST PRO PALETTE
// ═══════════════════════════════════════════════════════════════
BRAND_PRIMARY   = #00D5FE   // Cyan signature GOM KOLA SIDO
BRAND_SECONDARY = #FF6B35   // Orange alertes / spikes
BRAND_ACCENT    = #FFD700   // Gold excellence / qualité premium

BULL = #00FF80              // Green électrique (BUY confirmé)
BEAR = #FF3366              // Red moderne (SELL confirmé)
WAIT = #FFB800              // Orange neutre (attente / WAIT)

BG_MAIN   = color.new(#0A0E1A, 85)   // Background principal
BG_HEADER = color.new(#1A1F2E, 60)   // Headers tables
BG_CELL   = color.new(#14172B, 80)   // Cellules alternées
BORDER    = color.new(#2E3650, 40)   // Séparateurs

TEXT_PRIMARY   = color.white             // Valeurs importantes
TEXT_SECONDARY = color.new(#B0B8D0, 0)   // Labels
TEXT_MUTED     = color.new(#6B7280, 0)   // Notes

// GHOST OrderFlow (palette distinctive conservée)
OF_BULL = #2962ff
OF_BEAR = #f23645
OF_NEUT = #787b86
OF_GOLD = #ffd700
OF_BG   = color.new(#0c0e16, 80)
OF_HDR  = color.new(#191c2a, 60)
OF_SEP  = color.new(#282d40, 10)

// ═══════════════════════════════════════════════════════════════
// INPUTS (inchangés — copie depuis original)
// ═══════════════════════════════════════════════════════════════

grp_kola    = "KOLA LEVELS (pivot S/R + touches)"
kola_lb     = input.int(3,    "Line Break Period",     minval=1,  maxval=10,  group=grp_kola)
kola_bars   = input.int(120,  "Max bars analyse",      minval=40, maxval=300, group=grp_kola)
kola_show   = input.bool(true,"Afficher niveaux KOLA",                        group=grp_kola)
kola_touch  = input.bool(true,"Touch detection",                              group=grp_kola)
kola_touch_zone_pct = input.float(30.0, "Touch zone ATR%", minval=5, maxval=80, group=grp_kola)
kola_touch_bars = input.int(150, "Bars for touch count", minval=20, maxval=500, group=grp_kola)

grp_ob      = "ORDER BLOCKS"
ob_lookback = input.int(10,   "Lookback OB",         minval=3,  maxval=50,  group=grp_ob)
ob_show     = input.bool(true,"Afficher OBs",                               group=grp_ob)

grp_struct  = "STRUCTURE (CHoCH / BOS)"
show_choch  = input.bool(false,"Afficher CHoCH / BOS (masqué par défaut)",   group=grp_struct)
struct_lb   = input.int(8,    "Lookback pivots",      minval=3,  maxval=30,  group=grp_struct)

grp_sido    = "SIDO (FIGURES CHARTISTES)"
sido_enable = input.bool(true,"Activer SIDO",                                group=grp_sido)
sido_lb     = input.int(3,    "Pivot lookback SIDO",  minval=2,  maxval=10,  group=grp_sido)
sido_bars   = input.int(300,  "Bars to analyze",      minval=50, maxval=500, group=grp_sido)
sido_max_gap= input.int(80,   "Max bars between swings", minval=10,maxval=200,group=grp_sido)
sido_tol_pct= input.float(35.0,"Tolerance ATR%",      minval=5,  maxval=80,  group=grp_sido)

grp_fib     = "FIBONACCI OTE"
show_fib    = input.bool(true, "Afficher Fibonacci / OTE",                   group=grp_fib)
fib_lb      = input.int(50,   "Lookback swing",       minval=20, maxval=200, group=grp_fib)

grp_spike   = "SPIKE DETECTOR"
spike_lb    = input.int(25,   "Lookback spike",       minval=10, maxval=60,  group=grp_spike)
spike_min   = input.float(0.62,"Seuil alerte spike",  minval=0.40,maxval=0.95,step=0.01, group=grp_spike)
spike_blink = input.float(0.52,"Seuil alerte precoce",minval=0.40,maxval=0.95,step=0.01, group=grp_spike)

grp_spike_bc = "BOOM/CRASH — PRE-SPIKE"
spike_bc_en  = input.bool(true,  "Activer pre-spike Boom/Crash", group=grp_spike_bc)
spike_freq_ov= input.int(0,     "Frequence spike (0=auto)", minval=0, maxval=2000, group=grp_spike_bc)
spike_wake   = input.float(0.30,"Reveil cycle (30%)", minval=0.10, maxval=0.50, step=0.05, group=grp_spike_bc)
spike_watch  = input.float(0.55,"Zone watch (55%)", minval=0.40, maxval=0.70, step=0.05, group=grp_spike_bc)
spike_entry  = input.float(0.65,"Zone entree (65%)", minval=0.55, maxval=0.80, step=0.05, group=grp_spike_bc)
spike_overdue= input.float(0.85,"Reset cycle (85%)", minval=0.75, maxval=0.95, step=0.05, group=grp_spike_bc)
spike_min_prob=input.int(55,    "Prob min tradable %", minval=40, maxval=85, group=grp_spike_bc)
spike_z_min  = input.float(2.0, "Z-score spike min", minval=1.0, maxval=4.0, step=0.1, group=grp_spike_bc)
spike_stair_b= input.int(5,    "Barres stair", minval=3, maxval=10, group=grp_spike_bc)
spike_show_bc= input.bool(true, "Tableau pre-spike", group=grp_spike_bc)
spike_show_lbl=input.bool(true,"Labels spike chart", group=grp_spike_bc)
spike_sl_atr = input.float(0.8,"SL spike (x ATR)", minval=0.3, maxval=2.0, step=0.1, group=grp_spike_bc)
spike_tp_atr = input.float(1.2,"TP spike (x ATR)", minval=0.5, maxval=3.0, step=0.1, group=grp_spike_bc)

grp_ui      = "INTERFACE — SIGNAL CLAIR"
ui_signal_panel = input.bool(true, "Panneau SIGNAL unifié (recommandé Boom/Crash)", group=grp_ui)
ui_compact_bc   = input.bool(true, "Mode compact Boom/Crash (moins de bruit)", group=grp_ui)
ui_show_arrow   = input.bool(true, "Flèche clignotante entrée pre-spike", group=grp_ui)
path_show_bc    = input.bool(false, "Chemin predictif sur Boom/Crash", group=grp_ui)

grp_ind     = "INDICATEURS"
show_vwap   = input.bool(true,"VWAP session",                                group=grp_ind)
show_bb     = input.bool(true,"Bollinger Bands",                             group=grp_ind)
bb_period   = input.int(20,   "Periode BB",                                  group=grp_ind)
bb_dev      = input.float(2.0,"Deviation BB",                                group=grp_ind)
show_st     = input.bool(true,"Supertrend",                                  group=grp_ind)
st_atr_per  = input.int(10,   "ATR Supertrend",                              group=grp_ind)
st_mult     = input.float(3.0,"Mult Supertrend",                             group=grp_ind)
show_kc     = input.bool(true,"Keltner Channel",                             group=grp_ind)
kc_ema_per  = input.int(20,   "EMA Keltner",                                 group=grp_ind)
kc_atr_mult = input.float(1.5,"Mult Keltner",                                group=grp_ind)
show_dc     = input.bool(true,"Donchian Channel",                            group=grp_ind)
dc_period   = input.int(20,   "Periode Donchian",                            group=grp_ind)

grp_mtf     = "TABLEAU MTF"
show_mtf    = input.bool(true,"Afficher tableau MTF",                        group=grp_mtf)
tf1  = input.timeframe("1",  "TF1", group=grp_mtf)
tf2  = input.timeframe("5",  "TF2", group=grp_mtf)
tf3  = input.timeframe("15", "TF3", group=grp_mtf)
tf4  = input.timeframe("60", "TF4", group=grp_mtf)
tf5  = input.timeframe("240","TF5", group=grp_mtf)
tf6  = input.timeframe("D",  "TF6", group=grp_mtf)
tf7  = input.timeframe("W",  "TF7", group=grp_mtf)

grp_verdict = "VERDICT"
show_verdict= input.bool(true,"Afficher verdict",                            group=grp_verdict)
verdict_gap_th = input.float(0.45, "Gap threshold", minval=0.1, maxval=2.0, step=0.05, group=grp_verdict)
verdict_coherence = input.bool(true, "Coherence gate", group=grp_verdict)
verdict_bb_vwap_weight = input.float(1.0, "BB/VWAP weight", minval=0.0, maxval=3.0, step=0.1, group=grp_verdict)
verdict_adv_weight = input.float(0.8, "Advanced indic weight", minval=0.0, maxval=3.0, step=0.1, group=grp_verdict)

grp_quality = "ENTRY QUALITY"
show_quality = input.bool(true, "Afficher quality score", group=grp_quality)

grp_setup   = "TABLEAU SETUP (ordre limite)"
show_setup  = input.bool(true, "Afficher tableau SETUP", group=grp_setup)
setup_rr_mult = input.float(1.0, "TP1 = R x mult", minval=0.5, maxval=3.0, step=0.1, group=grp_setup)
setup_rr2_mult= input.float(1.5, "TP2 = R x mult", minval=0.5, maxval=4.0, step=0.1, group=grp_setup)

grp_path    = "CHEMIN PREDICTIF (200 bougies)"
path_horizon = input.int(200, "Horizon bougies", minval=20, maxval=200, group=grp_path)
path_show    = input.bool(true, "Segments direction futurs", group=grp_path)
path_show_candles = input.bool(true, "Bougies predites (fantomes)", group=grp_path)
path_candle_vis   = input.int(200, "Nb bougies fantomes visibles", minval=15, maxval=200, group=grp_path)
path_width   = input.int(3, "Epaisseur segments", minval=2, maxval=10, group=grp_path)
path_step    = input.float(0.16, "Pas (x ATR)", minval=0.05, maxval=0.45, step=0.01, group=grp_path)
path_in_alert= input.bool(true, "Envoyer chemin → webhook", group=grp_path)

// ═══════════════════════════════════════════════════════════════
// GHOST — ORDER FLOW (inputs)
// ═══════════════════════════════════════════════════════════════
grp_of      = "GHOST — ORDER FLOW"
of_hm_show  = input.bool(true,  "Heatmap liquidité",        group=grp_of)
of_hm_lb    = input.int(100,    "Heatmap lookback bougies", group=grp_of, minval=20, maxval=300)
of_hm_zones = input.int(24,     "Heatmap tranches",         group=grp_of, minval=8,  maxval=40)
of_dlt_show = input.bool(true,  "Delta + CVD",              group=grp_of)
of_dlt_bars = input.int(12,     "Barres histogramme Delta", group=grp_of, minval=6,  maxval=20)
of_cmp_show = input.bool(true,  "Boussole momentum",        group=grp_of)
of_snt_show = input.bool(true,  "Sentiment BUY/SELL%",      group=grp_of)
of_snt_per  = input.int(20,     "Sentiment période",        group=grp_of, minval=5,  maxval=100)

// ═══════════════════════════════════════════════════════════════
// VWAP SESSION (copie depuis original, inchangé)
// ═══════════════════════════════════════════════════════════════
var float vwap_sum = 0.0
var float vwap_vol = 0.0
is_new_session = ta.change(time("D")) != 0
if is_new_session
    vwap_sum := 0.0
    vwap_vol := 0.0
typical   = (high + low + close) / 3
vwap_sum += typical * volume
vwap_vol += volume
vwap_val  = vwap_vol > 0 ? vwap_sum / vwap_vol : close
plot(show_vwap ? vwap_val : na, "vwap", color=color.new(color.yellow, 0), linewidth=2)

// ═══════════════════════════════════════════════════════════════
// BOLLINGER BANDS (inchangé)
// ═══════════════════════════════════════════════════════════════
[bb_mid, bb_up, bb_dn] = ta.bb(close, bb_period, bb_dev)
plot(show_bb ? bb_up  : na, "bb_up", color=color.new(color.blue, 40), linewidth=1)
plot(show_bb ? bb_mid : na, "bb_mid", color=color.new(color.silver, 50), linewidth=1, style=plot.style_circles)
plot(show_bb ? bb_dn  : na, "bb_dn", color=color.new(color.blue, 40), linewidth=1)
bb_width = bb_up - bb_dn
bb_squeeze = bb_width < ta.sma(bb_width, 20) * 0.85
bb_pctb = bb_width > 0 ? (close - bb_dn) / bb_width : 0.5

// ═══════════════════════════════════════════════════════════════
// SUPERTREND (inchangé)
// ═══════════════════════════════════════════════════════════════
atr_st  = ta.atr(st_atr_per)
up_band = hl2 - st_mult * atr_st
dn_band = hl2 + st_mult * atr_st
var float st_up  = na
var float st_dn  = na
var int   st_dir = 1
st_up := math.max(up_band, nz(st_up[1], up_band))
st_dn := math.min(dn_band, nz(st_dn[1], dn_band))
if close > nz(st_dn[1])
    st_dir := 1
else if close < nz(st_up[1])
    st_dir := -1
st_line = st_dir == 1 ? st_up : st_dn
plot(show_st ? st_line : na, "st_line",
     color=st_dir==1 ? color.new(color.lime,30) : color.new(color.red,30), linewidth=2)

// ═══════════════════════════════════════════════════════════════
// KELTNER CHANNEL (sans plot)
// ═══════════════════════════════════════════════════════════════
kc_mid = ta.ema(close, kc_ema_per)
kc_atr = ta.atr(kc_ema_per)
kc_upper = kc_mid + kc_atr_mult * kc_atr
kc_lower = kc_mid - kc_atr_mult * kc_atr
kc_pos = kc_upper > kc_lower ? ((close - kc_lower) / (kc_upper - kc_lower)) * 2.0 - 1.0 : 0.0

// ═══════════════════════════════════════════════════════════════
// DONCHIAN CHANNEL (sans plot)
// ═══════════════════════════════════════════════════════════════
dc_high = ta.highest(high, dc_period)
dc_low  = ta.lowest(low, dc_period)
dc_mid_val = (dc_high + dc_low) / 2
dc_sig = close > dc_high - atr_st * 0.05 ? 1.0 : close < dc_low + atr_st * 0.05 ? -1.0 : 0.0

// ═══════════════════════════════════════════════════════════════
// KOLA LEVELS — HARMONISÉ (BULL/BEAR palette)
// ═══════════════════════════════════════════════════════════════
atr14 = ta.atr(14)
touch_zone = kola_touch ? atr14 * (kola_touch_zone_pct / 100.0) : 0.0

calc_touches(level, zone_size, max_bars) =>
    touches = 0
    for i = 0 to math.min(max_bars, 499)
        h = high[i]
        l = low[i]
        if math.abs(h - level) <= zone_size or math.abs(l - level) <= zone_size or (l <= level and h >= level)
            touches += 1
    touches

var float kola_buy_level  = na
var float kola_sell_level = na
var int   kola_buy_touches  = 0
var int   kola_sell_touches = 0

if barstate.islast and kola_show
    best_buy  = 0.0
    best_sell = 0.0
    best_buy_t  = 0
    best_sell_t = 0
    max_idx = math.min(bar_index, kola_bars)

    for i = kola_lb + 1 to max_idx
        is_pl = true
        for k = 1 to kola_lb
            if low[i - k] <= low[i] or low[i + k] < low[i]
                is_pl := false
                break
        if is_pl
            lvl = low[i]
            t = kola_touch ? calc_touches(lvl, touch_zone, kola_touch_bars) : 1
            if lvl < close
                if t > best_buy_t or (t == best_buy_t and lvl > best_buy)
                    best_buy := lvl
                    best_buy_t := t

        is_ph = true
        for k = 1 to kola_lb
            if high[i - k] >= high[i] or high[i + k] > high[i]
                is_ph := false
                break
        if is_ph
            lvl = high[i]
            t = kola_touch ? calc_touches(lvl, touch_zone, kola_touch_bars) : 1
            if lvl > close
                if t > best_sell_t or (t == best_sell_t and (best_sell == 0.0 or lvl < best_sell))
                    best_sell := lvl
                    best_sell_t := t

    kola_buy_level  := best_buy > 0 ? best_buy : na
    kola_sell_level := best_sell > 0 ? best_sell : na
    kola_buy_touches  := best_buy_t
    kola_sell_touches := best_sell_t

var line kola_buy_ln  = na
var line kola_sell_ln = na
var label kola_buy_lbl  = na
var label kola_sell_lbl = na

if barstate.islast and kola_show
    if not na(kola_buy_ln)
        line.delete(kola_buy_ln)
    if not na(kola_sell_ln)
        line.delete(kola_sell_ln)
    if not na(kola_buy_lbl)
        label.delete(kola_buy_lbl)
    if not na(kola_sell_lbl)
        label.delete(kola_sell_lbl)

    if not na(kola_buy_level)
        kola_buy_ln := line.new(bar_index - kola_bars, kola_buy_level, bar_index, kola_buy_level,
             color=color.new(BULL, 0), width=2, style=line.style_solid, extend=extend.right)
        kola_buy_lbl := label.new(bar_index, kola_buy_level,
             "BUY " + str.tostring(math.round(kola_buy_level, 2)) + " (" + str.tostring(kola_buy_touches) + "t)",
             color=color.new(color.black,100), textcolor=color.new(BULL, 0), size=size.small, style=label.style_label_left)

    if not na(kola_sell_level)
        kola_sell_ln := line.new(bar_index - kola_bars, kola_sell_level, bar_index, kola_sell_level,
             color=color.new(BEAR, 0), width=2, style=line.style_solid, extend=extend.right)
        kola_sell_lbl := label.new(bar_index, kola_sell_level,
             "SELL " + str.tostring(math.round(kola_sell_level, 2)) + " (" + str.tostring(kola_sell_touches) + "t)",
             color=color.new(color.black,100), textcolor=color.new(BEAR, 0), size=size.small, style=label.style_label_left)

// ═══════════════════════════════════════════════════════════════
// SIDO — HARMONISÉ (BRAND_SECONDARY / BRAND_PRIMARY)
// ═══════════════════════════════════════════════════════════════
var float sido_dt_level = na
var float sido_db_level = na
var line  sido_dt_ln = na
var line  sido_db_ln = na
var label sido_dt_lbl = na
var label sido_db_lbl = na

if barstate.islast and sido_enable
    if not na(sido_dt_ln)
        line.delete(sido_dt_ln)
    if not na(sido_db_ln)
        line.delete(sido_db_ln)
    if not na(sido_dt_lbl)
        label.delete(sido_dt_lbl)
    if not na(sido_db_lbl)
        label.delete(sido_db_lbl)

    sido_dt_level := na
    sido_db_level := na

    tol = atr14 * (sido_tol_pct / 100.0)
    max_idx_sido = math.min(bar_index, sido_bars)

    var int ph1_idx = -1
    var int ph2_idx = -1
    var int pl1_idx = -1
    var int pl2_idx = -1
    ph1_idx := -1
    ph2_idx := -1
    pl1_idx := -1
    pl2_idx := -1

    for i = sido_lb + 1 to max_idx_sido
        is_ph_s = true
        for k = 1 to sido_lb
            if high[i - k] >= high[i] or high[i + k] > high[i]
                is_ph_s := false
                break
        if is_ph_s
            if ph1_idx == -1
                ph1_idx := i
            else if ph2_idx == -1
                ph2_idx := i
                break

    for i = sido_lb + 1 to max_idx_sido
        is_pl_s = true
        for k = 1 to sido_lb
            if low[i - k] <= low[i] or low[i + k] < low[i]
                is_pl_s := false
                break
        if is_pl_s
            if pl1_idx == -1
                pl1_idx := i
            else if pl2_idx == -1
                pl2_idx := i
                break

    if ph1_idx >= 0 and ph2_idx >= 0
        bars_gap_h = math.abs(ph1_idx - ph2_idx)
        h1 = high[ph1_idx]
        h2 = high[ph2_idx]
        if bars_gap_h <= sido_max_gap and math.abs(h1 - h2) <= tol
            dt_lvl = (h1 + h2) / 2.0
            sido_dt_level := dt_lvl
            sido_dt_ln := line.new(bar_index - ph2_idx, dt_lvl, bar_index, dt_lvl,
                 color=color.new(BRAND_SECONDARY, 20), width=2, style=line.style_dashed, extend=extend.right)
            sido_dt_lbl := label.new(bar_index, dt_lvl, "DT",
                 color=color.new(BRAND_SECONDARY, 20), textcolor=color.white, size=size.small, style=label.style_label_left)

    if pl1_idx >= 0 and pl2_idx >= 0
        bars_gap_l = math.abs(pl1_idx - pl2_idx)
        l1 = low[pl1_idx]
        l2 = low[pl2_idx]
        if bars_gap_l <= sido_max_gap and math.abs(l1 - l2) <= tol
            db_lvl = (l1 + l2) / 2.0
            sido_db_level := db_lvl
            sido_db_ln := line.new(bar_index - pl2_idx, db_lvl, bar_index, db_lvl,
                 color=color.new(BRAND_PRIMARY, 20), width=2, style=line.style_dashed, extend=extend.right)
            sido_db_lbl := label.new(bar_index, db_lvl, "DB",
                 color=color.new(BRAND_PRIMARY, 20), textcolor=color.white, size=size.small, style=label.style_label_left)

// ═══════════════════════════════════════════════════════════════
// ORDER BLOCKS — HARMONISÉ (BULL/BEAR palette)
// ═══════════════════════════════════════════════════════════════
pivot_h = ta.pivothigh(high, ob_lookback, ob_lookback)
pivot_l = ta.pivotlow(low,  ob_lookback, ob_lookback)

var float ob_bear_top = na
var float ob_bear_bot = na
var int   ob_bear_bar = na
var float ob_bull_top = na
var float ob_bull_bot = na
var int   ob_bull_bar = na

if not na(pivot_h)
    ob_bear_top := high[ob_lookback + 1]
    ob_bear_bot := math.min(open[ob_lookback + 1], close[ob_lookback + 1])
    ob_bear_bar := bar_index - ob_lookback - 1
if not na(pivot_l)
    ob_bull_top := math.max(open[ob_lookback + 1], close[ob_lookback + 1])
    ob_bull_bot := low[ob_lookback + 1]
    ob_bull_bar := bar_index - ob_lookback - 1

if not na(ob_bear_top) and high >= ob_bear_bot
    ob_bear_top := na
    ob_bear_bot := na
if not na(ob_bull_bot) and low <= ob_bull_top
    ob_bull_top := na
    ob_bull_bot := na

var box ob_bear_box = na
var box ob_bull_box = na

if ob_show and not na(ob_bear_top) and not na(ob_bear_bar)
    if not na(ob_bear_box)
        box.delete(ob_bear_box)
    ob_bear_box := box.new(ob_bear_bar, ob_bear_top, bar_index, ob_bear_bot,
         border_color=color.new(BEAR, 0), border_width=2, bgcolor=color.new(BEAR, 88),
         extend=extend.right, text="OB Bear", text_color=color.new(BEAR, 0), text_size=size.small)

if ob_show and not na(ob_bull_bot) and not na(ob_bull_bar)
    if not na(ob_bull_box)
        box.delete(ob_bull_box)
    ob_bull_box := box.new(ob_bull_bar, ob_bull_top, bar_index, ob_bull_bot,
         border_color=color.new(BULL, 0), border_width=2, bgcolor=color.new(BULL, 88),
         extend=extend.right, text="OB Bull", text_color=color.new(BULL, 0), text_size=size.small)

// ═══════════════════════════════════════════════════════════════
// VERDICT CALCULATIONS — CRITICAL FOR EA SYNC
// ═══════════════════════════════════════════════════════════════
// Simplified verdict based on score diff
score_buy_rsi = ta.ema(close < open ? rsi - 50 : 0, 14)
score_sell_rsi = ta.ema(close > open ? 50 - rsi : 0, 14)
score_buy = score_buy_rsi + ta.ema(ta.lowest(low, 5), 14) / close * 50
score_sell = score_sell_rsi + ta.ema(ta.highest(high, 5), 14) / close * 50

verdict_num = score_buy > score_sell ? (score_buy - score_sell > 5 ? 2 : 1) :
              score_sell > score_buy ? (score_sell - score_buy > 5 ? -2 : -1) : 0
verdict_gap = math.abs(score_buy - score_sell)
verdict_txt = verdict_num == 2 ? "PERFECT BUY" : verdict_num == 1 ? "BUY" :
              verdict_num == -2 ? "PERFECT SELL" : verdict_num == -1 ? "SELL" : "WAIT"

// ═══════════════════════════════════════════════════════════════
// EXPORTS FOR EA SYNC (data_window plots)
// ═══════════════════════════════════════════════════════════════
plot(score_buy, "score_buy", display=display.data_window)
plot(score_sell, "score_sell", display=display.data_window)
plot(verdict_num, "verdict_num", display=display.data_window)
plot(verdict_gap, "verdict_gap", display=display.data_window)
plot(rsi, "rsi", display=display.data_window)
plot(st_dir, "st_dir", display=display.data_window)