@kuandotdev/indicator 0.1.1 → 0.1.3

package/project/skills/pinescript-v6/SKILL.md

@@ -0,0 +1,129 @@
+---
+name: pinescript-v6
+description: |
+  Use this skill whenever authoring, editing, reviewing, or migrating PineScript code,
+  and whenever a market-analysis workflow needs PineScript-compatible indicator semantics
+  such as default MACD analysis or user-requested RSI/SMA/EMA/Bollinger/ATR/VWAP logic.
+  Code triggers include .pine files, `//@version=`, `indicator(...)`, `strategy(...)`,
+  `library(...)`, `request.security`, `ta.*`, `strategy.*`, `array.*`, `matrix.*`,
+  `map.*`, etc. The skill encodes Pine Script v6 syntax, common patterns, and v5→v6
+  migration rules so generated code compiles in TradingView's Pine Editor.
+  Trigger phrases: "write a pine indicator", "pinescript strategy", "convert v5 to v6",
+  "fix this pine script", "create alert with webhook", "tradingview indicator".
+---
+
+# PineScript v6 authoring skill
+
+## Market-analysis indicator workflow
+
+For stock/ETF/crypto/forex/futures/index analysis requests, use this skill for PineScript-compatible indicator semantics even when no `.pine` file is being edited.
+
+Default behavior:
+
+1. Pull recent OHLCV through `tradingview-stock-data`.
+2. Compute/interpret MACD by default using Pine-compatible `ta.macd` semantics: EMA fast 12, EMA slow 26, signal EMA 9, plus histogram.
+3. Classify the signal as bullish, bearish, improving, weakening, or neutral from MACD line vs signal line, histogram direction, zero-line position, and recent crossovers.
+4. If the user requests another indicator, use that indicator instead or in addition: RSI, SMA/EMA, Bollinger Bands, ATR, VWAP, or custom PineScript logic.
+5. Feed the indicator result into the agent-evaluated `Rating: {Buy | Sell | hold}` plus Buy/Sell score. Do not treat TradingView's aggregate rating as the report rating.
+
+Only create or edit a Pine file when the user asks for code, a reusable indicator/strategy, or a TradingView chart script. If a `.pine` file is written or modified, run the validation checklist below before claiming it is ready.
+
+## ⚠️ Always check version first
+
+Every PineScript file MUST start with a version directive:
+
+```pinescript
+//@version=6
+```
+
+If the user provides code without `//@version=`, ask which version OR default to **v6**.
+**Never silently mix v4/v5/v6 syntax** — it will not compile.
+
+## Required reading before writing Pine code
+
+Load these in order based on the task:
+
+| Task | Files to read |
+|---|---|
+| New indicator from scratch | `reference/v6-language.md`, `reference/built-ins.md`, `reference/templates/indicator.pine` |
+| New strategy from scratch | `reference/v6-language.md`, `reference/built-ins.md`, `reference/templates/strategy.pine` |
+| Strategy with webhook alerts (for automation) | `reference/templates/alert-webhook.pine` |
+| Convert / migrate existing code | `reference/v5-to-v6-migration.md` first, then `reference/built-ins.md` |
+| Fix compile errors | `reference/v5-to-v6-migration.md` (most errors are v5-isms) |
+
+Paths are relative to this SKILL.md's directory.
+
+## Core authoring rules (apply every time)
+
+1. **One declaration statement per script**: exactly one `indicator()`, `strategy()`, or `library()` call near the top, after `//@version=6`.
+2. **Use namespaces explicitly**:
+   - `ta.sma()` not `sma()` (the un-namespaced form is v4)
+   - `math.abs()` not `abs()`
+   - `array.new<float>()` not `array.new_float()` (v6 prefers typed generics)
+   - `str.tostring()` not `tostring()`
+3. **Series vs simple types**: most TA functions need series; constants are `simple`/`const`. If you see `Cannot call X with arguments...` errors, this is usually the cause.
+4. **`request.security` lookahead**: always pass `barmerge.lookahead_off` unless intentionally peeking. Lookahead-on without `[1]` offset = repainting.
+5. **Strategy realism**: in `strategy(...)` declarations include `process_orders_on_close=true` and `calc_on_every_tick=false` for realistic backtests unless the user asks otherwise.
+6. **Alert messages for webhook automation**: use `alert(message, alert.freq_once_per_bar_close)` with a JSON-shaped string. See `reference/templates/alert-webhook.pine`.
+7. **No `var` abuse**: `var` initializes once. Use it for state that persists across bars; don't use it for values that should recompute.
+8. **Plot return values**: indicator() must produce at least one `plot()`, `plotshape()`, `plotchar()`, `bgcolor()`, or `hline()` to be valid.
+9. **Keep the declaration on one line**: TV's parser does NOT reliably accept the multi-line
+   `indicator(\n     title = "...",\n     ... \n )` style — it produces
+   "Syntax error at input ..." errors. Always write the `indicator(...)`, `strategy(...)`,
+   or `library(...)` call on a single line, even if long. (Local lint won't catch this;
+   only TV's compiler will.)
+
+## Quick reference: things that changed from v5 → v6
+
+| v5 | v6 |
+|---|---|
+| `array.new_float(0)` | `array.new<float>(0)` |
+| `matrix.new<float>(rows, cols, 0.0)` | unchanged ✓ |
+| `if barstate.islast` | unchanged ✓ |
+| Type declarations optional | Stronger inference; explicit types still allowed |
+| `request.security(syminfo.tickerid, "D", close)` | unchanged ✓ but prefer keyword args |
+| `input(...)` | `input.int / input.float / input.bool / input.source` (already true in v5) |
+| Maximum 500 bars `lookback` default | v6 raised some limits — check `reference/v6-language.md` |
+
+See `reference/v5-to-v6-migration.md` for the full delta.
+
+## Validation checklist before declaring "done"
+
+When the user asks you to write/edit Pine code, before responding:
+
+- [ ] First line is `//@version=6`
+- [ ] Exactly one `indicator()` / `strategy()` / `library()` call
+- [ ] All built-ins use correct namespace (`ta.`, `math.`, `str.`, `array.`, `request.`, `strategy.`, `input.`)
+- [ ] Every `input.*()` call has a `title=` and a sensible `defval`
+- [ ] `request.security` calls specify `lookahead` explicitly
+- [ ] For strategies: at least one `strategy.entry` / `strategy.close` / `strategy.exit`
+- [ ] For indicators: at least one visible output (`plot`, `plotshape`, `bgcolor`, `hline`)
+- [ ] If the script generates alerts for the user's webhook pipeline (`tv_browser` MCP / live trading), the `alert()` payload is a JSON string that downstream code can parse
+- [ ] No tabs (Pine Editor uses spaces); 4-space indent
+
+## Project conventions
+
+- Indicators live in `scripts/indicators/*.pine`
+- Strategies live in `scripts/strategies/*.pine`
+- File names use `snake_case.pine`
+- Each file starts with a header comment block:
+  ```
+  // ─────────────────────────────────────────────────────────────
+  // Title: <Display name>
+  // Author: <user>
+  // Description: <one paragraph>
+  // Version: v6, <date>
+  // ─────────────────────────────────────────────────────────────
+  ```
+
+## Pushing to TradingView
+
+After writing a `.pine` file, the user can push it to their TradingView Premium account via:
+
+```bash
+training-view browser push scripts/indicators/<file>.pine --apply NASDAQ:AAPL --screenshot
+```
+
+This logs in via session cookie, pastes into the Pine Editor, saves, applies to a chart,
+and screenshots. The screenshot ends up in `screenshots/` — read it back to visually
+verify the indicator looks correct before iterating.

package/project/skills/pinescript-v6/reference/built-ins.md

@@ -0,0 +1,219 @@
+# PineScript v6 — built-in namespaces cheat sheet
+
+## `ta.*` — technical analysis
+
+```
+ta.sma(src, len)              // Simple MA
+ta.ema(src, len)              // Exponential MA
+ta.wma(src, len)              // Weighted MA
+ta.rma(src, len)              // Wilder's smoothing (used by RSI/ATR)
+ta.vwma(src, len)             // Volume-weighted MA
+ta.hma(src, len)              // Hull MA
+
+ta.rsi(src, len)              // RSI
+ta.macd(src, fast, slow, sig) // returns [macd, signal, hist]
+ta.bb(src, len, mult)         // returns [basis, upper, lower]
+ta.atr(len)                   // Average True Range (uses high/low/close internally)
+ta.tr(handle_na = true)       // True Range
+ta.stoch(src, hi, lo, len)    // Stochastic
+ta.cci(src, len)
+ta.mom(src, len)
+ta.roc(src, len)
+
+ta.highest(src, len)          // Rolling max
+ta.lowest(src, len)           // Rolling min
+ta.highestbars(src, len)      // Bars-ago index of highest
+ta.lowestbars(src, len)
+
+ta.change(src, len = 1)       // src - src[len]
+ta.cum(src)                   // Cumulative sum
+ta.valuewhen(cond, src, occ)  // src value at the Nth occurrence of cond
+
+ta.crossover(a, b)            // bool: a crossed above b this bar
+ta.crossunder(a, b)
+ta.cross(a, b)                // either direction
+
+ta.pivothigh(src, left, right)
+ta.pivotlow(src, left, right)
+ta.barssince(cond)            // bars since cond was true; na if never
+```
+
+## `math.*`
+
+```
+math.abs(x)       math.sign(x)
+math.min(a, b)    math.max(a, b)
+math.round(x, precision = 0)
+math.floor(x)     math.ceil(x)
+math.pow(b, e)    math.sqrt(x)
+math.log(x)       math.log10(x)    math.exp(x)
+math.sin(x)       math.cos(x)      math.tan(x)
+math.atan(x)      math.atan2(y, x)
+math.random(min, max, seed)
+math.sum(src, len)
+math.avg(...)     // up to 10 args
+```
+
+## `str.*`
+
+```
+str.tostring(value, format = "#.##")
+str.tonumber(s)
+str.format("Price: {0,number,#.##}", close)
+str.length(s)
+str.contains(s, sub)
+str.startswith(s, sub)  str.endswith(s, sub)
+str.replace(s, from, to, occurrence = 0)
+str.replace_all(s, from, to)
+str.split(s, sep)         // returns array<string>
+str.upper(s)   str.lower(s)
+```
+
+## `array.*`
+
+```
+array.new<float>(size = 0, init_value = na)
+array.from(v1, v2, ...)        // literal
+array.size(arr)
+array.get(arr, i)              array.set(arr, i, v)
+array.push(arr, v)             array.pop(arr)
+array.unshift(arr, v)          array.shift(arr)
+array.insert(arr, i, v)        array.remove(arr, i)
+array.clear(arr)
+array.includes(arr, v)         array.indexof(arr, v)
+array.slice(arr, from, to)
+array.sort(arr, order = order.ascending)
+array.reverse(arr)
+array.sum(arr)   array.avg(arr)   array.min(arr)   array.max(arr)
+array.stdev(arr)  array.variance(arr)  array.median(arr)
+array.join(arr, sep = ",")
+```
+
+## `map.*`
+
+```
+map.new<keyType, valueType>()
+map.put(m, k, v)         map.get(m, k)
+map.contains(m, k)       map.remove(m, k)
+map.keys(m)              map.values(m)
+map.size(m)              map.clear(m)
+```
+
+## `request.*`
+
+```
+request.security(symbol, timeframe, expression,
+                 gaps = barmerge.gaps_off,
+                 lookahead = barmerge.lookahead_off,
+                 ignore_invalid_symbol = false,
+                 currency = syminfo.currency)
+
+request.security_lower_tf(symbol, timeframe, expression)
+                                // get array of intrabar values
+
+request.financial(symbol, financial_id, period)
+                                // e.g. "TOTAL_REVENUE", period = "FY"|"FQ"|"TTM"
+
+request.dividends(symbol, field, gaps, lookahead)
+request.earnings(symbol, field, gaps, lookahead)
+request.splits(symbol, field, gaps, lookahead)
+request.economic(country_code, field)
+request.quandl(...)              // legacy
+```
+
+## `strategy.*`
+
+```
+strategy.entry(id, direction, qty = na, limit = na, stop = na,
+               oca_name, oca_type, comment, alert_message)
+strategy.order(id, direction, qty, limit, stop, oca_name, oca_type, comment, alert_message)
+strategy.exit(id, from_entry, qty, qty_percent, profit, limit, loss, stop,
+              trail_price, trail_points, trail_offset,
+              oca_name, comment, alert_message)
+strategy.close(id, comment, qty, qty_percent, alert_message)
+strategy.close_all(comment, alert_message)
+strategy.cancel(id)              strategy.cancel_all()
+
+// Direction constants
+strategy.long     strategy.short
+
+// State
+strategy.position_size           // signed: + long, - short, 0 flat
+strategy.position_avg_price
+strategy.opentrades              // count
+strategy.openprofit
+strategy.netprofit
+strategy.equity
+strategy.initial_capital
+
+// Risk management (declarative)
+strategy.risk.allow_entry_in(strategy.direction.long)
+strategy.risk.max_position_size(10)
+strategy.risk.max_drawdown(20, strategy.percent_of_equity)
+strategy.risk.max_intraday_loss(5, strategy.percent_of_equity)
+```
+
+## `input.*`
+
+```
+input.int(defval, title, minval, maxval, step, options, tooltip, inline, group)
+input.float(defval, title, minval, maxval, step, options, tooltip, inline, group)
+input.bool(defval, title, ...)
+input.string(defval, title, options = [...], ...)
+input.color(defval, title, ...)
+input.source(defval, title, ...)              // returns series: close, hl2, hlc3, etc.
+input.symbol(defval, title, ...)              // returns string ticker
+input.timeframe(defval, title, options, ...)
+input.session(defval, title, ...)             // e.g. "0930-1600"
+input.time(defval, title, ...)
+input.price(defval, title, ...)
+```
+
+## `color.*`
+
+```
+color.new(base, transp)          // transp 0 (opaque) - 100 (invisible)
+color.rgb(r, g, b, transp = 0)
+color.from_gradient(value, bottom_value, top_value, bottom_color, top_color)
+color.red color.green color.blue color.yellow color.orange color.purple
+color.white color.black color.gray color.silver color.maroon color.navy
+color.lime color.teal color.aqua color.fuchsia color.olive
+```
+
+## `syminfo.*` (read-only)
+
+```
+syminfo.ticker          // "AAPL"
+syminfo.tickerid        // "NASDAQ:AAPL"
+syminfo.prefix          // "NASDAQ"
+syminfo.description     // "Apple Inc."
+syminfo.currency        // "USD"
+syminfo.basecurrency
+syminfo.type            // "stock", "futures", "crypto", "forex", ...
+syminfo.mintick         // minimum price increment
+syminfo.pointvalue
+syminfo.session
+syminfo.timezone
+```
+
+## `timeframe.*`
+
+```
+timeframe.period        // current chart TF as string "1", "5", "60", "D", "W"
+timeframe.multiplier
+timeframe.isintraday
+timeframe.isdaily
+timeframe.isweekly
+timeframe.ismonthly
+timeframe.in_seconds(tf = timeframe.period)
+```
+
+## `barstate.*` — see v6-language.md
+
+## `alert*`
+
+```
+alert(message, freq)
+// freq: alert.freq_once_per_bar, alert.freq_once_per_bar_close, alert.freq_all
+alertcondition(condition, title, message)
+```

package/project/skills/pinescript-v6/reference/templates/alert-webhook.pine

@@ -0,0 +1,76 @@
+// ─────────────────────────────────────────────────────────────
+// Title: Webhook-Ready Strategy Template
+// Description:
+//   Strategy that emits JSON-shaped alert messages on entry and exit.
+//   Pair with TradingView's alert webhook (Pro+ plan) — set the
+//   webhook URL to your agent / broker bridge endpoint.
+//
+// Webhook payload contract (per alert):
+//   {
+//     "action": "buy" | "sell" | "exit_long" | "exit_short",
+//     "symbol": "<TICKER>",
+//     "price":  <float>,
+//     "qty":    <float>,
+//     "time":   <unix ms>,
+//     "tag":    "<strategy-name>"
+//   }
+// ─────────────────────────────────────────────────────────────
+//@version=6
+strategy(
+     title                    = "Webhook Strategy",
+     overlay                  = true,
+     initial_capital          = 10000,
+     default_qty_type         = strategy.percent_of_equity,
+     default_qty_value        = 10,
+     process_orders_on_close  = true
+ )
+
+fastLen = input.int(10, "Fast")
+slowLen = input.int(30, "Slow")
+tag     = input.string("webhook-strat", "Strategy tag")
+
+fast = ta.ema(close, fastLen)
+slow = ta.ema(close, slowLen)
+
+longCond  = ta.crossover(fast,  slow)
+shortCond = ta.crossunder(fast, slow)
+
+// Build JSON payload helper
+buildPayload(simple string action) =>
+    '{' +
+      '"action":"' + action + '",' +
+      '"symbol":"' + syminfo.ticker + '",' +
+      '"price":'   + str.tostring(close) + ',' +
+      '"qty":'     + str.tostring(strategy.position_size) + ',' +
+      '"time":'    + str.tostring(time) + ',' +
+      '"tag":"'    + tag + '"' +
+    '}'
+
+if longCond
+    strategy.entry("L", strategy.long)
+    alert(buildPayload("buy"), alert.freq_once_per_bar_close)
+
+if shortCond
+    strategy.entry("S", strategy.short)
+    alert(buildPayload("sell"), alert.freq_once_per_bar_close)
+
+// Exit on opposite signal
+if strategy.position_size > 0 and shortCond
+    alert(buildPayload("exit_long"), alert.freq_once_per_bar_close)
+
+if strategy.position_size < 0 and longCond
+    alert(buildPayload("exit_short"), alert.freq_once_per_bar_close)
+
+plot(fast, "Fast", color=color.aqua)
+plot(slow, "Slow", color=color.orange)
+
+// ─────────────────────────────────────────────────────────────
+// HOW TO USE:
+// 1. Save this script in TradingView's Pine Editor.
+// 2. Add to chart. Open the alerts dialog (clock icon).
+// 3. Condition: select this strategy → "Any alert() function call".
+// 4. Notifications → Webhook URL → paste your endpoint
+//    (e.g. https://yourdomain.com/tv-webhook)
+// 5. Message: leave blank (the alert() calls in code provide the payload)
+// 6. Save. TradingView will POST the JSON above on each signal.
+// ─────────────────────────────────────────────────────────────

package/project/skills/pinescript-v6/reference/templates/indicator.pine

@@ -0,0 +1,48 @@
+// ─────────────────────────────────────────────────────────────
+// Title: <Indicator Name>
+// Author: <user>
+// Description: <one-paragraph description>
+// Version: v6, <date>
+// ─────────────────────────────────────────────────────────────
+//@version=6
+// NOTE: TV's compiler is picky about multi-line function calls — keep the
+// declaration on a single line (or use line continuations with a comma on
+// each line and the closing paren tight on the last line, NO leading space).
+indicator("<Indicator Name>", shorttitle="<short>", overlay=true, max_bars_back=500, max_labels_count=50, max_lines_count=50)
+
+// ───── Inputs ────────────────────────────────────────────────
+length    = input.int(14, "Length", minval=1, group="Core")
+src       = input.source(close, "Source", group="Core")
+smoothing = input.string("EMA", "Smoothing", options=["SMA", "EMA", "RMA", "WMA"], group="Core")
+showSignals = input.bool(true, "Show buy/sell signals", group="Display")
+
+// ───── Calculations ──────────────────────────────────────────
+smoothMA(series float source, simple int len, simple string method) =>
+    switch method
+        "SMA" => ta.sma(source, len)
+        "EMA" => ta.ema(source, len)
+        "RMA" => ta.rma(source, len)
+        "WMA" => ta.wma(source, len)
+        =>      ta.ema(source, len)
+
+basis = smoothMA(src, length, smoothing)
+upper = basis + ta.atr(length)
+lower = basis - ta.atr(length)
+
+longSignal  = ta.crossover(close, upper)
+shortSignal = ta.crossunder(close, lower)
+
+// ───── Plots ─────────────────────────────────────────────────
+plot(basis, "Basis", color=color.new(color.blue, 0), linewidth=2)
+plot(upper, "Upper Band", color=color.new(color.gray, 30))
+plot(lower, "Lower Band", color=color.new(color.gray, 30))
+
+plotshape(showSignals and longSignal,  "Long",  shape.triangleup,   location.belowbar, color.lime, size=size.tiny)
+plotshape(showSignals and shortSignal, "Short", shape.triangledown, location.abovebar, color.red,  size=size.tiny)
+
+bgcolor(longSignal  ? color.new(color.lime, 92) : na)
+bgcolor(shortSignal ? color.new(color.red,  92) : na)
+
+// ───── Alerts ────────────────────────────────────────────────
+alertcondition(longSignal,  "Long signal",  "Long signal on {{ticker}} at {{close}}")
+alertcondition(shortSignal, "Short signal", "Short signal on {{ticker}} at {{close}}")

package/project/skills/pinescript-v6/reference/templates/strategy.pine

@@ -0,0 +1,50 @@
+// ─────────────────────────────────────────────────────────────
+// Title: <Strategy Name>
+// Author: <user>
+// Description: <one-paragraph description of entry/exit logic>
+// Version: v6, <date>
+// ─────────────────────────────────────────────────────────────
+//@version=6
+// NOTE: keep the declaration on a single line (TV is picky about multi-line
+// function calls). Wrap with line continuations if needed for readability.
+strategy("<Strategy Name>", shorttitle="<short>", overlay=true, initial_capital=10000, currency=currency.USD, 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, calc_on_every_tick=false, max_bars_back=500)
+
+// ───── Inputs ────────────────────────────────────────────────
+fastLen   = input.int(10, "Fast MA",     minval=1, group="MA")
+slowLen   = input.int(30, "Slow MA",     minval=1, group="MA")
+useATRStop = input.bool(true,  "Use ATR stop", group="Risk")
+atrLen     = input.int(14,     "ATR length",   minval=1, group="Risk")
+atrMult    = input.float(2.0,  "ATR multiplier", minval=0.1, step=0.1, group="Risk")
+rrRatio    = input.float(2.0,  "Reward:Risk",    minval=0.1, step=0.1, group="Risk")
+
+// Session / time filter (optional)
+useTime    = input.bool(false, "Limit to session", group="Time")
+sess       = input.session("0930-1600", "Session", group="Time")
+inSession  = not useTime or not na(time(timeframe.period, sess))
+
+// ───── Calculations ──────────────────────────────────────────
+fastMA = ta.ema(close, fastLen)
+slowMA = ta.ema(close, slowLen)
+atr    = ta.atr(atrLen)
+
+longCond  = ta.crossover(fastMA, slowMA)  and inSession
+shortCond = ta.crossunder(fastMA, slowMA) and inSession
+
+// ───── Orders ────────────────────────────────────────────────
+if longCond
+    stopPx   = close - atrMult * atr
+    targetPx = close + atrMult * atr * rrRatio
+    strategy.entry("L", strategy.long)
+    if useATRStop
+        strategy.exit("L-exit", from_entry="L", stop=stopPx, limit=targetPx)
+
+if shortCond
+    stopPx   = close + atrMult * atr
+    targetPx = close - atrMult * atr * rrRatio
+    strategy.entry("S", strategy.short)
+    if useATRStop
+        strategy.exit("S-exit", from_entry="S", stop=stopPx, limit=targetPx)
+
+// ───── Plots ─────────────────────────────────────────────────
+plot(fastMA, "Fast MA", color=color.new(color.aqua, 0))
+plot(slowMA, "Slow MA", color=color.new(color.orange, 0))

package/project/skills/pinescript-v6/reference/v5-to-v6-migration.md

@@ -0,0 +1,102 @@
+# v5 → v6 migration guide
+
+Most v5 code runs unchanged when you bump the version directive, but a few patterns
+need updating. Common compile errors and their fixes:
+
+## 1. Generic type constructors
+
+```pinescript
+// v5 (still works but deprecated)
+arr = array.new_float(10, 0.0)
+mat = matrix.new_float(3, 3, 0.0)
+
+// v6 (preferred)
+arr = array.new<float>(10, 0.0)
+mat = matrix.new<float>(3, 3, 0.0)
+```
+
+Same applies to `int`, `bool`, `string`, `color`, `label`, `line`, `box`, custom types.
+
+## 2. Anonymous types in arrays/maps
+
+```pinescript
+// v5
+type Bar
+    float o
+    float c
+
+var bars = array.new<Bar>()
+
+// v6 — same syntax ✓ but you can now use methods
+method body(Bar self) =>
+    math.abs(self.c - self.o)
+
+method is_bull(Bar self) =>
+    self.c > self.o
+
+// Call site
+b = Bar.new(100, 110)
+size = b.body()      // method-style
+```
+
+## 3. Boolean optimization changes
+
+v6 short-circuits `and`/`or` more aggressively. Side effects in the second operand may
+not execute. Move side effects out:
+
+```pinescript
+// v5 may have worked; v6 may skip the second call
+ok = check_a() and (counter := counter + 1) > 0
+
+// v6 safe
+a_ok = check_a()
+counter := counter + 1
+ok = a_ok and counter > 0
+```
+
+## 4. `request.security` parameter ordering
+
+v6 enforces stricter type checking on the `expression` parameter. If you pass tuples,
+they must use the explicit form:
+
+```pinescript
+// v5 — implicit tuple
+[h, l, c] = request.security(sym, "D", [high, low, close])
+
+// v6 — same syntax ✓ but each element must be the same series type
+// If you need mixed types, use multiple calls
+```
+
+## 5. `strategy.exit` profit/loss in points vs ticks
+
+No behavioral change but stricter validation. Make sure `profit` and `loss` are in
+**points** (price units), or use `profit_percent`/`loss_percent`.
+
+## 6. Color transparency
+
+`color.new(color.red, 50)` — second arg is 0 (opaque) to 100 (transparent). Same in v6.
+If you used `transp=50` in `plot()`, that param still exists.
+
+## 7. Removed / renamed (rare)
+
+- `tickerid()` → `ticker.new()` (renamed in v5 already; remove any remaining v4 form)
+- `security()` (unprefixed) → `request.security()` (v5 already, but worth checking)
+- `sma()`, `ema()`, etc. unprefixed → `ta.sma()`, `ta.ema()` (v5 already)
+
+## 8. New in v6 (use these if helpful)
+
+- **Dynamic requests**: `request.security(sym, tf, expr)` where `sym` can change per bar (with caveats — check official docs)
+- **`chart.point`**: convenience type for line/label coordinates
+- **Polylines**: `polyline.new(points, ...)` for connected segments
+- **Improved `runtime.error()`**: clearer error surfaces
+
+## Compile error decoder
+
+| Error message | Likely cause |
+|---|---|
+| `Cannot call '...' with arguments (series int, ...)` | Passing series where simple expected. Cast or use `int(x)` if literal. |
+| `Undeclared identifier 'sma'` | Missing `ta.` prefix |
+| `The 'expression' has wrong type` in `request.security` | Mixing series types inside a tuple |
+| `Pine cannot determine the referencing length` | Add `max_bars_back=N` to `indicator()`/`strategy()` |
+| `Function should be called on each calculation` | `var`-initialized inside a conditional; move it out |
+| `Script must have at least one output` | Indicator without any `plot*` / `bgcolor` / `hline` |