MM Flow
FlowScripts

Perfected FlowScript

Price Action RSI

Price Action RSI — Perfected Edition is indexed as 142_price_action_rsi.flowscript. The exact FlowScript is viewable here; chart observe and trading automation use the current mmflow chart/recipe signal proxy until FlowScript v2 transpilation is available.

This exact FlowScript uses the v2 source dialect. It is viewable and connected to the chart/automation proxy, but direct editor execution needs the FlowScript v2 transpiler.

Dialect

flowscript-v2

Compatibility

flowscript-v2-needs-transpile

Position

offchart

Axis

true

Size

21.0 KB

Lines

700

Native Signal Candidates

16 source-level chart marker triggers extracted from guarded FlowScript v2 blocks.

16/16 guarded

Bull Div

line 501:9

Trigger

(showAlerts && enableDiv) && (bullDiv)

Value

rsi

Deps

bullDiv:var, enableDiv:input, showAlerts:input

Bear Div

line 511:9

Trigger

(showAlerts && enableDiv) && (bearDiv)

Value

rsi

Deps

bearDiv:var, enableDiv:input, showAlerts:input

Hidden Bull

line 521:9

Trigger

(showAlerts && enableDiv) && (showHidden && hiddenBullDiv)

Value

rsi

Deps

enableDiv:input, hiddenBullDiv:var, showAlerts:input, showHidden:input

Hidden Bear

line 531:9

Trigger

(showAlerts && enableDiv) && (showHidden && hiddenBearDiv)

Value

rsi

Deps

enableDiv:input, hiddenBearDiv:var, showAlerts:input, showHidden:input

Doji

line 545:9

Trigger

(showAlerts) && (showDoji && isDoji)

Value

rsi

Deps

isDoji:var, showAlerts:input, showDoji:input

Hammer

line 555:9

Trigger

(showAlerts) && (showHammer && isHammer)

Value

rsi

Deps

isHammer:var, showAlerts:input, showHammer:input

Shoot Star

line 565:9

Trigger

(showAlerts) && (showShootingStar && isShootingStar)

Value

rsi

Deps

isShootingStar:var, showAlerts:input, showShootingStar:input

Bull Engulf

line 575:9

Trigger

(showAlerts) && (showEngulfing && isBullEngulf)

Value

rsi

Deps

isBullEngulf:var, showAlerts:input, showEngulfing:input

Bear Engulf

line 585:9

Trigger

(showAlerts) && (showEngulfing && isBearEngulf)

Value

rsi

Deps

isBearEngulf:var, showAlerts:input, showEngulfing:input

Harami

line 595:9

Trigger

(showAlerts) && (showHarami && isHarami)

Value

rsi

Deps

isHarami:var, showAlerts:input, showHarami:input

Morn Star

line 605:9

Trigger

(showAlerts) && (showStar && isMorningStar)

Value

rsi

Deps

isMorningStar:var, showAlerts:input, showStar:input

Eve Star

line 615:9

Trigger

(showAlerts) && (showStar && isEveningStar)

Value

rsi

Deps

isEveningStar:var, showAlerts:input, showStar:input

Cross Up

line 629:9

Trigger

(showAlerts) && (crossUp)

Value

signal

Deps

crossUp:var, showAlerts:input

Cross Down

line 639:9

Trigger

(showAlerts) && (crossDown)

Value

signal

Deps

crossDown:var, showAlerts:input

OB Penetrate

line 649:9

Trigger

(showAlerts) && (obPenetrate)

Value

dynOb

Deps

obPenetrate:var, showAlerts:input

OS Penetrate

line 659:9

Trigger

(showAlerts) && (osPenetrate)

Value

dynOs

Deps

osPenetrate:var, showAlerts:input

142_price_action_rsi.flowscript

source path: kscripts/perfected/142_price_action_rsi.flowscript · sha256:606f8735c7b6eab6848d287c90009849aff5853aa7082d3ebe54b734793a44f6

hash verified
//@version=2
// ============================================================================
// Price Action RSI — Perfected Edition
// Author: E (@edselave) | Enhanced by kScript Perfection Engineer
// Tags: CORE, #price_action, #rsi, #divergence, #candlestick_patterns, #momentum
//
// Production-grade price-action-enhanced RSI oscillator. Combines canonical
// Wilder RSI with Nison candlestick pattern detection, regular and hidden
// divergence, dynamic volatility-adjusted thresholds, fill zones, and
// comprehensive shape-marker visualization.
//
// Academic foundations:
//  1. Wilder (1978), "New Concepts in Technical Trading Systems": canonical
//     RSI publication. RSI = 100 − [100 / (1 + RS)] where RS = RMA(gain, N) /
//     RMA(loss, N). Original smoothing period = 14. Wilder smoothing solves
//     erratic movement and creates a constant 0–100 range.
//  2. Nison (1991), "Japanese Candlestick Charting Techniques": systematized
//     candlestick pattern recognition. Engulfing, hammer, shooting star,
//     doji, harami, and morning/evening star patterns are all documented
//     with statistical reliability bounds.
//  3. Lane (1950s), Stochastic Oscillator: "momentum changes direction before
//     price." Bullish/bearish divergences foreshadow reversals. The script's
//     divergence engine follows Lane's momentum-leads-price principle.
//  4. Ponnusamy & Manual (2016), "A Study on Financial Indicators' Reliability
//     in Technical Analysis" (European Academic Research). Found RSI outperforms
//     MACD and Stochastic in signal reliability; recommends multi-indicator
//     confirmation. Underpins the RSI + price-action dual confirmation
//     architecture.
//  5. Poterba & Summers (1988), "Mean Reversion in Stock Prices: Evidence and
//     Implications" (JFE 22(1), 27–59). Negative autocorrelation at medium
//     horizons supports dynamic overbought/oversold thresholds calibrated to
//     rolling volatility.
//  6. Murphy (1999), "Technical Analysis of the Financial Markets": divergence
//     as a leading reversal signal — price/indicator disagreement at extremes
//     precedes regime shifts.
// ============================================================================

define(
    title="Price Action RSI — Perfected Edition",
    position="offchart",
    axis=true
)

// ---------------------------------------------------------------------------
// 1. USER INPUTS — grouped with constraints
// ---------------------------------------------------------------------------

// --- RSI Settings ---
var rsiLen = input(
    name="rsiLen",
    type="number",
    defaultValue=14,
    label="RSI Length",
    constraints={min: 2, max: 50, step: 1},
    group="RSI Settings"
)
var useWilder = input(
    name="useWilder",
    type="boolean",
    defaultValue=true,
    label="Use Wilder Smoothing (RMA)",
    group="RSI Settings"
)

// --- Smoothing ---
var smoothLen = input(
    name="smoothLen",
    type="number",
    defaultValue=3,
    label="EMA Smoothing Length",
    constraints={min: 1, max: 20, step: 1},
    group="Smoothing"
)
var signalLen = input(
    name="signalLen",
    type="number",
    defaultValue=14,
    label="Signal SMA Length",
    constraints={min: 2, max: 50, step: 1},
    group="Smoothing"
)

// --- Thresholds ---
var obLevel = input(
    name="obLevel",
    type="number",
    defaultValue=70,
    label="Static Overbought Level",
    constraints={min: 50, max: 95, step: 1},
    group="Thresholds"
)
var osLevel = input(
    name="osLevel",
    type="number",
    defaultValue=30,
    label="Static Oversold Level",
    constraints={min: 5, max: 50, step: 1},
    group="Thresholds"
)
var useDynamic = input(
    name="useDynamic",
    type="boolean",
    defaultValue=false,
    label="Dynamic Thresholds (volatility-adjusted)",
    group="Thresholds"
)
var volLookback = input(
    name="volLookback",
    type="number",
    defaultValue=20,
    label="Volatility Lookback",
    constraints={min: 5, max: 100, step: 1},
    group="Thresholds"
)
var volMultiplier = input(
    name="volMultiplier",
    type="number",
    defaultValue=1.5,
    label="Volatility Multiplier",
    constraints={min: 0.5, max: 5.0, step: 0.1},
    group="Thresholds"
)

// --- Pattern Detection ---
var showDoji = input(
    name="showDoji",
    type="boolean",
    defaultValue=true,
    label="Show Doji",
    group="Patterns"
)
var showHammer = input(
    name="showHammer",
    type="boolean",
    defaultValue=true,
    label="Show Hammer",
    group="Patterns"
)
var showEngulfing = input(
    name="showEngulfing",
    type="boolean",
    defaultValue=true,
    label="Show Engulfing",
    group="Patterns"
)
var showShootingStar = input(
    name="showShootingStar",
    type="boolean",
    defaultValue=true,
    label="Show Shooting Star",
    group="Patterns"
)
var showHarami = input(
    name="showHarami",
    type="boolean",
    defaultValue=true,
    label="Show Harami",
    group="Patterns"
)
var showStar = input(
    name="showStar",
    type="boolean",
    defaultValue=true,
    label="Show Morning/Evening Star",
    group="Patterns"
)

// --- Divergence ---
var enableDiv = input(
    name="enableDiv",
    type="boolean",
    defaultValue=true,
    label="Enable Divergence Detection",
    group="Divergence"
)
var divLookback = input(
    name="divLookback",
    type="number",
    defaultValue=10,
    label="Divergence Lookback (pivot bars)",
    constraints={min: 5, max: 50, step: 1},
    group="Divergence"
)
var showHidden = input(
    name="showHidden",
    type="boolean",
    defaultValue=true,
    label="Show Hidden Divergence",
    group="Divergence"
)

// --- Display ---
var showRsiLine = input(
    name="showRsiLine",
    type="boolean",
    defaultValue=true,
    label="Show RSI Line",
    group="Display"
)
var showSignal = input(
    name="showSignal",
    type="boolean",
    defaultValue=true,
    label="Show Signal SMA",
    group="Display"
)
var showFill = input(
    name="showFill",
    type="boolean",
    defaultValue=true,
    label="Show RSI/Signal Fill",
    group="Display"
)
var showObOs = input(
    name="showObOs",
    type="boolean",
    defaultValue=true,
    label="Show OB/OS Zones",
    group="Display"
)
var showAlerts = input(
    name="showAlerts",
    type="boolean",
    defaultValue=true,
    label="Show Alert Shapes",
    group="Display"
)
var showTable = input(
    name="showTable",
    type="boolean",
    defaultValue=true,
    label="Show Summary Table",
    group="Display"
)

// --- Colors ---
var bullColor = input(
    name="bullColor",
    type="color",
    defaultValue="#26a69a",
    label="Bull Color",
    group="Colors"
)
var bearColor = input(
    name="bearColor",
    type="color",
    defaultValue="#ef5350",
    label="Bear Color",
    group="Colors"
)
var signalColor = input(
    name="signalColor",
    type="color",
    defaultValue="#ffffff",
    label="Signal Line Color",
    group="Colors"
)
var divBullColor = input(
    name="divBullColor",
    type="color",
    defaultValue="#00e676",
    label="Bullish Divergence Color",
    group="Colors"
)
var divBearColor = input(
    name="divBearColor",
    type="color",
    defaultValue="#ff5252",
    label="Bearish Divergence Color",
    group="Colors"
)

// ---------------------------------------------------------------------------
// 2. DATA SOURCES & NaN GUARD
// ---------------------------------------------------------------------------
timeseries bars = ohlcv(symbol=currentSymbol, exchange=currentExchange)
timeseries c = bars.close
timeseries o = bars.open
timeseries h = bars.high
timeseries l = bars.low

if (isnan(c[0]) || isnan(o[0]) || isnan(h[0]) || isnan(l[0])) {
    return
}

// ---------------------------------------------------------------------------
// 3. WILDER RSI — canonical RMA implementation
// ---------------------------------------------------------------------------
// RSI = 100 − [100 / (1 + RS)] where RS = Average Gain / Average Loss
// Per Wilder (1978), the original uses RMA (recursive moving average) of
// gains/losses: Avg_t = (Prev Avg × (N−1) + Current) / N.

timeseries change = c - nz(c[1])
timeseries gain = change > 0 ? change : 0
timeseries loss = change < 0 ? -change : 0

timeseries avgGain = useWilder ? rma(gain, rsiLen) : sma(gain, rsiLen)
timeseries avgLoss = useWilder ? rma(loss, rsiLen) : sma(loss, rsiLen)

timeseries rs = (avgLoss > 0) ? (avgGain / avgLoss) : 0
timeseries rsiRaw = 100 - (100 / (1 + rs))

// ---------------------------------------------------------------------------
// 4. SMOOTHING & SIGNAL
// ---------------------------------------------------------------------------
timeseries rsi = ema(rsiRaw, smoothLen)
timeseries signal = sma(rsi, signalLen)
timeseries hist = rsi - signal

// ---------------------------------------------------------------------------
// 5. DYNAMIC THRESHOLDS
// ---------------------------------------------------------------------------
// Per Poterba & Summers (1988), mean-reversion intensity varies with volatility.
// We adjust OB/OS bands by rolling RSI standard deviation.
timeseries rsiVol = stddev(rsi, volLookback)
timeseries dynOb = useDynamic ? math.min(95, obLevel + rsiVol * volMultiplier) : obLevel
timeseries dynOs = useDynamic ? math.max(5, osLevel - rsiVol * volMultiplier) : osLevel

// Guard: ensure dynamic bands never cross
if (dynOb <= dynOs) {
    dynOb = 70
    dynOs = 30
}

// ---------------------------------------------------------------------------
// 6. REGIME DETECTION
// ---------------------------------------------------------------------------
var regimeBull = rsi > signal && rsi > 50
var regimeBear = rsi < signal && rsi < 50
var regimeNeutral = !regimeBull && !regimeBear

var regimeColor = regimeBull ? bullColor : (regimeBear ? bearColor : "#9e9e9e")

// ---------------------------------------------------------------------------
// 7. CANDLESTICK PATTERN DETECTION (Nison-based)
// ---------------------------------------------------------------------------
timeseries bodySize = math.abs(c - o)
timeseries upperWick = h - math.max(c, o)
timeseries lowerWick = math.min(c, o) - l
timeseries totalRange = h - l

// Avoid division by zero on doji bars
timeseries bodyRatio = (totalRange > 0) ? (bodySize / totalRange) : 1.0

// Doji: body is very small relative to range (< 10%)
var isDoji = bodySize <= totalRange * 0.1 && totalRange > 0

// Hammer: small body at upper end, long lower wick (>= 2x body), small upper wick
var isHammer = (lowerWick >= 2.0 * bodySize) && (upperWick <= bodySize * 0.5) && (c > o) && (totalRange > 0)

// Shooting star: small body at lower end, long upper wick (>= 2x body), small lower wick
var isShootingStar = (upperWick >= 2.0 * bodySize) && (lowerWick <= bodySize * 0.5) && (c < o) && (totalRange > 0)

// Bullish engulfing: prev red, curr green, curr body engulfs prev body
var prevBear = nz(c[1]) < nz(o[1])
var currBull = c > o
var isBullEngulf = prevBear && currBull && (o < nz(c[1])) && (c > nz(o[1])) && (totalRange > 0)

// Bearish engulfing: prev green, curr red, curr body engulfs prev body
var prevBull = nz(c[1]) > nz(o[1])
var currBear = c < o
var isBearEngulf = prevBull && currBear && (o > nz(c[1])) && (c < nz(o[1])) && (totalRange > 0)

// Harami: prev large body, curr small body inside prev body
var prevBody = math.abs(nz(c[1]) - nz(o[1]))
var isHarami = (bodySize < prevBody * 0.5) && (c < math.max(nz(c[1]), nz(o[1]))) && (c > math.min(nz(c[1]), nz(o[1]))) && (o < math.max(nz(c[1]), nz(o[1]))) && (o > math.min(nz(c[1]), nz(o[1]))) && (totalRange > 0)

// Morning star: bearish candle, small body (star), bullish candle
var isMorningStar = (nz(c[2]) < nz(o[2])) && (bodySize <= totalRange * 0.3) && (c > o) && (c > nz(o[2])) && (totalRange > 0)

// Evening star: bullish candle, small body (star), bearish candle
var isEveningStar = (nz(c[2]) > nz(o[2])) && (bodySize <= totalRange * 0.3) && (c < o) && (c < nz(o[2])) && (totalRange > 0)

// ---------------------------------------------------------------------------
// 8. DIVERGENCE DETECTION (stateful via static variables)
// ---------------------------------------------------------------------------
// Regular divergence: price makes higher high / lower low, RSI disagrees.
// Hidden divergence: price makes higher low / lower high, RSI disagrees.
// We track pivot high/low state across bars using static variables.

static prevPxHigh = -1.0
static prevRsiHigh = -1.0
static prevPxLow = -1.0
static prevRsiLow = -1.0

var bearDiv = false
var bullDiv = false
var hiddenBearDiv = false
var hiddenBullDiv = false

// Initialize on first real bar after NaN guard
if (prevPxHigh < 0) {
    prevPxHigh = h
    prevRsiHigh = rsi
    prevPxLow = l
    prevRsiLow = rsi
}

if (!isLiveUpdate && enableDiv) {
    // --- Regular Bearish Divergence ---
    // Price makes a higher high; RSI makes a lower high
    if (h > prevPxHigh) {
        if (rsi < prevRsiHigh) {
            bearDiv = true
        }
        prevPxHigh = h
        prevRsiHigh = rsi
    }

    // --- Regular Bullish Divergence ---
    // Price makes a lower low; RSI makes a higher low
    if (l < prevPxLow) {
        if (rsi > prevRsiLow) {
            bullDiv = true
        }
        prevPxLow = l
        prevRsiLow = rsi
    }

    // --- Hidden Divergence ---
    if (showHidden) {
        // Hidden bullish: price makes a higher low vs prior low, RSI makes lower low
        if (l > prevPxLow && h < prevPxHigh) {
            if (rsi < prevRsiLow) {
                hiddenBullDiv = true
            }
        }
        // Hidden bearish: price makes a lower high vs prior high, RSI makes higher high
        if (h < prevPxHigh && l > prevPxLow) {
            if (rsi > prevRsiHigh) {
                hiddenBearDiv = true
            }
        }
    }
}

// ---------------------------------------------------------------------------
// 9. ALERT CONDITIONS
// ---------------------------------------------------------------------------
var crossUp = rsi > signal && rsi[1] <= signal[1]
var crossDown = rsi < signal && rsi[1] >= signal[1]

var obPenetrate = rsi > dynOb && rsi[1] <= dynOb
var osPenetrate = rsi < dynOs && rsi[1] >= dynOs

var obExit = rsi < dynOb && rsi[1] >= dynOb
var osExit = rsi > dynOs && rsi[1] <= dynOs

// ---------------------------------------------------------------------------
// 10. PLOTTING
// ---------------------------------------------------------------------------

// --- Midline ---
hline(value=50, color="#ffffff20", width=1)

// --- OB / OS Zones ---
if (showObOs) {
    hline(value=dynOb, color=transparency(bearColor, 60), width=1)
    hline(value=dynOs, color=transparency(bullColor, 60), width=1)
}

// --- RSI vs Signal Fill ---
if (showFill) {
    var signalBull = rsi > signal
    plotLine(
        value=[rsi, signal],
        width=1,
        colors=[transparency(bullColor, 20), transparency(bearColor, 20)],
        colorIndex=signalBull ? 0 : 1,
        fill=true,
        label=["RSI", "Signal SMA"],
        desc=["Fill between RSI and signal SMA", "Fill between RSI and signal SMA"]
    )
}

// --- RSI Line (regime-colored) ---
if (showRsiLine) {
    plotLine(
        value=rsi,
        width=2,
        colors=[regimeColor],
        label=["RSI"],
        desc=["Smoothed RSI (Wilder " + rsiLen + ", regime-colored)"]
    )
}

// --- Signal SMA ---
if (showSignal) {
    plotLine(
        value=signal,
        width=1,
        colors=[signalColor],
        label=["Signal SMA"],
        desc=["SMA of smoothed RSI (" + signalLen + ")"]
    )
}

// --- Divergence Shapes ---
if (showAlerts && enableDiv) {
    if (bullDiv) {
        plotShape(
            value=rsi,
            shape="triangleup",
            colorIndex=divBullColor,
            width=2,
            label=["Bull Div"],
            desc=["Bullish regular divergence: price lower low, RSI higher low"]
        )
    }
    if (bearDiv) {
        plotShape(
            value=rsi,
            shape="triangledown",
            colorIndex=divBearColor,
            width=2,
            label=["Bear Div"],
            desc=["Bearish regular divergence: price higher high, RSI lower high"]
        )
    }
    if (showHidden && hiddenBullDiv) {
        plotShape(
            value=rsi,
            shape="arrowup",
            colorIndex=divBullColor,
            width=1,
            label=["Hidden Bull"],
            desc=["Hidden bullish divergence: price higher low, RSI lower low"]
        )
    }
    if (showHidden && hiddenBearDiv) {
        plotShape(
            value=rsi,
            shape="arrowdown",
            colorIndex=divBearColor,
            width=1,
            label=["Hidden Bear"],
            desc=["Hidden bearish divergence: price lower high, RSI higher high"]
        )
    }
}

// --- Candlestick Pattern Shapes ---
if (showAlerts) {
    if (showDoji && isDoji) {
        plotShape(
            value=rsi,
            shape="circle",
            colorIndex="#ffd700",
            width=1,
            label=["Doji"],
            desc=["Doji: indecision candle, body < 10% of range"]
        )
    }
    if (showHammer && isHammer) {
        plotShape(
            value=rsi,
            shape="triangleup",
            colorIndex=bullColor,
            width=1,
            label=["Hammer"],
            desc=["Hammer: long lower wick, bullish reversal at lows"]
        )
    }
    if (showShootingStar && isShootingStar) {
        plotShape(
            value=rsi,
            shape="triangledown",
            colorIndex=bearColor,
            width=1,
            label=["Shoot Star"],
            desc=["Shooting star: long upper wick, bearish reversal at highs"]
        )
    }
    if (showEngulfing && isBullEngulf) {
        plotShape(
            value=rsi,
            shape="triangleup",
            colorIndex=divBullColor,
            width=2,
            label=["Bull Engulf"],
            desc=["Bullish engulfing: green candle engulfs prior red body"]
        )
    }
    if (showEngulfing && isBearEngulf) {
        plotShape(
            value=rsi,
            shape="triangledown",
            colorIndex=divBearColor,
            width=2,
            label=["Bear Engulf"],
            desc=["Bearish engulfing: red candle engulfs prior green body"]
        )
    }
    if (showHarami && isHarami) {
        plotShape(
            value=rsi,
            shape="rectangle",
            colorIndex="#ffd700",
            width=1,
            label=["Harami"],
            desc=["Harami: small body inside prior large body, potential reversal"]
        )
    }
    if (showStar && isMorningStar) {
        plotShape(
            value=rsi,
            shape="triangleup",
            colorIndex=divBullColor,
            width=2,
            label=["Morn Star"],
            desc=["Morning star: bearish, small body, bullish — bottom reversal"]
        )
    }
    if (showStar && isEveningStar) {
        plotShape(
            value=rsi,
            shape="triangledown",
            colorIndex=divBearColor,
            width=2,
            label=["Eve Star"],
            desc=["Evening star: bullish, small body, bearish — top reversal"]
        )
    }
}

// --- Alert Shapes (crossovers, OB/OS) ---
if (showAlerts) {
    if (crossUp) {
        plotShape(
            value=signal,
            shape="circle",
            colorIndex=bullColor,
            width=2,
            label=["Cross Up"],
            desc=["RSI crossed above signal SMA"]
        )
    }
    if (crossDown) {
        plotShape(
            value=signal,
            shape="circle",
            colorIndex=bearColor,
            width=2,
            label=["Cross Down"],
            desc=["RSI crossed below signal SMA"]
        )
    }
    if (obPenetrate) {
        plotShape(
            value=dynOb,
            shape="xcross",
            colorIndex=bearColor,
            width=2,
            label=["OB Penetrate"],
            desc=["RSI entered overbought zone (RSI > " + dynOb + ")"]
        )
    }
    if (osPenetrate) {
        plotShape(
            value=dynOs,
            shape="xcross",
            colorIndex=bullColor,
            width=2,
            label=["OS Penetrate"],
            desc=["RSI entered oversold zone (RSI < " + dynOs + ")"]
        )
    }
}

// ---------------------------------------------------------------------------
// 11. SUMMARY TABLE (last bar only)
// ---------------------------------------------------------------------------
if (showTable && isLastBar) {
    var regimeText = regimeBull ? "BULLISH" : (regimeBear ? "BEARISH" : "NEUTRAL")
    var regimeTextColor = regimeBull ? bullColor : (regimeBear ? bearColor : "#9e9e9e")
    var obText = useDynamic ? "Dynamic OB: " + dynOb : "Static OB: " + obLevel
    var osText = useDynamic ? "Dynamic OS: " + dynOs : "Static OS: " + osLevel

    plotTable(
        data=[
            ["Price Action RSI", regimeText],
            ["RSI", rsi[0]],
            ["Signal", signal[0]],
            ["Momentum", hist[0]],
            [obText, osText]
        ],
        position="top_right",
        headerRow=true,
        headerColumn=true,
        textColor="#e2e8f0",
        headerTextColor="#ffffff",
        backgroundColor=transparency("#0f172a", 40),
        headerBackgroundColor=transparency("#1e293b", 40),
        borderColor=transparency("#334155", 40),
        borderWidth=1,
        fontSize=10,
        cellPadding=4
    )
}