//@version=6

indicator("FitMom Strategy", shorttitle = "FitMom Strategy", overlay = true, max_lines_count = 500, max_labels_count = 500, max_boxes_count = 500)

// ─────────────────────────────────────────────────────────────────────────────

// INPUTS

// ─────────────────────────────────────────────────────────────────────────────

grpS = "Sessions"

tzIn = input.string("America/Chicago", "Timezone", group = grpS, tooltip = "America/Chicago handles CST/CDT automatically.")

nySessIn = input.session("0830-1500", "NY session (profile built here)", group = grpS)

nightSessIn = input.session("1700-0100", "Level display window", group = grpS)

rangeSessIn = input.session("1800-1900", "High/Low window", group = grpS)

grpP = "Volume Profile"

rowsIn = input.int(1000, "Profile rows", minval = 10, maxval = 1000, group = grpP, tooltip = "More rows = finer price resolution for POC/VAH/VAL.")

vaPctIn = input.float(70, "Value area %", minval = 10, maxval = 100, step = 1, group = grpP) / 100

grpL = "Value Area Levels"

showPOC = input.bool(true, "POC", inline = "poc", group = grpL)

pocCol = input.color(color.orange, "", inline = "poc", group = grpL)

showVAH = input.bool(true, "VAH", inline = "vah", group = grpL)

vahCol = input.color(color.teal, "", inline = "vah", group = grpL)

showVAL = input.bool(true, "VAL", inline = "val", group = grpL)

valCol = input.color(color.teal, "", inline = "val", group = grpL)

lvlWidthIn = input.int(2, "Width", minval = 1, maxval = 5, group = grpL)

lvlStyleIn = input.string("Solid", "Style", options = ["Solid", "Dashed", "Dotted"], group = grpL)

showVAFill = input.bool(false, "Shade value area", inline = "fill", group = grpL)

vaFillCol = input.color(color.new(color.teal, 90), "", inline = "fill", group = grpL)

grpR = "High/Low Window"

showRH = input.bool(true, "High", inline = "rh", group = grpR)

rhCol = input.color(color.lime, "", inline = "rh", group = grpR)

showRL = input.bool(true, "Low", inline = "rl", group = grpR)

rlCol = input.color(color.red, "", inline = "rl", group = grpR)

rWidthIn = input.int(1, "Width", minval = 1, maxval = 5, group = grpR)

rStyleIn = input.string("Dashed", "Style", options = ["Solid", "Dashed", "Dotted"], group = grpR)

rangeName = input.string("6-7pm", "Label prefix", group = grpR)

grpV = "Trading Start Line"

showVLine = input.bool(true, "Show vertical line", group = grpV)

vHourIn = input.int(19, "Hour", minval = 0, maxval = 23, inline = "vt", group = grpV)

vMinIn = input.int(0, "Minute", minval = 0, maxval = 59, inline = "vt", group = grpV)

vTextIn = input.string("trading begins", "Text", group = grpV)

vCol = input.color(color.gray, "Color", group = grpV)

vWidthIn = input.int(1, "Width", minval = 1, maxval = 5, group = grpV)

vStyleIn = input.string("Dotted", "Style", options = ["Solid", "Dashed", "Dotted"], group = grpV)

grpLb = "Labels"

showLabels = input.bool(true, "Show labels", group = grpLb)

showDates = input.bool(true, "Include date in label", group = grpLb)

labelSizeIn = input.string("Small", "Label size", options = ["Tiny", "Small", "Normal"], group = grpLb)

grpF = "FVG Continuation Engine"

useFvgSig = input.bool(true, "Enable FVG continuation signals", group = grpF)

fvgOnVA = input.bool(true, "Use NY POC / VAH / VAL", group = grpF)

fvgOnRng = input.bool(true, "Use 6-7pm High / Low", group = grpF,

tooltip = "The 6-7pm levels only become tradable after the window closes. A high that is still forming touches itself on every new high.")

fvgAfterStart = input.bool(false, "Only arm after the trading start time", group = grpF,

tooltip = "When on, level touches only count between the 'trading begins' time and the end of the overnight window.")

atrLen = input.int(14, "ATR length", minval = 1, group = grpF)

fTolMode = input.string("ATR", "Touch tolerance", options = ["ATR", "Ticks", "None"], group = grpF)

fTolAtr = input.float(0.10, " ATR multiple", step = 0.05, minval = 0, group = grpF)

fTolTick = input.int(4, " Ticks", minval = 0, group = grpF)

fCool = input.int(10, "Bars before the same level can re-arm", minval = 1, group = grpF)

minLag = input.int(1, "Min bars from touch to FVG", minval = 0, group = grpF)

maxLag = input.int(4, "Max bars from touch to FVG", minval = 1, group = grpF)

minGap = input.float(0.10, "Min gap size (x ATR)", step = 0.05, minval = 0, group = grpF)

minDisp = input.float(0.60, "Min displacement body (x ATR)", step = 0.10, minval = 0, group = grpF)

needRej = input.bool(true, "FVG must reject the level (close clear of it)", group = grpF)

fillMode = input.string("Full (far edge)", "Fill requirement",

options = ["Touch (near edge)", "50% (CE)", "Full (far edge)"], group = grpF)

maxFill = input.int(30, "Max bars to fill the gap", minval = 1, group = grpF)

confMode = input.string("Close back through gap", "Continuation confirmation",

options = ["Close back through gap", "Close beyond FVG bar extreme"], group = grpF)

maxConf = input.int(15, "Max bars to confirm after the fill", minval = 1, group = grpF)

invBuf = input.float(0.15, "Invalidation buffer beyond gap (x ATR)", step = 0.05, minval = 0, group = grpF)

oneADay = input.bool(false, "Only one signal per level per day", group = grpF)

showFvg = input.bool(true, "Draw FVG boxes", group = grpF)

cFvgUp = input.color(#26A69A, "Signal colour long", inline = "fvgC", group = grpF)

cFvgDn = input.color(#EF5350, "short", inline = "fvgC", group = grpF)

fvgTr = input.int(75, " FVG box transparency %", minval = 0, maxval = 100, group = grpF)

showSigLb = input.bool(true, "Signal labels", group = grpF)

grpT = "Line Touch Alerts"

touchTicks = input.int(0, "Touch tolerance (ticks)", minval = 0, group = grpT,

tooltip = "0 = price must actually trade through the line. Higher values count a near miss as a touch.")

touchAfterStart = input.bool(false, "Only alert after the trading start time", group = grpT)

if timeframe.isdwm or timeframe.in_seconds() > 3600

runtime.error("Use an intraday chart of 1 hour or lower (1-5 min recommended for an accurate profile).")

// ─────────────────────────────────────────────────────────────────────────────

// HELPERS

// ─────────────────────────────────────────────────────────────────────────────

f_style(string s) =>

s == "Dashed" ? line.style_dashed : s == "Dotted" ? line.style_dotted : line.style_solid

f_size(string s) =>

s == "Tiny" ? size.tiny : s == "Normal" ? size.normal : size.small

// Make sessions apply to all 7 days unless the user specified days

f_sess(string s) =>

str.contains(s, ":") ? s : s + ":1234567"

// Minutes after midnight from "HHMM" starting at position pos of a session string

f_clock(string s, int pos) =>

int h = int(str.tonumber(str.substring(s, pos, pos + 2)))

int m = int(str.tonumber(str.substring(s, pos + 2, pos + 4)))

h * 60 + m

f_text(string name, int dateTs) =>

showDates ? name + " " + str.format_time(dateTs, "MMM d", tzIn) : name

// Builds a volume profile from stored bar highs/lows/volumes and returns [POC, VAH, VAL]

f_valueArea(array<float> hs, array<float> ls, array<float> vs, int rows, float vaPct) =>

float poc = na

float vah = na

float val = na

int n = hs.size()

if n > 0

float hi = hs.max()

float lo = ls.min()

if hi > lo

float step = (hi - lo) / rows

bool noVol = vs.sum() <= 0 // fall back to time-at-price if symbol has no volume

array<float> hist = array.new<float>(rows, 0.0)

for i = 0 to n - 1

float bH = hs.get(i)

float bL = ls.get(i)

float w = noVol ? 1.0 : vs.get(i)

float rng = bH - bL

int r0 = math.max(0, math.min(rows - 1, math.floor((bL - lo) / step)))

int r1 = math.max(0, math.min(rows - 1, math.floor((bH - lo) / step)))

if rng <= 0

hist.set(r0, hist.get(r0) + w)

else

// spread the bar's volume across the rows it covers, proportional to overlap

for r = r0 to r1

float rowLo = lo + r * step

float ov = math.min(bH, rowLo + step) - math.max(bL, rowLo)

if ov > 0

hist.set(r, hist.get(r) + w * ov / rng)

int pocRow = hist.indexof(hist.max())

float target = hist.sum() * vaPct

float acc = hist.get(pocRow)

int up = pocRow

int dn = pocRow

// expand value area outward from POC toward the heavier side

while acc < target and (up < rows - 1 or dn > 0)

float vUp = up < rows - 1 ? hist.get(up + 1) : -1.0

float vDn = dn > 0 ? hist.get(dn - 1) : -1.0

if vUp >= vDn

up += 1

acc += vUp

else

dn -= 1

acc += vDn

poc := math.round_to_mintick(lo + (pocRow + 0.5) * step)

vah := math.round_to_mintick(lo + (up + 1) * step)

val := math.round_to_mintick(lo + dn * step)

else

poc := hi

vah := hi

val := hi

[poc, vah, val]

f_drawLevel(bool show, float price, int x1, int x2, color col, string name, int dateTs) =>

line ln = na

if show and not na(price)

ln := line.new(x1, price, x2, price, xloc.bar_time, extend.none, col, f_style(lvlStyleIn), lvlWidthIn)

if showLabels

label.new(x2, price, f_text(name, dateTs), xloc.bar_time, yloc.price, color(na), label.style_label_left, col, f_size(labelSizeIn))

ln

// ─────────────────────────────────────────────────────────────────────────────

// SESSION STATE

// ─────────────────────────────────────────────────────────────────────────────

string nySess = f_sess(nySessIn)

string nightSess = f_sess(nightSessIn)

string rangeSess = f_sess(rangeSessIn)

bool inNY = not na(time(timeframe.period, nySess, tzIn))

bool inNight = not na(time(timeframe.period, nightSess, tzIn))

bool inRange = not na(time(timeframe.period, rangeSess, tzIn))

bool newDay = dayofmonth(time, tzIn) != dayofmonth(time[1], tzIn)

var array<float> hArr = array.new<float>()

var array<float> lArr = array.new<float>()

var array<float> vArr = array.new<float>()

var bool nyActive = false

var bool pending = false

var int nyDate = na

var int pDate = na

var float pPOC = na

var float pVAH = na

var float pVAL = na

var int nightEndTs = na

var float rHi = na

var float rLo = na

var line rHiLine = na

var line rLoLine = na

var label rHiLbl = na

var label rLoLbl = na

var int rEndTs = na

var bool rDone = false

// Levels currently available to the FVG engine

var float aPOC = na

var float aVAH = na

var float aVAL = na

var int vaEndTs = na

// 1) NY session finished -> compute that day's POC / VAH / VAL

if nyActive and (not inNY or newDay)

[vaP, vaH, vaL] = f_valueArea(hArr, lArr, vArr, rowsIn, vaPctIn)

pPOC := vaP

pVAH := vaH

pVAL := vaL

pDate := nyDate

pending := not na(vaP)

nyActive := false

// 2) Collect bars during the NY session

if inNY and not nyActive

hArr.clear()

lArr.clear()

vArr.clear()

nyDate := time

nyActive := true

if inNY

hArr.push(high)

lArr.push(low)

vArr.push(nz(volume))

// 3) Overnight window opens (5pm) -> draw the most recent session's levels until 5am

// Friday's levels appear at Sunday's 5pm open, since that's the next overnight session.

if inNight and not inNight[1]

int sMin = f_clock(nightSessIn, 0)

int eMin = f_clock(nightSessIn, 5)

int dur = eMin - sMin <= 0 ? eMin - sMin + 1440 : eMin - sMin

int startTs = timestamp(tzIn, year(time, tzIn), month(time, tzIn), dayofmonth(time, tzIn), math.floor(sMin / 60), sMin % 60)

if startTs > time

startTs -= 86400000

nightEndTs := startTs + dur * 60000

if pending

line vahLn = f_drawLevel(showVAH, pVAH, startTs, nightEndTs, vahCol, "NY VAH", pDate)

line valLn = f_drawLevel(showVAL, pVAL, startTs, nightEndTs, valCol, "NY VAL", pDate)

f_drawLevel(showPOC, pPOC, startTs, nightEndTs, pocCol, "NY POC", pDate)

if showVAFill and not na(vahLn) and not na(valLn)

linefill.new(vahLn, valLn, vaFillCol)

aPOC := showPOC ? pPOC : na

aVAH := showVAH ? pVAH : na

aVAL := showVAL ? pVAL : na

vaEndTs := nightEndTs

pending := false

// 4) 6pm-7pm high/low, extended to the end of the overnight window (5am)

if inRange and not inRange[1]

rHi := high

rLo := low

int x1 = time

int x2 = not na(nightEndTs) and nightEndTs > time ? nightEndTs : time + 11 * 3600000

rEndTs := x2

rDone := false

string rs = f_style(rStyleIn)

rHiLine := showRH ? line.new(x1, rHi, x2, rHi, xloc.bar_time, extend.none, rhCol, rs, rWidthIn) : na

rLoLine := showRL ? line.new(x1, rLo, x2, rLo, xloc.bar_time, extend.none, rlCol, rs, rWidthIn) : na

rHiLbl := showRH and showLabels ? label.new(x2, rHi, f_text(rangeName + " High", time), xloc.bar_time, yloc.price, color(na), label.style_label_left, rhCol, f_size(labelSizeIn)) : na

rLoLbl := showRL and showLabels ? label.new(x2, rLo, f_text(rangeName + " Low", time), xloc.bar_time, yloc.price, color(na), label.style_label_left, rlCol, f_size(labelSizeIn)) : na

else if inRange

rHi := math.max(rHi, high)

rLo := math.min(rLo, low)

if not na(rHiLine)

rHiLine.set_y1(rHi)

rHiLine.set_y2(rHi)

if not na(rLoLine)

rLoLine.set_y1(rLo)

rLoLine.set_y2(rLo)

if not na(rHiLbl)

rHiLbl.set_y(rHi)

if not na(rLoLbl)

rLoLbl.set_y(rLo)

if not inRange and inRange[1]

rDone := true

// 5) Vertical "trading begins" line at 19:00 CT each day

int vTs = timestamp(tzIn, year(time, tzIn), month(time, tzIn), dayofmonth(time, tzIn), vHourIn, vMinIn)

var int tradeStartTs = na

if time >= vTs and time[1] < vTs

tradeStartTs := vTs

if showVLine

float yTop = high > low ? high : high + syminfo.mintick

line.new(vTs, low, vTs, yTop, xloc.bar_time, extend.both, vCol, f_style(vStyleIn), vWidthIn)

label.new(vTs, high, vTextIn, xloc.bar_time, yloc.abovebar, color(na), label.style_label_down, vCol, f_size(labelSizeIn))

// ─────────────────────────────────────────────────────────────────────────────

// 6) FVG CONTINUATION ENGINE (from TO Bounce Engine v13, engine B only)

// 1 price touches one of this indicator's levels

// 2 within N bars an FVG prints in the rejection direction

// 3 price returns and fills that gap

// 4 price closes back through the gap -> signal

// ─────────────────────────────────────────────────────────────────────────────

atrv = ta.atr(atrLen)

var int dayCount = 0

if timeframe.change("D")

dayCount += 1

cFvgBoxB = color.new(cFvgUp, fvgTr)

cFvgBoxS = color.new(cFvgDn, fvgTr)

// A level is only live while its line is on the chart

bool vaLive = not na(vaEndTs) and time < vaEndTs

bool rngLive = rDone and not na(rEndTs) and time < rEndTs

bool tradeLive = not na(tradeStartTs) and not na(nightEndTs) and time >= tradeStartTs and time < nightEndTs

bool armOK = not fvgAfterStart or tradeLive

type Touch

string nm

float top

float bot

int bar

type Setup

string nm

int dir

float gTop

float gBot

float confP

int fvgBar

int fillBar

int st

box bx

var map<string, int> lastTouchBar = map.new<string, int>()

var map<string, int> lastSigDay = map.new<string, int>()

var array<Touch> touches = array.new<Touch>()

var array<Setup> setups = array.new<Setup>()

addLvl(array<string> ns, array<float> ts, array<float> bs, bool use, string nm, float t, float b) =>

if use and not na(t) and not na(b)

ns.push(nm)

ts.push(t)

bs.push(b)

0

bool lffcBull = false

bool lffcBear = false

string lffcName = ""

if useFvgSig and barstate.isconfirmed and not na(atrv)

names = array.new<string>()

tops = array.new<float>()

bots = array.new<float>()

addLvl(names, tops, bots, fvgOnVA and vaLive, "NY POC", aPOC, aPOC)

addLvl(names, tops, bots, fvgOnVA and vaLive, "NY VAH", aVAH, aVAH)

addLvl(names, tops, bots, fvgOnVA and vaLive, "NY VAL", aVAL, aVAL)

addLvl(names, tops, bots, fvgOnRng and rngLive and showRH, rangeName + " High", rHi, rHi)

addLvl(names, tops, bots, fvgOnRng and rngLive and showRL, rangeName + " Low", rLo, rLo)

// ── STAGE 1: register touches ──

float ftol = fTolMode == "ATR" ? atrv * fTolAtr : fTolMode == "Ticks" ? syminfo.mintick * fTolTick : 0.0

if armOK and names.size() > 0

for i = 0 to names.size() - 1

nm = names.get(i)

tp = tops.get(i)

bt = bots.get(i)

if low - ftol <= tp and high + ftol >= bt

prev = lastTouchBar.contains(nm) ? lastTouchBar.get(nm) : -999999

if bar_index - prev >= fCool

lastTouchBar.put(nm, bar_index)

touches.push(Touch.new(nm, tp, bt, bar_index))

if touches.size() > 0

for i = touches.size() - 1 to 0

if bar_index - touches.get(i).bar > maxLag

touches.remove(i)

// ── STAGE 2: FVG on the 3-bar window ending here ──

disp = math.abs(close[1] - open[1])

bull = low > high[2] and (low - high[2]) >= atrv * minGap and disp >= atrv * minDisp and close[1] > open[1]

bear = high < low[2] and (low[2] - high) >= atrv * minGap and disp >= atrv * minDisp and close[1] < open[1]

if (bull or bear) and touches.size() > 0

int dir = bull ? 1 : -1

float gBot = bull ? high[2] : high

float gTop = bull ? low : low[2]

int best = -1

for i = touches.size() - 1 to 0

tch = touches.get(i)

lag = bar_index - tch.bar

okLag = lag >= minLag and lag <= maxLag

okRej = not needRej or (dir == 1 ? close > tch.top : close < tch.bot)

if okLag and okRej and best == -1

best := i

if best >= 0

tch = touches.get(best)

float cp = na

if confMode == "Close back through gap"

cp := dir == 1 ? gTop : gBot

else

cp := dir == 1 ? high : low

box bx = na

if showFvg

bx := box.new(bar_index - 2, gTop, bar_index, gBot,

border_width = 0, bgcolor = dir == 1 ? cFvgBoxB : cFvgBoxS)

setups.push(Setup.new(tch.nm, dir, gTop, gBot, cp, bar_index, 0, 0, bx))

touches.remove(best)

// ── STAGES 3 & 4: manage open setups ──

float invB = atrv * invBuf

if setups.size() > 0

for i = setups.size() - 1 to 0

su = setups.get(i)

mid = (su.gTop + su.gBot) / 2

bool dead = false

bool fired = false

float fillP = na

if fillMode == "Full (far edge)"

fillP := su.dir == 1 ? su.gBot : su.gTop

else if fillMode == "50% (CE)"

fillP := mid

else

fillP := su.dir == 1 ? su.gTop : su.gBot

blown = su.dir == 1 ? close < su.gBot - invB : close > su.gTop + invB

if su.st == 0

filled = su.dir == 1 ? low <= fillP : high >= fillP

if filled

su.st := 1

su.fillBar := bar_index

else if blown or bar_index - su.fvgBar > maxFill

dead := true

if su.st == 1 and not dead

conf = su.dir == 1 ? close > su.confP : close < su.confP

ok = not oneADay or not lastSigDay.contains(su.nm) or lastSigDay.get(su.nm) != dayCount

if conf and ok

fired := true

dead := true

lastSigDay.put(su.nm, dayCount)

if su.dir == 1

lffcBull := true

else

lffcBear := true

lffcName := su.nm

else if conf and not ok

dead := true

else if blown or bar_index - su.fillBar > maxConf

dead := true

if not na(su.bx) and not dead

su.bx.set_right(bar_index + 1)

if dead

if not na(su.bx)

if fired

su.bx.set_bgcolor(color.new(su.dir == 1 ? cFvgUp : cFvgDn, math.max(fvgTr - 20, 0)))

su.bx.set_right(bar_index)

else

box.delete(su.bx)

setups.remove(i)

// ─────────────────────────────────────────────────────────────────────────────

// 7) SIGNAL MARKERS & ALERTS

// ─────────────────────────────────────────────────────────────────────────────

plotshape(lffcBull, "FVG continuation long", shape.arrowup, location.belowbar, cFvgUp, size = size.small)

plotshape(lffcBear, "FVG continuation short", shape.arrowdown, location.abovebar, cFvgDn, size = size.small)

string sigNote = lffcBull or lffcBear ? "FVG continuation " + (lffcBull ? "long" : "short") + " off " + lffcName : ""

if showSigLb and (lffcBull or lffcBear)

label.new(bar_index, lffcBull ? low : high, "FVG" + (lffcBull ? "▲" : "▼"),

style = lffcBull ? label.style_label_up : label.style_label_down,

color = color.new(lffcBull ? color.green : color.red, 25),

textcolor = color.white, size = size.tiny, tooltip = sigNote)

alertcondition(lffcBull, "FVG continuation long", "Bullish level → FVG → fill → continuation confirmed")

alertcondition(lffcBear, "FVG continuation short", "Bearish level → FVG → fill → continuation confirmed")

alertcondition(lffcBull or lffcBear, "Any FVG continuation", "Level → FVG → fill → continuation confirmed")

if lffcBull or lffcBear

alert(syminfo.ticker + " " + timeframe.period + " " + sigNote, alert.freq_once_per_bar)

// ─────────────────────────────────────────────────────────────────────────────

// 8) LINE TOUCH ALERTS

// Fires on the first bar that touches a line after a bar that didn't,

// so a candle chopping around a level doesn't alert on every bar.

// Only lines currently on the chart count (VA 5pm-5am, 6-7pm range after 7pm).

// ─────────────────────────────────────────────────────────────────────────────

float tTol = syminfo.mintick * touchTicks

bool touchOK = not touchAfterStart or tradeLive

f_touch(float lvl) =>

not na(lvl) and low - tTol <= lvl and high + tTol >= lvl

bool onPOC = touchOK and vaLive and f_touch(aPOC)

bool onVAH = touchOK and vaLive and f_touch(aVAH)

bool onVAL = touchOK and vaLive and f_touch(aVAL)

bool onRH = touchOK and rngLive and showRH and f_touch(rHi)

bool onRL = touchOK and rngLive and showRL and f_touch(rLo)

bool touchPOC = onPOC and not onPOC[1]

bool touchVAH = onVAH and not onVAH[1]

bool touchVAL = onVAL and not onVAL[1]

bool touchRH = onRH and not onRH[1]

bool touchRL = onRL and not onRL[1]

bool touchAny = touchPOC or touchVAH or touchVAL or touchRH or touchRL

alertcondition(touchPOC, "Touch: NY POC", "{{ticker}} touched NY POC")

alertcondition(touchVAH, "Touch: NY VAH", "{{ticker}} touched NY VAH")

alertcondition(touchVAL, "Touch: NY VAL", "{{ticker}} touched NY VAL")

alertcondition(touchRH, "Touch: 6-7pm High", "{{ticker}} touched the 6-7pm high")

alertcondition(touchRL, "Touch: 6-7pm Low", "{{ticker}} touched the 6-7pm low")

alertcondition(touchAny, "Touch: any line", "{{ticker}} touched a FitMom line")

if touchAny

string tMsg = ""

if touchPOC

tMsg += "NY POC " + str.tostring(aPOC, format.mintick) + " "

if touchVAH

tMsg += "NY VAH " + str.tostring(aVAH, format.mintick) + " "

if touchVAL

tMsg += "NY VAL " + str.tostring(aVAL, format.mintick) + " "

if touchRH

tMsg += rangeName + " High " + str.tostring(rHi, format.mintick) + " "

if touchRL

tMsg += rangeName + " Low " + str.tostring(rLo, format.mintick) + " "

alert(syminfo.ticker + " " + timeframe.period + " touched: " + tMsg, alert.freq_once_per_bar)