Wyckoff Range Engine [WillyAlgoTrader]

WillyAlgoTrader · study · 1845 行 · 点赞 1,023 · TradingView 原页

本页源码来自 TradingView 公开发布的开源脚本,版权归原作者所有, 请遵循其原始许可(Pine 脚本常见 CC BY-NC-SA / MPL-2.0 / MIT)。 本项目仅用于研究检索与许可范围内的移植。

Pine Script

//@version=6
// ══════════════════════════════════════════════════════════
// WYCKOFF RANGE ENGINE [WillyAlgoTrader]
// ══════════════════════════════════════════════════════════
// Author:  Willy | WillyAlgoTrader
// Version: 3.3.2
 
indicator(
     title               = "Wyckoff Range Engine [WillyAlgoTrader]",
     shorttitle          = "Wyckoff RE",
     overlay             = true,
     max_lines_count     = 500,
     max_labels_count    = 500,
     max_boxes_count     = 200,
     max_bars_back       = 5000)
 
// ══════════════════════════════════════
// CONSTANTS
// ══════════════════════════════════════
GRP_MAIN   = "⚙️ Main Settings"
GRP_SWING  = "〰️ Swing Engine"
GRP_RANGE  = "📐 Range Rules"
GRP_EVENT  = "🧩 Event Rules"
GRP_VISUAL = "🎨 Visual Settings"
GRP_RISK   = "🛡️ Risk Management"
GRP_DASH   = "📊 Dashboard"
GRP_ALERT  = "🔔 Alerts"
GRP_COLORS = "🎨 Colors"
 
INDICATOR_VERSION = "v3.3.2"
INDICATOR_SHORT   = "WRE"
 
// ── Trade engine ──
WICK_BUFFER_ATR   = 0.25 // Wick-Anchored / Structure SL buffer beyond the anchor, × ATR
WICK_MIN_ATR      = 0.5  // minimum SL distance for anchored stops, × ATR
LINE_FORWARD_BARS = 20   // length of trade lines when an entry is drawn
LINE_UPDATE_BARS  = 8    // extension beyond the current bar while a trade is open
LABEL_OFFSET_BARS = 1    // label offset from the end of trade lines
FORM_LEN          = 10   // length of the Form strip
GAUGE_WIDTH       = 8    // win-rate gauge cells
MS_DAY            = 86400000
STATS_PRUNE_DAYS  = 31   // rolling stats buffer horizon
RSI_LEN           = 14   // context oscillator shown in entry tooltips
MAX_SWINGS        = 60
EFF_BUF_MAX       = 3000
 
// ── Schematic drawing ──
EVENT_OFFSET_ATR  = 0.5  // event text sits this far beyond the swing, × ATR
PHASE_TAG_FRAC    = 0.14 // phase captions this fraction of range height below the support lines
DIVIDER_PAD_FRAC  = 0.06 // phase dividers overshoot the range edges by this fraction of height
MIN_PHASE_BARS    = 6    // phases shorter than this get a divider but no caption (avoids overlapping text)
PHASE_E_OFFSET_BARS = 8  // 'Phase E' caption this many bars past the LPS / LPSY divider
TAG_OFFSET_BARS   = 3    // 'Support / Resistance Lines' tags this many bars right of the line end
 
// ══════════════════════════════════════
// INPUTS
// ══════════════════════════════════════
// ── Main ──
effModeInput = input.string("Auto", "Effort Source", options = ["Auto", "Volume", "Bar Range"], group = GRP_MAIN,
     tooltip = "Chosen once per symbol.\n• Auto: volume if the symbol provides it, otherwise bar range\n" +
               "• Effort of a bar = source / its baseline average (1.0 = normal)")
effBaseLenInput = input.int(50, "Effort Baseline (bars)", minval = 10, maxval = 500, group = GRP_MAIN,
     tooltip = "Lookback of the effort baseline (simple average). Bar effort ratio = effort / baseline.")
atrLenInput = input.int(14, "ATR Period", minval = 1, maxval = 100, group = GRP_MAIN,
     tooltip = "ATR used for swing reversals, range height, break distances and quality scores.")
climaxScoreInput = input.int(60, "Climax Score Threshold (0–100)", minval = 20, maxval = 95, group = GRP_MAIN,
     tooltip = "A swing low (high) becomes a Selling (Buying) Climax candidate when the climactic RUN that ends there\n" +
               "(all consecutive lower-highs / higher-lows legs) scores at least this much: 30% mean effort of the run,\n" +
               "30% peak bar effort, 20% run length in ATR, 20% velocity (ATR per bar). Higher = fewer, stronger climaxes.")
climaxPeakInput = input.float(2.0, "Climax Peak Bar Effort (×baseline)", minval = 1.0, maxval = 6.0, step = 0.1, group = GRP_MAIN,
     tooltip = "Hard gate: the climactic run must contain at least one bar with effort this many times the baseline.")
trendSwingsInput = input.int(2, "Trend Context (lower lows in the run)", minval = 1, maxval = 6, group = GRP_MAIN,
     tooltip = "The climactic run must contain at least this many earlier swing lows above the SC (for a BC: swing highs\n" +
               "below it) while the swing highs keep falling (lows keep rising). Swing-structure replacement for an EMA filter.")
entrySignalInput = input.string("LPS / LPSY", "Trade Entry Signal", options = ["LPS / LPSY", "Spring / UTAD", "SOS / SOW", "Spring + LPS"], group = GRP_MAIN,
     tooltip = "Which Wyckoff event opens a position in the trade engine:\n" +
               "• LPS / LPSY: last point of support/supply after the breakout (classic, recommended)\n" +
               "• Spring / UTAD: early entry on the Phase C shakeout\n" +
               "• SOS / SOW: breakout bar\n• Spring + LPS: both (opposite signal reverses, same-direction ignored)")
 
// ── Swing engine ──
swingRevInput = input.float(1.0, "Swing Reversal (×ATR)", minval = 0.5, maxval = 6.0, step = 0.1, group = GRP_SWING,
     tooltip = "A swing high is confirmed when a bar closes this many ATR below the running high (swing low: above\n" +
               "the running low). Smaller = more swings, earlier confirmation of ST / TEST / LPS, more noise. Recommended 0.8–1.5.")
 
// ── Range rules ──
arRetraceInput = input.float(0.5, "AR Min Retrace (fraction of climactic run)", minval = 0.1, maxval = 1.0, step = 0.02, group = GRP_RANGE,
     tooltip = "The Automatic Rally / Reaction must retrace at least this fraction of the climactic run (from the start\n" +
               "of the final decline/advance to the climax extreme). Shallower bounces are ignored and the candidate keeps\n" +
               "waiting; a deeper extreme extends the candidate.")
minHeightAtrInput = input.float(3.0, "Min Range Height (×ATR)", minval = 0.5, maxval = 20.0, step = 0.25, group = GRP_RANGE,
     tooltip = "Minimum distance between the climax extreme and the AR swing.")
maxHeightAtrInput = input.float(8.0, "Max Range Height (×ATR)", minval = 2.0, maxval = 40.0, step = 0.5, group = GRP_RANGE,
     tooltip = "If the automatic reaction keeps extending (AR+) beyond this height before the first ST, the structure is a\n" +
               "trend, not a range: the candidate is dropped (gray 'NO RANGE - trend').")
arMaxBarsInput = input.int(60, "Max Bars To Confirm AR", minval = 5, maxval = 500, group = GRP_RANGE,
     tooltip = "Counted from the (latest) climax swing bar. If no qualifying AR swing is confirmed in time, the candidate is discarded.")
maxRangeBarsInput = input.int(400, "Range Lifetime (bars)", minval = 20, maxval = 5000, group = GRP_RANGE,
     tooltip = "Counted from the climax bar. A range without a breakout by then is closed as TIMED OUT (gray).")
 
// ── Event rules (all zones are fractions of range height measured from the climax side) ──
stZoneInput = input.float(0.30, "ST Zone (u ≤)", minval = 0.05, maxval = 0.9, step = 0.05, group = GRP_EVENT,
     tooltip = "Secondary Test: a climax-side swing inside the range with u ≤ this value\n(u = 0 climax edge, u = 1 reaction edge).")
maxSTInput = input.int(3, "Max ST Per Range", minval = 0, maxval = 6, group = GRP_EVENT,
     tooltip = "0 together with 'Spring Needs A Prior ST' makes Spring/UTAD impossible (validation stops the script).")
requireSTInput = input.bool(true, "Spring Needs A Prior ST", group = GRP_EVENT,
     tooltip = "Springs happen in Phase C after the range was tested. With this on, a swing beyond the climax side\n" +
               "before the first ST only extends the range edge (marked 'ext').")
reclaimBarsInput = input.int(8, "Reclaim Deadline (bars)", minval = 1, maxval = 40, group = GRP_EVENT,
     tooltip = "After a swing beyond the climax side is confirmed, price must close back inside the range within\n" +
               "this many bars. Otherwise the range is BROKEN.")
failDistAtrInput = input.float(0.5, "Decisive Break Distance (×ATR)", minval = 0.1, maxval = 5.0, step = 0.1, group = GRP_EVENT,
     tooltip = "A close this far beyond the climax edge ends the range immediately as BROKEN.")
testZoneInput = input.float(0.4, "Test Zone (u ≤)", minval = 0.05, maxval = 0.9, step = 0.05, group = GRP_EVENT,
     tooltip = "TEST: climax-side swing after the Spring, above the spring extreme, with u ≤ this value and a leg\n" +
               "with less effort than the spring leg.")
sosEffInput = input.float(1.2, "SOS / SOW Leg Effort (×baseline)", minval = 0.5, maxval = 5.0, step = 0.1, group = GRP_EVENT,
     tooltip = "Mean effort of the breakout LEG (from the last climax-side swing to the breakout bar).\n" +
               "A breakout is only recognised from Phase B on (after at least one ST or a Spring).")
sosLegAtrInput = input.float(1.5, "SOS / SOW Leg Length (×ATR)", minval = 0.25, maxval = 10.0, step = 0.25, group = GRP_EVENT,
     tooltip = "Length of the breakout leg in ATR units at the breakout bar.")
sosLogicInput = input.string("Effort OR leg length", "SOS / SOW Confirmation", options = ["Effort OR leg length", "Effort AND leg length"], group = GRP_EVENT,
     tooltip = "OR = either a strong leg or a long leg qualifies. AND = both required (stricter).")
sosBufAtrInput = input.float(0.1, "SOS / SOW Close Beyond Range (×ATR)", minval = 0.0, maxval = 3.0, step = 0.05, group = GRP_EVENT,
     tooltip = "Breakout close must exceed the reaction edge by this ATR multiple.")
lpsFloorInput = input.float(0.75, "LPS / LPSY Floor (u ≥)", minval = 0.5, maxval = 1.5, step = 0.05, group = GRP_EVENT,
     tooltip = "After SOS/SOW the first climax-side swing with u ≥ this value is the LPS / LPSY.\n" +
               "0.75 = upper quarter or above the range. 1.0 = must hold above the range edge.\n" +
               "A close below the midline (u < 0.5) after SOS fails the breakout.")
lpsMaxBarsInput = input.int(60, "LPS Search Window (bars)", minval = 5, maxval = 500, group = GRP_EVENT,
     tooltip = "After SOS/SOW. If no LPS appears, the range closes as MARKUP / MARKDOWN without LPS.")
markUTInput = input.bool(true, "Mark UT / SHAKEOUT (reaction-side false break)", group = GRP_EVENT,
     tooltip = "A reaction-side swing beyond the range edge after the first ST that did not qualify as SOS/SOW.\n" +
               "Before the first ST such a swing extends the AR instead (marked 'AR+'). Does not change state.")
projMultInput = input.float(1.0, "Target Projection (×range height)", minval = 0.25, maxval = 5.0, step = 0.25, group = GRP_EVENT,
     tooltip = "Measured-move target after SOS/SOW: reaction edge + height × multiplier.")
projBarsInput = input.int(40, "Target Line Extension (bars)", minval = 5, maxval = 300, group = GRP_EVENT,
     tooltip = "Visual length of the target line.")
tgtMarginAtrInput = input.float(0.5, "Target Must Be Ahead Of SOS Close (×ATR)", minval = 0.0, maxval = 5.0, step = 0.1, group = GRP_EVENT,
     tooltip = "Outcome tracking starts only if the target is at least this far ahead of the SOS close;\n" +
               "otherwise the case is counted as 'target already passed' and excluded from the hit rate.")
outcomeBarsInput = input.int(120, "SOS Outcome Horizon (bars)", minval = 10, maxval = 1000, group = GRP_EVENT,
     tooltip = "Bars after SOS to reach the target before a close back below the midline. Expiry is checked first.")
 
// ── Visual ──
themeInput = input.string("Auto", "Theme", options = ["Auto", "Dark", "Light"], group = GRP_VISUAL,
     tooltip = "Chart color theme.\n• Auto: detects from chart background\n• Dark: optimized for dark backgrounds\n• Light: optimized for light/white backgrounds")
showRangesInput = input.bool(true, "Show Range Lines", group = GRP_VISUAL,
     tooltip = "Draw the Resistance / Support lines of the range (outer edge + inner level) and the range title.")
showPhasesInput = input.bool(true, "Show Phase Dividers", group = GRP_VISUAL,
     tooltip = "Vertical dashed dividers at the A→B→C→D→E transitions with 'Phase X' captions under the range.")
showEventsInput = input.bool(true, "Show Event Labels", group = GRP_VISUAL,
     tooltip = "SC/BC, AR, ST, Test, Spring/UTAD, UT/Shakeout, SOS/SOW, LPS/LPSY as plain text beyond the swing.\nHover a label for scores and details.")
showSwingsInput = input.bool(false, "Show Swing Points", group = GRP_VISUAL,
     tooltip = "Small dots on every confirmed swing high / low (debug view of the swing engine).")
showSignalsInput = input.bool(true, "Show Buy/Sell Labels", group = GRP_VISUAL,
     tooltip = "'▲ BUY' / '▼ SELL' entry markers of the trade engine with a score tooltip.")
showTargetInput = input.bool(true, "Show Measured-Move Target", group = GRP_VISUAL,
     tooltip = "Measured-move target line after SOS/SOW.")
showDetectInput = input.bool(true, "Show Detection Markers (·)", group = GRP_VISUAL,
     tooltip = "A dot on the bar where an event became known (the swing confirmation bar).")
showFailedInput = input.bool(true, "Keep Failed / Expired Ranges (gray)", group = GRP_VISUAL,
     tooltip = "Off = failed and expired ranges are removed from the chart (still counted in the dashboard).")
detailLblInput = input.bool(false, "Detailed Event Labels", group = GRP_VISUAL,
     tooltip = "Adds quality scores and effort notes under the event text. Off = clean schematic; details stay in the tooltips.")
maxRangesInput = input.int(4, "Range History Depth", minval = 1, maxval = 20, group = GRP_VISUAL,
     tooltip = "Each range's drawings are removed together with the range.")
showWatermarkInput = input.bool(true, "Show Watermark", group = GRP_VISUAL,
     tooltip = "Display 'WillyAlgoTrader' watermark on chart")
signalFontSizeInput = input.string("Small", "Signal Label Size", options = ["Tiny", "Small", "Normal", "Large", "Huge"], group = GRP_VISUAL,
     tooltip = "Font size for signal labels and trade entry markers")
labelFontSizeInput = input.string("Small", "SL/TP Label Font Size", options = ["Tiny", "Small", "Normal", "Large", "Huge"], group = GRP_VISUAL,
     tooltip = "Font size for SL/TP price labels")
eventFontSizeInput = input.string("Normal", "Event Label Font", options = ["Tiny", "Small", "Normal", "Large", "Huge"], group = GRP_VISUAL,
     tooltip = "Font size for Wyckoff event labels and phase captions. Secondary marks (AR+, ext, UT) render one step smaller.")
eventBackdropInput = input.bool(true, "Event Label Backdrop", group = GRP_VISUAL,
     tooltip = "Draw event text and phase captions on a plate in the chart background color so they stay readable over candles.\nOff = bare text, closest to the classic schematic.")
 
// ── Risk management ──
riskPresetInput = input.string("Balanced", "Risk Preset", options = ["Conservative", "Balanced", "Aggressive", "Scalping", "Custom"], group = GRP_RISK,
     tooltip = "Quick risk presets (SL part applies to ATR mode; Wick-Anchored / Structure anchor the stop to price):\n" +
               "• Conservative: SL 2.5×ATR, TP 1R/2R/4R\n• Balanced: SL 1.5×ATR, TP 1R/2R/3R\n" +
               "• Aggressive: SL 1.0×ATR, TP 1.5R/2.5R/4R\n• Scalping: SL 0.8×ATR, TP 0.8R/1.5R/2R\n" +
               "• Custom: use manual SL/TP multipliers below")
slModeInput = input.string("Wick-Anchored", "SL Mode", options = ["Wick-Anchored", "ATR", "Structure"], group = GRP_RISK,
     tooltip = "How the stop-loss is placed at entry:\n" +
               "• Wick-Anchored: below/above the signal bar's wick + 0.25×ATR buffer (min 0.5×ATR). Recommended\n" +
               "• ATR: fixed SL Multiplier × ATR distance from entry\n" +
               "• Structure: beyond the Wyckoff swing (LPS swing / spring extreme / range edge) + 0.25×ATR, min 0.5×ATR")
atrLenRiskInput = input.int(14, "ATR Length (SL)", minval = 5, maxval = 50, group = GRP_RISK,
     tooltip = "ATR period for stop-loss calculation.\n• 14 = standard\n• Lower = tighter stops\n• Higher = wider stops")
slMultInput = input.float(1.5, "SL Multiplier (×ATR)", minval = 0.5, maxval = 5.0, step = 0.1, group = GRP_RISK,
     tooltip = "Stop-loss distance as multiple of ATR (ATR mode, Custom preset).\n• 1.0 = tight\n• 1.5 = balanced\n• 2.0–3.0 = wide")
tp1MultInput = input.float(1.0, "TP1 Multiplier (×Risk)", minval = 0.5, maxval = 5.0, step = 0.1, group = GRP_RISK,
     tooltip = "Take-profit 1 as multiple of the actual SL distance (Custom preset). 1.0 = 1:1")
tp2MultInput = input.float(2.0, "TP2 Multiplier (×Risk)", minval = 1.0, maxval = 10.0, step = 0.1, group = GRP_RISK,
     tooltip = "Take-profit 2 as multiple of risk (Custom preset). 2.0 = 1:2")
tp3MultInput = input.float(3.0, "TP3 Multiplier (×Risk)", minval = 1.5, maxval = 15.0, step = 0.1, group = GRP_RISK,
     tooltip = "Take-profit 3 as multiple of risk (Custom preset). 3.0 = 1:3")
beInput = input.bool(true, "Break-Even After TP1", group = GRP_RISK,
     tooltip = "Move stop-loss to entry price once TP1 is reached.\nPositions stopped at break-even after TP1 count as wins")
beOffsetInput = input.float(0.0, "BE Offset (×ATR)", minval = 0.0, maxval = 1.0, step = 0.05, group = GRP_RISK,
     tooltip = "Optional offset of the break-even stop from entry, in ATR of the entry bar. 0 = exactly at entry.")
showSlTpInput = input.bool(true, "Show SL/TP Lines", group = GRP_RISK,
     tooltip = "Draw entry, stop-loss and take-profit lines. Lines persist after the trade closes and are\n" +
               "replaced by the next entry.")
showSlTpLabelsInput = input.bool(true, "Show SL/TP Labels", group = GRP_RISK,
     tooltip = "Price labels on entry/SL/TP lines")
showPctOnLabelsInput = input.bool(true, "Show % Distance on Labels", group = GRP_RISK,
     tooltip = "Append % distance from entry to SL/TP labels,\ne.g. 'SL 1.2300 (-0.36%)'")
entryLineStyleInput = input.string("Dotted", "Entry Line Style", options = ["Solid", "Dashed", "Dotted"], group = GRP_RISK,
     tooltip = "Entry is a reference, not an action level — keep it subtle")
slLineStyleInput = input.string("Solid", "SL Line Style", options = ["Solid", "Dashed", "Dotted"], group = GRP_RISK,
     tooltip = "Stop-loss is the action level — solid, width 2")
tpLineStyleInput = input.string("Dashed", "TP Line Style", options = ["Solid", "Dashed", "Dotted"], group = GRP_RISK,
     tooltip = "Style for TP1/TP2/TP3. On hit, a TP line turns solid teal")
 
// ── Dashboard ──
showDashInput = input.bool(true, "Show Dashboard", group = GRP_DASH,
     tooltip = "Sectional dashboard with Market, Wyckoff, Trade and Stats sections")
dashPosStrInput = input.string("Top Right", "Dashboard Position", options = ["Top Left", "Top Right", "Bottom Left", "Bottom Right", "Middle Right"], group = GRP_DASH,
     tooltip = "Where the dashboard table is anchored")
dashFontSizeInput = input.string("Small", "Dashboard Font Size", options = ["Small", "Normal", "Large", "Huge"], group = GRP_DASH,
     tooltip = "Font size for the dashboard table. Section dividers and the\nversion footer render one step smaller to preserve hierarchy")
showMarketSecInput = input.bool(true, "  ├ Market section", group = GRP_DASH, tooltip = "Trend / Phase / Leg / Position / Last signal")
showWyckoffSecInput = input.bool(true, "  ├ Wyckoff section", group = GRP_DASH, tooltip = "Status / Range / Events / Quality / Outcomes")
showTradeSecInput = input.bool(true, "  ├ Trade section", group = GRP_DASH, tooltip = "Entry / SL / TP1-3 / R:R / SL distance")
showStatsSecInput = input.bool(true, "  └ Stats section", group = GRP_DASH, tooltip = "Trades / W / L / Win rate / Form (resets on chart reload)")
statsPeriodInput = input.string("All-Time", "Win Rate Period", options = ["24 Hours", "30 Days", "All-Time"], group = GRP_DASH,
     tooltip = "Time window for the Stats section (Trades / Wins / Losses / Win rate):\n" +
               "• 24 Hours: trades closed in the last 24h (relative to the latest bar)\n" +
               "• 30 Days: trades closed in the last 30 days\n• All-Time: all trades on the loaded chart history\n" +
               "Form strip always shows the last trades regardless of period.\nAll stats reset on chart reload")
 
// ── Alerts ──
webhookInput = input.bool(false, "Webhook JSON Format", group = GRP_ALERT,
     tooltip = "Send entry alerts in JSON format for webhook integrations")
alertEventsInput = input.bool(true, "Alert on Wyckoff Events", group = GRP_ALERT,
     tooltip = "Climax, AR, ST, Spring/UTAD, TEST, SOS/SOW, LPS/LPSY, range failed. Suppressed on bars that open or reverse a trade.")
alertSlRevInput = input.bool(true, "Alert on SL Hit & Reversal", group = GRP_ALERT,
     tooltip = "🛑 SL HIT / 🛡️ BE STOP-OUT and 🔄 REVERSAL alerts")
alertTpBeInput = input.bool(true, "Alert on TP & Break-Even", group = GRP_ALERT,
     tooltip = "🎯 TP1 / TP2 / 🏆 TP3 hits and 🛡️ break-even move")
 
// ── Colors ──
bullColorInput = input.color(#00E676, "Bull", inline = "clr", group = GRP_COLORS)
bearColorInput = input.color(#FF5252, "Bear", inline = "clr", group = GRP_COLORS)
sigColorInput  = input.color(#FFEB3B, "Spring/UTAD", inline = "clr2", group = GRP_COLORS)
climColorInput = input.color(#00E5FF, "Climax", inline = "clr2", group = GRP_COLORS)
failColorInput = input.color(#FF9100, "Failure", inline = "clr3", group = GRP_COLORS)
 
// ══════════════════════════════════════
// INPUT VALIDATION
// ══════════════════════════════════════
if tp1MultInput >= tp2MultInput or tp2MultInput >= tp3MultInput
    runtime.error("Invalid TP multipliers: required TP1 < TP2 < TP3")
if slMultInput <= 0
    runtime.error("SL Multiplier must be greater than 0")
if maxSTInput == 0 and requireSTInput
    runtime.error("Max ST = 0 with 'Spring Needs A Prior ST' makes springs impossible: set Max ST ≥ 1 or disable Require ST")
if beInput and beOffsetInput > 0 and beOffsetInput >= tp1MultInput
    runtime.error("BE Offset too large: breakeven level would be at or beyond TP1")
if testZoneInput < stZoneInput
    runtime.error("Test Zone must be ≥ ST Zone")
if maxHeightAtrInput <= minHeightAtrInput
    runtime.error("Max Range Height must be greater than Min Range Height")
 
// ══════════════════════════════════════
// THEME DETECTION & COLORS
// ══════════════════════════════════════
isDark = switch themeInput
    "Dark"  => true
    "Light" => false
    =>         color.r(chart.bg_color) < 128
 
// ── Texts ──
TEXT_COLOR  = isDark ? #E0E0E0 : #1A1A1A
TEXT_MUTED  = isDark ? color.new(#9E9E9E, 0) : color.new(#757575, 0)
TEXT_BRIGHT = isDark ? #FFFFFF : #000000
 
// ── Signal colors for text (on chart/table background) ──
BULL_TEXT    = isDark ? #00E676 : #00A152
BEAR_TEXT    = isDark ? #FF5252 : #D32F2F
NEUTRAL_TEXT = isDark ? #FFEB3B : #F57F17
 
// ── Labels ──
BULL_LABEL_TEXT = #004D25
BEAR_LABEL_TEXT = #FFFFFF
LABEL_TEXT      = isDark ? #1A1A1A : #FFFFFF
EVENT_LABEL_TEXT = #0B0B0B
 
// ── Dashboard ──
TABLE_BG      = isDark ? color.new(#131722, 5) : color.new(#FFFFFF, 5)
TABLE_BORDER  = isDark ? color.new(#2A2E39, 0) : color.new(#D0D0D0, 0)
TABLE_ROW_ALT = isDark ? color.new(#1C2030, 0) : color.new(#F0F4F8, 0)
HEADER_TEXT   = #FFFFFF
HEADER_BG_BULL = color.new(#0F6E56, 0)
HEADER_BG_BEAR = color.new(#A32D2D, 0)
HEADER_BG_NEUTRAL = isDark ? color.new(#0D47A1, 0) : color.new(#1565C0, 0)
 
// ── Lines ──
LINE_SUBTLE = isDark ? color.new(#666666, 0) : color.new(#999999, 0)
GRAY_RANGE  = isDark ? color.new(#7F8C8D, 0) : color.new(#9AA3A8, 0)
WM_COLOR    = isDark ? color.new(#FFFFFF, 80) : color.new(#000000, 80)
TRANSP_COLOR = color.new(#000000, 100)
SWING_DOT   = isDark ? color.new(#B0BEC5, 40) : color.new(#546E7A, 40)
LABEL_PLATE = isDark ? color.new(#131722, 15) : color.new(#FFFFFF, 10)   // backdrop plate under schematic text
int FILL_TRANSP = isDark ? 88 : 82
 
// ── Risk palette (muted, theme-aware) ──
SL_COLOR       = isDark ? color.new(#E57373, 0)  : color.new(#B71C1C, 0)
TP1_COLOR      = isDark ? color.new(#66BB6A, 30) : color.new(#388E3C, 30)
TP2_COLOR      = isDark ? color.new(#66BB6A, 40) : color.new(#388E3C, 40)
TP3_COLOR      = isDark ? color.new(#66BB6A, 0)  : color.new(#388E3C, 0)
ENTRY_COLOR    = isDark ? color.new(#5C8AAE, 0)  : color.new(#34495E, 0)
TP_LABEL_COLOR = isDark ? color.new(#66BB6A, 0)  : color.new(#388E3C, 0)
TP_HIT_COLOR   = isDark ? color.new(#4DB6AC, 0)  : color.new(#00695C, 0)
BE_COLOR       = isDark ? color.new(#FFA726, 0)  : color.new(#E65100, 0)
// LABEL_TEXT (above) = text on filled Entry / SL / TP labels
 
// ══════════════════════════════════════
// TYPES
// ══════════════════════════════════════
// A confirmed swing point together with the statistics of the leg that ENDS at it.
type Swing
    int   kind      // +1 swing high, -1 swing low
    float price
    int   bar
    float legEff    // mean bar effort ratio over the leg
    float legPeak   // max bar effort ratio in the leg
    float legAtr    // leg length in ATR units
    int   legBars
    int   confBar   // bar on which the swing was confirmed
 
// An accumulation (side = +1) or distribution (side = -1) range.
// Normalized coordinate u: 0 = climax edge, 1 = reaction edge.
type Rng
    int   id
    int   side
    float top
    float bot
    int   climaxBar
    int   reactBar
    int   stage          // 1..5 = A..E
    float climEff
    float climPeak
    int   climScore
    int   nTests
    int   utCount
    bool  sprung
    bool  springCounted
    bool  tested
    bool  brokeOut
    bool  lpsSeen
    bool  pendBreak      // climax-side swing beyond the edge, waiting for reclaim
    int   pendBar
    float pendPrice
    float pendEff
    int   pendConfBar
    float springPrice
    int   springBar
    float springEff
    int   springScore
    int   breakBar
    int   sosScore
    float sosEff
    float target
    line  edgeClim       // outer line on the climax side (SC low / BC high)
    line  innerClim      // inner line on the climax side (first ST)
    line  edgeReact      // outer line on the reaction side (AR, extended by AR+)
    line  innerReact     // inner line on the reaction side (previous AR level after an extension)
    label tagClim        // 'Support Lines' / 'Resistance Lines' tag at the climax edge
    label tagReact       // tag at the reaction edge
    label stageLbl       // range title
    label curPhaseTag    // caption of the running phase
    int   lastDivBar     // x of the last phase divider (climax bar before the first one)
    array<line>  dividers
    array<label> phaseTags
    line  tgtLn
    label tgtTag
    array<label> marks
 
// ══════════════════════════════════════
// FUNCTIONS
// ══════════════════════════════════════
safeDiv(float num, float den, float fallback = 0.0) =>
    den != 0 and not na(num) and not na(den) ? num / den : fallback
 
fmtPrice(float v) =>
    na(v) ? "—" : str.tostring(v, format.mintick)
 
fmtScore(float v) =>
    na(v) ? "—" : str.tostring(math.round(v))
 
formatPctFromEntry(float level, float entry) =>
    string res = ""
    if showPctOnLabelsInput and not na(level) and not na(entry) and entry != 0
        float pct   = (level - entry) / entry * 100.0
        string sign = pct >= 0 ? "+" : ""
        res := " (" + sign + str.tostring(pct, "#.##") + "%)"
    res
 
sizeFromString(string s) =>
    s == "Tiny" ? size.tiny : s == "Small" ? size.small : s == "Normal" ? size.normal : s == "Large" ? size.large : s == "Huge" ? size.huge : size.small
 
sizeDownFromString(string s) =>
    s == "Tiny" ? size.tiny : s == "Small" ? size.tiny : s == "Normal" ? size.small : s == "Large" ? size.normal : s == "Huge" ? size.large : size.tiny
 
lineStyleFromString(string s) =>
    s == "Dashed" ? line.style_dashed : s == "Dotted" ? line.style_dotted : line.style_solid
 
clamp01(float x) =>
    math.max(0.0, math.min(1.0, x))
 
buildGauge(float value, float maxVal, int width) =>
    string result = ""
    int filled = maxVal <= 0 ? 0 : math.round(math.min(width, math.max(0.0, value / maxVal * width)))
    for i = 0 to width - 1
        result += i < filled ? "▰" : "▱"
    result
 
periodStats(array<int> tms, array<bool> wns, int cutoff) =>
    int w = 0
    int l = 0
    int n = array.size(tms)
    if n > 0
        for i = 0 to n - 1
            if array.get(tms, i) >= cutoff
                if array.get(wns, i)
                    w += 1
                else
                    l += 1
    [w, l]
 
phaseTxt(int p) =>
    p == 1 ? "A" : p == 2 ? "B" : p == 3 ? "C" : p == 4 ? "D" : p == 5 ? "E" : "—"
 
chk(bool b) =>
    b ? "✓" : "–"
 
// text color readable on the chart background: as is on dark charts, darkened on light ones
inkOf(color c) =>
    isDark ? c : color.rgb(color.r(c) * 0.55, color.g(c) * 0.55, color.b(c) * 0.55, color.t(c))
 
// schematic text (events, phase captions): plain text, or text on a plate in the chart background color
schemLabel(int x, float y, string txt, color c, string sz, string tip = "") =>
    label.new(x, y, txt, xloc = xloc.bar_index, style = eventBackdropInput ? label.style_label_center : label.style_none, color = eventBackdropInput ? LABEL_PLATE : TRANSP_COLOR, textcolor = inkOf(c), size = sz, text_font_family = font.family_monospace, tooltip = tip)
 
// u-space helpers
uOf(Rng r, float p) =>
    float h = r.top - r.bot
    h > 0 ? (r.side == 1 ? (p - r.bot) / h : (r.top - p) / h) : 0.5
 
pOf(Rng r, float u) =>
    float h = r.top - r.bot
    r.side == 1 ? r.bot + u * h : r.top - u * h
 
nmOf(Rng r, string a, string d) =>
    r.side == 1 ? a : d
 
dashPos = switch dashPosStrInput
    "Top Left"     => position.top_left
    "Top Right"    => position.top_right
    "Bottom Left"  => position.bottom_left
    "Bottom Right" => position.bottom_right
    "Middle Right" => position.middle_right
    => position.top_right
 
signalSize   = sizeFromString(signalFontSizeInput)
labelSize    = sizeFromString(labelFontSizeInput)
eventSize    = sizeFromString(eventFontSizeInput)
eventSizeSub = sizeDownFromString(eventFontSizeInput)
dashFontSize = sizeFromString(dashFontSizeInput)
dashFontSizeSub = sizeDownFromString(dashFontSizeInput)
 
// ══════════════════════════════════════
// CALCULATIONS (na-protected)
// ══════════════════════════════════════
int WARMUP_BARS = math.max(math.max(effBaseLenInput, atrLenInput), 50)
bool isWarmedUp = bar_index >= WARMUP_BARS
bool confirmed  = barstate.isconfirmed
 
float atr     = nz(ta.atr(atrLenInput), 0.0)
float riskAtr = nz(ta.atr(atrLenRiskInput), 0.0)
float rsiValue = nz(ta.rsi(close, RSI_LEN), 50.0)
 
// effort source chosen once per symbol; bar effort ratio = effort / baseline
var bool useVol = false
if barstate.isfirst
    useVol := effModeInput == "Volume" ? true : effModeInput == "Bar Range" ? false : not na(volume)
float effRaw   = useVol ? nz(volume, 0.0) : high - low
float effBase  = nz(ta.sma(effRaw, effBaseLenInput), effRaw)
float effRatio = effBase > 0 ? effRaw / effBase : 1.0
 
// per-bar effort buffer (for leg statistics)
var array<float> effBuf = array.new<float>()
if confirmed
    array.push(effBuf, effRatio)
    if array.size(effBuf) > EFF_BUF_MAX
        array.shift(effBuf)
 
// statistics of the leg covering bars (startBar, endBar]
legStats(int startBar, int endBar) =>
    float s  = 0.0
    float pk = 0.0
    int   n  = 0
    int   sz = array.size(effBuf)
    if endBar > startBar
        for k = startBar + 1 to endBar
            int idx = sz - 1 - (bar_index - k)
            if idx >= 0 and idx < sz
                float v = array.get(effBuf, idx)
                s  += v
                pk := math.max(pk, v)
                n  += 1
    [n > 0 ? s / n : 1.0, pk, n]
 
float barRng = high - low
float cpos   = barRng > 0 ? (close - low) / barRng : 0.5
 
// ══════════════════════════════════════
// SWING ENGINE — ATR-reversal swing stream
// ══════════════════════════════════════
var array<Swing> swings = array.new<Swing>()
var int   legDir        = 0      // +1 up-leg in progress (candidate swing high), -1 down-leg
var float extPrice      = na
var int   extBar        = na
var int   legStartBar   = na
var float legStartPrice = na
 
int   nSince       = math.max(1, bar_index - nz(extBar, bar_index))
float lowSinceExt  = ta.lowest(low, nSince)
int   lowSinceOff  = ta.lowestbars(low, nSince)
float highSinceExt = ta.highest(high, nSince)
int   highSinceOff = ta.highestbars(high, nSince)
 
bool  newSwing = false
Swing sw = na
 
if confirmed and isWarmedUp
    if legDir == 0
        legDir        := 1
        legStartBar   := bar_index
        legStartPrice := low
        extPrice      := high
        extBar        := bar_index
    else if legDir == 1
        if high > extPrice
            extPrice := high
            extBar   := bar_index
        if close < extPrice - swingRevInput * atr
            [le, lp, ln] = legStats(legStartBar, extBar)
            sw := Swing.new(1, extPrice, extBar, le, lp, safeDiv(extPrice - legStartPrice, atr, 0.0), ln, bar_index)
            newSwing := true
            legDir        := -1
            legStartBar   := extBar
            legStartPrice := extPrice
            if extBar == bar_index
                extPrice := low
                extBar   := bar_index
            else
                extPrice := lowSinceExt
                extBar   := bar_index + lowSinceOff
    else
        if low < extPrice
            extPrice := low
            extBar   := bar_index
        if close > extPrice + swingRevInput * atr
            [le, lp, ln] = legStats(legStartBar, extBar)
            sw := Swing.new(-1, extPrice, extBar, le, lp, safeDiv(legStartPrice - extPrice, atr, 0.0), ln, bar_index)
            newSwing := true
            legDir        := 1
            legStartBar   := extBar
            legStartPrice := extPrice
            if extBar == bar_index
                extPrice := high
                extBar   := bar_index
            else
                extPrice := highSinceExt
                extBar   := bar_index + highSinceOff
    if newSwing
        array.push(swings, sw)
        if array.size(swings) > MAX_SWINGS
            array.shift(swings)
        if showSwingsInput
            label.new(sw.bar, sw.price, "", xloc = xloc.bar_index, style = label.style_circle, color = SWING_DOT, size = size.tiny)
 
// Climactic run ending at the newest swing (kind = -1 for a selling climax, +1 for a buying climax):
// walk back while the opposite-kind swings keep falling (rising) and the same-kind swings stay above (below)
// the candidate. Returns [runStartBar, runStartPrice, sameKindSwingsInsideRun].
runOf(int kind, float candPx) =>
    int   n        = array.size(swings)
    int   startBar = na
    float startPx  = na
    int   cnt      = 0
    if n >= 2
        int   i = n - 2
        Swing s = array.get(swings, i)
        startBar := s.bar
        startPx  := s.price
        bool go = true
        while go and i - 2 >= 0
            Swing prevOpp  = array.get(swings, i - 2)
            Swing between  = array.get(swings, i - 1)
            bool oppOk     = kind == -1 ? prevOpp.price > s.price : prevOpp.price < s.price
            bool betweenOk = kind == -1 ? between.price > candPx : between.price < candPx
            if oppOk and betweenOk
                i -= 2
                s := prevOpp
                startBar := s.bar
                startPx  := s.price
                cnt += 1
            else
                go := false
    [startBar, startPx, cnt]
 
// ══════════════════════════════════════
// RANGE ENGINE — climax candidate → range → events (u-space)
// ══════════════════════════════════════
var Rng cur = na
var array<Rng> hist = array.new<Rng>()
var int rangeSeq = 0
 
// climax candidate (awaiting AR)
var int   candDir   = 0
var float candPrice = na
var int   candBar   = na
var float candEff   = na
var float candPeak  = na
var float candLegPx = na      // climactic leg in price
var int   candScore = 0
var label candLbl   = na
 
// counters
var int accTotal = 0
var int distTotal = 0
var int accOk = 0
var int accBad = 0
var int distOk = 0
var int distBad = 0
var int springRanges = 0
var int sprungBroke = 0
var int utadRanges = 0
var int utadBroke = 0
var int tgtHit = 0
var int tgtMiss = 0
var int tgtExp = 0
var int tgtPre = 0
var array<int>   oId  = array.new<int>()
var array<int>   oDir = array.new<int>()
var array<float> oTgt = array.new<float>()
var array<float> oInv = array.new<float>()
var array<int>   oBar = array.new<int>()
 
// per-bar events
bool evClimax = false
bool evAR     = false
bool evST     = false
bool evTEST   = false
bool evSpring = false
bool evUtad   = false
bool evSos    = false
bool evSow    = false
bool evLps    = false
bool evLpsy   = false
bool evFailed = false
bool sigDetect = false
string eventMsg = ""
float  eventLevel = na
int    entryScoreEv = 0
string entryInfoEv = ""      // event behind the entry, for the entry tooltip
 
// current leg (towards the reaction side) statistics — for SOS/SOW quality
float legEffNow  = 1.0
float legPeakNow = 0.0
float legAtrNow  = 0.0
 
// Event text beyond the swing (below lows for accumulation's climax side, above highs for its reaction side;
// mirrored for distribution). Details go to the tooltip.
evLabel(Rng r, int x, float y, string txt, bool atClimaxSide, color c, string sz, string tip = "") =>
    bool  below = (r.side == 1) == atClimaxSide
    float yy    = below ? y - EVENT_OFFSET_ATR * atr : y + EVENT_OFFSET_ATR * atr
    if showEventsInput
        label mk = schemLabel(x, yy, txt, c, sz, tip)
        array.push(r.marks, mk)
    showEventsInput
 
climEdge(Rng r) =>
    r.side == 1 ? r.bot : r.top
 
reactEdge(Rng r) =>
    r.side == 1 ? r.top : r.bot
 
// outer lines and tags follow the current edges
redrawRange(Rng r) =>
    line.set_y1(r.edgeClim, climEdge(r))
    line.set_y2(r.edgeClim, climEdge(r))
    line.set_y1(r.edgeReact, reactEdge(r))
    line.set_y2(r.edgeReact, reactEdge(r))
    label.set_y(r.tagClim, climEdge(r))
    label.set_y(r.tagReact, reactEdge(r))
    label.set_y(r.stageLbl, reactEdge(r))
    true
 
// vertical dashed divider at x closing the phase `ended`, with its caption centered on the closed phase
addDivider(Rng r, int x, int ended, color c) =>
    float h   = math.max(r.top - r.bot, syminfo.mintick)
    float yTop = r.top + DIVIDER_PAD_FRAC * h
    float yBot = r.bot - (PHASE_TAG_FRAC + DIVIDER_PAD_FRAC) * h
    if showPhasesInput and x > r.lastDivBar
        array.push(r.dividers, line.new(x, yTop, x, yBot, xloc = xloc.bar_index, color = color.new(inkOf(c), 15), style = line.style_dashed, width = 1))
        if x - r.lastDivBar >= MIN_PHASE_BARS
            int mid = math.round((r.lastDivBar + x) / 2.0)
            array.push(r.phaseTags, schemLabel(mid, r.bot - PHASE_TAG_FRAC * h, "Phase " + phaseTxt(ended), c, eventSize))
        r.lastDivBar := x
    true
 
removeOutcome(int id) =>
    n = 0
    if array.size(oId) > 0
        for i = array.size(oId) - 1 to 0
            if array.get(oId, i) == id
                n += 1
                array.remove(oId, i)
                array.remove(oDir, i)
                array.remove(oTgt, i)
                array.remove(oInv, i)
                array.remove(oBar, i)
    n
 
// finalization flags for this bar
bool   closeRange = false
bool   failedRange = false
string closeTag    = ""
 
// ── A) bar-level checks on the active range ──
if confirmed and not na(cur)
    float h    = math.max(cur.top - cur.bot, syminfo.mintick)
    float uC   = uOf(cur, close)
    color rngCol = cur.side == 1 ? bullColorInput : bearColorInput
 
    // 1) expiry (before events)
    if not cur.brokeOut and bar_index - cur.climaxBar > maxRangeBarsInput
        closeRange := true
        failedRange := true
        closeTag := "TIMED OUT"
 
    // 2) decisive break beyond the climax edge
    if not closeRange and not cur.brokeOut and uC < -failDistAtrInput * atr / h
        evLabel(cur, bar_index, cur.side == 1 ? low : high, nmOf(cur, "BREAKDOWN", "BREAKOUT"), true, failColorInput, eventSize, "Decisive close beyond the climax edge: range failed")
        if cur.side == 1
            accBad += 1
        else
            distBad += 1
        evFailed := true
        eventMsg += nmOf(cur, "Accumulation", "Distribution") + " range FAILED (decisive break) | "
        closeRange := true
        failedRange := true
        closeTag := "BROKEN"
 
    // 3) pending spring: reclaim or timeout
    if not closeRange and cur.pendBreak
        if uC >= 0
            cur.pendBreak := false
            if requireSTInput and cur.nTests == 0
                if na(cur.innerClim)
                    cur.innerClim := line.new(cur.climaxBar, climEdge(cur), bar_index, climEdge(cur), xloc = xloc.bar_index, color = color.new(inkOf(rngCol), 35), width = 1)
                if cur.side == 1
                    cur.bot := cur.pendPrice
                else
                    cur.top := cur.pendPrice
                redrawRange(cur)
                evLabel(cur, cur.pendBar, cur.pendPrice, "ext", true, climColorInput, eventSizeSub, "Climax extreme extended before the first ST")
            else
                cur.sprung  := true
                cur.tested    := false
                cur.springPrice := cur.pendPrice
                cur.springBar   := cur.pendBar
                cur.springEff   := cur.pendEff
                cur.stage       := 3
                float depthAtr = safeDiv(cur.side == 1 ? cur.bot - cur.pendPrice : cur.pendPrice - cur.top, atr, 0.0)
                float depthC = clamp01(1.0 - depthAtr / 1.5)
                float effC   = clamp01(1.0 - safeDiv(cur.pendEff, cur.climEff, 1.0))
                float speedC = clamp01(1.0 - (bar_index - cur.pendConfBar) / 10.0)
                cur.springScore := math.round(40.0 * depthC + 40.0 * effC + 20.0 * speedC)
                string effNote = cur.pendEff < 1.0 ? nmOf(cur, "no supply", "no demand") : "shake-out"
                string sprDet = str.tostring(cur.springScore) + "/100 · " + effNote + " · " + str.tostring(depthAtr, "#.##") + " ATR"
                evLabel(cur, cur.pendBar, cur.pendPrice, nmOf(cur, "Spring", "UTAD") + (detailLblInput ? "\n" + sprDet : ""), true, sigColorInput, eventSize, nmOf(cur, "Spring", "Upthrust After Distribution") + "\n" + sprDet)
                addDivider(cur, cur.pendBar, 2, rngCol)
                sigDetect := true
                eventLevel := cur.pendPrice
                entryScoreEv := cur.springScore
                entryInfoEv := nmOf(cur, "Spring", "UTAD") + " @ " + fmtPrice(cur.pendPrice) + " (" + effNote + ")"
                if cur.side == 1
                    evSpring := true
                    if not cur.springCounted
                        springRanges += 1
                        cur.springCounted := true
                else
                    evUtad := true
                    if not cur.springCounted
                        utadRanges += 1
                        cur.springCounted := true
                eventMsg += nmOf(cur, "SPRING", "UTAD") + " " + str.tostring(cur.springScore) + "/100 (" + effNote + ") at " + fmtPrice(cur.pendPrice) + " | "
        else if bar_index - cur.pendConfBar > reclaimBarsInput
            evLabel(cur, bar_index, cur.side == 1 ? low : high, nmOf(cur, "BREAKDOWN", "BREAKOUT"), true, failColorInput, eventSize, "No reclaim within the deadline: range failed")
            if cur.side == 1
                accBad += 1
            else
                distBad += 1
            evFailed := true
            eventMsg += nmOf(cur, "Accumulation", "Distribution") + " range FAILED (no reclaim) | "
            cur.pendBreak := false
            closeRange := true
            failedRange := true
            closeTag := "BROKEN"
 
    // 4) SOS failure: back below the midline before LPS
    if not closeRange and cur.brokeOut and not cur.lpsSeen and bar_index > cur.breakBar and uC < 0.5
        evLabel(cur, bar_index, cur.side == 1 ? low : high, nmOf(cur, "SOS lost", "SOW lost"), true, failColorInput, eventSize, "Close back below the midline before LPS: breakout failed")
        if cur.side == 1
            accBad += 1
        else
            distBad += 1
        tgtMiss += removeOutcome(cur.id)
        evFailed := true
        eventMsg += nmOf(cur, "SOS", "SOW") + " FAILED — back below midline | "
        closeRange := true
        failedRange := true
        closeTag := "BREAKOUT LOST"
 
    // 5) SOS / SOW: breakout close with a quality leg (leg runs from the last climax-side swing)
    if not closeRange and not cur.brokeOut and not cur.pendBreak and legDir == cur.side and (cur.nTests > 0 or cur.sprung)
        [le, lp, ln] = legStats(legStartBar, bar_index)
        legEffNow  := le
        legPeakNow := lp
        legAtrNow  := safeDiv(math.abs(close - legStartPrice), atr, 0.0)
        bool effOk  = legEffNow >= sosEffInput
        bool lenOk  = legAtrNow >= sosLegAtrInput
        bool qualOk = sosLogicInput == "Effort AND leg length" ? (effOk and lenOk) : (effOk or lenOk)
        if uC > 1.0 + sosBufAtrInput * atr / h and qualOk
            float tCpos = cur.side == 1 ? cpos : 1.0 - cpos
            cur.sosScore := math.round(clamp01((legEffNow - 1.0) / 1.5) * 40.0 + clamp01(legAtrNow / 3.0) * 30.0 + tCpos * 30.0)
            cur.brokeOut := true
            cur.breakBar  := bar_index
            cur.sosEff  := legEffNow
            cur.stage   := 4
            string sosDet = str.tostring(cur.sosScore) + "/100 · leg eff ×" + str.tostring(legEffNow, "#.#") + " · " + str.tostring(legAtrNow, "#.#") + " ATR"
            evLabel(cur, bar_index, cur.side == 1 ? high : low, nmOf(cur, "SOS", "SOW") + (detailLblInput ? "\n" + sosDet : ""), false, rngCol, eventSize, nmOf(cur, "Sign of Strength", "Sign of Weakness") + "\n" + sosDet)
            addDivider(cur, bar_index, cur.sprung ? 3 : 2, rngCol)
            sigDetect := true
            eventLevel := cur.side == 1 ? cur.top : cur.bot
            entryScoreEv := cur.sosScore
            entryInfoEv := nmOf(cur, "SOS", "SOW") + " @ " + fmtPrice(close) + " · leg eff ×" + str.tostring(legEffNow, "#.#")
            if cur.side == 1
                evSos := true
            else
                evSow := true
            if cur.sprung
                if cur.side == 1
                    sprungBroke += 1
                else
                    utadBroke += 1
            cur.target := pOf(cur, 1.0 + projMultInput)
            if showTargetInput
                cur.tgtLn    := line.new(bar_index, cur.target, bar_index + projBarsInput, cur.target, xloc = xloc.bar_index, color = inkOf(rngCol), style = line.style_dashed, width = 2)
                cur.tgtTag := label.new(bar_index + projBarsInput, cur.target, "Target " + fmtPrice(cur.target), xloc = xloc.bar_index, style = label.style_label_left, color = eventBackdropInput ? LABEL_PLATE : TRANSP_COLOR, textcolor = inkOf(rngCol), size = eventSize, text_font_family = font.family_monospace)
            if math.abs(cur.target - close) >= tgtMarginAtrInput * atr
                array.push(oId, cur.id)
                array.push(oDir, cur.side)
                array.push(oTgt, cur.target)
                array.push(oInv, pOf(cur, 0.5))
                array.push(oBar, bar_index)
            else
                tgtPre += 1
            eventMsg += nmOf(cur, "SOS", "SOW") + " " + str.tostring(cur.sosScore) + "/100 at " + fmtPrice(close) + " → target " + fmtPrice(cur.target) + " | "
 
    // 6) LPS timeout
    if not closeRange and cur.brokeOut and not cur.lpsSeen and bar_index - cur.breakBar > lpsMaxBarsInput
        if cur.side == 1
            accOk += 1
        else
            distOk += 1
        closeRange := true
        closeTag := nmOf(cur, "MARKUP · no LPS", "MARKDOWN · no LPSY")
 
// ── B) swing-level classification ──
if confirmed and newSwing
    if na(cur)
        // B1) climax candidate: reaction-side swing = AR test, climax-side swing = possible extension
        if candDir != 0
            bool reactionKind = (candDir == 1 and sw.kind == 1) or (candDir == -1 and sw.kind == -1)
            if reactionKind
                float heightPx = candDir == 1 ? sw.price - candPrice : candPrice - sw.price
                float retrace  = safeDiv(heightPx, candLegPx, 0.0)
                if heightPx >= minHeightAtrInput * atr and retrace >= arRetraceInput
                    rangeSeq += 1
                    color rngCol = candDir == 1 ? bullColorInput : bearColorInput
                    float top  = candDir == 1 ? sw.price : candPrice
                    float bot  = candDir == 1 ? candPrice : sw.price
                    color lineCol = showRangesInput ? inkOf(rngCol) : color.new(rngCol, 100)
                    color tagCol  = showRangesInput ? TEXT_MUTED : color.new(TEXT_MUTED, 100)
                    float climPx  = candDir == 1 ? bot : top
                    float reactPx = candDir == 1 ? top : bot
                    line  lC  = line.new(candBar, climPx, bar_index, climPx, xloc = xloc.bar_index, color = lineCol, width = 2)
                    line  lR  = line.new(candBar, reactPx, bar_index, reactPx, xloc = xloc.bar_index, color = lineCol, width = 2)
                    color plate   = eventBackdropInput and showRangesInput ? LABEL_PLATE : TRANSP_COLOR
                    label tC  = label.new(bar_index + TAG_OFFSET_BARS, climPx, candDir == 1 ? "Support Lines" : "Resistance Lines", xloc = xloc.bar_index, style = label.style_label_left, color = plate, textcolor = tagCol, size = eventSizeSub, text_font_family = font.family_monospace)
                    label tR  = label.new(bar_index + TAG_OFFSET_BARS, reactPx, candDir == 1 ? "Resistance Lines" : "Support Lines", xloc = xloc.bar_index, style = label.style_label_left, color = plate, textcolor = tagCol, size = eventSizeSub, text_font_family = font.family_monospace)
                    label phl = label.new(candBar, reactPx, "", xloc = xloc.bar_index, color = plate, style = candDir == 1 ? label.style_label_upper_left : label.style_label_lower_left, textcolor = showRangesInput ? inkOf(rngCol) : color.new(rngCol, 100), size = eventSize, text_font_family = font.family_monospace)
                    label cpt = label.new(bar_index, bot, "", xloc = xloc.bar_index, style = eventBackdropInput ? label.style_label_center : label.style_none, color = TRANSP_COLOR, textcolor = showPhasesInput ? inkOf(rngCol) : color.new(rngCol, 100), size = eventSize, text_font_family = font.family_monospace)
                    cur := Rng.new(id = rangeSeq, side = candDir, top = top, bot = bot, climaxBar = candBar, reactBar = sw.bar, stage = 1, climEff = candEff, climPeak = candPeak, climScore = candScore, nTests = 0, utCount = 0, sprung = false, springCounted = false, tested = false, brokeOut = false, lpsSeen = false, pendBreak = false, pendBar = 0, pendConfBar = 0, springBar = 0, springScore = 0, breakBar = 0, sosScore = 0, edgeClim = lC, edgeReact = lR, tagClim = tC, tagReact = tR, stageLbl = phl, curPhaseTag = cpt, lastDivBar = candBar, dividers = array.new<line>(), phaseTags = array.new<label>(), marks = array.new<label>())
                    if not na(candLbl)
                        array.push(cur.marks, candLbl)
                    candLbl := na
                    string arDet = str.tostring(retrace * 100, "#") + "% retrace of the climactic run"
                    evLabel(cur, sw.bar, sw.price, "AR" + (detailLblInput ? "\n" + arDet : ""), false, rngCol, eventSize, (candDir == 1 ? "Automatic Rally" : "Automatic Reaction") + "\n" + arDet)
                    sigDetect := true
                    evAR := true
                    if candDir == 1
                        accTotal += 1
                    else
                        distTotal += 1
                    eventMsg += (candDir == 1 ? "ACCUMULATION" : "DISTRIBUTION") + " range confirmed (AR) " + fmtPrice(bot) + " – " + fmtPrice(top) + " | "
                    candDir := 0
            else
                bool deeper = candDir == 1 ? sw.price < candPrice : sw.price > candPrice
                if deeper
                    candLegPx += math.abs(sw.price - candPrice)
                    candPrice := sw.price
                    candBar   := sw.bar
                    if not na(candLbl)
                        label.set_xy(candLbl, sw.bar, candDir == 1 ? sw.price - EVENT_OFFSET_ATR * atr : sw.price + EVENT_OFFSET_ATR * atr)
        // B2) climax test on this swing: score the whole climactic run that ends here
        if candDir == 0 and na(cur)
            [runStartBar, runStartPx, runLows] = runOf(sw.kind, sw.price)
            bool  trendOk = runLows >= trendSwingsInput
            float runPx   = na(runStartPx) ? 0.0 : math.abs(runStartPx - sw.price)
            float runAtr  = safeDiv(runPx, atr, 0.0)
            int   runBars = na(runStartBar) ? 0 : sw.bar - runStartBar
            [runEff, runPeak, runN] = legStats(nz(runStartBar, sw.bar), sw.bar)
            float effC  = clamp01(runEff - 1.0)
            float peakC = clamp01((runPeak - 1.0) / 3.0)
            float extC  = clamp01((runAtr - 2.0) / 6.0)
            float velC  = clamp01(safeDiv(runAtr, math.max(runBars, 1), 0.0) / 0.5)
            int   score = math.round(30.0 * effC + 30.0 * peakC + 20.0 * extC + 20.0 * velC)
            if trendOk and runPeak >= climaxPeakInput and score >= climaxScoreInput
                candDir   := sw.kind == -1 ? 1 : -1
                candPrice := sw.price
                candBar   := sw.bar
                candEff   := runEff
                candPeak  := runPeak
                candLegPx := runPx
                candScore := score
                if showEventsInput
                    string scDet = str.tostring(score) + "/100 · peak ×" + str.tostring(runPeak, "#.#") + " · run " + str.tostring(runAtr, "#.#") + " ATR"
                    float  scY   = candDir == 1 ? sw.price - EVENT_OFFSET_ATR * atr : sw.price + EVENT_OFFSET_ATR * atr
                    candLbl := schemLabel(sw.bar, scY, (candDir == 1 ? "SC" : "BC") + (detailLblInput ? "\n" + scDet : ""), climColorInput, eventSize, (candDir == 1 ? "Selling Climax" : "Buying Climax") + "\n" + scDet)
                sigDetect := true
                evClimax := true
                eventMsg += (candDir == 1 ? "Selling Climax (SC)" : "Buying Climax (BC)") + " " + str.tostring(score) + "/100 | "
    else if not closeRange
        float u    = uOf(cur, sw.price)
        float uC   = uOf(cur, close)
        color rngCol = cur.side == 1 ? bullColorInput : bearColorInput
        bool climaxSide = (cur.side == 1 and sw.kind == -1) or (cur.side == -1 and sw.kind == 1)
        if climaxSide
            if u < 0 and not cur.brokeOut
                // beyond the climax edge: extension, spring, or pending reclaim
                if uC >= 0
                    if requireSTInput and cur.nTests == 0
                        if na(cur.innerClim)
                            cur.innerClim := line.new(cur.climaxBar, climEdge(cur), bar_index, climEdge(cur), xloc = xloc.bar_index, color = color.new(inkOf(rngCol), 35), width = 1)
                        if cur.side == 1
                            cur.bot := sw.price
                        else
                            cur.top := sw.price
                        redrawRange(cur)
                        evLabel(cur, sw.bar, sw.price, "ext", true, climColorInput, eventSizeSub, "Climax extreme extended before the first ST")
                    else
                        cur.sprung  := true
                        cur.tested    := false
                        cur.springPrice := sw.price
                        cur.springBar   := sw.bar
                        cur.springEff   := sw.legEff
                        cur.stage       := 3
                        float depthAtr = safeDiv(cur.side == 1 ? cur.bot - sw.price : sw.price - cur.top, atr, 0.0)
                        float depthC = clamp01(1.0 - depthAtr / 1.5)
                        float effC   = clamp01(1.0 - safeDiv(sw.legEff, cur.climEff, 1.0))
                        float speedC = clamp01(1.0 - (bar_index - sw.bar) / 10.0)
                        cur.springScore := math.round(40.0 * depthC + 40.0 * effC + 20.0 * speedC)
                        string effNote = sw.legEff < 1.0 ? nmOf(cur, "no supply", "no demand") : "shake-out"
                        string sprDet = str.tostring(cur.springScore) + "/100 · " + effNote + " · " + str.tostring(depthAtr, "#.##") + " ATR"
                        evLabel(cur, sw.bar, sw.price, nmOf(cur, "Spring", "UTAD") + (detailLblInput ? "\n" + sprDet : ""), true, sigColorInput, eventSize, nmOf(cur, "Spring", "Upthrust After Distribution") + "\n" + sprDet)
                        addDivider(cur, sw.bar, 2, rngCol)
                        sigDetect := true
                        eventLevel := sw.price
                        entryScoreEv := cur.springScore
                        entryInfoEv := nmOf(cur, "Spring", "UTAD") + " @ " + fmtPrice(sw.price) + " (" + effNote + ")"
                        if cur.side == 1
                            evSpring := true
                            if not cur.springCounted
                                springRanges += 1
                                cur.springCounted := true
                        else
                            evUtad := true
                            if not cur.springCounted
                                utadRanges += 1
                                cur.springCounted := true
                        eventMsg += nmOf(cur, "SPRING", "UTAD") + " " + str.tostring(cur.springScore) + "/100 (" + effNote + ") at " + fmtPrice(sw.price) + " | "
                else
                    cur.pendBreak   := true
                    cur.pendBar     := sw.bar
                    cur.pendPrice   := sw.price
                    cur.pendEff     := sw.legEff
                    cur.pendConfBar := bar_index
            else if cur.brokeOut
                if not cur.lpsSeen and sw.bar > cur.breakBar and u >= lpsFloorInput
                    cur.lpsSeen := true
                    cur.stage   := 5
                    string lpsDet = "u " + str.tostring(u, "#.##") + " · eff ×" + str.tostring(sw.legEff, "#.#")
                    evLabel(cur, sw.bar, sw.price, nmOf(cur, "LPS", "LPSY") + (detailLblInput ? "\n" + lpsDet : ""), true, rngCol, eventSize, nmOf(cur, "Last Point of Support", "Last Point of Supply") + "\n" + lpsDet)
                    addDivider(cur, sw.bar, 4, rngCol)
                    sigDetect := true
                    eventLevel := sw.price
                    entryScoreEv := math.max(cur.sosScore, cur.springScore)
                    entryInfoEv := nmOf(cur, "LPS", "LPSY") + " @ " + fmtPrice(sw.price) + " · u " + str.tostring(u, "#.##")
                    if cur.side == 1
                        evLps := true
                        accOk += 1
                    else
                        evLpsy := true
                        distOk += 1
                    eventMsg += nmOf(cur, "LPS", "LPSY") + " locked in at " + fmtPrice(sw.price) + " | "
                    closeRange := true
                    closeTag := nmOf(cur, "MARKUP", "MARKDOWN")
            else if cur.sprung
                float uSpring = uOf(cur, cur.springPrice)
                if not cur.tested and u > uSpring and u <= testZoneInput and sw.legEff < cur.springEff
                    cur.tested := true
                    evLabel(cur, sw.bar, sw.price, "Test" + (detailLblInput ? "\neff ×" + str.tostring(sw.legEff, "#.#") : ""), true, rngCol, eventSize, "Test of the " + nmOf(cur, "spring", "UTAD") + "\nleg effort ×" + str.tostring(sw.legEff, "#.#") + " (spring leg ×" + str.tostring(cur.springEff, "#.#") + ")")
                    sigDetect := true
                    evTEST := true
                    eventMsg += "TEST confirmed | "
            else if u >= 0 and u <= stZoneInput and cur.nTests < maxSTInput
                cur.nTests += 1
                if cur.stage < 2
                    cur.stage := 2
                    addDivider(cur, sw.bar, 1, rngCol)
                if na(cur.innerClim)
                    cur.innerClim := line.new(sw.bar, sw.price, bar_index, sw.price, xloc = xloc.bar_index, color = color.new(inkOf(rngCol), 35), width = 1)
                evLabel(cur, sw.bar, sw.price, "ST" + (detailLblInput ? (sw.legEff < cur.climEff ? "\neff↓" : "\neff↑") : ""), true, rngCol, eventSize, "Secondary Test\nleg effort ×" + str.tostring(sw.legEff, "#.#") + (sw.legEff < cur.climEff ? " (below climax)" : " (above climax)"))
                sigDetect := true
                evST := true
                eventMsg += "ST confirmed | "
        else
            // reaction-side swing
            if cur.pendBreak and u < 0
                // structure continued beyond the climax edge: breakdown
                evLabel(cur, sw.bar, sw.price, nmOf(cur, "BREAKDOWN", "BREAKOUT"), false, failColorInput, eventSize, "Reaction-side swing formed beyond the climax edge: structure broke")
                if cur.side == 1
                    accBad += 1
                else
                    distBad += 1
                evFailed := true
                eventMsg += nmOf(cur, "Accumulation", "Distribution") + " range FAILED (structure) | "
                cur.pendBreak := false
                closeRange := true
                failedRange := true
                closeTag := "BROKEN"
            else if u > 1 and not cur.brokeOut
                if cur.nTests == 0 and not cur.sprung
                    float newH = safeDiv(cur.side == 1 ? sw.price - cur.bot : cur.top - sw.price, atr, 0.0)
                    if newH > maxHeightAtrInput
                        // the "reaction" never stopped: this is a trend, not a range
                        evLabel(cur, sw.bar, sw.price, "no range · trend", false, failColorInput, eventSizeSub, "The reaction never stopped: trend, not a range")
                        if cur.side == 1
                            accBad += 1
                        else
                            distBad += 1
                        eventMsg += nmOf(cur, "Accumulation", "Distribution") + " candidate dropped: reaction exceeded Max Range Height | "
                        closeRange := true
                        failedRange := true
                        closeTag := "NO RANGE · trend"
                    else
                        // Phase A: the automatic reaction is still running — extend the reaction edge
                        if na(cur.innerReact)
                            cur.innerReact := line.new(cur.reactBar, reactEdge(cur), bar_index, reactEdge(cur), xloc = xloc.bar_index, color = color.new(inkOf(rngCol), 35), width = 1)
                        if cur.side == 1
                            cur.top := sw.price
                        else
                            cur.bot := sw.price
                        cur.reactBar := sw.bar
                        redrawRange(cur)
                        evLabel(cur, sw.bar, sw.price, "AR+", false, rngCol, eventSizeSub, "Automatic reaction extended (Phase A)")
                else if markUTInput and uC <= 1
                    cur.utCount += 1
                    evLabel(cur, sw.bar, sw.price, nmOf(cur, "UT", "Shakeout"), false, sigColorInput, eventSizeSub, nmOf(cur, "Upthrust: false break of the resistance", "Shakeout: false break of the support"))
 
// ── C) extend / finalize the active range ──
if confirmed and not na(cur)
    line.set_x2(cur.edgeClim, bar_index)
    line.set_x2(cur.edgeReact, bar_index)
    if not na(cur.innerClim)
        line.set_x2(cur.innerClim, bar_index)
    if not na(cur.innerReact)
        line.set_x2(cur.innerReact, bar_index)
    label.set_x(cur.tagClim, bar_index + TAG_OFFSET_BARS)
    label.set_x(cur.tagReact, bar_index + TAG_OFFSET_BARS)
    label.set_text(cur.stageLbl, nmOf(cur, "ACCUMULATION", "DISTRIBUTION") + " · Phase " + phaseTxt(cur.stage))
    float hC = math.max(cur.top - cur.bot, syminfo.mintick)
    bool showTag = bar_index - cur.lastDivBar >= MIN_PHASE_BARS
    label.set_xy(cur.curPhaseTag, math.round((cur.lastDivBar + bar_index) / 2.0), cur.bot - PHASE_TAG_FRAC * hC)
    label.set_text(cur.curPhaseTag, showTag ? "Phase " + phaseTxt(cur.stage) : "")
    label.set_color(cur.curPhaseTag, showTag and showPhasesInput and eventBackdropInput ? LABEL_PLATE : TRANSP_COLOR)
    if closeRange
        bool hide = failedRange and not showFailedInput
        if hide
            line.delete(cur.edgeClim)
            line.delete(cur.edgeReact)
            line.delete(cur.innerClim)
            line.delete(cur.innerReact)
            label.delete(cur.tagClim)
            label.delete(cur.tagReact)
            label.delete(cur.stageLbl)
            label.delete(cur.curPhaseTag)
            line.delete(cur.tgtLn)
            label.delete(cur.tgtTag)
            for dv in cur.dividers
                line.delete(dv)
            for pt in cur.phaseTags
                label.delete(pt)
            for mk in cur.marks
                label.delete(mk)
        else
            label.set_text(cur.stageLbl, nmOf(cur, "ACCUMULATION", "DISTRIBUTION") + " · " + closeTag)
            if cur.lpsSeen
                // the range ends at the LPS / LPSY: Phase E is the tail, captioned just past the last divider
                label.set_xy(cur.curPhaseTag, cur.lastDivBar + PHASE_E_OFFSET_BARS, cur.bot - PHASE_TAG_FRAC * hC)
                label.set_text(cur.curPhaseTag, "Phase E")
                label.set_color(cur.curPhaseTag, showPhasesInput and eventBackdropInput ? LABEL_PLATE : TRANSP_COLOR)
            if failedRange
                color gLine = showRangesInput ? color.new(GRAY_RANGE, 10) : color.new(GRAY_RANGE, 100)
                line.set_color(cur.edgeClim, gLine)
                line.set_color(cur.edgeReact, gLine)
                if not na(cur.innerClim)
                    line.set_color(cur.innerClim, color.new(GRAY_RANGE, 40))
                if not na(cur.innerReact)
                    line.set_color(cur.innerReact, color.new(GRAY_RANGE, 40))
                label.set_textcolor(cur.tagClim, showRangesInput ? color.new(GRAY_RANGE, 20) : color.new(GRAY_RANGE, 100))
                label.set_textcolor(cur.tagReact, showRangesInput ? color.new(GRAY_RANGE, 20) : color.new(GRAY_RANGE, 100))
                label.set_textcolor(cur.stageLbl, showRangesInput ? GRAY_RANGE : color.new(GRAY_RANGE, 100))
                label.set_textcolor(cur.curPhaseTag, showPhasesInput ? color.new(GRAY_RANGE, 20) : color.new(GRAY_RANGE, 100))
                for dv in cur.dividers
                    line.set_color(dv, color.new(GRAY_RANGE, 35))
                for pt in cur.phaseTags
                    label.set_textcolor(pt, color.new(GRAY_RANGE, 20))
                for mk in cur.marks
                    label.set_textcolor(mk, color.new(GRAY_RANGE, 20))
            array.push(hist, cur)
            if array.size(hist) > maxRangesInput
                Rng old = array.shift(hist)
                line.delete(old.edgeClim)
                line.delete(old.edgeReact)
                line.delete(old.innerClim)
                line.delete(old.innerReact)
                label.delete(old.tagClim)
                label.delete(old.tagReact)
                label.delete(old.stageLbl)
                label.delete(old.curPhaseTag)
                line.delete(old.tgtLn)
                label.delete(old.tgtTag)
                for dv in old.dividers
                    line.delete(dv)
                for pt in old.phaseTags
                    label.delete(pt)
                for mk in old.marks
                    label.delete(mk)
        cur := na
 
// candidate timeout (no AR swing in time)
if confirmed and candDir != 0 and na(cur) and bar_index - candBar > arMaxBarsInput
    label.delete(candLbl)
    candLbl := na
    candDir := 0
 
// ── D) outcome tracker (from the bar after SOS; expiry before hit) ──
if confirmed and array.size(oId) > 0
    for i = array.size(oId) - 1 to 0
        if bar_index <= array.get(oBar, i)
            continue
        int d = array.get(oDir, i)
        int ageO = bar_index - array.get(oBar, i)
        bool hitT = d > 0 ? high >= array.get(oTgt, i) : low <= array.get(oTgt, i)
        bool inv  = d > 0 ? close < array.get(oInv, i) : close > array.get(oInv, i)
        bool done = false
        if ageO > outcomeBarsInput
            tgtExp += 1
            done := true
        else if hitT
            tgtHit += 1
            done := true
        else if inv
            tgtMiss += 1
            done := true
        if done
            array.remove(oId, i)
            array.remove(oDir, i)
            array.remove(oTgt, i)
            array.remove(oInv, i)
            array.remove(oBar, i)
 
// ── Entry signals ──
bool useLps    = entrySignalInput == "LPS / LPSY" or entrySignalInput == "Spring + LPS"
bool useSpring = entrySignalInput == "Spring / UTAD" or entrySignalInput == "Spring + LPS"
bool useSos    = entrySignalInput == "SOS / SOW"
bool confirmedLongSignal  = isWarmedUp and confirmed and ((useLps and evLps) or (useSpring and evSpring) or (useSos and evSos))
bool confirmedShortSignal = isWarmedUp and confirmed and ((useLps and evLpsy) or (useSpring and evUtad) or (useSos and evSow))
int  entryScore = entryScoreEv
 
var string lastSigType   = ""
var float  lastSigScore  = na
var int    lastSigBarIdx = na
if confirmedLongSignal
    lastSigType   := "Long"
    lastSigScore  := entryScore
    lastSigBarIdx := bar_index
if confirmedShortSignal
    lastSigType   := "Short"
    lastSigScore  := entryScore
    lastSigBarIdx := bar_index
 
// ══════════════════════════════════════
// RISK MANAGEMENT (SL/TP) — TRADE ENGINE
// ══════════════════════════════════════
[effectiveSLMult, effTP1m, effTP2m, effTP3m] = switch riskPresetInput
    "Conservative" => [2.5, 1.0, 2.0, 4.0]
    "Aggressive"   => [1.0, 1.5, 2.5, 4.0]
    "Scalping"     => [0.8, 0.8, 1.5, 2.0]
    "Custom"       => [slMultInput, tp1MultInput, tp2MultInput, tp3MultInput]
    => [1.5, 1.0, 2.0, 3.0]
float slDistance = riskAtr * effectiveSLMult
 
// state
var float activeEntry = na
var float activeSL    = na
var float activeTP1   = na
var float activeTP2   = na
var float activeTP3   = na
var int   activeDir   = 0
var int   entryBarIdx = na
var float entryAtr    = na
var bool  tp1Reached  = false
var bool  tp2Reached  = false
var bool  tp3Reached  = false
var bool  beActive    = false
 
// session stats
var int    winCount  = 0
var int    lossCount = 0
var string formStr   = ""
var array<int>  tradeTimes = array.new<int>()
var array<bool> tradeWins  = array.new<bool>()
 
// bar-start captures
bool  beActiveAtBarStart = beActive
float effectiveSL        = activeSL
 
// hit detection: entry-bar guard + confirmed only
bool canCheckHit = activeDir != 0 and not na(entryBarIdx) and bar_index > entryBarIdx and barstate.isconfirmed
bool slHitRaw  = canCheckHit and (activeDir == 1 ? low  <= effectiveSL : high >= effectiveSL)
bool tp1HitRaw = canCheckHit and (activeDir == 1 ? high >= activeTP1   : low  <= activeTP1)
bool tp2HitRaw = canCheckHit and (activeDir == 1 ? high >= activeTP2   : low  <= activeTP2)
bool tp3HitRaw = canCheckHit and (activeDir == 1 ? high >= activeTP3   : low  <= activeTP3)
 
bool tp1FirstTouch = tp1HitRaw and not tp1Reached
bool tp2FirstTouch = tp2HitRaw and not tp2Reached
bool tp3FirstTouch = tp3HitRaw and not tp3Reached
if tp1FirstTouch
    tp1Reached := true
if tp2FirstTouch
    tp2Reached := true
if tp3FirstTouch
    tp3Reached := true
 
// break-even after TP1
bool  beJustActivated = false
float beLevel         = na
if beInput and tp1FirstTouch and not beActive and activeDir != 0
    activeSL        := activeEntry + activeDir * beOffsetInput * nz(entryAtr, 0.0)
    beActive        := true
    beJustActivated := true
    beLevel         := activeSL
 
// snapshots before reset
var float hitSL    = na
var float hitEntry = na
if slHitRaw
    hitSL    := effectiveSL
    hitEntry := activeEntry
float exitEntry         = activeEntry
int   exitDir           = activeDir
float exitTP1           = activeTP1
float exitTP2           = activeTP2
float exitTP3           = activeTP3
bool  exitBeActive      = beActiveAtBarStart
bool  displayTp1Reached = tp1Reached
bool  displayTp2Reached = tp2Reached
bool  displayTp3Reached = tp3Reached
 
// closure: SL blocked by first TP touch of this bar (TP priority)
bool closeBySl = slHitRaw and not tp1FirstTouch and not tp3FirstTouch
bool evSlHit   = closeBySl
bool evTp3Hit  = false
if (tp3HitRaw or closeBySl) and activeDir != 0
    evTp3Hit := tp3HitRaw
    bool tradeWin = tp1Reached
    if tradeWin
        winCount += 1
    else
        lossCount += 1
    formStr := formStr + (tradeWin ? "▰" : "▱")
    if str.length(formStr) > FORM_LEN
        formStr := str.substring(formStr, str.length(formStr) - FORM_LEN)
    array.push(tradeTimes, time)
    array.push(tradeWins, tradeWin)
    while array.size(tradeTimes) > 0 and array.get(tradeTimes, 0) < time - MS_DAY * STATS_PRUNE_DAYS
        array.shift(tradeTimes)
        array.shift(tradeWins)
    activeDir   := 0
    activeEntry := na
    activeSL    := na
    activeTP1   := na
    activeTP2   := na
    activeTP3   := na
    entryBarIdx := na
    entryAtr    := na
    tp1Reached  := false
    tp2Reached  := false
    tp3Reached  := false
    beActive    := false
 
// signal-trade parity: reversal
int  sigDir = confirmedLongSignal ? 1 : confirmedShortSignal ? -1 : 0
bool reverseToShort = sigDir == -1 and activeDir == 1
bool reverseToLong  = sigDir ==  1 and activeDir == -1
bool evReversal = false
bool reversalWin = false
if reverseToShort or reverseToLong
    evReversal := true
    bool tradeWin = tp1Reached
    reversalWin := tradeWin
    if tradeWin
        winCount += 1
    else
        lossCount += 1
    formStr := formStr + (tradeWin ? "▰" : "▱")
    if str.length(formStr) > FORM_LEN
        formStr := str.substring(formStr, str.length(formStr) - FORM_LEN)
    array.push(tradeTimes, time)
    array.push(tradeWins, tradeWin)
    while array.size(tradeTimes) > 0 and array.get(tradeTimes, 0) < time - MS_DAY * STATS_PRUNE_DAYS
        array.shift(tradeTimes)
        array.shift(tradeWins)
    activeDir   := 0
    activeEntry := na
    activeSL    := na
    activeTP1   := na
    activeTP2   := na
    activeTP3   := na
    entryBarIdx := na
    entryAtr    := na
    tp1Reached  := false
    tp2Reached  := false
    tp3Reached  := false
    beActive    := false
 
// entries
bool evLongEntry  = false
bool evShortEntry = false
if confirmedLongSignal and activeDir == 0 and slDistance > 0
    float slAtrLong   = close - slDistance
    float slWickLong  = math.min(low - riskAtr * WICK_BUFFER_ATR, close - riskAtr * WICK_MIN_ATR)
    float slStructLong = na(eventLevel) ? slWickLong : math.min(eventLevel - riskAtr * WICK_BUFFER_ATR, close - riskAtr * WICK_MIN_ATR)
    float slLong = slModeInput == "ATR" ? slAtrLong : slModeInput == "Structure" ? slStructLong : slWickLong
    float riskLong = close - slLong
    if riskLong > 0
        activeEntry := close
        activeSL    := slLong
        activeTP1   := close + riskLong * effTP1m
        activeTP2   := close + riskLong * effTP2m
        activeTP3   := close + riskLong * effTP3m
        activeDir   := 1
        entryBarIdx := bar_index
        entryAtr    := riskAtr
        tp1Reached  := false
        tp2Reached  := false
        tp3Reached  := false
        beActive    := false
        evLongEntry := true
if confirmedShortSignal and activeDir == 0 and slDistance > 0
    float slAtrShort   = close + slDistance
    float slWickShort  = math.max(high + riskAtr * WICK_BUFFER_ATR, close + riskAtr * WICK_MIN_ATR)
    float slStructShort = na(eventLevel) ? slWickShort : math.max(eventLevel + riskAtr * WICK_BUFFER_ATR, close + riskAtr * WICK_MIN_ATR)
    float slShort = slModeInput == "ATR" ? slAtrShort : slModeInput == "Structure" ? slStructShort : slWickShort
    float riskShort = slShort - close
    if riskShort > 0
        activeEntry  := close
        activeSL     := slShort
        activeTP1    := close - riskShort * effTP1m
        activeTP2    := close - riskShort * effTP2m
        activeTP3    := close - riskShort * effTP3m
        activeDir    := -1
        entryBarIdx  := bar_index
        entryAtr     := riskAtr
        tp1Reached   := false
        tp2Reached   := false
        tp3Reached   := false
        beActive     := false
        evShortEntry := true
 
bool newEntry = evLongEntry or evShortEntry
 
// ── Statistics ──
int   closedTrades = winCount + lossCount
float winRate      = closedTrades > 0 ? winCount * 100.0 / closedTrades : 0.0
 
// ══════════════════════════════════════
// PLOTS & VISUALS
// ══════════════════════════════════════
plotchar(showDetectInput and sigDetect, "Event detected", "·", location.top, color.new(TEXT_COLOR, 20), size = size.small)
 
// ══════════════════════════════════════
// LABELS & SHAPES — ENTRY LABELS
// ══════════════════════════════════════
// Every entry is marked. Same-direction signals while a trade is open are
// ignored by the engine (no pyramiding) and are not marked.
if showSignalsInput and evLongEntry
    string buyKind = evReversal ? "Long entry (reversal from short)" : "Long entry · " + entrySignalInput
    string buyTip  = buyKind + "\nScore: " + fmtScore(entryScore) + "/100" + "\nEvent: " + entryInfoEv + "\nRSI: " + str.tostring(rsiValue, "#.0") + "\nSL: " + fmtPrice(activeSL) + " | TP1: " + fmtPrice(activeTP1)
    label.new(bar_index, low, "Long ▲", color = bullColorInput, textcolor = BULL_LABEL_TEXT, style = label.style_label_up, size = signalSize, tooltip = buyTip)
 
if showSignalsInput and evShortEntry
    string sellKind = evReversal ? "Short entry (reversal from long)" : "Short entry · " + entrySignalInput
    string sellTip  = sellKind + "\nScore: " + fmtScore(entryScore) + "/100" + "\nEvent: " + entryInfoEv + "\nRSI: " + str.tostring(rsiValue, "#.0") + "\nSL: " + fmtPrice(activeSL) + " | TP1: " + fmtPrice(activeTP1)
    label.new(bar_index, high, "Short ▼", color = bearColorInput, textcolor = BEAR_LABEL_TEXT, style = label.style_label_down, size = signalSize, tooltip = sellTip)
 
// ══════════════════════════════════════
// SL/TP LINES & LABELS
// ══════════════════════════════════════
var line  entryLine  = na
var line  slLine     = na
var line  tp1Line    = na
var line  tp2Line    = na
var line  tp3Line    = na
var label entryLabel = na
var label slLabel    = na
var label tp1Label   = na
var label tp2Label   = na
var label tp3Label   = na
 
string entryStyle = lineStyleFromString(entryLineStyleInput)
string slStyle    = lineStyleFromString(slLineStyleInput)
string tpStyle    = lineStyleFromString(tpLineStyleInput)
 
// New entry: replace the previous trade's lines (they persist until now as a record)
if newEntry and showSlTpInput
    line.delete(entryLine)
    line.delete(slLine)
    line.delete(tp1Line)
    line.delete(tp2Line)
    line.delete(tp3Line)
    label.delete(entryLabel)
    label.delete(slLabel)
    label.delete(tp1Label)
    label.delete(tp2Label)
    label.delete(tp3Label)
    int x1 = bar_index
    int x2 = bar_index + LINE_FORWARD_BARS
    entryLine := line.new(x1, activeEntry, x2, activeEntry, color = ENTRY_COLOR, style = entryStyle, width = 1)
    slLine    := line.new(x1, activeSL, x2, activeSL, color = SL_COLOR, style = slStyle, width = 2)
    tp1Line   := line.new(x1, activeTP1, x2, activeTP1, color = TP1_COLOR, style = tpStyle, width = 1)
    tp2Line   := line.new(x1, activeTP2, x2, activeTP2, color = TP2_COLOR, style = tpStyle, width = 1)
    tp3Line   := line.new(x1, activeTP3, x2, activeTP3, color = TP3_COLOR, style = tpStyle, width = 1)
    if showSlTpLabelsInput
        int lx = x2 + LABEL_OFFSET_BARS
        entryLabel := label.new(lx, activeEntry, "ENTRY " + fmtPrice(activeEntry), color = ENTRY_COLOR, textcolor = LABEL_TEXT, style = label.style_label_left, size = labelSize)
        slLabel    := label.new(lx, activeSL, "SL " + fmtPrice(activeSL) + formatPctFromEntry(activeSL, activeEntry), color = SL_COLOR, textcolor = LABEL_TEXT, style = label.style_label_left, size = labelSize)
        tp1Label   := label.new(lx, activeTP1, "TP1 " + fmtPrice(activeTP1) + formatPctFromEntry(activeTP1, activeEntry), color = TP_LABEL_COLOR, textcolor = LABEL_TEXT, style = label.style_label_left, size = labelSize)
        tp2Label   := label.new(lx, activeTP2, "TP2 " + fmtPrice(activeTP2) + formatPctFromEntry(activeTP2, activeEntry), color = TP_LABEL_COLOR, textcolor = LABEL_TEXT, style = label.style_label_left, size = labelSize)
        tp3Label   := label.new(lx, activeTP3, "TP3 " + fmtPrice(activeTP3) + formatPctFromEntry(activeTP3, activeEntry), color = TP_LABEL_COLOR, textcolor = LABEL_TEXT, style = label.style_label_left, size = labelSize)
 
// Open trade: lines end LINE_UPDATE_BARS after the current bar, labels right behind them
if activeDir != 0 and showSlTpInput and not na(slLine)
    int xe = bar_index + LINE_UPDATE_BARS
    line.set_x2(entryLine, xe)
    line.set_x2(slLine, xe)
    line.set_x2(tp1Line, xe)
    line.set_x2(tp2Line, xe)
    line.set_x2(tp3Line, xe)
    if showSlTpLabelsInput and not na(slLabel)
        label.set_x(entryLabel, xe + LABEL_OFFSET_BARS)
        label.set_x(slLabel, xe + LABEL_OFFSET_BARS)
        label.set_x(tp1Label, xe + LABEL_OFFSET_BARS)
        label.set_x(tp2Label, xe + LABEL_OFFSET_BARS)
        label.set_x(tp3Label, xe + LABEL_OFFSET_BARS)
 
// Break-even: the stop is still the action level, so it stays solid, now in the BE color
// (not on a bar where new lines were just drawn)
if showSlTpInput and beJustActivated and not newEntry
    if not na(slLine)
        line.set_color(slLine, BE_COLOR)
        line.set_y1(slLine, beLevel)
        line.set_y2(slLine, beLevel)
    if showSlTpLabelsInput
        if not na(slLabel)
            label.set_y(slLabel, beLevel)
            label.set_text(slLabel, "SL → BE " + fmtPrice(beLevel))
            label.set_color(slLabel, BE_COLOR)
            label.set_textcolor(slLabel, LABEL_TEXT)
        if not na(entryLabel)
            if math.abs(beLevel - exitEntry) < syminfo.mintick / 2
                // the stop now sits exactly on the entry: one label is enough, hide the entry label
                label.set_text(entryLabel, "")
                label.set_color(entryLabel, TRANSP_COLOR)
                label.set_textcolor(entryLabel, TRANSP_COLOR)
            else
                label.set_text(entryLabel, "ENTRY " + fmtPrice(exitEntry) + "  → SL (BE)")
                label.set_color(entryLabel, BE_COLOR)
 
// TP hit: the reached target turns solid teal with a check mark (from snapshots)
if showSlTpInput and not newEntry
    if displayTp1Reached and not na(tp1Line)
        line.set_color(tp1Line, TP_HIT_COLOR)
        line.set_style(tp1Line, line.style_solid)
        if showSlTpLabelsInput and not na(tp1Label)
            label.set_text(tp1Label, "TP1 ✓ " + fmtPrice(exitTP1) + formatPctFromEntry(exitTP1, exitEntry))
            label.set_color(tp1Label, TP_HIT_COLOR)
    if displayTp2Reached and not na(tp2Line)
        line.set_color(tp2Line, TP_HIT_COLOR)
        line.set_style(tp2Line, line.style_solid)
        if showSlTpLabelsInput and not na(tp2Label)
            label.set_text(tp2Label, "TP2 ✓ " + fmtPrice(exitTP2) + formatPctFromEntry(exitTP2, exitEntry))
            label.set_color(tp2Label, TP_HIT_COLOR)
    if displayTp3Reached and not na(tp3Line)
        line.set_color(tp3Line, TP_HIT_COLOR)
        line.set_style(tp3Line, line.style_solid)
        if showSlTpLabelsInput and not na(tp3Label)
            label.set_text(tp3Label, "TP3 ✓ " + fmtPrice(exitTP3) + formatPctFromEntry(exitTP3, exitEntry))
            label.set_color(tp3Label, TP_HIT_COLOR)
 
// ══════════════════════════════════════
// DASHBOARD 2.0 — sectional
// ══════════════════════════════════════
var table dashTable = na
if showDashInput and barstate.islast
    int marketRows  = showMarketSecInput  ? 6 : 0
    int wyckoffRows = showWyckoffSecInput ? 9 : 0
    int tradeRows   = showTradeSecInput   ? (activeDir != 0 ? 8 : 2) : 0
    int statsRows   = showStatsSecInput   ? 6 : 0
    int totalRows   = 2 + marketRows + wyckoffRows + tradeRows + statsRows
    if not na(dashTable)
        table.delete(dashTable)
    dashTable := table.new(dashPos, 2, totalRows, bgcolor = TABLE_BG, border_color = TABLE_BORDER, border_width = 1, frame_color = TABLE_BORDER, frame_width = 1)
 
    int  r   = 0
    bool zeb = false
    color rb = TABLE_BG
 
    // snapshot of the active range (no field access on an na object)
    bool   hasRng    = not na(cur)
    int    rDir      = candDir
    int    rPhase    = 0
    string rangeRow    = "—"
    string eventsRow     = "—"
    string qTxt      = "—"
    if hasRng
        rDir   := cur.side
        rPhase := cur.stage
        rangeRow := fmtPrice(cur.bot) + " – " + fmtPrice(cur.top) + " (" + str.tostring(safeDiv(cur.top - cur.bot, atr, 0.0), "#.#") + " ATR) · u " + str.tostring(uOf(cur, close), "#.##")
        eventsRow  := nmOf(cur, "SC", "BC") + "✓ AR✓ ST" + str.tostring(cur.nTests) + " " + nmOf(cur, "UT", "SHK") + str.tostring(cur.utCount) + " " + nmOf(cur, "SPR", "UTAD") + chk(cur.sprung) + " TEST" + chk(cur.tested) + " " + nmOf(cur, "SOS", "SOW") + chk(cur.brokeOut) + (cur.pendBreak ? " ⏳" : "")
        qTxt   := "Climax " + str.tostring(cur.climScore) + (cur.sprung ? " · " + nmOf(cur, "Spring ", "UTAD ") + str.tostring(cur.springScore) : "") + (cur.brokeOut ? " · " + nmOf(cur, "SOS ", "SOW ") + str.tostring(cur.sosScore) : "")
    string accWord = rDir == 1 ? "Accumulation" : "Distribution"
    color  rngColD   = rDir == 1 ? bullColorInput : rDir == -1 ? bearColorInput : TEXT_COLOR
 
    // header: trend = range direction, else last swing structure
    int trendDir = rDir
    if trendDir == 0 and array.size(swings) >= 3
        Swing s1 = array.get(swings, array.size(swings) - 1)
        Swing s3 = array.get(swings, array.size(swings) - 3)
        trendDir := s1.price > s3.price ? 1 : s1.price < s3.price ? -1 : 0
    string trendWord = hasRng ? accWord : trendDir == 1 ? "Bullish" : trendDir == -1 ? "Bearish" : "Neutral"
    color headerBg = trendDir == 1 ? HEADER_BG_BULL : trendDir == -1 ? HEADER_BG_BEAR : HEADER_BG_NEUTRAL
    color trendCol = trendDir == 1 ? BULL_TEXT : trendDir == -1 ? BEAR_TEXT : TEXT_MUTED
    table.cell(dashTable, 0, r, "◆ " + INDICATOR_SHORT + " · " + trendWord, text_color = HEADER_TEXT, bgcolor = headerBg, text_size = dashFontSize, text_halign = text.align_center)
    table.merge_cells(dashTable, 0, r, 1, r)
    r += 1
 
    // — Market —
    if showMarketSecInput
        table.cell(dashTable, 0, r, "— Market —", text_color = TEXT_MUTED, bgcolor = TABLE_ROW_ALT, text_size = dashFontSizeSub, text_halign = text.align_center)
        table.merge_cells(dashTable, 0, r, 1, r)
        r += 1
        rb := zeb ? TABLE_ROW_ALT : TABLE_BG
        table.cell(dashTable, 0, r, "Trend", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "Range direction while a range is active, otherwise swing structure (last swing vs the one two back)")
        table.cell(dashTable, 1, r, trendWord, text_color = trendCol, text_size = dashFontSize, bgcolor = rb)
        r += 1
        zeb := not zeb
        rb := zeb ? TABLE_ROW_ALT : TABLE_BG
        table.cell(dashTable, 0, r, "Phase", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "Wyckoff phase A–E of the active range")
        table.cell(dashTable, 1, r, hasRng ? "Phase " + phaseTxt(rPhase) : candDir != 0 ? "Awaiting AR" : "—", text_color = TEXT_COLOR, text_size = dashFontSize, bgcolor = rb)
        r += 1
        zeb := not zeb
        rb := zeb ? TABLE_ROW_ALT : TABLE_BG
        [leD, lpD, lnD] = legStats(nz(legStartBar, bar_index), bar_index)
        string legStr = legDir == 0 ? "—" : (legDir == 1 ? "↑ " : "↓ ") + str.tostring(safeDiv(math.abs(close - nz(legStartPrice, close)), atr, 0.0), "#.#") + " ATR · eff ×" + str.tostring(leD, "#.#") + " · " + str.tostring(lnD) + "b"
        table.cell(dashTable, 0, r, "Leg", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "Current leg: direction, length in ATR, mean bar effort vs baseline, bars. Source: " + (useVol ? "volume" : "bar range"))
        table.cell(dashTable, 1, r, legStr, text_color = leD >= sosEffInput ? NEUTRAL_TEXT : TEXT_COLOR, text_size = dashFontSize, bgcolor = rb)
        r += 1
        zeb := not zeb
        rb := zeb ? TABLE_ROW_ALT : TABLE_BG
        string posStr = activeDir == 1 ? "Long" : activeDir == -1 ? "Short" : "Flat"
        table.cell(dashTable, 0, r, "Position", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "Trade engine state. Entry signal: " + entrySignalInput)
        table.cell(dashTable, 1, r, posStr, text_color = activeDir == 1 ? BULL_TEXT : activeDir == -1 ? BEAR_TEXT : TEXT_MUTED, text_size = dashFontSize, bgcolor = rb)
        r += 1
        zeb := not zeb
        rb := zeb ? TABLE_ROW_ALT : TABLE_BG
        string lastStr = na(lastSigBarIdx) ? "—" : lastSigType + " · " + fmtScore(lastSigScore) + " (" + str.tostring(bar_index - lastSigBarIdx) + ")"
        color  lastCol = lastSigType == "Long" ? BULL_TEXT : lastSigType == "Short" ? BEAR_TEXT : TEXT_MUTED
        table.cell(dashTable, 0, r, "Last Signal", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "Last confirmed signal · quality score (bars ago). Score is heuristic, 0–100.")
        table.cell(dashTable, 1, r, lastStr, text_color = lastCol, text_size = dashFontSize, bgcolor = rb)
        r += 1
        zeb := not zeb
 
    // — Wyckoff —
    if showWyckoffSecInput
        table.cell(dashTable, 0, r, "— Wyckoff —", text_color = TEXT_MUTED, bgcolor = TABLE_ROW_ALT, text_size = dashFontSizeSub, text_halign = text.align_center)
        table.merge_cells(dashTable, 0, r, 1, r)
        r += 1
        string statusRow = hasRng ? str.upper(accWord) + " · Phase " + phaseTxt(rPhase) : candDir != 0 ? (candDir == 1 ? "SC" : "BC") + " " + str.tostring(candScore) + "/100 · awaiting AR" : "Scanning swings for a climax"
        color statusCol = hasRng ? rngColD : candDir != 0 ? climColorInput : TEXT_COLOR
        rb := zeb ? TABLE_ROW_ALT : TABLE_BG
        table.cell(dashTable, 0, r, "Status", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "Swing stream → climax candidate → range (phases A–E)")
        table.cell(dashTable, 1, r, statusRow, text_color = statusCol, text_size = dashFontSize, bgcolor = rb)
        r += 1
        zeb := not zeb
        rb := zeb ? TABLE_ROW_ALT : TABLE_BG
        table.cell(dashTable, 0, r, "Range", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "Active range edges, height in ATR and the close in u-space (0 = climax edge, 1 = reaction edge)")
        table.cell(dashTable, 1, r, rangeRow, text_color = statusCol, text_size = dashFontSize, bgcolor = rb)
        r += 1
        zeb := not zeb
        rb := zeb ? TABLE_ROW_ALT : TABLE_BG
        table.cell(dashTable, 0, r, "Events", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "Checklist of Wyckoff events in the active range. ⏳ = swing beyond the climax edge awaiting reclaim")
        table.cell(dashTable, 1, r, eventsRow, text_color = statusCol, text_size = dashFontSize, bgcolor = rb)
        r += 1
        zeb := not zeb
        rb := zeb ? TABLE_ROW_ALT : TABLE_BG
        table.cell(dashTable, 0, r, "Quality", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "Heuristic 0–100 scores (climax run, spring depth/effort/speed, breakout leg). Not a probability.")
        table.cell(dashTable, 1, r, qTxt, text_color = NEUTRAL_TEXT, text_size = dashFontSize, bgcolor = rb)
        r += 1
        zeb := not zeb
        rb := zeb ? TABLE_ROW_ALT : TABLE_BG
        string springRow = springRanges > 0 ? str.tostring(100.0 * sprungBroke / springRanges, "#") + "% (" + str.tostring(sprungBroke) + "/" + str.tostring(springRanges) + ")" : "—"
        string utadRow  = utadRanges > 0 ? str.tostring(100.0 * utadBroke / utadRanges, "#") + "% (" + str.tostring(utadBroke) + "/" + str.tostring(utadRanges) + ")" : "—"
        table.cell(dashTable, 0, r, "Spring→SOS / UTAD→SOW", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "Ranges whose Spring/UTAD was followed by a breakout. Unit = range. Resets on chart reload")
        table.cell(dashTable, 1, r, springRow + " / " + utadRow, text_color = TEXT_COLOR, text_size = dashFontSize, bgcolor = rb)
        r += 1
        zeb := not zeb
        rb := zeb ? TABLE_ROW_ALT : TABLE_BG
        int tgtDone = tgtHit + tgtMiss
        int tgtAll  = tgtHit + tgtMiss + tgtExp
        string tgtTxt = tgtDone > 0 ? str.tostring(100.0 * tgtHit / tgtDone, "#") + "% · in horizon " + str.tostring(100.0 * tgtHit / math.max(tgtAll, 1), "#") + "%" : "—"
        table.cell(dashTable, 0, r, "SOS→Target", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "Target reached before a close back below the midline (first %), and within the outcome horizon incl. expired (second %). Resets on chart reload")
        table.cell(dashTable, 1, r, tgtTxt, text_color = tgtDone > 0 and tgtHit * 2 >= tgtDone ? BULL_TEXT : tgtDone > 0 ? BEAR_TEXT : TEXT_MUTED, text_size = dashFontSize, bgcolor = rb)
        r += 1
        zeb := not zeb
        rb := zeb ? TABLE_ROW_ALT : TABLE_BG
        string outTxt = "hit " + str.tostring(tgtHit) + " · miss " + str.tostring(tgtMiss) + " · exp " + str.tostring(tgtExp) + " · pend " + str.tostring(array.size(oId)) + " · passed " + str.tostring(tgtPre)
        table.cell(dashTable, 0, r, "Outcomes", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "hit = target reached · miss = closed below midline · exp = horizon expired · pend = still open · passed = target already beyond SOS close (excluded)")
        table.cell(dashTable, 1, r, outTxt, text_color = TEXT_COLOR, text_size = dashFontSize, bgcolor = rb)
        r += 1
        zeb := not zeb
        rb := zeb ? TABLE_ROW_ALT : TABLE_BG
        string rangesRow = "Acc " + str.tostring(accTotal) + " ✓" + str.tostring(accOk) + " ✗" + str.tostring(accBad) + "   Dist " + str.tostring(distTotal) + " ✓" + str.tostring(distOk) + " ✗" + str.tostring(distBad)
        table.cell(dashTable, 0, r, "Ranges", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "Confirmed ranges: total, ✓ completed, ✗ broken. Resets on chart reload")
        table.cell(dashTable, 1, r, rangesRow, text_color = TEXT_COLOR, text_size = dashFontSize, bgcolor = rb)
        r += 1
        zeb := not zeb
 
    // — Trade —
    if showTradeSecInput
        table.cell(dashTable, 0, r, "— Trade —", text_color = TEXT_MUTED, bgcolor = TABLE_ROW_ALT, text_size = dashFontSizeSub, text_halign = text.align_center)
        table.merge_cells(dashTable, 0, r, 1, r)
        r += 1
        if activeDir == 0
            table.cell(dashTable, 0, r, "Flat · waiting for signal", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = TABLE_BG, text_halign = text.align_center)
            table.merge_cells(dashTable, 0, r, 1, r)
            r += 1
        else
            string entryStr = (activeDir == 1 ? "Long @ " : "Short @ ") + fmtPrice(activeEntry)
            string slStr    = beActive ? "BE @ " + fmtPrice(activeSL) : fmtPrice(activeSL) + formatPctFromEntry(activeSL, activeEntry)
            color  slCol    = beActive ? BE_COLOR : SL_COLOR
            string tp1Str   = (tp1Reached ? "✓ " : "") + fmtPrice(activeTP1)
            string tp2Str   = (tp2Reached ? "✓ " : "") + fmtPrice(activeTP2)
            string tp3Str   = (tp3Reached ? "✓ " : "") + fmtPrice(activeTP3)
            color  tp1Col   = tp1Reached ? TP_HIT_COLOR : TP_LABEL_COLOR
            color  tp2Col   = tp2Reached ? TP_HIT_COLOR : TP_LABEL_COLOR
            color  tp3Col   = tp3Reached ? TP_HIT_COLOR : TP_LABEL_COLOR
            string rrStr    = str.tostring(effTP1m, "#.#") + "R · " + str.tostring(effTP2m, "#.#") + "R · " + str.tostring(effTP3m, "#.#") + "R"
            color  rrCol    = effTP1m >= 1.5 ? BULL_TEXT : effTP1m >= 1.0 ? NEUTRAL_TEXT : BEAR_TEXT
            float  riskPct  = safeDiv(math.abs(activeEntry - activeSL), activeEntry) * 100.0
            string riskStr  = str.tostring(riskPct, "#.##") + "%"
            color  riskCol  = riskPct > 3.0 ? BEAR_TEXT : riskPct > 1.0 ? NEUTRAL_TEXT : BULL_TEXT
            rb := zeb ? TABLE_ROW_ALT : TABLE_BG
            table.cell(dashTable, 0, r, "Entry", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "Entry at the close of the signal bar.")
            table.cell(dashTable, 1, r, entryStr, text_color = ENTRY_COLOR, text_size = dashFontSize, bgcolor = rb)
            r += 1
            zeb := not zeb
            rb := zeb ? TABLE_ROW_ALT : TABLE_BG
            table.cell(dashTable, 0, r, "SL", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "Stop-loss (" + slModeInput + " mode). 'BE @' = stop moved to break-even after TP1.")
            table.cell(dashTable, 1, r, slStr, text_color = slCol, text_size = dashFontSize, bgcolor = rb)
            r += 1
            zeb := not zeb
            rb := zeb ? TABLE_ROW_ALT : TABLE_BG
            table.cell(dashTable, 0, r, "TP1", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "✓ = reached. Reaching TP1 makes the trade a win.")
            table.cell(dashTable, 1, r, tp1Str, text_color = tp1Col, text_size = dashFontSize, bgcolor = rb)
            r += 1
            zeb := not zeb
            rb := zeb ? TABLE_ROW_ALT : TABLE_BG
            table.cell(dashTable, 0, r, "TP2", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "✓ = reached.")
            table.cell(dashTable, 1, r, tp2Str, text_color = tp2Col, text_size = dashFontSize, bgcolor = rb)
            r += 1
            zeb := not zeb
            rb := zeb ? TABLE_ROW_ALT : TABLE_BG
            table.cell(dashTable, 0, r, "TP3", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "Final target: closes the trade.")
            table.cell(dashTable, 1, r, tp3Str, text_color = tp3Col, text_size = dashFontSize, bgcolor = rb)
            r += 1
            zeb := not zeb
            rb := zeb ? TABLE_ROW_ALT : TABLE_BG
            table.cell(dashTable, 0, r, "R:R", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "Reward-to-risk of TP1 · TP2 · TP3, in multiples of the actual SL distance.")
            table.cell(dashTable, 1, r, rrStr, text_color = rrCol, text_size = dashFontSize, bgcolor = rb)
            r += 1
            zeb := not zeb
            rb := zeb ? TABLE_ROW_ALT : TABLE_BG
            table.cell(dashTable, 0, r, "SL Dist", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "Current distance from entry to stop, % of entry price.")
            table.cell(dashTable, 1, r, riskStr, text_color = riskCol, text_size = dashFontSize, bgcolor = rb)
            r += 1
            zeb := not zeb
 
    // — Stats —
    if showStatsSecInput
        int cutoff = statsPeriodInput == "24 Hours" ? time - MS_DAY : statsPeriodInput == "30 Days" ? time - MS_DAY * 30 : 0
        int pW = winCount
        int pL = lossCount
        if statsPeriodInput != "All-Time"
            [w, l] = periodStats(tradeTimes, tradeWins, cutoff)
            pW := w
            pL := l
        int pTotal = pW + pL
        float pWR = pTotal > 0 ? pW / float(pTotal) * 100.0 : 0.0
        string periodTag = statsPeriodInput == "24 Hours" ? "24H" : statsPeriodInput == "30 Days" ? "30D" : "All-Time"
        table.cell(dashTable, 0, r, "— Stats · " + periodTag + " —", text_color = TEXT_MUTED, bgcolor = TABLE_ROW_ALT, text_size = dashFontSizeSub, text_halign = text.align_center)
        table.merge_cells(dashTable, 0, r, 1, r)
        r += 1
        rb := zeb ? TABLE_ROW_ALT : TABLE_BG
        table.cell(dashTable, 0, r, "Trades", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "Closed trades in the selected period (resets on chart reload)")
        table.cell(dashTable, 1, r, pTotal > 0 ? str.tostring(pTotal) : "—", text_color = pTotal > 0 ? TEXT_COLOR : TEXT_MUTED, text_size = dashFontSize, bgcolor = rb)
        r += 1
        zeb := not zeb
        rb := zeb ? TABLE_ROW_ALT : TABLE_BG
        table.cell(dashTable, 0, r, "W / L", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "A trade is a WIN once TP1 is touched (TP3, BE-stop, reversal after TP1). Loss = closed before TP1")
        table.cell(dashTable, 1, r, pTotal > 0 ? str.tostring(pW) + " / " + str.tostring(pL) : "—", text_color = pTotal > 0 ? TEXT_COLOR : TEXT_MUTED, text_size = dashFontSize, bgcolor = rb)
        r += 1
        zeb := not zeb
        rb := zeb ? TABLE_ROW_ALT : TABLE_BG
        string dashWR = pTotal > 0 ? str.tostring(pWR, "#.#") + "%  " + buildGauge(pWR, 100.0, GAUGE_WIDTH) : "—"
        color wrCol = pTotal == 0 ? TEXT_MUTED : pWR >= 55.0 ? BULL_TEXT : pWR >= 45.0 ? NEUTRAL_TEXT : BEAR_TEXT
        table.cell(dashTable, 0, r, "Win rate", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "Optimistic intrabar fill model (TP priority). Not a backtest")
        table.cell(dashTable, 1, r, dashWR, text_color = wrCol, text_size = dashFontSize, bgcolor = rb)
        r += 1
        zeb := not zeb
        rb := zeb ? TABLE_ROW_ALT : TABLE_BG
        table.cell(dashTable, 0, r, "Form", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb, tooltip = "▰ = win · ▱ = loss (newest right). Always the last trades, not filtered by period")
        table.cell(dashTable, 1, r, formStr == "" ? "—" : formStr, text_color = TEXT_COLOR, text_size = dashFontSize, bgcolor = rb)
        r += 1
        zeb := not zeb
        rb := zeb ? TABLE_ROW_ALT : TABLE_BG
        table.cell(dashTable, 0, r, "TF", text_color = TEXT_MUTED, text_size = dashFontSize, bgcolor = rb)
        table.cell(dashTable, 1, r, timeframe.period, text_color = TEXT_COLOR, text_size = dashFontSize, bgcolor = rb)
        r += 1
        zeb := not zeb
 
    // footer
    table.cell(dashTable, 0, r, INDICATOR_SHORT + " · " + INDICATOR_VERSION, text_color = TEXT_MUTED, bgcolor = TABLE_ROW_ALT, text_size = dashFontSizeSub, text_halign = text.align_center)
    table.merge_cells(dashTable, 0, r, 1, r)
 
// ══════════════════════════════════════
// WATERMARK — WillyAlgoTrader
// ══════════════════════════════════════
if barstate.islast and showWatermarkInput
    var table wmTable = table.new(position = position.bottom_center, columns = 1, rows = 1, bgcolor = TRANSP_COLOR, border_color = TRANSP_COLOR, border_width = 0, frame_color = TRANSP_COLOR, frame_width = 0)
    table.cell(wmTable, 0, 0, "WillyAlgoTrader", text_color = WM_COLOR, text_size = size.normal, text_halign = text.align_center, bgcolor = TRANSP_COLOR)
 
// ══════════════════════════════════════
// ALERTS — management → closures → reversal → entries → info
// ══════════════════════════════════════
string tick       = syminfo.tickerid
string tfStr      = timeframe.period
string aPrice     = str.tostring(close, format.mintick)
string exitDirStr = exitDir == 1 ? "Long" : exitDir == -1 ? "Short" : "—"
 
// 1) trade management
if beJustActivated and alertTpBeInput
    alert("🛡️ BREAK-EVEN | " + tick + " | TF: " + tfStr + " | " + exitDirStr + " | SL moved to " + fmtPrice(beLevel), alert.freq_once_per_bar_close)
if tp1FirstTouch and alertTpBeInput
    alert("🎯 TP1 HIT | " + tick + " | TF: " + tfStr + " | " + exitDirStr + " | TP1: " + fmtPrice(exitTP1), alert.freq_once_per_bar_close)
if tp2FirstTouch and alertTpBeInput
    alert("🎯🎯 TP2 HIT | " + tick + " | TF: " + tfStr + " | " + exitDirStr + " | TP2: " + fmtPrice(exitTP2), alert.freq_once_per_bar_close)
// 2) closures
if evTp3Hit and alertTpBeInput
    alert("🏆 TP3 HIT | " + tick + " | TF: " + tfStr + " | " + exitDirStr + " | Entry: " + fmtPrice(exitEntry) + " | TP3: " + fmtPrice(exitTP3), alert.freq_once_per_bar_close)
if evSlHit and alertSlRevInput
    string textSlHit = (exitBeActive ? "🛡️ BE STOP-OUT | " : "🛑 SL HIT | ") + tick + " | TF: " + tfStr + " | " + exitDirStr + " | Entry: " + fmtPrice(hitEntry) + " | SL: " + fmtPrice(hitSL)
    alert(textSlHit, alert.freq_once_per_bar_close)
// 3) reversal
if evReversal and alertSlRevInput
    string newDirStr = exitDir == 1 ? "Short" : "Long"
    string revResult = reversalWin ? "Closed after TP1 (win)" : "Closed before TP1 (loss)"
    alert("🔄 REVERSAL | " + tick + " | TF: " + tfStr + " | " + exitDirStr + " → " + newDirStr + " | " + revResult + " | Exit: " + aPrice, alert.freq_once_per_bar_close)
// 4) new entries
if newEntry
    string slS   = str.tostring(nz(activeSL), format.mintick)
    string tp1S  = str.tostring(nz(activeTP1), format.mintick)
    string tp2S  = str.tostring(nz(activeTP2), format.mintick)
    string tp3S  = str.tostring(nz(activeTP3), format.mintick)
    string rrS   = str.tostring(effTP1m, "#.#")
    string scS   = fmtScore(entryScore)
    string act   = evLongEntry ? "buy" : "sell"
    string head  = evLongEntry ? "🟢 LONG | " : "🔴 SHORT | "
    string jsonEntry = '{"action":"' + act + '","ticker":"' + tick + '","tf":"' + tfStr + '","price":' + aPrice + ',"score":' + scS + ',"sl":' + slS + ',"tp1":' + tp1S + ',"tp2":' + tp2S + ',"tp3":' + tp3S + ',"rr":' + rrS + '}'
    string textEntry = head + tick + " | TF: " + tfStr + " | Price: " + aPrice + " | Score: " + scS + "/100 | Event: " + entryInfoEv + " | SL: " + slS + " | TP1: " + tp1S + " | TP2: " + tp2S + " | TP3: " + tp3S + " | R:R: " + rrS
    alert(webhookInput ? jsonEntry : textEntry, alert.freq_once_per_bar_close)
// 5) info — Wyckoff events (suppressed on bars that opened or reversed a trade)
if alertEventsInput and eventMsg != "" and not evLongEntry and not evShortEntry and not evReversal
    alert("ℹ️ WYCKOFF | " + tick + " | TF: " + tfStr + " | " + eventMsg + "Price: " + aPrice, alert.freq_once_per_bar_close)

← 返回列表