Superior-Range Bound Renko - Alerts - 11-29-25 - Signal Lynx

Superior-Range Bound Renko – Alerts Edition with Advanced Risk Management Template

Signal Lynx | Free Scripts supporting Automation for the Night-Shift Nation 🌙

1. Overview

This is the Alerts & Indicator Edition of Superior-Range Bound Renko (RBR).

The Strategy version is built for backtesting inside TradingView.

This Alerts version is built for automation: it emits clean, discrete alert events that you can route into webhooks, bots, or relay engines (including your own Signal Lynx-style infrastructure).

Under the hood, this script contains the same core engine as the strategy:

Adaptive Range Bounding based on volatility

Renko Brick Emulation on standard candles

A stack of Laguerre Filters for impulse detection

K-Means-style Adaptive SuperTrend for trend confirmation

The full Signal Lynx Risk Management Engine (state machine, layered exits, AATS, RSIS, etc.)

The difference is in what we output:

Instead of placing historical trades, this version:

Plots the entry and RM signals in a separate pane (overlay = false)

Exposes alertconditions for:

Long Entry

Short Entry

Close Long

Close Short

TP1, TP2, TP3 hits (Staged Take Profit)

This makes it ideal as the signal source for automated execution via TradingView Alerts + Webhooks.

2. Quick Action Guide (TL;DR)

Best Timeframe:
4H and above. This is a swing-trading / position-trading style engine, not a micro-scalper.

Best Assets:
Volatile but structured markets, e.g.:
BTC, ETH, XAUUSD (Gold), GBPJPY, and similar high-volatility majors or indices.

Script Type:
indicator() – Alerts & Visualization Only

No built-in order placement

All “orders” are emitted as alerts for your external bot or manual handling

Strategy Type:
Volatility-Adaptive Trend Following + Impulse Detection
using Renko-like structure and multi-layer Laguerre filters.

Repainting:
Designed to be non-repainting on closed candles.
The underlying Risk Management engine is built around previous-bar data (close[1], high[1], low[1]) for execution-critical logic.
Intrabar values can move while the bar is forming (normal for any advanced signal), but once a bar closes, the alert logic is stable.

Recommended Alert Settings:

Condition: one of the built-in signals (see section 3.B)

Options: “Once Per Bar Close” is strongly recommended for automation

Message: JSON, CSV, or simple tokens – whatever your webhook / relay expects

3. Detailed Report: How the Alerts Edition Works
A. Relationship to the Strategy Version

The Alerts Edition shares the same internal logic as the strategy version:

Same Adaptive Lookback and volatility normalization

Same Range and Close Range construction

Same Renko Brick Emulator and directional memory (renkoDir)

Same Fib structures, Laguerre stack, K-Means SuperTrend, and Baseline signals (B1, B2)

Same Risk Management Engine and layered exits

In the strategy script, these signals are wired into strategy.entry, strategy.exit, and strategy.close.

In the alerts script:

We still compute the final entry/exit signals (Fin, CloseEmAll, TakeProfit1Plot, etc.)

Instead of placing trades, we:

Plot them for visual inspection

Expose them via alertcondition(...) so that TradingView can fire alerts.

This ensures that:

If you use the same settings on the same symbol/timeframe, the Alerts Edition and Strategy Edition agree on where entries and exits occur.
(Subject only to normal intrabar vs. bar-close differences.)

B. Signals & Alert Conditions

The alerts script focuses on discrete, automation-friendly events.

Internally, the main signals are:

Fin – Final entry decision from the RM engine

CloseEmAll – RM-driven “hard close” signal (for full-position exits)

TakeProfit1Plot / 2Plot / 3Plot – One-time event markers when each TP stage is hit

On the chart (in the separate indicator pane), you get:

plot(Fin) – where:

+2 = Long Entry event

-2 = Short Entry event

plot(CloseEmAll) – where:

+1 = “Close Long” event

-1 = “Close Short” event

plot(TP1/TP2/TP3) (if Staged TP is enabled) – integer tags for TP hits:

+1 / +2 / +3 = TP1 / TP2 / TP3 for Longs

-1 / -2 / -3 = TP1 / TP2 / TP3 for Shorts

The corresponding alertconditions are:

Long Entry

alertcondition(Fin == 2, title="Long Entry", message="Long Entry Triggered")


Fire this to open/scale a long position in your bot.

Short Entry

alertcondition(Fin == -2, title="Short Entry", message="Short Entry Triggered")


Fire this to open/scale a short position.

Close Long

alertcondition(CloseEmAll == 1, title="Close Long", message="Close Long Triggered")


Fire this to fully exit a long position.

Close Short

alertcondition(CloseEmAll == -1, title="Close Short", message="Close Short Triggered")


Fire this to fully exit a short position.

TP 1 Hit

alertcondition(TakeProfit1Plot != 0, title="TP 1 Hit", message="TP 1 Level Reached")


First staged take profit hit (either long or short). Your bot can interpret the direction based on position state or message tags.

TP 2 Hit

alertcondition(TakeProfit2Plot != 0, title="TP 2 Hit", message="TP 2 Level Reached")


TP 3 Hit

alertcondition(TakeProfit3Plot != 0, title="TP 3 Hit", message="TP 3 Level Reached")


Together, these give you a complete trade lifecycle:

Open Long / Short

Optionally scale out via TP1/TP2/TP3

Close remaining via Close Long / Close Short

All while the Risk Management Engine enforces the same logic as the strategy version.

C. Using This Script for Automation

This Alerts Edition is designed for:

Webhook-based bots

Execution relays (e.g., your own Lynx-Relay-style engine)

Dedicated external trade managers

Typical setup flow:

Add the script to your chart

Same symbol, timeframe, and settings you use in the Strategy Edition backtests.

Configure Inputs:

Longs / Shorts enabled

Risk Management toggles (SL, TS, Staged TP, AATS, RSIS)

Weekend filter (if you do not want weekend trades)

RBR-specific knobs (Adaptive Lookback, Brick type, ATR vs Standard Brick, etc.)

Create Alerts for Each Event Type You Need:

Long Entry

Short Entry

Close Long

Close Short

TP1 / TP2 / TP3 (optional, if your bot handles partial closes)

For each:

Condition: the corresponding alertcondition

Option: “Once Per Bar Close” is strongly recommended

Message:

You can use structured JSON or a simple token set like:
{"side":"long","event":"entry","symbol":"{{ticker}}","time":"{{timenow}}"}

or a simpler text for manual trading like:
LONG ENTRY | {{ticker}} | {{interval}}

Wire Up Your Bot / Relay:

Point TradingView’s webhook URL to your execution engine

Parse the messages and map them into:

Exchange

Symbol

Side (long/short)

Action (open/close/partial)

Size and risk model (this script does not position-size for you; it only signals when, not how much.)

Because the alerts come from a non-repainting, RM-backed engine that you’ve already validated via the Strategy Edition, you get a much cleaner automation pipeline.

D. Repainting Protection (Alerts Edition)

The same protections as the Strategy Edition apply here:

Execution-critical logic (trailing stop, TP triggers, SL, RM state changes) uses previous bar OHLC:

open[1], high[1], low[1], close[1]

No security() with lookahead or future-bar dependencies.

This means:

Alerts are designed to fire on states that would have been visible at bar close, not on hypothetical “future history.”

Important practical note:

Intrabar: While a bar is forming, internal conditions can oscillate.

Bar Close: With “Once Per Bar Close” alerts, the fired signal corresponds to the final state of the engine for that candle, matching your Strategy Edition expectations.

4. For Developers & Modders

You can treat this Alerts script as an ”RM + Alert Framework” and inject any signal logic you want.

Where to plug in:

Find the section:
// BASELINE & SIGNAL GENERATION

You’ll see how B1 and B2 are built from the RBR stack and then combined:

baseSig = B2
altSig = B1
finalSig = sigSwap ? baseSig : altSig


To use your own logic:

Replace or wrap the code that sets baseSig / altSig with your own conditions:

e.g., RSI, MACD, Heikin Ashi filters, candle patterns, volume filters, etc.

Make sure your final decision is still:

2 → Long / Buy signal

-2 → Short / Sell signal

0 → No trade

finalSig is then passed into the RM engine and eventually becomes Fin, which:

Drives the Long/Short Entry alerts

Interacts with the RM state machine to integrate properly with AATS, SL, TS, TP, etc.

Because this script already exposes alertconditions for key lifecycle events, you don’t need to re-wire alerts each time — just ensure your logic feeds into finalSig correctly.

This lets you use the Signal Lynx Risk Management Engine + Alerts wrapper as a drop-in chassis for your own strategies.

5. About Signal Lynx

Automation for the Night-Shift Nation 🌙

Signal Lynx builds tools and templates that help traders move from:

“I have an indicator” → “I have a structured, automatable strategy with real risk management.”

This Superior-Range Bound Renko – Alerts Edition is the automation-focused companion to the Strategy Edition. It’s designed for:

Traders who backtest with the Strategy version

Then deploy live signals with this Alerts version via webhooks or bots

While relying on the same non-repainting, RM-driven logic

We release this code under the Mozilla Public License 2.0 (MPL-2.0) to support the Pine community with:

Transparent, inspectable logic

A reusable Risk Management template

A reference implementation of advanced adaptive logic + alerts

If you are exploring full-stack automation (TradingView → Webhooks → Exchange / VPS), keep Signal Lynx in your search.

License: Mozilla Public License 2.0 (Open Source).
If you build improvements or helpful variants, please consider sharing them back with the community.