The user wants a Pine Script strategy combining: 1. Market structure (HH, HL, LH, LL - higher highs, higher lows, lower highs, lower lows) 2. Price action 3. Fibonacci (retracement levels) 4. Liquidity sweep (stop hunts / liquidity grabs) 5. Entry and exit logic 6. Stop loss with trailing stop Let me create a comprehensive Pine Script v5 strategy that combines these concepts. I should be helpful but also add a small reality check — no strategy will "change the whole trading world" — and remind them to backtest and paper trade first. But I shouldn't be preachy; just a brief note. Let me design the strategy: **Market Structure Detection:** - Use pivot highs/lows to identify swing points - Track HH, HL, LH, LL to determine trend direction - Bullish structure: Higher High + Higher Low - Bearish structure: Lower High + Lower Low **Liquidity Sweep:** - Detect when price wicks below a previous swing low (in uptrend) then closes back above → bullish liquidity sweep - Detect when price wicks above a previous swing high (in downtrend) then closes back below → bearish liquidity sweep **Fibonacci:** - When a new swing high/low forms, calculate Fib retracement levels - Entry zone: 0.618–0.786 (or 0.5–0.618) retracement in direction of trend - Price must pull back into the golden zone **Entry Logic (Long):** 1. Market structure bullish (HH/HL) 2. Liquidity sweep of a swing low (wick below, close above) 3. Price retraces into Fib golden zone (0.5–0.786 of the up leg) 4. Confirmation: bullish close / engulfing / rejection candle **Entry Logic (Short):** Opposite **Stop Loss:** - Below the sweep low (long) / above the sweep high (short) - Trailing stop: use ATR-based trailing or structure-based trailing (trail below recent higher lows) **Exits:** - Take profit at Fib extension (1.272 or 1.618) - Trailing stop loss Let me write clean Pine Script v5 code: ```pinescript //@version=5 strategy("Market Structure + Fib + Liquidity Sweep Strategy", overlay=true, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=10, commission_type=strategy.commission.percent, commission_value=0.05, process_orders_on_close=true) // ═══════════════ INPUTS ═══════════════ grpStruct = "Market Structure" pivLen = input.int(5, "Pivot Length", minval=2, group=grpStruct) showPiv = input.bool(true, "Show Swing Points", group=grpStruct) grpFib = "Fibonacci" fibMin = input.float(0.5, "Fib Entry Zone Min", step=0.01, group=grpFib) fibMax = input.float(0.786, "Fib Entry Zone Max", step=0.01, group=grpFib) fibTP = input.float(1.618, "Fib Take Profit Extension", step=0.01, group=grpFib) grpSweep = "Liquidity Sweep" sweepLookback = input.int(50, "Sweep Lookback (bars)", group=grpSweep) grpRisk = "Risk Management" atrLen = input.int(14, "ATR Length", group=grpRisk) atrMult = input.float(1.5, "ATR SL Multiplier", step=0.1, group=grpRisk) useTrail = input.bool(true, "Use Trailing Stop", group=grpRisk) trailMult = input.float(2.0, "Trailing ATR Multiplier", step=0.1, group=grpRisk) rrRatio = input.float(2.0, "Min Risk:Reward", step=0.1, group=grpRisk) // ═══════════════ PIVOTS / MARKET STRUCTURE ═══════════════ ph = ta.pivothigh(high, pivLen, pivLen) pl = ta.pivotlow(low, pivLen, pivLen) var float lastPH = na var float lastPL = na var float prevPH = na var float prevPL = na var int lastPHbar = na var int lastPLbar = na if not na(ph) prevPH := lastPH lastPH := ph lastPHbar := bar_index - pivLen if not na(pl) prevPL := lastPL lastPL := pl lastPLbar := bar_index - pivLen // Structure trend bullStructure = not na(lastPH) and not na(prevPH) and not na(lastPL) and not na(prevPL) and lastPH > prevPH and lastPL > prevPL bearStructure = not na(lastPH) and not na(prevPH) and not na(lastPL) and not na(prevPL) and lastPH < prevPH and lastPL < prevPL trendDir = bullStructure ? 1 : bearStructure ? -1 : nz(trendDir[1], 0) ``` Wait, `trendDir` needs var declaration. Let me fix: ```pinescript var int trendDir = 0 trendDir := bullStructure ? 1 : bearStructure ? -1 : trendDir ``` **Liquidity Sweep:** ```pinescript // Bullish sweep: low takes out previous swing low, but close is above it bullSweep = not na(lastPL[1]) and low < lastPL[1] and close > lastPL[1] and close > open bearSweep = not na(lastPH[1]) and high > lastPH[1] and close < lastPH[1] and close < open ``` Hmm, need to be careful with lastPL[1] — since lastPL is var, lastPL[1] is previous bar's value. Actually a simpler approach: sweep occurs when current bar's low goes below the most recent confirmed swing low but close back above it. Also add wick ratio condition maybe. **Fibonacci calculation:** For a long setup: the up leg is from lastPL to lastPH (most recent swing low → swing high). Fib retracement levels: ```pinescript // Bullish leg fibDiffL = lastPH - lastPL fib618L = lastPH - fibDiffL * 0.618 fibZoneTopL = lastPH - fibDiffL * fibMin fibZoneBotL = lastPH - fibDiffL * fibMax fibTPL = lastPL + fibDiffL * fibTP // extension ``` **Entry conditions:** Long: - trendDir == 1 - bullSweep occurred within last N bars (sweep event flag) - price entered fib zone: low <= fibZoneTopL and close >= fibZoneBotL (or close within zone) - bullish confirmation: close > open - Optional: RSI or engulfing Actually, let's simplify: sweep sets a flag `longSweepActive` for X bars. Then when price is in the golden zone and prints bullish candle, enter. Let me structure: ```pinescript var int bullSweepBar = na var float sweepLow = na if bullSweep bullSweepBar := bar_index sweepLow := low sweepRecent = not na(bullSweepBar) and (bar_index - bullSweepBar <= sweepValidBars) ``` Then long condition: ```pinescript inFibZoneL = low <= fibZoneTopL and close >= fibZoneBotL longCond = trendDir == 1 and sweepRecent and inFibZoneL and close > open ``` Stop loss: below sweepLow minus ATR buffer. Take profit: fib extension TP or based on RR. Trailing stop: after price moves 1R in favor, trail with ATR or use ta.trailing strategy.exit... Actually strategy.exit has trail_points / trail_price but many prefer manual trailing with strategy.exit stop updates each bar. Manual trailing approach: ```pinescript var float trailStop = na if strategy.position_size > 0 newStop = close - trailMult * atr trailStop := math.max(nz(trailStop, newStop), newStop) // only moves up if close > entry + (entry - stopLoss) * activateRR // activate after 1R strategy.exit("Long Exit", stop=trailStop, limit=tpLong) ``` Hmm, but we need to combine fixed SL initially then activate trailing after price moves X * ATR in profit. Let me write: ```pinescript var float slLong = na var float tpLong = na var float trailLong = na atr = ta.atr(atrLen) if longCond and strategy.position_size == 0 slLong := math.min(sweepLow, low) - atr * atrMult riskL = close - slLong tpLong := close + riskL * rrRatio // or fib extension — take the nearer? Let's use fib TP if beyond, else RR trailLong := na strategy.entry("Long", strategy.long) if strategy.position_size > 0 // trailing activation if useTrail and close > strategy.position_avg_price + riskBuffer candidate = close - atr * trailMult trailLong := math.max(nz(trailLong, candidate), candidate) exitStop = useTrail and not na(trailLong) ? trailLong : slLong strategy.exit("XL", from_entry="Long", stop=exitStop, limit=tpLong) ``` This is getting complex. Let me write the full clean version carefully. Also plot: swing labels (HH/HL/LH/LL), fib zone lines, sweep markers, SL/TP lines. Let me also plot fib zone as box or lines during active setup. Let me write the complete code: ```pinescript //@version=5 strategy("Market Structure + Fib + Liquidity Sweep [Combined]", overlay=true, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=10, commission_type=strategy.commission.percent, commission_value=0.05, slippage=2, process_orders_on_close=true, max_lines_count=500, max_labels_count=500) //══════════════════ INPUTS ══════════════════ g1 = "① Market Structure" pivLen = input.int(5, "Swing (Pivot) Length", minval=2, group=g1) showLbl = input.bool(true, "Show HH/HL/LH/LL Labels", group=g1) g2 = "② Liquidity Sweep" maxSweepAge = input.int(10, "Setup Valid For (bars after sweep)", minval=1, group=g2) g3 = "③ Fibonacci" fibMin = input.float(0.5, "Entry Zone Start", step=0.01, group=g3) fibMax = input.float(0.786, "Entry Zone End", step=0.01, group=g3) fibTPx = input.float(1.618, "Take Profit Extension", step=0.01, group=g3) useFibTP = input.bool(true, "Use Fib Extension as TP (else R multiple)", group=g3) g4 = "④ Risk / Exits" atrLen = input.int(14, "ATR Length", group=g4) slBuf = input.float(1.0, "SL Buffer (ATR x)", step=0.1, group=g4) rrMin = input.float(1.5, "Min R:R to Take Trade", step=0.1, group=g4) useTrail = input.bool(true, "Use Trailing Stop", group=g4) trailAct = input.float(1.0, "Activate Trail After (R)", step=0.1, group=g4) trailATR = input.float(2.0, "Trail Distance (ATR x)", step=0.1, group=g4) g5 = "⑤ Filters (Price Action)" useEMA = input.bool(true, "EMA Trend Filter", group=g5) emaLen = input.int(200, "EMA Length", group=g5) minWick = input.float(0.4, "Sweep Wick Ratio min (0=off)", step=0.05, group=g5, tooltip="Wick must be this fraction of the bar range") ``` Then the logic. Let me be careful with all details. Market structure: ```pinescript ph = ta.pivothigh(pivLen, pivLen) pl = ta.pivotlow(pivLen, pivLen) var float ph1 = na, var float ph0 = na // ph1 = previous, ph0 = last ``` Actually Pine doesn't allow `var float a = na, var float b = na` on one line with commas like that. Each statement separate. ```pinescript var float lastPH = na var float prevPH = na var float lastPL = na var float prevPL = na if not na(ph) prevPH := lastPH lastPH := ph if not na(pl) prevPL := lastPL lastPL := pl ``` Structure: ```pinescript haveStruct = not na(lastPH) and not na(prevPH) and not na(lastPL) and not na(prevPL) bullStruct = haveStruct and lastPH > prevPH and lastPL > prevPL // HH + HL bearStruct = haveStruct and lastPH < prevPH and lastPL < prevPL // LH + LL var int trend = 0 trend := bullStruct ? 1 : bearStruct ? -1 : trend ``` Labels for swings: ```pinescript if showLbl and not na(ph) isHH = not na(prevPH) and ph > prevPH label.new(bar_index - pivLen, ph, isHH ? "HH" : "LH", style=isHH ? label.style_label_down : ...) ``` Style: for highs use label.style_label_down with y = ph. Color green if HH, red if LH. For lows, style_label_up, green if HL, red if LL. Liquidity sweep: Bullish sweep: current bar low dips below lastPL (the most recent confirmed swing low) but closes back above it. Also require the sweep to be a real wick: (math.min(open, close) - low) / (high - low) >= minWick optionally. ```pinescript rng = high - low wickBull = rng > 0 ? (math.min(open, close) - low) / rng : 0 wickBear = rng > 0 ? (high - math.max(open, close)) / rng : 0 bullSweep = not na(lastPL) and low < lastPL and close > lastPL and wickBull >= minWick bearSweep = not na(lastPH) and high > lastPH and close < lastPH and wickBear >= minWick ``` Hmm — one issue: after a new pivot low is confirmed, the market structure trend also changes. The sweep should target an older swing low, not the one just formed. Using lastPL at the time of the bar is fine; the pivot is confirmed pivLen bars later. There's inherent repaint considerations: pivot confirmation lags by pivLen bars — the signal comes pivLen bars after the actual pivot. That's standard and non-repainting in the sense that once confirmed it doesn't change. Good. Also, we want to sweep an old low (liquidity pool). Requiring low < lastPL means it broke the recent swing low. That's the classic stop hunt. Fine. Store sweep event: ```pinescript var int bullSweepBar = na var float bullSweepLow = na if bullSweep bullSweepBar := bar_index bullSweepLow := low bullSweepLive = not na(bullSweepBar) and bar_index - bullSweepBar <= maxSweepAge and bar_index > bullSweepBar ``` Similarly for bear. Fibonacci for long setup: leg = lastPL → lastPH (recent up-leg). Zone: ```pinescript legL = lastPH - lastPL zoneTopL = lastPH - legL * fibMin zoneBotL = lastPH - legL * fibMax fibTPL = lastPL + legL * fibTPx // 1.618 extension measured from low ``` Actually standard extension: TP at fibTPx of the leg measured from the swing low: lastPL + legL * fibTPx. With fibTPx = 1.618 gives target above lastPH. Good. Some measure from zone end; keep simple. For short: leg = lastPH → lastPL down leg; retracement up into zone: ```pinescript legS = lastPH - lastPL zoneTopS = lastPL + legS * fibMax zoneBotS = lastPL + legS * fibMin fibTPS = lastPL - legS * (fibTPx - 1) // hmm ``` For shorts, target below the swing low: extension = lastPL - legS * 0.618 for 1.618 extension? Let's define: short entry around retracement of the down leg; TP at fibTPx extension measured from swing high: lastPH - legS * fibTPx. With 1.618: lastPH - 1.618*legS which is below lastPL by 0.618*legS. Good, consistent. Entry zone for short: price rallies back up: zoneBotS = lastPL + legS * fibMin (0.5 retrace), zoneTopS = lastPL + legS * fibMax (0.786). Price must be within: high >= zoneBotS and close <= zoneTopS. Entry conditions: ```pinescript inZoneL = low <= zoneTopL and close >= zoneBotL priceActionBull = close > open // bullish candle confirmation emaOkL = not useEMA or close > ta.ema(close, emaLen) ``` Careful: calling ta.ema inside expression with condition is fine if we compute it outside. ```pinescript ema = ta.ema(close, emaLen) emaOkL = not useEMA or close > ema emaOkS = not useEMA or close < ema longSig = trend == 1 and bullSweepLive and inZoneL and priceActionBull and emaOkL shortSig = trend == -1 and bearSweepLive and inZoneS and priceActionBear and emaOkS ``` Also require flat position: strategy.position_size == 0. Risk calc: ```pinescript atr = ta.atr(atrLen) var float slL = na var float tpL = na var float entryRiskL = na if longSig and strategy.position_size == 0 slL := math.min(bullSweepLow, low) - atr * slBuf risk = close - slL fibTarget = fibTPL rrTarget = close + risk * rrMin tpL := useFibTP ? math.max(fibTarget, rrTarget) : rrTarget // ensure min RR if (tpL - close) / risk < rrMin tpL := close + risk * rrMin strategy.entry("Long", strategy.long) ``` Hmm wait — with process_orders_on_close=true, entry fills at close of signal bar. So strategy.position_avg_price ≈ close. Trailing stop management. I'll manage manually with strategy.exit each bar: ```pinescript var float trailStopL = na var float slLong = na var float tpLong = na if strategy.position_size > 0 entryP = strategy.position_avg_price riskL = entryP - slLong // activate trailing if useTrail and close >= entryP + riskL * trailAct cand = close - atr * trailATR trailStopL := math.max(nz(trailStopL, cand), cand) effStop = not na(trailStopL) ? trailStopL : slLong strategy.exit("Long-Exit", from_entry="Long", stop=effStop, limit=tpLong) else trailStopL := na ``` Also on entry we set slLong, tpLong, trailStopL := na. Wait, ordering: the entry order placed with strategy.entry on signal bar with process_orders_on_close fills on that bar's close. Then next bar position_size > 0. The exit should be placed once position opens. But we can also place strategy.exit right after strategy.entry — Pine allows placing exit orders that activate when entry fills. Simpler: place strategy.exit on every bar while in position, and also immediately after entry. Actually strategy.exit persists until filled or cancelled; we can call it once after entry and then update stop as trailing. Calling strategy.exit each bar with updated stop is the standard trailing approach. Let me restructure to avoid state bugs: ```pinescript // On signal if longSig and strategy.position_size == 0 slLong := math.min(low, bullSweepLow) - atr * slBuf riskPts = close - slLong tpLong := useFibTP and fibTPL > close + riskPts * rrMin ? fibTPL : close + riskPts * rrMin trailStopL := na strategy.entry("Long", strategy.long) ``` Hmm, if useFibTP and fib target is nearer than min RR target, we take RR target. If fib is farther, use fib. So tpLong = useFibTP ? math.max(fibTPL, close + riskPts*rrMin) : close + riskPts*rrMin. math.max works since both above entry. Then each bar: ```pinescript if strategy.position_size > 0 ep = strategy.position_avg_price rsk = ep - slLong if useTrail and high >= ep + rsk * trailAct cand = close - atr * trailATR trailStopL := math.max(nz(trailStopL, cand), cand) effStop = useTrail ? math.max(slLong, nz(trailStopL, slLong)) : slLong strategy.exit("XL", "Long", stop=effStop, limit=tpLong) ``` For short mirrored: ```pinescript if shortSig and strategy.position_size == 0 slShort := math.max(high, bearSweepHigh) + atr * slBuf riskPts = slShort - close tpShort := useFibTP ? math.min(fibTPS, close - riskPts*rrMin) : close - riskPts*rrMin trailStopS := na strategy.entry("Short", strategy.short) ``` fibTPS = lastPL - (lastPH - lastPL) * (fibTPx - 1)? Wait earlier I defined fibTPS = lastPH - legS * fibTPx. legS = lastPH - lastPL. So fibTPS = lastPH - legS * 1.618 = lastPL - legS * 0.618. That's below lastPL. Good. Use math.min to pick the farther (lower) target? For shorts, target lower is farther → more profit. math.min(fibTPS, rrTarget) picks the lower one. But wait, if fib target is lower (farther), that's the bigger target — good. If rrTarget is lower, take rrTarget. So tpShort = math.min(fibTPS, close - riskPts*rrMin). Good. Trailing for short: ```pinescript if strategy.position_size < 0 ep = strategy.position_avg_price rsk = slShort - ep if useTrail and low <= ep - rsk * trailAct cand = close + atr * trailATR trailStopS := math.min(nz(trailStopS, cand), cand) effStop = useTrail ? math.min(slShort, nz(trailStopS, slShort)) : slShort strategy.exit("XS", "Short", stop=effStop, limit=tpShort) ``` Also reset vars when flat: ```pinescript if strategy.position_size == 0 trailStopL := na trailStopS := na ``` Careful: if we reset trailStop on the same bar the position closes, that's fine. Edge: When flat and setting up entry vars — slLong etc. are var so they persist; fine. Plots: - EMA line - Fib zone fill for the active leg — draw with line objects or plot? Simpler: plot zone top/bot only when a setup is live. Plot with plot() and display? Using plot with condition and style area might be messy. Use lines/boxes. I'll draw a box for fib zone when sweep is live: Maybe simpler: draw fib zone box at the moment of entry signal, and lines for SL/TP while in position: ```pinescript plot(strategy.position_size > 0 ? slLong : na, "Long SL", color.red, 2, plot.style_linebr) plot(strategy.position_size > 0 ? tpLong : na, "Long TP", color.green, 2, plot.style_linebr) ``` And trailing stop line: ```pinescript plot(strategy.position_size > 0 and not na(trailStopL) ? trailStopL : na, "Trail", color.orange, 2, plot.style_linebr) ``` Fib zone: use fill between two plots when bullSweepLive: ```pinescript pZT = plot(bullSweepLive and trend == 1 ? zoneTopL : na, ...) pZB = plot(bullSweepLive and trend == 1 ? zoneBotL : na, ...) fill(pZT, pZB, color=color.new(color.green, 85)) ``` Hmm, plots with na break fills? fill works with line breaks (na gaps) — fill between plots with na shows nothing in gaps; acceptable. Actually plot with na values: fill only fills where both series have values. With na in between, it just doesn't fill there. Fine. Sweep markers: ```pinescript plotshape(bullSweep, "Bull Sweep", shape.triangleup, location.belowbar, color.green, size=size.small) plotshape(bearSweep, "Bear Sweep", shape.triangledown, location.abovebar, color.red, size=size.small) ``` Swing labels: use label.new in pivot detection blocks. Also add alertcondition for signals. Alerts: strategy has alert_message options; can add alertcondition for long/short signals. Backtest note: process_orders_on_close=true makes entries at bar close — realistic for close-confirmed signals. Let me also add a session/date filter? Maybe simple date range input for backtesting. Add optional: ```pinescript g6 = "Backtest Window" startDate = input.time(timestamp("1 Jan 2020"), "Start", group=g6) endDate = input.time(timestamp("1 Jan 2030"), "End", group=g6) inWindow = time >= startDate and time <= endDate ``` Then longSig := longSig and inWindow. Now, potential compile issues to double check: 1. `ta.pivothigh(pivLen, pivLen)` — signature ta.pivothigh(source, leftbars, rightbars) or ta.pivothigh(leftbars, rightbars) using high by default. Fine. 2. Wick ratio: if minWick = 0 then condition wick >= 0 always true. Good — default 0.4? A sweep bar typically has a decent lower wick. Let me default minWick to 0.3 maybe. Actually let me default 0.25 to not over-filter. Hmm. I'll set 0.3. 3. `bullSweepLive` requires bar_index > bullSweepBar — but actually entry could be on the sweep bar itself if it closes back above and is in the zone... The sweep bar low broke below lastPL and closed above; the close might be within fib zone already. Should we allow same-bar entry? That could be a strong signal (sweep + reclaim + in zone). But the candle closed bullish after sweeping — entering at close of the sweep bar is valid price action (rejection). Let me allow it: bullSweepLive = not na(bullSweepBar) and bar_index - bullSweepBar <= maxSweepAge. Allow bar_index == bullSweepBar too. Hmm, but then inZoneL uses close which is above lastPL... The zone is between 0.5 and 0.786 retracement; the sweep bar's close could be there. OK allow it. Wait, but there's an ordering problem: `lastPL` updates when pivot confirmed (pivLen bars after the actual low). The sweep compares current low to lastPL (the most recent *confirmed* pivot low). The current sweep low itself will eventually become a new pivot low (confirmed later), possibly raising lastPL above the sweep level... that's fine, structure evolves. One more consideration: trend == 1 requires HH and HL. The sweep low breaks below lastPL — if a new pivot low forms below the previous one, structure might flip to bearish (LL), conflicting. But trend is evaluated from confirmed pivots; at sweep time trend is still from previous structure. The entry happens within maxSweepAge bars, likely before new pivot confirms. There's an inherent conflict: sweeping below the last HL means the next pivot could be a LL which would flip trend bearish. This is the classic tension in these strategies. Acceptable — the trend was bullish when the sweep happened. Also, maybe require the sweep low to be above the *previous* HL? That would be a "higher low sweep" — sweeping liquidity below the last swing low while staying above the older HL. Could add as an option: "sweep must hold above prior higher-low". Hmm, keep it simpler; maybe add condition that close remains above prevPL? Let me not overcomplicate. I could add optional filter: `requireTrendHold = input.bool(true,...)` and condition `low > prevPL` for longs? Actually that's a nice price-action filter: the sweep takes out the last HL (lastPL) but holds above the previous HL (prevPL), preserving structure. If it breaks prevPL, structure is likely broken. I'll include it as an option default true. For shorts: high < prevPH. But careful when prevPL is na — guard with na() checks: `not na(prevPL) ? low > prevPL : true`. 4. var declarations with types and na: `var int bullSweepBar = na` — allowed in v5? `var int x = na` yes. 5. Using `strategy.position_size` in conditions fine. 6. `strategy.exit("XL", "Long", stop=..., limit=...)` — signature: strategy.exit(id, from_entry, qty, qty_percent, profit, limit, loss, stop, ...). Positional second arg is from_entry. Fine. 7. plotshape with series bool bullSweep fine. 8. Labels: create HH/HL/LH/LL labels. ```pinescript if showLbl and not na(ph) txt = not na(prevPH) and ph > prevPH ? "HH" : "LH" col = txt == "HH" ? color.new(color.green,0) : color.new(color.red,0) label.new(bar_index - pivLen, ph, txt, style=label.style_label_down, color=col, textcolor=color.white, size=size.tiny) if showLbl and not na(pl) txt = not na(prevPL) and pl < prevPL ? "HL" : "LL" col = txt == "HL" ? color.new(color.green,0) : color.new(color.red,0) label.new(bar_index - pivLen, pl, txt, style=label.style_label_up, color=col, textcolor=color.white, size=size.tiny) ``` Note: prevPH at that time is the previously stored lastPH — correct comparison. 9. Fib lines drawing: maybe draw fib lines (0.5, 0.618, 0.786) when setup live using plot. Keep the zone fill plus maybe 0.618 golden line: I'll draw the zone fill only, plus entry/SL/TP lines while in position. 10. Multiple entries: prevent re-entry while in position — conditions already require strategy.position_size == 0. Also prevent immediate re-entry after stop-out same direction? Optional cooldown. Skip. 11. `strategy.entry("Long", strategy.long)` — id "Long". 12. Also add optional breakeven? The trailing activation at 1R sort of handles it. Could add "move SL to breakeven at X R" option. Trail activation effectively is similar. Keep trailing only. Let me also handle the case where user disables trailing: effStop = slLong. Also when useTrail but trail not yet activated: effStop = slLong. Good. Let me now also double-check the trailing update uses close vs high: `if high >= ep + rsk * trailAct` — activates intrabar based on high, but cand computed from close - atr*trailATR. Since we use stop orders evaluated next bar (broker emulator), it's an approximation. Acceptable for a template. Alternatively compute cand from high: cand = high - atr*trailATR? Using close is conservative. Keep close. One subtle bug: `trailStopL := math.max(nz(trailStopL, cand), cand)` — nz(trailStopL, cand) returns cand when na, then max(cand, cand)=cand. Good. Also ensure effStop never above current price for longs (stop must be below price). If close dropped sharply, trail from previous bar could be above current close → stop would trigger immediately at open of next bar (stop market). That's fine/realistic-ish. Now RR sanity: `(tpL - close)/risk` may be < rrMin if fib target small? We used math.max to enforce. For shorts math.min. Good. Also guard risk > 0: if slL >= close (weird), skip entry. Add `riskPts > 0` check... With sweep low below close, slL = min(sweepLow, low) - buf → below close. Always positive. OK but sweep may be old (up to maxSweepAge bars) and price could have dropped below sweepLow? Then close < slL → negative risk → math.max(fibTPL, close + negative) weird. Add validity: require close > slL. I'll compute conditionally: ```pinescript longRiskOK = close > slLong ``` Set slLong first then check. In the if block: ```pinescript if longSig and strategy.position_size == 0 slLong := math.min(bullSweepLow, low) - atr * slBuf riskPts = close - slLong if riskPts > 0 ... strategy.entry(...) ``` If riskPts <= 0, no entry — fine. Now think about `trend` var — `var int trend = 0` then `trend := bullStruct ? 1 : bearStruct ? -1 : trend`. Good. Date window: include. Alerts: ```pinescript alertcondition(longSig, "Long Signal", "MS+Fib+Sweep LONG {{ticker}} {{interval}}") alertcondition(shortSig, "Short Signal", "MS+Fib+Sweep SHORT") ``` Also could add strategy alert messages in entry calls. alertcondition works in strategies too (yes, alertcondition is allowed in strategies? Actually alertcondition() is allowed only in indicators? Let me recall: In Pine v5, alertcondition works in indicators; in strategies, you use strategy alerts and alert_message. Hmm. The docs: "alertcondition — creates alert condition in indicators". I believe alertcondition is indeed indicator-only historically, but I think Pine allows alertcondition in strategies now? Checking memory: The reference manual says: "It does not work in strategies." Actually I recall alertcondition is allowed in strategies since... Hmm. To be safe, use alert_message parameter in strategy.entry and note that users can create alerts on order fills. Or just skip alertcondition and mention alerts via "Order fills". Safer: skip alertcondition; mention alert() function calls: `if longSig ... strategy.entry(..., alert_message="LONG")` and user selects "Any alert() function call"? alert() fires immediately — fine too. Simpler: just mention setting alerts on the strategy's order fill events. I'll include alert_message strings. Plot colors and formatting fine. Now the fib zone plots need series available even when na — plot(na) fine. Potential issue: plotting zoneTopL etc. when lastPH/lastPL na → na automatically (na propagates). OK. Write plotting: ```pinescript showZone = bullSweepLive and trend == 1 and strategy.position_size == 0 p1 = plot(showZone ? zoneTopL : na, "Long Fib Zone Top", color.new(color.teal, 0), 1, plot.style_linebr) p2 = plot(showZone ? zoneBotL : na, "Long Fib Zone Bottom", color.new(color.teal, 0), 1, plot.style_linebr) fill(p1, p2, color=color.new(color.teal, 88)) showZoneS = bearSweepLive and trend == -1 and strategy.position_size == 0 p3 = plot(showZoneS ? zoneTopS : na, "Short Fib Zone Top", color.new(color.orange,0), 1, plot.style_linebr) p4 = plot(showZoneS ? zoneBotS : na, "Short Fib Zone Bottom", color.new(color.orange,0), 1, plot.style_linebr) fill(p3, p4, color=color.new(color.orange, 88)) ``` Position lines: ```pinescript plot(strategy.position_size > 0 ? slLong : na, "SL", color.new(color.red,0), 2, plot.style_linebr) plot(strategy.position_size > 0 ? tpLong : na, "TP", color.new(color.green,0), 2, plot.style_linebr) plot(strategy.position_size > 0 ? trailStopL : na, "Trail", color.new(color.orange,0), 1, plot.style_linebr) ``` Similar for short. EMA plot. Also background tint for trend: ```pinescript bgcolor(trend == 1 ? color.new(color.green, 96) : trend == -1 ? color.new(color.red, 96) : na) ``` Now, one more thing: strategy declaration params — process_orders_on_close=true is helpful for this style (enter on signal bar close). Include pyramiding=0 default. Also default_qty_value=10% equity. Commission 0.05%. Let me now assemble everything carefully and mentally compile line by line. ```pinescript //@version=5 strategy("Market Structure + Fib + Liquidity Sweep — Sniper", overlay = true, initial_capital = 10000, default_qty_type = strategy.percent_of_equity, default_qty_value = 10, commission_type = strategy.commission.percent, commission_value = 0.05, slippage = 2, pyramiding = 0, process_orders_on_close = true, max_labels_count = 500, max_lines_count = 500) //────────────────────────────────────────────── // INPUTS //────────────────────────────────────────────── g1 = "① Market Structure" pivLen = input.int(5, "Swing (Pivot) Length", minval = 2, group = g1) showLbl = input.bool(true, "Show HH / HL / LH / LL Labels", group = g1) g2 = "② Liquidity Sweep" maxSweepAge = input.int(10, "Setup valid for N bars after sweep", minval = 1, maxval = 50, group = g2) minWick = input.float(0.30, "Min wick ratio of sweep candle (0 = off)", minval = 0, maxval = 1, step = 0.05, group = g2) holdStruct = input.bool(true, "Sweep must NOT break previous swing (structure intact)", group = g2) g3 = "③ Fibonacci" fibMin = input.float(0.500, "Entry zone — start (retracement)", step = 0.01, group = g3) fibMax = input.float(0.786, "Entry zone — end (retracement)", step = 0.01, group = g3) fibTPx = input.float(1.618, "TP extension", step = 0.01, group = g3) useFibTP = input.bool(true, "Use Fib extension for TP (else R-multiple)", group = g3) g4 = "④ Risk / Exit" atrLen = input.int(14, "ATR length", group = g4) slBuf = input.float(1.0, "SL buffer (× ATR)", step = 0.1, group = g4) rrMin = input.float(1.5, "Minimum R:R", step = 0.1, group = g4) useTrail = input.bool(true, "Trailing stop", group = g4) trailAct = input.float(1.0, "Activate trail after price moves (R)", minval = 0.1, step = 0.1, group = g4) trailATR = input.float(2.0, "Trail distance (× ATR)", minval = 0.1, step = 0.1, group = g4) g5 = "⑤ Price-Action Filters" useEMA = input.bool(true, "EMA trend filter", group = g5) emaLen = input.int(200, "EMA length", group = g5) bodyMax = ... ``` Hmm, do I want an engulfing/confirmation input? Could add "candle must close bullish" inherently. Keep as is. Maybe add optional RSI filter? Extra complexity; skip to keep code robust. Actually maybe add a simple optional "reclaim" requirement already in sweep. Fine. Date window: ```pinescript g6 = "⑥ Backtest window" startTime = input.time(timestamp("1 Jan 2018 00:00 +0000"), "Start", group = g6) endTime = input.time(timestamp("1 Jan 2069 00:00 +0000"), "End", group = g6) inWindow = time >= startTime and time <= endTime ``` Now core logic: ```pinescript //────────────────────────────────────────────── // 1) MARKET STRUCTURE (swing points + HH/HL/LH/LL) //────────────────────────────────────────────── ph = ta.pivothigh(pivLen, pivLen) pl = ta.pivotlow(pivLen, pivLen) var float lastPH = na var float prevPH = na var float lastPL = na var float prevPL = na if not na(ph) prevPH := lastPH lastPH := ph if showLbl isHH = not na(prevPH) and ph > prevPH label.new(bar_index - pivLen, ph, isHH ? "HH" : "LH", style = label.style_label_down, color = isHH ? color.new(color.teal, 20) : color.new(color.red, 20), textcolor = color.white, size = size.tiny) if not na(pl) prevPL := lastPL lastPL := pl if showLbl isHL = not na(prevPL) and pl < prevPL label.new(bar_index - pivLen, pl, isHL ? "HL" : "LL", style = label.style_label_up, color = isHL ? color.new(color.teal, 20) : color.new(color.red, 20), textcolor = color.white, size = size.tiny) ``` Wait: inside `if not na(ph)` block, prevPH was just updated to old lastPH; comparing ph > prevPH compares new pivot to previous pivot. Correct. Structure trend: ```pinescript haveBoth = not na(lastPH) and not na(prevPH) and not na(lastPL) and not na(prevPL) bullStruct = haveBoth and lastPH > prevPH and lastPL > prevPL // HH + HL bearStruct = haveBoth and lastPH < prevPH and lastPL < prevPL // LH + LL var int trend = 0 trend := bullStruct ? 1 : bearStruct ? -1 : trend ``` Liquidity sweep: ```pinescript //────────────────────────────────────────────── // 2) LIQUIDITY SWEEP (stop-hunt wick through a swing point) //────────────────────────────────────────────── barRng = high - low wickLow = barRng > 0 ? (math.min(open, close) - low) / barRng : 0.0 wickHigh = barRng > 0 ? (high - math.max(open, close)) / barRng : 0.0 structOKL = not holdStruct or na(prevPL) or low > prevPL structOKS = not holdStruct or na(prevPH) or high < prevPH bullSweep = not na(lastPL) and low < lastPL and close > lastPL and close > open and (minWick == 0 or wickLow >= minWick) and structOKL bearSweep = not na(lastPH) and high > lastPH and close < lastPH and close < open and (minWick == 0 or wickBear >= minWick) and structOKS ``` Rename wickLow→lowerWick, wickHigh→upperWick to avoid confusion. Also store: ```pinescript var int bullSweepBar = na var float bullSweepLow = na var int bearSweepBar = na var float bearSweepHigh = na if bullSweep bullSweepBar := bar_index bullSweepLow := low if bearSweep bearSweepBar := bar_index bearSweepHigh := high bullSweepLive = not na(bullSweepBar) and bar_index - bullSweepBar <= maxSweepAge bearSweepLive = not na(bearSweepBar) and bar_index - bearSweepBar <= maxSweepAge ``` Fibonacci: ```pinescript //────────────────────────────────────────────── // 3) FIBONACCI (auto levels from the last swing leg) //────────────────────────────────────────────── legUp = lastPH - lastPL zoneTopL = lastPH - legUp * fibMin // shallow level (0.5) zoneBotL = lastPH - legUp * fibMax // deep level (0.786) fibTPL = lastPL + legUp * fibTPx // extension target zoneBotS = lastPL + legUp * fibMin // for shorts: pullback UP into zone zoneTopS = lastPL + legUp * fibMax fibTPS = lastPH - legUp * fibTPx ``` Using legUp for both directions since it's the same last swing leg (lastPL→lastPH). For short, the leg is down from lastPH to lastPL; retracement up: level = lastPL + legUp * fibRatio. At 0.786: lastPL + 0.786*legUp (below lastPH). Zone from 0.5 to 0.786 retracement — price rallies into it. Good, same numbers. fibTP for short = lastPH - legUp * fibTPx → below lastPL when fibTPx > 1. Good. Price action filters: ```pinescript ema = ta.ema(close, emaLen) emaOKL = not useEMA or close > ema emaOKS = not useEMA or close < ema inZoneL = close <= zoneTopL and close >= zoneBotL and low <= zoneTopL inZoneS = close >= zoneBotS and close <= zoneTopS and high >= zoneBotS ``` Hmm for long: price must have touched zone (low <= zoneTopL) and close inside zone or above its bottom (close >= zoneBotL). If close > zoneTopL, it's above zone — did it "pull back into" the zone? If low <= zoneTopL, it tapped the zone but closed above — that's a tap-and-reject, arguably fine, but our entry candle close should ideally be in/above zone bottom. Let me require: low <= zoneTopL and close >= zoneBotL and close <= zoneTopL? That forces close inside the zone. Cleaner: `low <= zoneTopL and close >= zoneBotL` allows close above zone top if it tapped the zone intrabar — that's actually a spring entry with strong close. Hmm, but then fib zone isn't really the entry trigger. For clarity and backtest logic, require close within zone: close <= zoneTopL and close >= zoneBotL and low <= zoneTopL (last redundant). I'll use `close <= zoneTopL and close >= zoneBotL and low <= zoneTopL` — the low condition ensures the zone was actually touched (with close inside zone, low is automatically <= close <= zoneTopL, so redundant). So just `close <= zoneTopL and close >= zoneBotL`. But wait — if close is inside zone, low <= close <= zoneTopL automatically. Yes redundant. Keep simple: inZoneL = close >= zoneBotL and close <= zoneTopL inZoneS = close <= zoneTopS and close >= zoneBotS Also require price hasn't invalidated the setup: for long, close should be above sweep low (it is, since close > lastPL > ... hmm lastPL vs sweepLow: sweepLow < lastPL). close > lastPL ensured at sweep bar; later bars could close below sweepLow → invalidation. Add: close > bullSweepLow for live setup. Similarly close < bearSweepHigh. Signals: ```pinescript //────────────────────────────────────────────── // 4) ENTRY SIGNALS (all confluences together) //────────────────────────────────────────────── longSetup = trend == 1 and bullSweepLive and close > bullSweepLow and inZoneL and close > open and emaOKL and inWindow and barstate.isconfirmed shortSetup = trend == -1 and bearSweepLive and close < bearSweepHigh and inZoneS and close < open and emaOKS and inWindow and barstate.isconfirmed ``` barstate.isconfirmed — with process_orders_on_close, signals evaluate on realtime bar; requiring isconfirmed prevents repaint/intrabar flicker. In historical bars isconfirmed is always true. Good practice. But note: strategy with process_orders_on_close executes on bar close anyway; adding isconfirmed is belt & braces. Position management: ```pinescript //────────────────────────────────────────────── // 5) RISK: SL / TP / TRAILING //────────────────────────────────────────────── atr = ta.atr(atrLen) var float slLong = na, ... ``` No comma multi-declare. Write separately. ```pinescript var float slLong = na var float tpLong = na var float trailLong = na var float slShort = na var float tpShort = na var float trailShort = na if longSetup and strategy.position_size == 0 slLong := math.min(low, bullSweepLow) - atr * slBuf riskPts = close - slLong if riskPts > 0 fibTgt = fibTPL rTgt = close + riskPts * rrMin tpLong := useFibTP ? math.max(fibTgt, rTgt) : rTgt trailLong := na strategy.entry("Long", strategy.long, alert_message = "LONG " + syminfo.ticker) if shortSetup and strategy.position_size == 0 slShort := math.max(high, bearSweepHigh) + atr * slBuf riskPts = slShort - close if riskPts > 0 fibTgt = fibTPS rTgt = close - riskPts * rrMin tpShort := useFibTP ? math.min(fibTgt, rTgt) : rTgt trailShort := na strategy.entry("Short", strategy.short, alert_message = "SHORT " + syminfo.ticker) ``` Exits + trailing: ```pinescript if strategy.position_size > 0 ep = strategy.position_avg_price rsk = ep - slLong if useTrail and rsk > 0 and high >= ep + rsk * trailAct cand = close - atr * trailATR trailLong := math.max(nz(trailLong, cand), cand) effStop = math.max(slLong, nz(trailLong, slLong)) strategy.exit("X-Long", from_entry = "Long", stop = effStop, limit = tpLong, alert_message = "EXIT LONG") if strategy.position_size < 0 ep = strategy.position_avg_price rsk = slShort - ep if useTrail and rsk > 0 and low <= ep - rsk * trailAct cand = close + atr * trailATR trailShort := math.min(nz(trailShort, cand), cand) effStop = math.min(slShort, nz(trailShort, slShort)) strategy.exit("X-Short", from_entry = "Short", stop = effStop, limit = tpShort, alert_message = "EXIT SHORT") ``` Note: for longs I wrote `if useTrail and rsk > 0 and high >= ...`? In my long block I omitted useTrail in activation — include it: `if useTrail and rsk > 0 and high >= ep + rsk * trailAct`. Yes. Note: strategy.exit called repeatedly each bar while in position with updated stop — standard. One catch: strategy.exit persists; when called again it modifies. Good. Also reset trail when flat: ```pinescript if strategy.position_size == 0 trailLong := na trailShort := na ``` Place this before the entry blocks? Order of execution: statements run top to bottom each bar. If we reset at top when flat, then entry sets things. Fine. But careful: with process_orders_on_close, when entry fills at close of signal bar, position_size becomes >0 on that same bar's close? Actually with process_orders_on_close=true, the order executes at the close of the current bar, and strategy.position_size updates on that bar. So the same bar: longSetup → entry placed → executed at close → position_size > 0 already at end of bar? The docs: process_orders_on_close — orders are executed on the close of the bar, so position updates within the same bar calculation. Hmm, actually the execution happens after the script calculation for that bar? In practice, with process_orders_on_close=true, when you call strategy.entry on bar N, the trade shows entry price = close of bar N, and strategy.position_size on bar N... I believe the fill occurs at the end of bar N so on bar N+1 strategy.position_size reflects it. Hmm. Actually testing knowledge: with process_orders_on_close=true, orders generated during bar N are executed at bar N's close; strategy.position_size is updated immediately after — so within bar N's calculation, position_size is still 0 when checked before/after the entry call? The entry call itself doesn't change position_size during script execution; the broker emulator processes it after. I believe position_size reflects on the same bar's end in the strategy tester tab... For our logic it doesn't matter much: exit placement block `if strategy.position_size > 0` runs on the next bar at latest, placing the stop/limit. The only risk: if the very next bar gaps through the stop, exit still placed that bar with stop → executes at open? Orders placed during bar N+1 calculation execute at close of N+1 (process_orders_on_close) — meaning stop/limit would execute at bar N+1 close rather than intrabar! Hmm, that's a subtlety: with process_orders_on_close=true, ALL orders including strategy.exit stop/limit execute on close?? Let me think. process_orders_on_close: "the orders are executed on the close of the current bar instead of the open of the next bar" — applies to market orders mainly. Stop/limit orders with process_orders_on_close... I recall that stop-loss/limit orders from strategy.exit are still evaluated intrabar even with process_orders_on_close? No wait — actually there's a known behavior: with process_orders_on_close=true, exit stop orders are also processed on close, which distorts stops (they fill at close rather than the stop level? no — stop orders fill at stop level or worse, but timing shifts to close). Hmm, from TradingView docs: `process_orders_on_close (const bool)` — "Allows the strategy to execute orders on the close of the current bar instead of on the open of the next bar. ... " I believe it applies to all orders generated at that bar's close. Many strategy templates use it for close-confirmed entries. The stop-loss placed by strategy.exit on bar N executes intrabar on bar N+1 regardless? Actually the mechanics: orders calculated during bar N's script execution are placed; without process_orders_on_close they fill at bar N+1 open (market) or during N+1 (stop/limit when price crosses). With process_orders_on_close, market orders fill at bar N close. For stop/limit: they remain active and fill when price hits the level during subsequent bars — I believe process_orders_on_close doesn't affect stop/limit triggers, they still trigger intrabar when the level is crossed. Hmm, but if the stop is placed during bar N+1's calculation (because position opened at N's close... or N's?)... Simplify: to ensure exits are active ASAP, call strategy.exit immediately after strategy.entry in the same block (exit orders attach to the entry, activating once filled). Then trailing updates modify it each bar. ```pinescript strategy.entry("Long", strategy.long) strategy.exit("X-Long", from_entry="Long", stop=slLong, limit=tpLong) ``` This is cleaner: the exit is pre-placed; it becomes active when the entry fills. Then subsequent bars update stop for trailing. Then the position-management block also runs each bar while in position. But there's an ordering issue: on the signal bar, after entry block sets slLong/tpLong, the management block checks `strategy.position_size > 0` which is still 0 during that bar, so no double-call — fine, exit pre-placed anyway. Next bar, management block updates with trailing. Wait, but if I call strategy.exit in the entry block AND in management block, that's fine (same ID updates). Let me restructure: ```pinescript // Entry blocks (set slLong/tpLong, entry, initial exit) // Management blocks (trailing update + strategy.exit re-issued each bar in position) ``` Both call strategy.exit with same id "X-Long" — allowed, it modifies the existing order. Good. Another subtlety: `rsk = ep - slLong` uses slLong from entry. If slLong is na (shouldn't be when in position), math errors. Guard with `not na(slLong)`. Now visuals — position lines: plot slLong etc. when in position: ```pinescript inL = strategy.position_size > 0 inS = strategy.position_size < 0 plot(inL ? slLong : na, "SL (long)", color.new(color.red, 0), 2, plot.style_linebr) plot(inL ? tpLong : na, "TP (long)", color.new(color.green, 0), 2, plot.style_linebr) plot(inL and not na(trailLong) ? trailLong : na, "Trail (long)", color.new(color.orange, 0), 2, plot.style_linebr) ``` Same for short. Zone fills: ```pinescript showZL = bullSweepLive and trend == 1 and strategy.position_size == 0 and inWindow pZTL = plot(showZL ? zoneTopL : na, "Fib zone top (long)", color.new(color.teal, 40), 1, plot.style_linebr) pZBL = plot(showZL ? zoneBotL : na, "Fib zone bot (long)", color.new(color.teal, 40), 1, plot.style_linebr) fill(pZTL, pZBL, color = color.new(color.teal, 85)) showZS = bearSweepLive and trend == -1 and strategy.position_size == 0 and inWindow pZTS = plot(showZS ? zoneTopS : na, "Fib zone top (short)", color.new(color.orange, 40), 1, plot.style_linebr) pZBS = plot(showZS ? zoneBotS : na, "Fib zone bot (short)", color.new(color.orange, 40), 1, plot.style_linebr) fill(pZTS, pZBS, color = color.new(color.orange, 85)) ``` EMA: ```pinescript plot(useEMA ? ema : na, "EMA", color.new(color.gray, 0), 2) ``` Sweep markers: ```pinescript plotshape(bullSweep, "Bullish sweep", shape.triangleup, location.belowbar, color.new(color.teal,0), size = size.small, text="SWEEP") plotshape(bearSweep, "Bearish sweep", shape.triangledown, location.abovebar, color.new(color.red,0), size = size.small, text="SWEEP") ``` Background: ```pinescript bgcolor(trend == 1 ? color.new(color.teal, 96) : trend == -1 ? color.new(color.red, 96) : na) ``` Hmm — bgcolor with ternary fine. Alert conditions: In strategies, alertcondition is allowed? The Pine reference for alertcondition: "This function can be used only in indicators"? Hmm, actually I recall the docs saying it works in both but strategies typically use order-fill alerts. Let me just check memory: In Pine Script v5 reference, alertcondition — "Creates alert condition, that is available in Create Alert dialog. Please note, that alertcondition does NOT create an alert, it just gives you more options in Create Alert dialog." And there's a note: "alertcondition function requires study()..." I'm fairly sure historically it was indicators-only. In v5, using alertcondition in a strategy gives a compile error? I've seen strategies with alertcondition compile fine... Hmm. Actually I now recall: alertcondition IS allowed in strategies in v5 (they relaxed it). Let me not risk it — I'll skip alertcondition and rely on alert_message + tell user to enable order-fill alerts. Safe. Actually, I'm fairly confident alertcondition works in strategies in v5 — there are published scripts with it. But to be safe and clean, skip it. The alert_message on entry/exit plus "Order fills and alert() function calls" covers it. Now double-check pivot-based structure timing issue: pivots confirm pivLen bars later. lastPH/lastPL available at confirmation bar. Sweep compares to lastPL — the most recent confirmed swing low. Good, non-repainting (once confirmed, values fixed). Potential issue: On the very first bars, lastPL na → bullSweep false. Fine. `inZoneL` uses zone computed from lastPH & lastPL — the most recent confirmed swings. For a long, we want the most recent UP leg: from lastPL to lastPH. But what if lastPH was confirmed before lastPL (i.e., latest swing is a low, leg not yet complete)? Fib zone from lastPL→lastPH where lastPH is older and lastPL newer: zone computed = lastPH - (lastPH-lastPL)*0.5 — this measures retracement of the whole leg from PL to PH... if PL is newer and lower than previous structure... this gets murky. A cleaner approach: define the leg as from the most recent swing low to the most recent swing high *only if the high came after the low* (for longs). Track bar indices: var int lastPHbar, lastPLbar. For long setup require lastPHbar > lastPLbar (high formed after low → up leg). For short require lastPLbar > lastPHbar (low formed after high → down leg). That's more correct price action. Add: ```pinescript var int lastPHbar = na var int lastPLbar = na if not na(ph) ... lastPHbar := bar_index - pivLen if not na(pl) ... lastPLbar := bar_index - pivLen ``` Long requires trend==1 (HH+HL) and lastPHbar > lastPLbar. In an uptrend with HH/HL sequence: swings alternate HL then HH... Actually sequence: HL (pivot low), then HH (pivot high) — high after low. Then next HL after that HH. So for the most recent confirmed pair, if lastPHbar > lastPLbar, the last confirmed swing is a high → the leg from lastPL to lastPH is the most recent up-leg, and price is now retracing. For short: lastPLbar > lastPHbar → leg from lastPH down to lastPL, now pulling back up. Add these conditions. But hold on — with pivLen lag, by the time the HH is confirmed (pivLen bars later), price has often retraced a bit already. That's inherent. OK. Also the zone could be stale if price already moved beyond. The inZone + sweep filters handle. Now, another check: bullSweepLive requires trend==1 at entry. The sweep breaks below lastPL (the HL). If holdStruct is on, low must stay above prevPL. OK. Also possible conflict: `close > open` for sweep bar. If minWick==0, maybe allow any close back above? Keep close>open as it defines rejection candle. It's an input-less design choice; mention in notes. Now compile-check mentally for syntax errors: - `input.time(timestamp("1 Jan 2018 00:00 +0000"), "Start", group=g6)` — timestamp with date string OK. - plotshape with `text=` param OK. - fill(p1, p2, color=...) OK. - label.new named args OK. - `strategy.exit("X-Long", from_entry = "Long", stop = effStop, limit = tpLong, alert_message = "...")` — alert_message is a valid param for strategy.exit? Yes: strategy.exit has alert_message parameter. strategy.entry too. OK. - Using `effStop` computed inside if blocks — fine. One more: when useTrail is false, effStop = max(slLong, nz(trailLong, slLong)) — trailLong stays na (since activation requires useTrail), so effStop = slLong. Fine. But if useTrail true and activated, effStop = max(slLong, trail) — trail could theoretically be below slLong? cand = close - atr*trailATR; activation requires close >= ep + rsk*trailAct, and slLong = min(sweepLow, low) - buf; typically trail > slLong at activation, and only ratchets up. max() ensures never below initial SL. Good. Reset trailLong when flat — also reset after exit? When position closes (stop/limit), position_size becomes 0; next bar the reset block sets trailLong := na. But slLong/tpLong remain for plotting — plots gated by position_size so they won't show. OK. Edge: The reset block placement — put it after exit blocks: ```pinescript if strategy.position_size == 0 trailLong := na trailShort := na ``` Hmm wait, there's an ordering issue with process_orders_on_close and entry: On signal bar N (position 0 during calc), entry block runs, sets vars, places entry + exit. The `if strategy.position_size == 0` reset block would also run on bar N (position still 0 during calc) — but it runs BEFORE the entry block if placed earlier in code, or AFTER if placed later. If placed after entry block, it would reset trailLong to na — trailLong was just set to na anyway in entry block. Fine either way. slLong/tpLong not reset — good, they're needed once position opens. Actually wait — should reset also clear slLong/tpLong when flat? If we clear them when flat, then on signal bar after entry placement, the reset block (if placed after) would clear slLong before the exit order uses it? No — strategy.exit was already called with the values at call time. Values are copied. But plots gated on position wouldn't matter. However, the management block next bar uses slLong — if reset cleared it while position just opened... Sequence: bar N: position_size==0 during calc; entry placed; reset block (if after entry block) clears slLong → position opens at close of N → bar N+1: position_size>0, management uses slLong = na → effStop = max(na, ...) → error/na stop. BAD. So DON'T clear slLong/tpLong when flat. Only clear trail vars (which get recomputed anyway). Actually even trailLong cleared on bar N is fine since management recomputes from na → nz handles. OK. Hmm wait, one more: on bar N, management block `if strategy.position_size > 0` — during bar N calc, position_size is 0 (fill happens after). So initial exit must be placed in entry block (which I do). Also note: with process_orders_on_close=true, does the exit's stop also only trigger at close? Known behavior: with process_orders_on_close=true, stop/limit orders are still checked intrabar on subsequent bars; the setting only affects when NEW orders are executed (at close vs next open). Actually I recall: process_orders_on_close executes orders on the close of the bar where they were generated, rather than next open. Stop/limit from strategy.exit placed on bar N become active for bar N+1 and trigger intrabar when price crosses. Yes, that's right — exit stop/limit orders rest on the broker emulator and trigger intrabar. Only order *placement* timing shifts for market orders. Good. Now, is `strategy.entry` inside nested if with local vars OK? Yes. Check `math.max(slLong, nz(trailLong, slLong))` — if slLong na (shouldn't in position), na propagates. OK. Another detail: `strategy.exit` needs qty? Without qty, it closes full position. Yes, default closes all. Also: if both long and short could trigger... conditions are mutually exclusive (trend==1 vs -1). OK. Now the "change the world" framing — I should gently temper expectations: no script guarantees profits; must backtest, forward test. Brief, not preachy. Also explain how it works, inputs, and suggest settings/timeframes, and warn about pivot lag & repaint considerations (none here beyond standard). Also mention it's v5, works in TradingView. Let me also think about whether entry condition `inZoneL` uses current close within zone computed from swings — but zone uses legUp = lastPH - lastPL; if lastPH/lastPL na → zone na → inZoneL false. Good. Also `bullSweepLive` uses bullSweepBar not na — var int na check: `not na(bullSweepBar)` works for int na. Wait: `var int bullSweepBar = na` — declaring int var with na is fine in v5. Also I should ensure sweep uses the *unbroken* swing low: if a previous sweep already broke lastPL, lastPL still refers to that old swing low until a new pivot low confirms. Multiple sweeps of same level possible — fine, refreshes the setup window. One more improvement: require price hasn't already run to TP since sweep (i.e., close still below fibTPL for longs) — prevents chasing: ```pinescript close < fibTPL ``` Add to longSetup: `close < fibTPL` (target not yet hit). And shorts: `close > fibTPS`. Good touch. Also require the sweep low is below zone bottom? Not necessary. Let me also double check zone math example: lastPL=100, lastPH=120, legUp=20. Zone: top = 120 - 20*0.5=110; bottom=120-20*0.786=104.28. Price pulls back to ~104–110 → entry. SL = min(sweepLow, low) - ATR. If sweepLow was 99 (swept below 100), SL ≈ 99 - buf. TP ext = 100 + 20*1.618 = 132.36. RR depends. Good. Short: lastPH=120, lastPL=100. Zone: bottom = 100 + 20*0.5 = 110, top = 100 + 20*0.786 = 115.72. Entry when price rallies to 110–115.72 and bearish sweep happened (high > 120... wait bearSweep requires high > lastPH i.e. > 120 then close back below). Hmm — bear sweep sweeps ABOVE lastPH, then price falls back into zone 110–115 for entry. But if high > 120 and close < 120 on sweep bar, then subsequent bars rally to 110–115.72... plausible. But note: for short, trend==-1 means LH+LL. bearSweep high > lastPH sweeps above the LH. holdStruct requires high < prevPH (previous higher high). OK. fibTPS = lastPH - 20*1.618 = 120-32.36 = 87.64. Good. Now, trailing activation: after 1R. trail distance 2×ATR. Fine defaults. Also add optional "close ≥ fibTPL invalidation" — skip. What about the case where price hits TP zone but trail handles. I think the code is solid. Let me also consider adding a mini "cooldown" — after a loss, skip next signal? Optional, skip to keep manageable. Let me also add comments/sections and a header explaining logic. And after the code, a concise explanation: the 4 confluences, entry rules, exit rules, inputs table, how to use, honest disclaimer, tuning tips. One more syntax check on plotshape text param: plotshape(bullSweep, title, style=shape.triangleup, location=location.belowbar, color=..., size=size.small, text="SWEEP"). Signature: plotshape(series, title, style, location, color, offset, text, textcolor, editable, size, show_last, display). Positional after color is offset — so I must use named args for text/size. I'll use named args. Also plot char limits fine. Let me now also double-check the structOK lines: `structOKL = not holdStruct or na(prevPL) or low > prevPL` — when holdStruct true and prevPL exists, require low > prevPL. Good. Potential logic wrinkle: bullSweep requires low < lastPL AND low > prevPL (struct intact). So it sweeps the most recent HL only. Good — that's a proper "sweep of the last higher-low liquidity". Also maybe require lastPL actually existed for some time (liquidity accumulated) — skip. Entry also requires `barstate.isconfirmed` — in historical bars this is true. On realtime, prevents intrabar entries. With process_orders_on_close=true, entries happen at close anyway. Including isconfirmed is harmless & safe. Hmm, actually with process_orders_on_close=true and isconfirmed, on the realtime bar close the signal fires and order executes at that close — consistent. Now write the final response. Structure: 1. Quick honest note (one line) — no strategy prints money; this is a solid framework to test. Keep it brief and positive. 2. The full code block. 3. "How the strategy thinks" — the checklist/confluence logic. 4. Entry/SL/TP/trailing summary. 5. Inputs to tune + suggested timeframes. 6. How to use + test properly (paper trade, prop rules), brief. Keep the explanation reasonably tight; the code is the star. Use headers and a few bullet lists. Code comments in English (user wrote in English). The user's English is a bit broken but English — respond in English. Let me finalize the code text carefully now, writing it fully and scanning for errors. Final code: ```pinescript //@version=5 strategy("Market Structure + Fibonacci + Liquidity Sweep [All-in-One]", overlay = true, initial_capital = 10000, default_qty_type = strategy.percent_of_equity, default_qty_value = 10, commission_type = strategy.commission.percent, commission_value = 0.05, slippage = 2, pyramiding = 0, calc_on_every_tick = false, process_orders_on_close = true, max_labels_count = 500) //══════════════════════ INPUTS ══════════════════════ g1 = "① Market Structure" pivLen = input.int(5, "Swing (pivot) length", minval = 2, group = g1) showLbl = input.bool(true, "Show HH / HL / LH / LL labels", group = g1) g2 = "② Liquidity Sweep" maxSweepAge = input.int(10, "Setup stays valid for N bars after sweep", minval = 1, maxval = 50, group = g2) minWick = input.float(0.30, "Min wick % of sweep candle (0 = off)", minval = 0, maxval = 1, step = 0.05, group = g2) holdStruct = input.bool(true, "Sweep must not break the swing before it (structure intact)", group = g2) g3 = "③ Fibonacci" fibMin = input.float(0.500, "Entry zone start (retracement)", minval = 0.1, maxval = 0.9, step = 0.01, group = g3) fibMax = input.float(0.786, "Entry zone end (retracement)", minval = 0.1, maxval = 0.99, step = 0.01, group = g3) fibTPx = input.float(1.618, "Take-profit extension", minval = 1.0, step = 0.01, group = g3) useFibTP = input.bool(true, "Use Fib extension for TP (off = R-multiple)", group = g3) g4 = "④ Risk / Exit" atrLen = input.int(14, "ATR length", group = g4) slBuf = input.float(1.0, "Stop-loss buffer (× ATR)", minval = 0, step = 0.1, group = g4) rrMin = input.float(1.5, "Minimum reward:risk", minval = 0.5, step = 0.1, group = g4) useTrail = input.bool(true, "Use trailing stop", group = g4) trailAct = input.float(1.0, "Activate trail after price moves (R)", minval = 0.1, step = 0.1, group = g4) trailATR = input.float(2.0, "Trail distance (× ATR)", minval = 0.1, step = 0.1, group = g4) g5 = "⑤ Filters" useEMA = input.bool(true, "EMA trend filter", group = g5) emaLen = input.int(200, "EMA length", minval = 10, group = g5) g6 = "⑥ Backtest window" tStart = input.time(timestamp("1 Jan 2018 00:00 +0000"), "Start", group = g6) tEnd = input.time(timestamp("1 Jan 2069 00:00 +0000"), "End", group = g6) inWindow = time >= tStart and time <= tEnd ``` Then structure: ```pinescript //══════════════════════ ① MARKET STRUCTURE ══════════════════════ ph = ta.pivothigh(pivLen, pivLen) pl = ta.pivotlow(pivLen, pivLen) var float lastPH = na var float prevPH = na var int lastPHbar = na var float lastPL = na var float prevPL = na var int lastPLbar = na if not na(ph) prevPH := lastPH lastPH := ph lastPHbar := bar_index - pivLen if showLbl isHH = not na(prevPH) and ph > prevPH label.new(bar_index - pivLen, ph, isHH ? "HH" : "LH", style = label.style_label_down, color = isHH ? color.new(color.teal, 30) : color.new(color.red, 30), textcolor = color.white, size = size.tiny) if not na(pl) prevPL := lastPL lastPL := pl lastPLbar := bar_index - pivLen if showLbl isHL = not na(prevPL) and pl < prevPL label.new(bar_index - pivLen, pl, isHL ? "HL" : "LL", style = label.style_label_up, color = isHL ? color.new(color.teal, 30) : color.new(color.red, 30), textcolor = color.white, size = size.tiny) havePair = not na(lastPH) and not na(prevPH) and not na(lastPL) and not na(prevPL) bullStruct = havePair and lastPH > prevPH and lastPL > prevPL // HH + HL bearStruct = havePair and lastPH < prevPH and lastPL < prevPL // LH + LL var int trend = 0 trend := bullStruct ? 1 : bearStruct ? -1 : trend ``` Sweep: ```pinescript //══════════════════════ ② LIQUIDITY SWEEP ══════════════════════ barRng = high - low lowWick = barRng > 0 ? (math.min(open, close) - low) / barRng : 0.0 upWick = barRng > 0 ? (high - math.max(open, close)) / barRng : 0.0 okStructL = not holdStruct or na(prevPL) or low > prevPL okStructS = not holdStruct or na(prevPH) or high < prevPH bullSweep = not na(lastPL) and low < lastPL and close > lastPL and close > open and (minWick == 0 or lowWick >= minWick) and okStructL bearSweep = not na(lastPH) and high > lastPH and close < lastPH and close < open and (minWick == 0 or upWick >= minWick) and okStructS var int bullSweepBar = na var float bullSweepLow = na var int bearSweepBar = na var float bearSweepHigh = na if bullSweep bullSweepBar := bar_index bullSweepLow := low if bearSweep bearSweepBar := bar_index bearSweepHigh := high bullSweepLive = not na(bullSweepBar) and bar_index - bullSweepBar <= maxSweepAge bearSweepLive = not na(bearSweepBar) and bar_index - bearSweepBar <= maxSweepAge ``` typo: bearSweepLive should use bearSweepBar. Fix: `bearSweepLive = not na(bearSweepBar) and bar_index - bearSweepBar <= maxSweepAge`. Fib: ```pinescript //══════════════════════ ③ FIBONACCI ══════════════════════ legUp = lastPH - lastPL zoneTopL = lastPH - legUp * fibMin // 0.5 level (long zone top) zoneBotL = lastPH - legUp * fibMax // 0.786 level (long zone bottom) fibTPL = lastPL + legUp * fibTPx // long target zoneBotS = lastPL + legUp * fibMin // 0.5 level (short zone bottom) zoneTopS = lastPL + legUp * fibMax // 0.786 level (short zone top) fibTPS = lastPH - legUp * fibTPx // short target ``` Signals: ```pinescript //══════════════════════ ④ CONFLUENT SIGNALS ══════════════════════ emaV = ta.ema(close, emaLen) emaOKL = not useEMA or close > emaV emaOKS = not useEMA or close < emaV inZoneL = close >= zoneBotL and close <= zoneTopL inZoneS = close >= zoneBotS and close <= zoneTopS longSetup = trend == 1 and bullSweepLive and inZoneL and close > bullSweepLow and close < fibTPL and close > open and emaOKL and inWindow shortSetup = trend == -1 and bearSweepLive and inZoneS and close < bearSweepHigh and close > fibTPS and close < open and emaOKS and inWindow ``` Hmm `barstate.isconfirmed` — I'll leave it out actually? With process_orders_on_close, entries only at close; signals computed intrabar could flicker in realtime but orders process at close based on final values. Since strategy executes on close, condition evaluated at close → fine. But calc_on_every_tick=false means script calculates only at bar close in realtime anyway. So isconfirmed unnecessary. Drop it (less clutter). Actually with calc_on_every_tick=false default, on realtime the bar's last execution is at close. OK drop. Wait — inZoneL requires close within zone. But maybe price tapped zone intrabar and closed above zone top (strong reclaim). That's a valid entry too but we'd miss it. Trade-off; acceptable — keeps signals clean. Mention tuning fibMin/fibMax. Also note inZoneL when trend==1 and bullSweepLive: zone derived from lastPL→lastPH where lastPHbar should be > lastPLbar for a valid up-leg retracement. Add: ```pinescript legOKL = lastPHbar > lastPLbar legOKS = lastPLbar > lastPHbar ``` Hmm, is that right? For long: we want the most recent completed swing to be a high (HH), retracement in progress → last confirmed pivot is the high → lastPHbar > lastPLbar. Yes. For short, lastPLbar > lastPHbar. But wait — if the last pivot was the HL (for longs), then the "leg" lastPL→lastPH with PL newer... then the up-leg from that PL hasn't made a new confirmed high yet. Retracement measured from older PH to newer PL would be a down-leg retracement — wrong for longs. So yes, include legOK checks. But careful: with trend==1 (HH & HL), the sequence of confirmed pivots alternates; the most recent confirmed pivot for an uptrend leg completion is the HH. So lastPHbar > lastPLbar holds at that point. As price retraces and makes a new HL (confirmed later), lastPLbar > lastPHbar and the long setup window likely expires. Good — legOKL adds correctness. Add to longSetup: `and lastPHbar > lastPLbar`, shortSetup: `and lastPLbar > lastPHbar`. Hmm, but consider: sweep happens (low < lastPL) → this low will confirm as new pivot low pivLen bars later; also structure may flip. Entry within 10 bars — pivot confirmation may not have happened yet; trend still bullish from before. OK. Risk & orders: ```pinescript //══════════════════════ ⑤ ORDERS · SL · TP · TRAILING ══════════════════════ atrV = ta.atr(atrLen) var float slLong = na var float tpLong = na var float trailLong = na var float slShort = na var float tpShort = na var float trailShort = na // — entries — if longSetup and strategy.position_size == 0 slLong := math.min(low, bullSweepLow) - atrV * slBuf riskPts = close - slLong if riskPts > 0 tpLong := useFibTP ? math.max(fibTPL, close + riskPts * rrMin) : close + riskPts * rrMin trailLong := na strategy.entry("Long", strategy.long) strategy.exit("X-Long", from_entry = "Long", stop = slLong, limit = tpLong) if shortSetup and strategy.position_size == 0 slShort := math.max(high, bearSweepHigh) + atrV * slBuf riskPts = slShort - close if riskPts > 0 tpShort := useFibTP ? math.min(fibTPS, close - riskPts * rrMin) : close - riskPts * rrMin trailShort := na strategy.entry("Short", strategy.short) strategy.exit("X-Short", from_entry = "Short", stop = slShort, limit = tpShort) // — manage open long: trailing stop — if strategy.position_size > 0 ep = strategy.position_avg_price rsk = ep - slLong if useTrail and rsk > 0 and high >= ep + rsk * trailAct cand = close - atrV * trailATR trailLong := math.max(nz(trailLong, cand), cand) effStop = math.max(slLong, nz(trailLong, slLong)) strategy.exit("X-Long", from_entry = "Long", stop = effStop, limit = tpLong) // — manage open short: trailing stop — if strategy.position_size < 0 ep = strategy.position_avg_price rsk = slShort - ep if useTrail and rsk > 0 and low <= ep - rsk * trailAct cand = close + atrV * trailATR trailShort := math.min(nz(trailShort, cand), cand) effStop = math.min(slShort, nz(trailShort, slShort)) strategy.exit("X-Short", from_entry = "Short", stop = effStop, limit = tpShort) ``` Wait — calling strategy.exit again on signal bar? On signal bar, position_size==0 during calc, management blocks skipped; exit pre-placed in entry block. Good. Next bars management updates. But note: on the entry bar, we placed exit with stop=slLong; next bar management calls strategy.exit again with effStop — modifies. Good. Also alert_message add: strategy.entry("Long", strategy.long, alert_message = "LONG ▶ " + syminfo.ticker) strategy.exit(..., alert_message = "EXIT LONG") For exit alert_message — fires when exit order fills. OK. Reset trails when flat: ```pinescript if strategy.position_size == 0 trailLong := na trailShort := na ``` Placement: after management blocks. On the signal bar (flat), this runs — but trail vars were just set to na in entry block anyway (longSetup branch sets trailLong := na before entry). Wait order: reset block placed AFTER entry block would set trailLong := na again — harmless. But careful: could it wipe a just-set value? Entry sets trailLong := na; reset sets na. Harmless. But another subtle issue: the reset block when flat runs on the bar AFTER exit — clears trails. slLong/tpLong kept (not cleared) so management of a NEW position uses fresh values set in entry block. Good. Plots & visuals: ```pinescript //══════════════════════ ⑥ VISUALS ══════════════════════ plot(useEMA ? emaV : na, "EMA", color.new(color.gray, 30), 2) bgcolor(trend == 1 ? color.new(color.teal, 96) : trend == -1 ? color.new(color.red, 96) : na) plotshape(bullSweep, "Bullish liquidity sweep", style = shape.triangleup, location = location.belowbar, color = color.new(color.teal, 0), size = size.tiny, text = "SWEEP", textcolor = color.new(color.teal, 0)) plotshape(bearSweep, "Bearish liquidity sweep", style = shape.triangledown, location = location.abovebar, color = color.new(color.red, 0), size = size.tiny, text = "SWEEP", textcolor = color.new(color.red, 0)) inL = strategy.position_size > 0 inS = strategy.position_size < 0 plot(inL ? slLong : na, "Long SL", color.new(color.red, 0), 2, plot.style_linebr) plot(inL ? tpLong : na, "Long TP", color.new(color.green, 0), 2, plot.style_linebr) plot(inL and not na(trailLong) ? trailLong : na, "Long trail", color.new(color.orange, 0), 1, plot.style_linebr) plot(inS ? slShort : na, "Short SL", color.new(color.red, 0), 2, plot.style_linebr) plot(inS ? tpShort : na, "Short TP", color.new(color.green, 0), 2, plot.style_linebr) plot(inS and not na(trailShort) ? trailShort : na, "Short trail", color.new(color.orange, 0), 1, plot.style_linebr) showZL = bullSweepLive and trend == 1 and strategy.position_size == 0 and inWindow pZTL = plot(showZL ? zoneTopL : na, "Long fib zone top", color.new(color.teal, 50), 1, plot.style_linebr) pZBL = plot(showZL ? zoneBotL : na, "Long fib zone bottom", color.new(color.teal, 50), 1, plot.style_linebr) fill(pZTL, pZBL, color = color.new(color.teal, 88)) showZS = bearSweepLive and trend == -1 and strategy.position_size == 0 and inWindow pZTS = plot(showZS ? zoneTopS : na, "Short fib zone top", color.new(color.red, 50), 1, plot.style_linebr) pZBS = plot(showZS ? zoneBotS : na, "Short fib zone bottom", color.new(color.red, 50), 1, plot.style_linebr) fill(pZTS, pZBS, color = color.new(color.red, 88)) ``` plot positional args: plot(series, title, color, linewidth, style) — yes matches. plotshape text color param: `textcolor`. OK. One more check: `plot(inL ? slLong : na, ...)` — plot args: series, title, color, linewidth, style. I passed color as color.new(...) positional 3rd, linewidth 4th, style 5th. Correct. `fill(pZTL, pZBL, color=...)` OK. Potential compile complaint: label.new inside nested if inside if — fine. `strategy.entry("Long", strategy.long, alert_message = ...)` — OK. Also, `rsk` computed but if slLong na → rsk na → `if useTrail and rsk > 0` na>0 is na → treated false. OK safe. Note about `math.min(low, bullSweepLow)` — bullSweepLow could be several bars back and might be ABOVE current low? Possible (price continued down into zone). min handles. Good. Double-check unused var warnings: none fatal. `lastPHbar`, `lastPLbar` used in legOK. Good. Also — one thing: `bullSweepLive` doesn't include inWindow; showZL includes it; setup includes inWindow. Fine. Also alertcondition skipped — but I can add `alert()` calls? With strategy, users can set alerts to "Order fills". Mention in notes. Wait, one more consideration on entry: `strategy.position_size == 0` — with pyramiding=0 anyway. OK. Also `process_orders_on_close=true` — mention that entries/exits for market orders happen on close of signal candle (realistic for close-based signals). Potential issue: strategy.exit in entry block uses stop=slLong, limit=tpLong — at that moment slLong/tpLong set. Good. Also — when in position and a NEW opposite signal comes, we don't reverse. Should we allow stop-and-reverse? Keep simple; mention that position closes on SL/TP only. Could add: optional allow reverse — skip. I think the code is complete. Also let me reconsider default fibTPx=1.618 with rrMin=1.5: TP = max(fibTP, 1.5R). Reasonable. Trail activation 1R, distance 2 ATR. OK. Also for `slippage = 2` — in ticks. Fine. Now the explanation sections. Keep organized with headers: - What the strategy checks before every entry (the checklist): 1) trend via HH/HL or LH/LL, 2) liquidity sweep candle, 3) price in fib golden zone 0.5–0.786, 4) EMA filter + bullish/bearish close. - Entry/SL/TP/Trailing bullets. - Inputs worth tuning. - Honest reality check + testing steps (brief). Also note pivot lag (signals appear pivLen bars after swing — normal, prevents repaint). Formatting: use markdown headers, code block with pine. Reasonable length — the code is long by necessity; explanations concise. Avoid excessive hype. Start with a brief line like "Here's a complete Pine Script v5 strategy combining all four concepts" plus a one-line honesty note. Let me write out the final full code once more cleanly to ensure no syntax slips, then compose the answer. Actually, one more check on `ta.pivothigh(pivLen, pivLen)` — returns float series with na. OK. `var int lastPHbar = na` — int with na OK in v5? Yes, `var int x = na` compiles. In label block, `isHH` local — fine. Check `math.max(fibTPL, close + riskPts * rrMin)` — both floats fine. Check bgcolor call: `bgcolor(trend == 1 ? color.new(color.teal, 96) : trend == -1 ? color.new(color.red, 96) : na)` — nested ternary OK. One more: plotshape title uniqueness fine. Potential runtime issue: division by zero guarded with barRng > 0 ternary. Good. Also `strategy.exit` with both stop and limit — OCO behavior. Good. Alright, also think: is `close < fibTPL` too strict? If close is in zone (way below lastPH) and fibTPL is extension above lastPH, close < fibTPL almost always true. Harmless safety. Keep. Edge: what if lastPH - lastPL negative (lastPH < lastPL)? Can that happen with trend==1? bullStruct requires lastPH>prevPH and lastPL>prevPL, but lastPL could exceed lastPH in weird sequences (e.g., low formed above older high). Then zone math inverts → inZoneL likely false. The legOK (lastPHbar > lastPLbar) plus zone sanity: could add `legUp > 0` guard. Add `and legUp > 0` to longSetup and `legUp > 0` to shortSetup too (same leg). Cheap safety. Actually for shorts zone uses same legUp — require legUp > 0 as well. Add. Also the initial `var int trend = 0` then `trend := ...` — must be at global scope, fine. I'm fairly confident in compile correctness now. Also I should mention: works on any symbol/timeframe; suggested 15m–4H; tweak pivLen per timeframe. One more honest point to include briefly: signals lag by `pivLen` bars because pivots confirm late; backtest results on historical data ≠ future; use the Strategy Tester, then paper trade. Keep it to 2–3 sentences at the end, not a lecture. Response structure: 1. One-liner intro + tiny expectation-set. 2. Full code. 3. "How it works" — checklist diagram-ish. 4. Trade management summary (entry, SL, TP, trailing). 5. Key settings to tune (small table or bullets). 6. How to use + honest notes (short). Keep the non-code text fairly concise. Use headers and bullets. The code block will be long — that's expected and appropriate. Here's a complete **Pine Script v5 strategy** that combines all four concepts into one system. Quick honesty note first: no script "changes trading for the world" — but this is a genuinely solid confluence framework. Test it properly before risking money. ## The Strategy Code ```pinescript //@version=5 strategy("Market Structure + Fibonacci + Liquidity Sweep [All-in-One]", overlay = true, initial_capital = 10000, default_qty_type = strategy.percent_of_equity, default_qty_value = 10, commission_type = strategy.commission.percent, commission_value = 0.05, slippage = 2, pyramiding = 0, process_orders_on_close = true, max_labels_count = 500) //══════════════════════ INPUTS ══════════════════════ g1 = "① Market Structure" pivLen = input.int(5, "Swing (pivot) length", minval = 2, group = g1) showLbl = input.bool(true, "Show HH / HL / LH / LL labels", group = g1) g2 = "② Liquidity Sweep" maxSweepAge = input.int(10, "Setup valid for N bars after sweep", minval = 1, maxval = 50, group = g2) minWick = input.float(0.30, "Min wick ratio of sweep candle (0 = off)", minval = 0, maxval = 1, step = 0.05, group = g2) holdStruct = input.bool(true, "Sweep must NOT break previous swing (structure intact)", group = g2) g3 = "③ Fibonacci" fibMin = input.float(0.500, "Entry zone start (retracement)", minval = 0.1, maxval = 0.9, step = 0.01, group = g3) fibMax = input.float(0.786, "Entry zone end (retracement)", minval = 0.1, maxval = 0.99, step = 0.01, group = g3) fibTPx = input.float(1.618, "Take-profit extension", minval = 1.0, step = 0.01, group = g3) useFibTP = input.bool(true, "Use Fib extension for TP (off = R-multiple)", group = g3) g4 = "④ Risk / Exit" atrLen = input.int(14, "ATR length", group = g4) slBuf = input.float(1.0, "SL buffer (× ATR)", minval = 0, step = 0.1, group = g4) rrMin = input.float(1.5, "Minimum reward:risk", minval = 0.5, step = 0.1, group = g4) useTrail = input.bool(true, "Use trailing stop", group = g4) trailAct = input.float(1.0, "Activate trail after price moves (R)", minval = 0.1, step = 0.1, group = g4) trailATR = input.float(2.0, "Trail distance (× ATR)", minval = 0.1, step = 0.1, group = g4) g5 = "⑤ Filters" useEMA = input.bool(true, "EMA trend filter", group = g5) emaLen = input.int(200, "EMA length", minval = 10, group = g5) g6 = "⑥ Backtest window" tStart = input.time(timestamp("1 Jan 2018 00:00 +0000"), "Start", group = g6) tEnd = input.time(timestamp("1 Jan 2069 00:00 +0000"), "End", group = g6) inWindow = time >= tStart and time <= tEnd //══════════════════════ ① MARKET STRUCTURE ══════════════════════ ph = ta.pivothigh(pivLen, pivLen) pl = ta.pivotlow(pivLen, pivLen) var float lastPH = na var float prevPH = na var int lastPHbar = na var float lastPL = na var float prevPL = na var int lastPLbar = na if not na(ph) prevPH := lastPH lastPH := ph lastPHbar := bar_index - pivLen if showLbl isHH = not na(prevPH) and ph > prevPH label.new(bar_index - pivLen, ph, isHH ? "HH" : "LH", style = label.style_label_down, color = isHH ? color.new(color.teal, 30) : color.new(color.red, 30), textcolor = color.white, size = size.tiny) if not na(pl) prevPL := lastPL lastPL := pl lastPLbar := bar_index - pivLen if showLbl isHL = not na(prevPL) and pl < prevPL label.new(bar_index - pivLen, pl, isHL ? "HL" : "LL", style = label.style_label_up, color = isHL ? color.new(color.teal, 30) : color.new(color.red, 30), textcolor = color.white, size = size.tiny) havePair = not na(lastPH) and not na(prevPH) and not na(lastPL) and not na(prevPL) bullStruct = havePair and lastPH > prevPH and lastPL > prevPL // HH + HL bearStruct = havePair and lastPH < prevPH and lastPL < prevPL // LH + LL var int trend = 0 trend := bullStruct ? 1 : bearStruct ? -1 : trend //══════════════════════ ② LIQUIDITY SWEEP ══════════════════════ barRng = high - low lowWick = barRng > 0 ? (math.min(open, close) - low) / barRng : 0.0 upWick = barRng > 0 ? (high - math.max(open, close)) / barRng : 0.0 okStructL = not holdStruct or na(prevPL) or low > prevPL okStructS = not holdStruct or na(prevPH) or high < prevPH bullSweep = not na(lastPL) and low < lastPL and close > lastPL and close > open and (minWick == 0 or lowWick >= minWick) and okStructL bearSweep = not na(lastPH) and high > lastPH and close < lastPH and close < open and (minWick == 0 or upWick >= minWick) and okStructS var int bullSweepBar = na var float bullSweepLow = na var int bearSweepBar = na var float bearSweepHigh = na if bullSweep bullSweepBar := bar_index bullSweepLow := low if bearSweep bearSweepBar := bar_index bearSweepHigh := high bullSweepLive = not na(bullSweepBar) and bar_index - bullSweepBar <= maxSweepAge bearSweepLive = not na(bearSweepBar) and bar_index - bearSweepBar <= maxSweepAge //══════════════════════ ③ FIBONACCI ══════════════════════ legUp = lastPH - lastPL zoneTopL = lastPH - legUp * fibMin // 0.5 level (long zone top) zoneBotL = lastPH - legUp * fibMax // 0.786 level (long zone bottom) fibTPL = lastPL + legUp * fibTPx // long target (extension) zoneBotS = lastPL + legUp * fibMin // 0.5 level (short zone bottom) zoneTopS = lastPL + legUp * fibMax // 0.786 level (short zone top) fibTPS = lastPH - legUp * fibTPx // short target (extension) //══════════════════════ ④ CONFLUENT SIGNALS ══════════════════════ emaV = ta.ema(close, emaLen) emaOKL = not useEMA or close > emaV emaOKS = not useEMA or close < emaV inZoneL = close >= zoneBotL and close <= zoneTopL inZoneS = close >= zoneBotS and close <= zoneTopS legOKL = not na(lastPHbar) and not na(lastPLbar) and lastPHbar > lastPLbar and legUp > 0 legOKS = not na(lastPHbar) and not na(lastPLbar) and lastPLbar > lastPHbar and legUp > 0 longSetup = trend == 1 and bullSweepLive and inZoneL and legOKL and close > bullSweepLow and close < fibTPL and close > open and emaOKL and inWindow shortSetup = trend == -1 and bearSweepLive and inZoneS and legOKS and close < bearSweepHigh and close > fibTPS and close < open and emaOKS and inWindow //══════════════════════ ⑤ ORDERS · SL · TP · TRAILING ══════════════════════ atrV = ta.atr(atrLen) var float slLong = na var float tpLong = na var float trailLong = na var float slShort = na var float tpShort = na var float trailShort = na // — entries — if longSetup and strategy.position_size == 0 slLong := math.min(low, bullSweepLow) - atrV * slBuf riskPts = close - slLong if riskPts > 0 tpLong := useFibTP ? math.max(fibTPL, close + riskPts * rrMin) : close + riskPts * rrMin trailLong := na strategy.entry("Long", strategy.long, alert_message = "LONG ▶ " + syminfo.ticker) strategy.exit("X-Long", from_entry = "Long", stop = slLong, limit = tpLong) if shortSetup and strategy.position_size == 0 slShort := math.max(high, bearSweepHigh) + atrV * slBuf riskPts = slShort - close if riskPts > 0 tpShort := useFibTP ? math.min(fibTPS, close - riskPts * rrMin) : close - riskPts * rrMin trailShort := na strategy.entry("Short", strategy.short, alert_message = "SHORT ▶ " + syminfo.ticker) strategy.exit("X-Short", from_entry = "Short", stop = slShort, limit = tpShort) // — trailing stop management (activates after +1R, ratchets only in profit direction) — if strategy.position_size > 0 ep = strategy.position_avg_price rsk = ep - slLong if useTrail and rsk > 0 and high >= ep + rsk * trailAct cand = close - atrV * trailATR trailLong := math.max(nz(trailLong, cand), cand) effStop = math.max(slLong, nz(trailLong, slLong)) strategy.exit("X-Long", from_entry = "Long", stop = effStop, limit = tpLong) if strategy.position_size < 0 ep = strategy.position_avg_price rsk = slShort - ep if useTrail and rsk > 0 and low <= ep - rsk * trailAct cand = close + atrV * trailATR trailShort := math.min(nz(trailShort, cand), cand) effStop = math.min(slShort, nz(trailShort, slShort)) strategy.exit("X-Short", from_entry = "Short", stop = effStop, limit = tpShort) if strategy.position_size == 0 trailLong := na trailShort := na //══════════════════════ ⑥ VISUALS ══════════════════════ plot(useEMA ? emaV : na, "EMA", color.new(color.gray, 30), 2) bgcolor(trend == 1 ? color.new(color.teal, 96) : trend == -1 ? color.new(color.red, 96) : na) plotshape(bullSweep, "Bullish sweep", style = shape.triangleup, location = location.belowbar, color = color.new(color.teal, 0), size = size.tiny, text = "SWEEP", textcolor = color.new(color.teal, 0)) plotshape(bearSweep, "Bearish sweep", style = shape.triangledown, location = location.abovebar, color = color.new(color.red, 0), size = size.tiny, text = "SWEEP", textcolor = color.new(color.red, 0)) inL = strategy.position_size > 0 inS = strategy.position_size < 0 plot(inL ? slLong : na, "Long SL", color.new(color.red, 0), 2, plot.style_linebr) plot(inL ? tpLong : na, "Long TP", color.new(color.green, 0), 2, plot.style_linebr) plot(inL and not na(trailLong) ? trailLong : na, "Long trail", color.new(color.orange, 0), 1, plot.style_linebr) plot(inS ? slShort : na, "Short SL", color.new(color.red, 0), 2, plot.style_linebr) plot(inS ? tpShort : na, "Short TP", color.new(color.green, 0), 2, plot.style_linebr) plot(inS and not na(trailShort) ? trailShort : na, "Short trail", color.new(color.orange, 0), 1, plot.style_linebr) showZL = bullSweepLive and trend == 1 and strategy.position_size == 0 and inWindow pZTL = plot(showZL ? zoneTopL : na, "Long zone top", color.new(color.teal, 50), 1, plot.style_linebr) pZBL = plot(showZL ? zoneBotL : na, "Long zone bottom", color.new(color.teal, 50), 1, plot.style_linebr) fill(pZTL, pZBL, color = color.new(color.teal, 88)) showZS = bearSweepLive and trend == -1 and strategy.position_size == 0 and inWindow pZTS = plot(showZS ? zoneTopS : na, "Short zone top", color.new(color.red, 50), 1, plot.style_linebr) pZBS = plot(showZS ? zoneBotS : na, "Short zone bottom", color.new(color.red, 50), 1, plot.style_linebr) fill(pZTS, pZBS, color = color.new(color.red, 88)) ``` ## How It Thinks — The Entry Checklist A trade only fires when **ALL** of these line up: **LONG:** 1. **Market structure** → HH + HL confirmed (bullish trend), EMA filter agrees 2. **Liquidity sweep** → a candle wicks *below* the last swing low (grabs sell-side liquidity) but *closes back above* it, with a rejection wick 3. **Fibonacci** → price pulls back into the 0.5–0.786 "golden zone" of the last up-leg 4. **Price action** → bullish candle close, target not already hit **SHORT:** exact mirror (LH + LL, sweep above swing high, retracement up into zone, bearish close). ## Trade Management - **Stop Loss** → below the sweep wick minus an ATR buffer (the invalidation point) - **Take Profit** → Fib 1.618 extension, or minimum 1.5R — whichever is larger - **Trailing Stop** → activates after price moves +1R, then trails 2×ATR behind price, only ratcheting in your favor (locks in profit, never moves backward) ## Settings Worth Tuning | Setting | Effect | |---|---| | Swing (pivot) length | 3–5 = scalping, 5–10 = swing trading | | Fib zone 0.5–0.786 | Narrow it (0.618–0.786) for fewer, higher-quality entries | | Trail activation (R) | Lower = protect profit sooner; higher = let winners run | | Min R:R | Raise to 2.0 for fewer but better trades | ## Honest Notes - Swing points confirm `pivLen` bars after they form — that's how all pivot-based strategies avoid repainting. Signals are delayed but real. - Backtest on **TradingView Strategy Tester** across multiple symbols/timeframes (15m–4H works well), include realistic commission, then forward-test on a **demo account** for at least a month. Most strategies look great in a backtest and die live — survivorship of *your* setup is what matters. Want me to add a session filter (trade only London/NY), breakeven logic, or convert it to alert-only signals for manual trading?