diff --git a/.env b/.env
new file mode 100644
index 000000000..05dc23651
--- /dev/null
+++ b/.env
@@ -0,0 +1,43 @@
+# PowerTrader AI .env
+
+# ---------------------------
+# Common settings
+# ---------------------------
+EXCHANGE_PROVIDER=binance
+
+# Training speed controls (optional)
+# TRAIN_FAST=true
+TRAIN_LOOKBACK=2000
+
+# ---------------------------
+# TEST / PAPER MODE (enable for dry runs)
+# ---------------------------
+BINANCE_TESTNET=true
+BINANCE_PAPER=true
+BINANCE_PAPER_BALANCE=1000
+
+# Force a full paper trade cycle (entry/hold/dca/exit)
+BINANCE_PAPER_TEST=true
+BINANCE_PAPER_TEST_COIN=BNB
+BINANCE_PAPER_TEST_ALLOC_USD=50
+BINANCE_PAPER_TEST_DCA_SECONDS=60
+BINANCE_PAPER_TEST_HOLD_SECONDS=120
+BINANCE_PAPER_FEE_RATE=0.001 # 0.1% fee for paper trading
+BINANCE_TAKER_FEE_RATE=0.001
+BINANCE_MAKER_FEE_RATE=0.001
+
+# Binance keys (optional in PAPER mode)
+BINANCE_API_KEY=your_key_here
+BINANCE_API_SECRET=your_secret_here
+
+# ---------------------------
+# PROD / LIVE MODE (comment TEST block above, then set these)
+# ---------------------------
+# BINANCE_TESTNET=false
+# BINANCE_PAPER=false
+# BINANCE_API_KEY=your_real_key
+# BINANCE_API_SECRET=your_real_secret
+
+# Optional Binance settings
+# BINANCE_API_BASE_URL=https://api.binance.com
+# BINANCE_QUOTE_ASSET=USDT
diff --git a/.env.example b/.env.example
new file mode 100644
index 000000000..05dc23651
--- /dev/null
+++ b/.env.example
@@ -0,0 +1,43 @@
+# PowerTrader AI .env
+
+# ---------------------------
+# Common settings
+# ---------------------------
+EXCHANGE_PROVIDER=binance
+
+# Training speed controls (optional)
+# TRAIN_FAST=true
+TRAIN_LOOKBACK=2000
+
+# ---------------------------
+# TEST / PAPER MODE (enable for dry runs)
+# ---------------------------
+BINANCE_TESTNET=true
+BINANCE_PAPER=true
+BINANCE_PAPER_BALANCE=1000
+
+# Force a full paper trade cycle (entry/hold/dca/exit)
+BINANCE_PAPER_TEST=true
+BINANCE_PAPER_TEST_COIN=BNB
+BINANCE_PAPER_TEST_ALLOC_USD=50
+BINANCE_PAPER_TEST_DCA_SECONDS=60
+BINANCE_PAPER_TEST_HOLD_SECONDS=120
+BINANCE_PAPER_FEE_RATE=0.001 # 0.1% fee for paper trading
+BINANCE_TAKER_FEE_RATE=0.001
+BINANCE_MAKER_FEE_RATE=0.001
+
+# Binance keys (optional in PAPER mode)
+BINANCE_API_KEY=your_key_here
+BINANCE_API_SECRET=your_secret_here
+
+# ---------------------------
+# PROD / LIVE MODE (comment TEST block above, then set these)
+# ---------------------------
+# BINANCE_TESTNET=false
+# BINANCE_PAPER=false
+# BINANCE_API_KEY=your_real_key
+# BINANCE_API_SECRET=your_real_secret
+
+# Optional Binance settings
+# BINANCE_API_BASE_URL=https://api.binance.com
+# BINANCE_QUOTE_ASSET=USDT
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 000000000..2eea525d8
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+.env
\ No newline at end of file
diff --git a/BTC_trading_signal.pine b/BTC_trading_signal.pine
new file mode 100644
index 000000000..e4041eade
--- /dev/null
+++ b/BTC_trading_signal.pine
@@ -0,0 +1,678 @@
+//@version=6
+indicator("BTC Trading Signals", overlay=true, max_lines_count=500, max_boxes_count=500)
+
+// Fonction utilitaire pour nettoyer les valeurs
+f_clean_value(float value) => value == 0.0 ? na : value
+
+// === TYPES ===
+type srInfo
+    int startTime
+    float price
+    string srType
+    int strength
+    string timeframeStr
+    bool ephemeral = false
+
+    int breakTime
+    array<int> retestTimes
+
+type srObj
+    srInfo info
+    
+    bool startFixed
+    bool breakFixed
+
+    bool rendered
+    string combinedTimeframeStr
+
+    line srLine
+    box srBox
+    label srLabel
+    label breakLabel
+    array<label> retestLabels
+
+type barInfo
+    int t
+    int tc
+    float c
+    float h
+    float l
+
+// === SUPPORT & RESISTANCE MTF ===
+const bool DEBUG = false
+const bool fixSRs = true
+const bool fixRetests = false
+
+const int maxSRInfoListSize = 10
+const int maxBarInfoListSize = 3000
+const int maxDistanceToLastBar = 500
+const int minSRSize = 5
+const int retestLabelCooldown = 3
+const float tooCloseATR = 1.0 / 8.0
+const int labelOffsetBars = 20
+
+const int atrLen = 20
+atr = ta.atr(atrLen)
+avgVolume = ta.sma(volume, atrLen)
+
+var int curTFMS = timeframe.in_seconds(timeframe.period) * 1000
+var map<string, bool> alerts = map.new<string, bool>()
+alerts.put("Retest", false)
+alerts.put("Break", false)
+
+// Variables globales
+var allSRInfoList = array.new<srInfo>()
+var barInfoList = array.new<barInfo>()
+var allSRList = array.new<srObj>()
+insideBounds = (bar_index > last_bar_index - maxDistanceToLastBar)
+
+// Paramètres avec display=display.none pour les masquer
+srPivotLength = input.int(15, "Pivot Length", minval = 3, maxval = 50, group = "Support & Resistance", display=display.none)
+srStrength = input.int(1, "Strength", [1, 2, 3], group = "Support & Resistance", display=display.none)
+srInvalidation = input.string("Close", "Invalidation", ["Wick", "Close"], group = "Support & Resistance", display=display.none)
+expandZones = input.string("Only Valid", "Expand Lines & Zones", options = ["All", "Only Valid", "None"], group = "Support & Resistance", display=display.none)
+showInvalidated = input.bool(true, "Show Invalidated", group = "Support & Resistance", display=display.none)
+
+timeframe1Enabled = input.bool(true, title = "", group = "Timeframes", inline = "timeframe1", display=display.none)
+timeframe1 = input.timeframe("", title = "", group = "Timeframes", inline = "timeframe1", display=display.none)
+timeframe2Enabled = input.bool(false, title = "", group = "Timeframes", inline = "timeframe2", display=display.none)
+timeframe2 = input.timeframe("D", title = "", group = "Timeframes", inline = "timeframe2", display=display.none)
+timeframe3Enabled = input.bool(false, title = "", group = "Timeframes", inline = "timeframe3", display=display.none)
+timeframe3 = input.timeframe("W", title = "", group = "Timeframes", inline = "timeframe3", display=display.none)
+
+showBreaks = input.bool(true, "Show Breaks", group = "Breaks & Retests", inline = "ShowBR", display=display.none)
+showRetests = input.bool(true, "Show Retests", group = "Breaks & Retests", inline = "ShowBR", display=display.none)
+avoidFalseBreaks = input.bool(false, "Avoid False Breaks", group = "Breaks & Retests", display=display.none)
+breakVolumeThreshold = input.float(0.3, "Break Volume Threshold", minval = 0.1, maxval = 2.0, step = 0.1, group = "Breaks & Retests", display=display.none)
+inverseBrokenLineColor = input.bool(false, "Inverse Color After Broken", group = "Breaks & Retests", display=display.none)
+
+styleMode = input.string("Lines", "Style", ["Lines", "Zones"], group = "Style", display=display.none)
+lineStyle = input.string("____", "Line Style", ["____", "----", "...."], group = "Style", display=display.none)
+lineWidth = input.int(2, "Line Width", minval = 1, group = "Style", display=display.none)
+zoneSize = input.float(1.0, "Zone Width", minval = 0.1, maxval = 10, step = 0.1, group = "Style", display=display.none)
+zoneSizeATR = zoneSize * 0.075
+supportColor = input.color(#08998180, "Support Color", group = "Style", inline = "RScolors", display=display.none)
+resistanceColor = input.color(#f2364580, "Resistance Color", group = "Style", inline = "RScolors", display=display.none)
+breakColor = input.color(color.blue, "Break Color", group = "Style", inline = "RScolors2", display=display.none)
+textColor = input.color(#ffffff80, "Text Color", group = "Style", inline = "RScolors2", display=display.none)
+
+enableRetestAlerts = input.bool(true, "Enable Retest Alerts", tooltip = "Needs Show Retests option enabled.", group = "Alerts", display=display.none)
+enableBreakAlerts = input.bool(true, "Enable Break Alerts", tooltip = "Needs Show Breaks option enabled.", group = "Alerts", display=display.none)
+
+// === PARAMÈTRES ===
+// RSI
+rsi_length = input.int(14, "RSI Length", minval=1, display=display.none)
+rsi_overbought = input.float(70, "RSI Overbought", minval=0, maxval=100, display=display.none)
+rsi_oversold = input.float(30, "RSI Oversold", minval=0, maxval=100, display=display.none)
+
+// MACD
+macd_fast = input.int(12, "MACD Fast Length", minval=1, display=display.none)
+macd_slow = input.int(26, "MACD Slow Length", minval=1, display=display.none)
+macd_signal = input.int(9, "MACD Signal Length", minval=1, display=display.none)
+show_macd_extremes = input.bool(true, "Afficher extremes MACD (+/-)", group="MACD", display=display.none)
+macd_lookback = input.int(3, "Lookback pour extremes MACD", minval=1, maxval=10, group="MACD", display=display.none)
+
+// EMA
+ema_short = input.int(9, "EMA Short Length", minval=1, display=display.none)
+ema_long = input.int(21, "EMA Long Length", minval=1, display=display.none)
+
+// Ichimoku
+tenkan_len = input.int(9, "Tenkan-Sen Length", minval=1, display=display.none)
+kijun_len = input.int(26, "Kijun-Sen Length", minval=1, display=display.none)
+senkou_span_b_len = input.int(52, "Senkou Span B Length", minval=1, display=display.none)
+displacement = input.int(26, "Displacement", minval=1, display=display.none)
+
+// Bollinger Bands
+bb_length = input.int(20, "BB Length", minval=1, display=display.none)
+bb_mult = input.float(2.0, "BB StdDev", minval=0.001, maxval=5, display=display.none)
+
+// Volume Profile
+show_vp = input.bool(true, "Show Volume Profile", display=display.none)
+vp_lookback = input.int(20, "Volume Profile Lookback", minval=1, display=display.none)
+
+// Paramètres d'affichage
+show_ichimoku = input.bool(true, "Afficher Ichimoku Cloud", group="Affichage", display=display.none)
+show_bb = input.bool(true, "Afficher Bollinger Bands", group="Affichage", display=display.none)
+show_minor_signals = input.bool(false, "Afficher signaux mineurs", group="Affichage", display=display.none)
+show_ema_ribbon = input.bool(true, "Afficher EMA Ribbon", group="Affichage", display=display.none)
+
+// === CALCUL DES INDICATEURS ===
+// Indicateurs existants
+rsi = ta.rsi(close, rsi_length)
+[macd_line, signal_line, hist_line] = ta.macd(close, macd_fast, macd_slow, macd_signal)
+ema9 = ta.ema(close, ema_short)
+ema21 = ta.ema(close, ema_long)
+
+// Ichimoku Cloud
+donchian(len) => math.avg(ta.lowest(len), ta.highest(len))
+tenkan = donchian(tenkan_len)
+kijun = donchian(kijun_len)
+senkou_span_a = math.avg(tenkan, kijun)
+senkou_span_b = donchian(senkou_span_b_len)
+
+// Bollinger Bands
+[bb_middle, bb_upper, bb_lower] = ta.bb(close, bb_length, bb_mult)
+bb_squeeze = (bb_upper - bb_lower) / bb_middle < 0.1
+
+// Volume Profile
+vp_sum = 0.0
+vp_green_sum = 0.0
+for i = 0 to vp_lookback-1
+    vp_sum := vp_sum + volume[i]
+    vp_green_sum := vp_green_sum + (close[i] > open[i] ? volume[i] : 0)
+vp_ratio = vp_green_sum / vp_sum
+volume_surge = volume > ta.sma(volume, 20) * 2
+
+// Détection des croisements MACD
+macd_bullish = ta.crossover(macd_line, signal_line)
+macd_bearish = ta.crossunder(macd_line, signal_line)
+
+// === CONDITIONS DE SIGNAL ===
+// Conditions élémentaires
+rsi_oversold_condition = rsi < rsi_oversold
+rsi_overbought_condition = rsi > rsi_overbought
+ema_bullish = ta.crossover(ema9, ema21)
+ema_bearish = ta.crossunder(ema9, ema21)
+cloud_bullish = close > senkou_span_a and close > senkou_span_b and tenkan > kijun
+cloud_bearish = close < senkou_span_a and close < senkou_span_b and tenkan < kijun
+high_vol_bullish = vp_ratio > 0.7 and volume_surge
+high_vol_bearish = vp_ratio < 0.3 and volume_surge
+
+// Variables pour suivi des logs
+rsi_bull_signal = false
+rsi_bear_signal = false
+macd_bull_signal = false
+macd_bear_signal = false
+ema_bull_signal = false
+ema_bear_signal = false
+cloud_bull_signal = false
+cloud_bear_signal = false
+bb_bull_signal = false
+bb_bear_signal = false
+
+// === CALCUL DES SIGNAUX COMBINÉS ===
+// Force du signal (de 0 à 3)
+bullish_strength = 0
+bearish_strength = 0
+
+// Ajouter des forces selon les indicateurs
+if rsi_oversold_condition
+    bullish_strength := bullish_strength + 1
+    rsi_bull_signal := true
+    
+if rsi_overbought_condition
+    bearish_strength := bearish_strength + 1
+    rsi_bear_signal := true
+    
+if macd_bullish
+    bullish_strength := bullish_strength + 1
+    macd_bull_signal := true
+    
+if macd_bearish
+    bearish_strength := bearish_strength + 1
+    macd_bear_signal := true
+    
+if ema_bullish
+    bullish_strength := bullish_strength + 1
+    ema_bull_signal := true
+    
+if ema_bearish
+    bearish_strength := bearish_strength + 1
+    ema_bear_signal := true
+    
+if cloud_bullish and volume_surge
+    bullish_strength := bullish_strength + 2
+    cloud_bull_signal := true
+    
+if cloud_bearish and volume_surge
+    bearish_strength := bearish_strength + 2
+    cloud_bear_signal := true
+    
+if bb_squeeze and high_vol_bullish
+    bullish_strength := bullish_strength + 1
+    bb_bull_signal := true
+    
+if bb_squeeze and high_vol_bearish
+    bearish_strength := bearish_strength + 1
+    bb_bear_signal := true
+
+// Signaux finaux
+weak_buy_signal = bullish_strength == 1
+medium_buy_signal = bullish_strength == 2
+strong_buy_signal = bullish_strength >= 3
+weak_sell_signal = bearish_strength == 1
+medium_sell_signal = bearish_strength == 2
+strong_sell_signal = bearish_strength >= 3
+
+// === AFFICHAGE ===
+// Plots conditionnels sans blocs if - Solution avec opérateurs sûrs
+ichimoku_span_a = show_ichimoku ? senkou_span_a : 0.0
+ichimoku_span_b = show_ichimoku ? senkou_span_b : 0.0
+ichimoku_tenkan = show_ichimoku ? tenkan : 0.0
+ichimoku_kijun = show_ichimoku ? kijun : 0.0
+
+bollinger_upper = show_bb ? bb_upper : 0.0
+bollinger_lower = show_bb ? bb_lower : 0.0
+
+// Plots pour Ichimoku seulement s'il est activé
+plot(f_clean_value(show_ichimoku ? ichimoku_span_a : na), "Senkou Span A", color=color.new(color.green, 70))
+plot(f_clean_value(show_ichimoku ? ichimoku_span_b : na), "Senkou Span B", color=color.new(color.red, 70))
+plot(f_clean_value(show_ichimoku ? ichimoku_tenkan : na), "Tenkan-Sen", color=color.blue)
+plot(f_clean_value(show_ichimoku ? ichimoku_kijun : na), "Kijun-Sen", color=color.red)
+
+// Coloration du nuage Ichimoku si activé
+spanA = plot(show_ichimoku ? f_clean_value(ichimoku_span_a) : na, "", color=na)
+spanB = plot(show_ichimoku ? f_clean_value(ichimoku_span_b) : na, "", color=na)
+fill(spanA, spanB, color=show_ichimoku ? (ichimoku_span_a > ichimoku_span_b ? color.new(color.green, 90) : color.new(color.red, 90)) : na)
+
+// Plots Bollinger Bands
+plot(f_clean_value(show_bb ? bollinger_upper : na), "BB Upper", color=color.new(color.blue, 50))
+plot(f_clean_value(show_bb ? bollinger_lower : na), "BB Lower", color=color.new(color.blue, 50))
+
+// Plots des signaux mineurs
+plotshape(show_minor_signals ? rsi_oversold_condition : false, title="RSI Oversold", location=location.belowbar, color=color.new(color.green, 40), style=shape.triangleup, size=size.tiny)
+plotshape(show_minor_signals ? rsi_overbought_condition : false, title="RSI Overbought", location=location.abovebar, color=color.new(color.red, 40), style=shape.triangledown, size=size.tiny)
+plotshape(show_minor_signals ? macd_bullish : false, title="MACD Bullish", location=location.belowbar, color=color.new(color.green, 40), style=shape.diamond, size=size.tiny)
+plotshape(show_minor_signals ? macd_bearish : false, title="MACD Bearish", location=location.abovebar, color=color.new(color.red, 40), style=shape.diamond, size=size.tiny)
+plotshape(show_minor_signals ? ema_bullish : false, title="EMA Bullish", location=location.belowbar, color=color.new(color.green, 40), style=shape.circle, size=size.tiny)
+plotshape(show_minor_signals ? ema_bearish : false, title="EMA Bearish", location=location.abovebar, color=color.new(color.red, 40), style=shape.circle, size=size.tiny)
+
+// Signaux principaux (toujours affichés)
+plotshape(medium_buy_signal, title="Medium Buy", location=location.belowbar, color=color.new(color.green, 20), style=shape.triangleup, size=size.small)
+plotshape(medium_sell_signal, title="Medium Sell", location=location.abovebar, color=color.new(color.red, 20), style=shape.triangledown, size=size.small)
+plotshape(strong_buy_signal, title="Strong Buy", location=location.belowbar, color=color.green, style=shape.triangleup, size=size.normal)
+plotshape(strong_sell_signal, title="Strong Sell", location=location.abovebar, color=color.red, style=shape.triangledown, size=size.normal)
+
+// Indicateur spécifique pour MACD (flèches plus grandes)
+plotshape(macd_bullish, title="MACD Achat", location=location.belowbar, color=color.green, style=shape.arrowup, size=size.huge)
+plotshape(macd_bearish, title="MACD Vente", location=location.abovebar, color=color.red, style=shape.arrowdown, size=size.huge)
+
+// == INDICATEUR DE FORCE DU MARCHÉ ==
+// Indice de force des tendances (de -100 à +100)
+market_strength = math.max(-100, math.min(100, (bullish_strength - bearish_strength) * 33))
+
+// Alerte principale
+alertcondition(medium_buy_signal or strong_buy_signal or medium_sell_signal or strong_sell_signal, title="Signal Alert", message="Signal détecté sur {{ticker}} - {{interval}}")
+
+// Alerte spécifique MACD
+alertcondition(macd_bullish, title="MACD Crossover Haussier", message="MACD croise au-dessus de la ligne de signal sur {{ticker}} - {{interval}}")
+alertcondition(macd_bearish, title="MACD Crossover Baissier", message="MACD croise en-dessous de la ligne de signal sur {{ticker}} - {{interval}}")
+
+// Paramètres EMA Ribbon avec display=display.none
+int emaPeriod1 = input.int(5, "EMA Période 1", minval=1, display=display.none)
+int emaPeriod2 = input.int(10, "EMA Période 2", minval=1, display=display.none)
+int emaPeriod3 = input.int(15, "EMA Période 3", minval=1, display=display.none)
+int emaPeriod4 = input.int(20, "EMA Période 4", minval=1, display=display.none)
+int emaPeriod5 = input.int(25, "EMA Période 5", minval=1, display=display.none)
+int emaPeriod6 = input.int(30, "EMA Période 6", minval=1, display=display.none)
+
+// Calcul des EMA
+ema1 = ta.ema(close, emaPeriod1)
+ema2 = ta.ema(close, emaPeriod2)
+ema3 = ta.ema(close, emaPeriod3)
+ema4 = ta.ema(close, emaPeriod4)
+ema5 = ta.ema(close, emaPeriod5)
+ema6 = ta.ema(close, emaPeriod6)
+
+// Fonction de couleur pour le gradient
+emaColor(period) => color.from_gradient(period, emaPeriod1, emaPeriod6, color.rgb(255, 0, 0), color.rgb(0, 255, 0))
+
+// Plots pour le ribbon EMA
+plot(f_clean_value(show_ema_ribbon ? ema1 : na), "EMA 5", color=emaColor(emaPeriod1), linewidth=2)
+plot(f_clean_value(show_ema_ribbon ? ema2 : na), "EMA 10", color=emaColor(emaPeriod2), linewidth=2)
+plot(f_clean_value(show_ema_ribbon ? ema3 : na), "EMA 15", color=emaColor(emaPeriod3), linewidth=2)
+plot(f_clean_value(show_ema_ribbon ? ema4 : na), "EMA 20", color=emaColor(emaPeriod4), linewidth=2)
+plot(f_clean_value(show_ema_ribbon ? ema5 : na), "EMA 25", color=emaColor(emaPeriod5), linewidth=2)
+plot(f_clean_value(show_ema_ribbon ? ema6 : na), "EMA 30", color=emaColor(emaPeriod6), linewidth=2)
+
+// Exemple avec l'EMA 50
+ema50 = ta.ema(close, 50)
+plot(show_ema_ribbon ? f_clean_value(ema50) : na, "EMA 50", color=color.blue, linewidth=2)
+
+// === TYPES ET FONCTIONS SUPPORT & RESISTANCE ===
+// Fonctions utilitaires
+findValRtnTime (barInfo[] biList, valToFind, toSearch, searchMode, minTime, maxTime, int defVal = na) =>
+    int rtnTime = defVal
+    float minDiff = na
+    if biList.size() > 0
+        for i = biList.size() - 1 to 0
+            curBI = biList.get(i)
+            if curBI.t >= minTime and curBI.t < maxTime
+                toLook = (toSearch == "Low" ? curBI.l : toSearch == "High" ? curBI.h : curBI.c)
+                if searchMode == "Nearest"
+                    curDiff = math.abs(valToFind - toLook)
+                    if na(minDiff)
+                        rtnTime := curBI.t
+                        minDiff := curDiff
+                    else
+                        if curDiff <= minDiff
+                            minDiff := curDiff
+                            rtnTime := curBI.t
+                if searchMode == "Higher"
+                    if toLook >= valToFind
+                        rtnTime := curBI.t
+                        break
+                if searchMode == "Lower"
+                    if toLook <= valToFind
+                        rtnTime := curBI.t
+                        break
+    rtnTime
+
+formatTimeframeString (string formatTimeframe, bool short = false) =>
+    timeframeF = (formatTimeframe == "" ? timeframe.period : formatTimeframe)
+    if str.contains(timeframeF, "D") or str.contains(timeframeF, "W") or str.contains(timeframeF, "S") or str.contains(timeframeF, "M")
+        timeframe.from_seconds(timeframe.in_seconds(timeframeF))
+    else
+        seconds = timeframe.in_seconds(timeframeF)
+        if seconds >= 3600
+            hourCount = int(seconds / 3600)
+            if short
+                str.tostring(hourCount) + "h"
+            else
+                str.tostring(hourCount) + " Hour" + (hourCount > 1 ? "s" : "")
+        else
+            if short
+                timeframeF + "m"
+            else
+                timeframeF + " Min"
+
+// Fonctions de rendu et gestion SR
+renderSRObj (srObj sr) =>
+    if na(sr.info.breakTime) or showInvalidated
+        sr.rendered := true
+        endTime = nz(sr.info.breakTime, time + curTFMS * labelOffsetBars)
+        extendType = extend.none
+        if na(sr.info.breakTime)
+            extendType := extend.right
+        if expandZones == "Only Valid" and na(sr.info.breakTime)
+            extendType := extend.both
+        else if expandZones == "All"
+            extendType := extend.both
+            endTime := time + curTFMS * labelOffsetBars
+        
+        labelTitle = formatTimeframeString(sr.info.timeframeStr)
+        if not na(sr.combinedTimeframeStr)
+            labelTitle := sr.combinedTimeframeStr
+
+        labelTitle += " | " + str.tostring(math.round_to_mintick(sr.info.price)) + ((sr.info.ephemeral and DEBUG) ? " [E]" : "")
+        if styleMode == "Lines"
+            // Line
+            sr.srLine := line.new(sr.info.startTime, sr.info.price, endTime, sr.info.price, xloc = xloc.bar_time, color = sr.info.srType == "Resistance" ? resistanceColor : supportColor, width = lineWidth, style = lineStyle == "----" ? line.style_dashed : lineStyle == "...." ? line.style_dotted : line.style_solid, extend = extendType)
+            // Label
+            sr.srLabel := label.new(extendType == extend.none ? ((sr.info.startTime + endTime) / 2) : endTime, sr.info.price, xloc = xloc.bar_time, text = labelTitle, textcolor = textColor, style = label.style_none)
+        else
+            // Zone
+            sr.srBox := box.new(sr.info.startTime, sr.info.price + atr * zoneSizeATR, endTime, sr.info.price - atr * zoneSizeATR, xloc = xloc.bar_time, bgcolor = sr.info.srType == "Resistance" ? resistanceColor : supportColor, border_color = na, text = labelTitle, text_color = textColor, extend = extendType, text_size = size.normal, text_halign = (extendType != extend.none) ? text.align_right : text.align_center)
+
+        // Break Label
+        if showBreaks
+            if not na(sr.info.breakTime)
+                sr.breakLabel := label.new(sr.info.breakTime, sr.info.price, "B", yloc = sr.info.srType ==  "Resistance" ? yloc.belowbar : yloc.abovebar, style = sr.info.srType == "Resistance" ? label.style_label_up : label.style_label_down, color = breakColor, textcolor = color.new(textColor, 0), xloc = xloc.bar_time, size = size.small)
+                if (time - curTFMS <= sr.info.breakTime) and (time + curTFMS >= sr.info.breakTime)
+                    alerts.put("Break", true)
+
+        // Retest Labels
+        if showRetests
+            if sr.info.retestTimes.size() > 0
+                for i = sr.info.retestTimes.size() - 1 to 0
+                    curRetestTime = sr.info.retestTimes.get(i)
+                    cooldownOK = true
+                    if sr.retestLabels.size() > 0
+                        lastLabel = sr.retestLabels.get(0)
+                        if math.abs(lastLabel.get_x() - curRetestTime) < curTFMS * retestLabelCooldown
+                            cooldownOK := false
+
+                    if cooldownOK and (curRetestTime >= sr.info.startTime) and (na(sr.info.breakTime) or curRetestTime < sr.info.breakTime)
+                        if time - curTFMS <= curRetestTime and time >= curRetestTime
+                            alerts.put("Retest", true)
+                        sr.retestLabels.unshift(label.new(curRetestTime, sr.info.price, "R" + (DEBUG ?  (" " + str.tostring(sr.info.price)) : ""), yloc = sr.info.srType ==  "Resistance" ? yloc.abovebar : yloc.belowbar, style = sr.info.srType == "Resistance" ? label.style_label_down : label.style_label_up, color = sr.info.srType == "Resistance" ? resistanceColor : supportColor, textcolor = color.new(textColor, 0), xloc = xloc.bar_time, size = size.small))
+
+safeDeleteSRObj (srObj sr) =>
+    if sr.rendered
+        line.delete(sr.srLine)
+        box.delete(sr.srBox)
+        label.delete(sr.srLabel)
+        label.delete(sr.breakLabel)
+        if sr.retestLabels.size() > 0
+            for i = 0 to sr.retestLabels.size() - 1
+                curRetestLabel = sr.retestLabels.get(i)
+                label.delete(curRetestLabel)
+        sr.rendered := false
+
+// Fonctions de gestion des timeframes
+fixSRToTimeframe (srObj sr) =>
+    srMS = math.max(timeframe.in_seconds(sr.info.timeframeStr), timeframe.in_seconds()) * 1000
+    if (not sr.startFixed)
+        if not sr.info.ephemeral
+            if sr.info.srType == "Resistance"
+                sr.info.startTime := findValRtnTime(barInfoList, sr.info.price, "High", "Nearest", sr.info.startTime - srMS, sr.info.startTime + srMS, sr.info.startTime)
+            else
+                sr.info.startTime := findValRtnTime(barInfoList, sr.info.price, "Low", "Nearest", sr.info.startTime - srMS, sr.info.startTime + srMS, sr.info.startTime)
+            sr.startFixed := true
+        else
+            if allSRList.size() > 0
+                for i = 0 to allSRList.size() - 1
+                    curSR = allSRList.get(i)
+                    if (not curSR.info.ephemeral) and (not na(curSR.info.breakTime)) and curSR.info.price == sr.info.price and ((sr.info.srType == "Resistance" and curSR.info.srType == "Support") or (sr.info.srType == "Support" and curSR.info.srType == "Resistance"))
+                        if curSR.breakFixed
+                            sr.info.startTime := curSR.info.breakTime
+                            sr.startFixed := true
+                        break
+
+    if not na(sr.info.breakTime)
+        if (not sr.breakFixed)
+            if sr.info.srType == "Resistance"
+                sr.info.breakTime := findValRtnTime(barInfoList, sr.info.price, srInvalidation == "Wick" ? "High" : "Close", "Higher", sr.info.breakTime - srMS, sr.info.breakTime + srMS, sr.info.breakTime)
+            else
+                sr.info.breakTime := findValRtnTime(barInfoList, sr.info.price, srInvalidation == "Wick" ? "Low" : "Close", "Lower", sr.info.breakTime - srMS, sr.info.breakTime + srMS, sr.info.breakTime)
+            sr.breakFixed := true
+    
+    if sr.info.retestTimes.size() > 0 and fixRetests
+        for i = 0 to sr.info.retestTimes.size() - 1
+            curRetestTime = sr.info.retestTimes.get(i)
+
+            retestStartTime = curRetestTime - srMS
+            retestStartTime := math.max(retestStartTime, sr.info.startTime + 1)
+            
+            retestEndTime = curRetestTime + srMS
+            if not na(sr.info.breakTime)
+                retestEndTime := math.min(retestEndTime, sr.info.breakTime - 1)
+            
+            if sr.info.srType == "Resistance"
+                sr.info.retestTimes.set(i, findValRtnTime(barInfoList, sr.info.price, "High", "Higher", retestStartTime, retestEndTime, sr.info.retestTimes.get(i)))
+            else
+                sr.info.retestTimes.set(i, findValRtnTime(barInfoList, sr.info.price, "Low", "Lower", retestStartTime, retestEndTime, sr.info.retestTimes.get(i)))
+
+getSR (srObj[] list, srPrice, eph, srType, timeframeStr) =>
+    srObj rtnSR = na
+    if list.size() > 0
+        for i = 0 to list.size() - 1
+            curSR = list.get(i)
+            if curSR.info.price == srPrice and curSR.info.ephemeral == eph and curSR.info.srType == srType and curSR.info.timeframeStr == timeframeStr
+                rtnSR := curSR
+                break
+    rtnSR
+
+handleTF (tfStr, tfEnabled) =>
+    if tfEnabled
+        tfSRInfoList = request.security(syminfo.tickerid, tfStr, allSRInfoList)
+        if not na(tfSRInfoList) and tfSRInfoList.size() > 0
+            for i = 0 to tfSRInfoList.size() - 1
+                srInfo curSRInfo = tfSRInfoList.get(i)
+                if fixSRs
+                    currentSameSR = getSR(allSRList, curSRInfo.price, curSRInfo.ephemeral, curSRInfo.srType, curSRInfo.timeframeStr)
+                    if not na(currentSameSR)
+                        if currentSameSR.startFixed
+                            curSRInfo.startTime := currentSameSR.info.startTime
+                        if currentSameSR.breakFixed
+                            curSRInfo.breakTime := currentSameSR.info.breakTime
+                        curSRInfo.retestTimes := currentSameSR.info.retestTimes
+                        // All other info should be replaced except fixed start, break and all retests.
+                        currentSameSR.info := curSRInfo
+                        if not currentSameSR.breakFixed
+                            fixSRToTimeframe(currentSameSR)
+                    else
+                        srObj newSRObj = srObj.new(curSRInfo)
+                        // We handle retests in current timeframe so no need to get them from upper.
+                        newSRObj.info.retestTimes := array.new<int>()
+                        newSRObj.retestLabels := array.new<label>()
+                        fixSRToTimeframe(newSRObj)
+                        allSRList.unshift(newSRObj)
+                else
+                    srObj newSRObj = srObj.new(curSRInfo)
+                    newSRObj.retestLabels := array.new<label>()
+                    allSRList.unshift(newSRObj)
+    true
+
+// Logique principale
+pivotHigh = ta.pivothigh(srPivotLength, srPivotLength)
+pivotLow = ta.pivotlow(srPivotLength, srPivotLength)
+
+barInfoList.unshift(barInfo.new(time, time_close, close, high, low))
+if barInfoList.size() > maxBarInfoListSize
+    barInfoList.pop()
+
+if insideBounds and barstate.isconfirmed
+    // Find Supports
+    if not na(pivotLow)
+        validSR = true
+        if allSRInfoList.size() > 0
+            for i = 0 to allSRInfoList.size() - 1
+                curRSInfo = allSRInfoList.get(i)
+                if (math.abs(curRSInfo.price - pivotLow) < atr * tooCloseATR) and na(curRSInfo.breakTime)
+                    validSR := false
+                    break
+        
+        if validSR
+            newSRInfo = srInfo.new(barInfoList.get(srPivotLength).t, pivotLow, "Support", 1, timeframe.period)
+            newSRInfo.retestTimes := array.new<int>()
+            allSRInfoList.unshift(newSRInfo)
+            while allSRInfoList.size() > maxSRInfoListSize
+                allSRInfoList.pop()
+    
+    // Find Resistances
+    if not na(pivotHigh)
+        validSR = true
+        if allSRInfoList.size() > 0
+            for i = 0 to allSRInfoList.size() - 1
+                curRSInfo = allSRInfoList.get(i)
+                if (math.abs(curRSInfo.price - pivotLow) < atr * tooCloseATR) and na(curRSInfo.breakTime)
+                    validSR := false
+                    break
+        if validSR
+            newSRInfo = srInfo.new(barInfoList.get(srPivotLength).t, pivotHigh, "Resistance", 1, timeframe.period)
+            newSRInfo.retestTimes := array.new<int>()
+            allSRInfoList.unshift(newSRInfo)
+            if allSRInfoList.size() > maxSRInfoListSize
+                allSRInfoList.pop()
+
+// Handle SR Infos
+if insideBounds and (srInvalidation == "Wick" or barstate.isconfirmed)
+    if allSRInfoList.size() > 0
+        for i = 0 to allSRInfoList.size() - 1
+            srInfo curSRInfo = allSRInfoList.get(i)
+            
+            // Breaks
+            invHigh = (srInvalidation == "Close" ? close : high)
+            invLow = (srInvalidation == "Close" ? close : low)
+            closeTime = time
+            if na(curSRInfo.breakTime)
+                if curSRInfo.srType == "Resistance" and invHigh > curSRInfo.price
+                    if (not avoidFalseBreaks) or (volume > avgVolume * breakVolumeThreshold)
+                        curSRInfo.breakTime := closeTime
+                        if inverseBrokenLineColor and (not curSRInfo.ephemeral) and curSRInfo.strength >= srStrength
+                            ephSR = srInfo.new(closeTime, curSRInfo.price, "Support", curSRInfo.strength, curSRInfo.timeframeStr, true)
+                            ephSR.retestTimes := array.new<int>()
+                            allSRInfoList.unshift(ephSR)
+                else if curSRInfo.srType == "Support" and invLow < curSRInfo.price
+                    if (not avoidFalseBreaks) or (volume > avgVolume * breakVolumeThreshold)
+                        curSRInfo.breakTime := closeTime
+                        if inverseBrokenLineColor and (not curSRInfo.ephemeral) and curSRInfo.strength >= srStrength
+                            ephSR = srInfo.new(closeTime, curSRInfo.price, "Resistance", curSRInfo.strength, curSRInfo.timeframeStr, true)
+                            ephSR.retestTimes := array.new<int>()
+                            allSRInfoList.unshift(ephSR)
+                
+            // Strength & Retests
+            if na(curSRInfo.breakTime) and time > curSRInfo.startTime and barstate.isconfirmed
+                if curSRInfo.srType == "Resistance" and high >= curSRInfo.price and close <= curSRInfo.price
+                    int lastRetestTime = 0
+                    if curSRInfo.retestTimes.size() > 0
+                        lastRetestTime := curSRInfo.retestTimes.get(0)
+                    
+                    if lastRetestTime != time
+                        if not curSRInfo.ephemeral
+                            curSRInfo.strength += 1
+                        curSRInfo.retestTimes.unshift(time)
+                
+                else if curSRInfo.srType == "Support" and low <= curSRInfo.price and close >= curSRInfo.price
+                    int lastRetestTime = 0
+                    if curSRInfo.retestTimes.size() > 0
+                        lastRetestTime := curSRInfo.retestTimes.get(0)
+                    
+                    if lastRetestTime != time
+                        if not curSRInfo.ephemeral
+                            curSRInfo.strength += 1
+                        curSRInfo.retestTimes.unshift(time)
+
+// Handle SR
+if (bar_index > last_bar_index - maxDistanceToLastBar * 8) and barstate.isconfirmed
+    if not fixSRs
+        if allSRList.size() > 0
+            for i = 0 to allSRList.size() - 1
+                srObj curSRObj = allSRList.get(i)
+                safeDeleteSRObj(curSRObj)
+        allSRList.clear()
+        
+    handleTF(timeframe1, timeframe1Enabled)
+    handleTF(timeframe2, timeframe2Enabled)
+    handleTF(timeframe3, timeframe3Enabled)
+    
+    if allSRList.size() > 0
+        for i = 0 to allSRList.size() - 1
+            srObj curSRObj = allSRList.get(i)
+            safeDeleteSRObj(curSRObj)
+            tooClose = false
+            for j = 0 to allSRList.size() - 1
+                closeSR = allSRList.get(j)
+                if closeSR.rendered and math.abs(closeSR.info.price - curSRObj.info.price) <= tooCloseATR * atr and closeSR.info.srType == curSRObj.info.srType and closeSR.info.ephemeral == curSRObj.info.ephemeral
+                    tooClose := true
+                    if not str.contains((na(closeSR.combinedTimeframeStr) ? formatTimeframeString(closeSR.info.timeframeStr) : closeSR.combinedTimeframeStr), formatTimeframeString(curSRObj.info.timeframeStr))
+                        if na(closeSR.combinedTimeframeStr)
+                            closeSR.combinedTimeframeStr := formatTimeframeString(closeSR.info.timeframeStr) + " & " + formatTimeframeString(curSRObj.info.timeframeStr)
+                        else
+                            closeSR.combinedTimeframeStr += " & " + formatTimeframeString(curSRObj.info.timeframeStr)
+                    break
+            
+            if (curSRObj.info.strength >= srStrength) and (na(curSRObj.info.breakTime) or (curSRObj.info.breakTime - curSRObj.info.startTime) >= minSRSize * curTFMS) and (not tooClose)
+                renderSRObj(curSRObj)
+
+// Current Timeframe Retests
+if allSRList.size() > 0 and barstate.isconfirmed
+    for i = 0 to allSRList.size() - 1
+        srObj curSR = allSRList.get(i)
+        if na(curSR.info.breakTime) and time > curSR.info.startTime
+            if curSR.info.srType == "Resistance" and high >= curSR.info.price and close <= curSR.info.price
+                int lastRetestTime = 0
+                if curSR.info.retestTimes.size() > 0
+                    lastRetestTime := curSR.info.retestTimes.get(0)
+                
+                if lastRetestTime != time
+                    curSR.info.retestTimes.unshift(time)
+            
+            else if curSR.info.srType == "Support" and low <= curSR.info.price and close >= curSR.info.price
+                int lastRetestTime = 0
+                if curSR.info.retestTimes.size() > 0
+                    lastRetestTime := curSR.info.retestTimes.get(0)
+                
+                if lastRetestTime != time
+                    curSR.info.retestTimes.unshift(time)
+
+// Alertes
+alertcondition(alerts.get("Retest"), "New Retest", "")
+alertcondition(alerts.get("Break"), "New Break", "")
+
+if enableRetestAlerts and alerts.get("Retest")
+    alert("New Retests Occured.")
+
+if enableBreakAlerts and alerts.get("Break")
+    alert("New Breaks Occured.") 
\ No newline at end of file
diff --git a/README.md b/README.md
index 18dd406d3..b37da3882 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,52 @@
 # PowerTrader_AI
 Fully automated crypto trading powered by a custom price prediction AI and a structured/tiered DCA system.
+For Binance Spot setup and migration steps, see EXCHANGE_MIGRATION.md.
+You can place all config in `.env` and just run `python pt_hub.py`.
+Testnet still needs keys; use `BINANCE_PAPER=true` to simulate trades without keys.
+Use `BINANCE_PAPER_TEST=true` to force a full paper trade cycle (entry/hold/dca/exit).
+
+## Run
+- UI: `python pt_hub.py`
+- Tests: `pytest -q`
+
+## Exchange modes (Robinhood + Binance)
+
+PowerTrader can run with Robinhood (legacy) or Binance Spot. Use `.env` to select the provider and mode.
+
+### Minimal `.env` (paper test)
+```env
+EXCHANGE_PROVIDER=binance
+BINANCE_TESTNET=true
+BINANCE_PAPER=true
+BINANCE_PAPER_BALANCE=1000
+BINANCE_PAPER_TEST=true
+BINANCE_PAPER_TEST_COIN=BNB
+BINANCE_PAPER_TEST_ALLOC_USD=50
+BINANCE_PAPER_TEST_DCA_SECONDS=60
+BINANCE_PAPER_TEST_HOLD_SECONDS=120
+```
+
+### Production `.env` (live trading)
+```env
+EXCHANGE_PROVIDER=binance
+BINANCE_TESTNET=false
+BINANCE_PAPER=false
+BINANCE_API_KEY=your_real_key
+BINANCE_API_SECRET=your_real_secret
+```
+
+### Parameter reference
+- `EXCHANGE_PROVIDER`: `robinhood` or `binance`
+- `BINANCE_TESTNET`: use Binance testnet endpoints (still requires testnet keys)
+- `BINANCE_PAPER`: simulate trades with fake balance (no keys required)
+- `BINANCE_PAPER_BALANCE`: starting paper balance (default 1000)
+- `BINANCE_PAPER_TEST`: force a full paper trade cycle (entry/hold/dca/exit)
+- `BINANCE_PAPER_TEST_COIN`: coin used for paper test cycle (ex: `BNB`)
+- `BINANCE_PAPER_TEST_ALLOC_USD`: order size for paper test entries
+- `BINANCE_PAPER_TEST_DCA_SECONDS`: seconds before a test DCA buy
+- `BINANCE_PAPER_TEST_HOLD_SECONDS`: seconds before a test exit
+- `BINANCE_API_KEY`, `BINANCE_API_SECRET`: required for live/testnet real orders
+
 
 “It’s an instance-based (kNN/kernel-style) predictor with online per-instance reliability weighting, used as a multi-timeframe trading signal.” - ChatGPT on the type of AI used in this trading bot.
 
@@ -114,6 +161,7 @@ PowerTrader AI uses a simple folder style:
 ## Step 6 — Train (inside the Hub)
 
 Training builds the system’s coin “memory” so it can generate signals.
+Optional: set `TRAIN_FAST=true` or `TRAIN_LOOKBACK=20000` (The number will depend on the duration of the training; configure a slow to fast training, but comprehension will be worse (use TRAIN_LOOKBACK only in paper mode)) in `.env` to speed up training.
 
 1. In the Hub, click **Train All**.
 2. Wait until training finishes.
diff --git a/base.png b/base.png
new file mode 100644
index 000000000..f55c659c2
Binary files /dev/null and b/base.png differ
diff --git a/env_loader.py b/env_loader.py
new file mode 100644
index 000000000..e5af8a5ce
--- /dev/null
+++ b/env_loader.py
@@ -0,0 +1,53 @@
+import os
+from typing import Optional
+
+
+def load_env(path: Optional[str] = None, override: bool = False) -> Optional[str]:
+    """
+    Load environment variables from a .env file.
+    Returns the path that was loaded, or None if not found.
+    """
+    candidates = []
+    if path:
+        candidates.append(path)
+
+    env_path = os.environ.get("POWERTRADER_ENV")
+    if env_path:
+        candidates.append(env_path)
+
+    candidates.append(os.path.join(os.getcwd(), ".env"))
+    candidates.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".env"))
+
+    target = None
+    for cand in candidates:
+        if cand and os.path.isfile(cand):
+            target = cand
+            break
+
+    if not target:
+        return None
+
+    try:
+        with open(target, "r", encoding="utf-8") as f:
+            for line in f:
+                raw = line.strip()
+                if not raw or raw.startswith("#"):
+                    continue
+                if raw.startswith("export "):
+                    raw = raw[7:].strip()
+                if "=" not in raw:
+                    continue
+                key, value = raw.split("=", 1)
+                key = key.strip()
+                value = value.strip()
+                if not key:
+                    continue
+                if len(value) >= 2 and value[0] == value[-1] and value[0] in {"'", '"'}:
+                    value = value[1:-1]
+                if not override and key in os.environ:
+                    continue
+                os.environ[key] = value
+    except Exception:
+        return None
+
+    return target
diff --git a/exchanges/__init__.py b/exchanges/__init__.py
new file mode 100644
index 000000000..b7280c25c
--- /dev/null
+++ b/exchanges/__init__.py
@@ -0,0 +1,3 @@
+from .binance_client import BinanceExchangeClient, BinancePaperExchangeClient
+
+__all__ = ["BinanceExchangeClient", "BinancePaperExchangeClient"]
diff --git a/exchanges/__pycache__/__init__.cpython-313.pyc b/exchanges/__pycache__/__init__.cpython-313.pyc
new file mode 100644
index 000000000..cbabcdd96
Binary files /dev/null and b/exchanges/__pycache__/__init__.cpython-313.pyc differ
diff --git a/exchanges/__pycache__/binance_client.cpython-313.pyc b/exchanges/__pycache__/binance_client.cpython-313.pyc
new file mode 100644
index 000000000..6f3d1104c
Binary files /dev/null and b/exchanges/__pycache__/binance_client.cpython-313.pyc differ
diff --git a/exchanges/binance_client.py b/exchanges/binance_client.py
new file mode 100644
index 000000000..ca71863d3
--- /dev/null
+++ b/exchanges/binance_client.py
@@ -0,0 +1,729 @@
+import hashlib
+import hmac
+import logging
+import os
+import random
+import time
+from decimal import Decimal, ROUND_DOWN
+from typing import Any, Dict, List, Optional, Tuple
+from urllib.parse import urlencode
+
+import requests
+
+
+class BinanceAPIError(Exception):
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        code: Optional[int] = None,
+        endpoint: Optional[str] = None,
+        params: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.code = code
+        self.endpoint = endpoint
+        self.params = params or {}
+
+
+class BinanceRateLimitError(BinanceAPIError):
+    pass
+
+
+class BinanceTimestampError(BinanceAPIError):
+    pass
+
+
+class ExchangeClient:
+    def get_price(self, symbol: str) -> float:
+        raise NotImplementedError
+
+    def get_klines(self, symbol: str, interval: str, limit: int) -> List[Dict[str, Any]]:
+        raise NotImplementedError
+
+    def get_balances(self) -> Dict[str, Dict[str, float]]:
+        raise NotImplementedError
+
+    def create_order(
+        self,
+        symbol: str,
+        side: str,
+        type: str,
+        quantity: float,
+        price: Optional[float] = None,
+    ) -> Dict[str, Any]:
+        raise NotImplementedError
+
+    def cancel_order(self, symbol: str, order_id: str) -> Dict[str, Any]:
+        raise NotImplementedError
+
+    def get_open_orders(self, symbol: Optional[str] = None) -> List[Dict[str, Any]]:
+        raise NotImplementedError
+
+    def get_order(self, symbol: str, order_id: str) -> Dict[str, Any]:
+        raise NotImplementedError
+
+    def get_order_history(self, symbol: str, limit: int = 100) -> List[Dict[str, Any]]:
+        raise NotImplementedError
+
+
+class _RateLimiter:
+    def __init__(self, max_per_second: Optional[float]) -> None:
+        self._min_interval = 1.0 / float(max_per_second) if max_per_second else None
+        self._last_ts = 0.0
+
+    def wait(self) -> None:
+        if not self._min_interval:
+            return
+        now = time.time()
+        elapsed = now - self._last_ts
+        remaining = self._min_interval - elapsed
+        if remaining > 0:
+            time.sleep(remaining)
+        self._last_ts = time.time()
+
+
+def _env_flag(name: str, default: bool = False) -> bool:
+    raw = os.environ.get(name, None)
+    if raw is None:
+        return default
+    return str(raw).strip().lower() in {"1", "true", "yes", "y", "on"}
+
+
+def _format_decimal(value: Decimal) -> str:
+    s = format(value, "f")
+    if "." in s:
+        s = s.rstrip("0").rstrip(".")
+    return s
+
+
+class BinanceExchangeClient(ExchangeClient):
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        api_secret: Optional[str] = None,
+        base_url: Optional[str] = None,
+        testnet: Optional[bool] = None,
+        timeout: int = 10,
+        recv_window: int = 5000,
+        max_retries: int = 4,
+        logger: Optional[logging.Logger] = None,
+        default_quote: str = "USDT",
+        rate_limit_per_sec: Optional[float] = None,
+        time_sync_interval: int = 60,
+        public_only: bool = False,
+    ) -> None:
+        self.public_only = bool(public_only)
+        self.api_key = (api_key or os.environ.get("BINANCE_API_KEY", "")).strip()
+        self.api_secret = (api_secret or os.environ.get("BINANCE_API_SECRET", "")).strip()
+        if not self.public_only:
+            if not self.api_key or not self.api_secret:
+                raise ValueError(
+                    "Missing BINANCE_API_KEY and/or BINANCE_API_SECRET in environment or constructor."
+                )
+
+        if base_url:
+            self.base_url = base_url.rstrip("/")
+        else:
+            env_base_url = os.environ.get("BINANCE_API_BASE_URL", "").strip()
+            if env_base_url:
+                self.base_url = env_base_url.rstrip("/")
+            else:
+                use_testnet = bool(testnet) if testnet is not None else _env_flag("BINANCE_TESTNET", False)
+                self.base_url = "https://testnet.binance.vision" if use_testnet else "https://api.binance.com"
+
+        self.timeout = int(timeout)
+        self.recv_window = int(recv_window)
+        self.max_retries = int(max_retries)
+        quote_env = os.environ.get("BINANCE_QUOTE_ASSET", None)
+        self.default_quote = (quote_env or default_quote or "USDT").strip().upper()
+        self.time_sync_interval = int(time_sync_interval)
+
+        self.session = requests.Session()
+        self.logger = logger or logging.getLogger("powertrader.exchange.binance")
+        self._rate_limiter = _RateLimiter(rate_limit_per_sec)
+
+        self._time_offset_ms = 0
+        self._last_time_sync = 0.0
+
+        # cache: symbol -> (ts, filters)
+        self._exchange_info_cache: Dict[str, Tuple[float, Dict[str, Dict[str, str]]]] = {}
+
+    def _now_ms(self) -> int:
+        return int(time.time() * 1000)
+
+    def _timestamp_ms(self) -> int:
+        return int(self._now_ms() + self._time_offset_ms)
+
+    def _sync_time(self, force: bool = False) -> None:
+        now = time.time()
+        if not force and (now - self._last_time_sync) < self.time_sync_interval:
+            return
+        data = self._request("GET", "/api/v3/time", signed=False, skip_time_sync=True)
+        server_time = int(data.get("serverTime", 0))
+        if server_time > 0:
+            local_time = self._now_ms()
+            self._time_offset_ms = server_time - local_time
+            self._last_time_sync = now
+
+    def _normalize_symbol(self, symbol: str) -> str:
+        raw = (symbol or "").strip().upper()
+        if not raw:
+            raise ValueError("Symbol is required.")
+
+        if "-" in raw:
+            base, quote = raw.split("-", 1)
+        elif "_" in raw:
+            base, quote = raw.split("_", 1)
+        elif "/" in raw:
+            base, quote = raw.split("/", 1)
+        else:
+            base, quote = raw, ""
+            known_quotes = [self.default_quote, "USDT", "USDC", "BUSD", "BTC", "ETH", "BNB", "USD"]
+            for q in known_quotes:
+                if raw.endswith(q) and len(raw) > len(q):
+                    base = raw[: -len(q)]
+                    quote = q
+                    break
+
+        base = (base or "").strip().upper()
+        quote = (quote or "").strip().upper()
+        if not base:
+            raise ValueError(f"Invalid symbol format: {symbol}")
+        if not quote:
+            quote = self.default_quote
+        if quote == "USD":
+            quote = "USDT"
+        return f"{base}{quote}"
+
+    def _sign_params(self, params: Dict[str, Any]) -> str:
+        query = urlencode(sorted(params.items()), doseq=True)
+        return hmac.new(
+            self.api_secret.encode("utf-8"),
+            query.encode("utf-8"),
+            hashlib.sha256,
+        ).hexdigest()
+
+    def _redacted_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        redacted = dict(params)
+        if "signature" in redacted:
+            redacted["signature"] = "***"
+        return redacted
+
+    def _parse_error(self, resp: requests.Response) -> Tuple[Optional[int], str, Dict[str, Any]]:
+        try:
+            data = resp.json() or {}
+        except Exception:
+            data = {}
+        code = data.get("code")
+        msg = data.get("msg") or resp.text or "Binance API error"
+        return code, msg, data
+
+    def _sleep_backoff(self, attempt: int, base: float = 0.5, factor: float = 2.0, cap: float = 10.0) -> None:
+        delay = min(cap, base * (factor ** attempt))
+        jitter = random.uniform(0.0, delay * 0.1)
+        time.sleep(delay + jitter)
+
+    def _sleep_rate_limit(self, resp: requests.Response, attempt: int) -> None:
+        retry_after = resp.headers.get("Retry-After", None)
+        if retry_after:
+            try:
+                time.sleep(float(retry_after))
+                return
+            except Exception:
+                pass
+        self._sleep_backoff(attempt)
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        params: Optional[Dict[str, Any]] = None,
+        signed: bool = False,
+        skip_time_sync: bool = False,
+    ) -> Any:
+        method = method.upper().strip()
+        url = f"{self.base_url}{path}"
+        params = params or {}
+
+        if signed and self.public_only:
+            raise BinanceAPIError(
+                "Signed endpoints require BINANCE_API_KEY/BINANCE_API_SECRET.",
+                endpoint=path,
+                params=self._redacted_params(params),
+            )
+
+        resynced = False
+        for attempt in range(self.max_retries + 1):
+            if signed and not skip_time_sync:
+                self._sync_time()
+
+            req_params = dict(params)
+            headers: Dict[str, str] = {}
+            if signed:
+                req_params["timestamp"] = self._timestamp_ms()
+                req_params["recvWindow"] = self.recv_window
+                req_params["signature"] = self._sign_params(req_params)
+                headers["X-MBX-APIKEY"] = self.api_key
+
+            try:
+                self._rate_limiter.wait()
+                resp = self.session.request(
+                    method=method,
+                    url=url,
+                    params=req_params,
+                    headers=headers,
+                    timeout=self.timeout,
+                )
+            except requests.RequestException as exc:
+                if attempt < self.max_retries:
+                    self._sleep_backoff(attempt)
+                    continue
+                self.logger.warning(
+                    "Binance request error: %s %s error=%s params=%s",
+                    method,
+                    path,
+                    exc,
+                    self._redacted_params(req_params),
+                )
+                raise BinanceAPIError(str(exc), endpoint=path, params=self._redacted_params(req_params))
+
+            if resp.status_code in (418, 429):
+                if attempt < self.max_retries:
+                    self._sleep_rate_limit(resp, attempt)
+                    continue
+                self.logger.warning(
+                    "Binance rate limit: %s %s status=%s params=%s",
+                    method,
+                    path,
+                    resp.status_code,
+                    self._redacted_params(req_params),
+                )
+                raise BinanceRateLimitError(
+                    f"Rate limited ({resp.status_code}).",
+                    status_code=resp.status_code,
+                    endpoint=path,
+                    params=self._redacted_params(req_params),
+                )
+
+            if resp.status_code >= 400:
+                code, msg, data = self._parse_error(resp)
+                if code in (-1021, -1022):
+                    if not resynced:
+                        self._sync_time(force=True)
+                        resynced = True
+                        continue
+                    self.logger.warning(
+                        "Binance timestamp/signature error: %s %s status=%s code=%s msg=%s params=%s",
+                        method,
+                        path,
+                        resp.status_code,
+                        code,
+                        msg,
+                        self._redacted_params(req_params),
+                    )
+                    raise BinanceTimestampError(
+                        msg,
+                        status_code=resp.status_code,
+                        code=code,
+                        endpoint=path,
+                        params=self._redacted_params(req_params),
+                    )
+                self.logger.warning(
+                    "Binance API error: %s %s status=%s code=%s msg=%s params=%s",
+                    method,
+                    path,
+                    resp.status_code,
+                    code,
+                    msg,
+                    self._redacted_params(req_params),
+                )
+                raise BinanceAPIError(
+                    msg,
+                    status_code=resp.status_code,
+                    code=code,
+                    endpoint=path,
+                    params=self._redacted_params(req_params),
+                )
+
+            try:
+                return resp.json()
+            except Exception:
+                return resp.text
+
+        raise BinanceAPIError("Unexpected request failure.", endpoint=path, params=self._redacted_params(params))
+
+    def get_price(self, symbol: str) -> float:
+        symbol_norm = self._normalize_symbol(symbol)
+        data = self._request("GET", "/api/v3/ticker/price", params={"symbol": symbol_norm}, signed=False)
+        return float(data.get("price", 0.0))
+
+    def get_klines(self, symbol: str, interval: str, limit: int) -> List[Dict[str, Any]]:
+        symbol_norm = self._normalize_symbol(symbol)
+        data = self._request(
+            "GET",
+            "/api/v3/klines",
+            params={"symbol": symbol_norm, "interval": interval, "limit": int(limit)},
+            signed=False,
+        )
+        candles: List[Dict[str, Any]] = []
+        for row in data or []:
+            try:
+                ts_ms = int(row[0])
+                o = float(row[1])
+                h = float(row[2])
+                l = float(row[3])
+                c = float(row[4])
+                v = float(row[5]) if len(row) > 5 else 0.0
+                candles.append(
+                    {
+                        "ts": int(ts_ms / 1000),
+                        "open": o,
+                        "high": h,
+                        "low": l,
+                        "close": c,
+                        "volume": v,
+                    }
+                )
+            except Exception:
+                continue
+        return candles
+
+    def get_balances(self) -> Dict[str, Dict[str, float]]:
+        data = self._request("GET", "/api/v3/account", signed=True)
+        balances: Dict[str, Dict[str, float]] = {}
+        for bal in data.get("balances", []):
+            asset = str(bal.get("asset", "")).strip().upper()
+            if not asset:
+                continue
+            try:
+                free = float(bal.get("free", 0.0))
+                locked = float(bal.get("locked", 0.0))
+            except Exception:
+                free = 0.0
+                locked = 0.0
+            balances[asset] = {"free": free, "locked": locked, "total": free + locked}
+        return balances
+
+    def get_exchange_info(self, symbol: str) -> Dict[str, Dict[str, str]]:
+        symbol_norm = self._normalize_symbol(symbol)
+        cached = self._exchange_info_cache.get(symbol_norm)
+        now = time.time()
+        if cached and (now - cached[0]) < 900:
+            return dict(cached[1])
+
+        data = self._request(
+            "GET",
+            "/api/v3/exchangeInfo",
+            params={"symbol": symbol_norm},
+            signed=False,
+        )
+        symbols = data.get("symbols") or []
+        if not symbols:
+            raise BinanceAPIError(f"No exchangeInfo for symbol {symbol_norm}.", endpoint="/api/v3/exchangeInfo")
+        filters = symbols[0].get("filters") or []
+
+        out: Dict[str, Dict[str, str]] = {}
+        for f in filters:
+            ftype = f.get("filterType")
+            if ftype:
+                out[str(ftype)] = {k: str(v) for k, v in f.items()}
+
+        self._exchange_info_cache[symbol_norm] = (now, out)
+        return dict(out)
+
+    def adjust_order_params(
+        self,
+        symbol: str,
+        quantity: float,
+        price: Optional[float] = None,
+    ) -> Tuple[float, Optional[float], bool]:
+        symbol_norm = self._normalize_symbol(symbol)
+        filters = self.get_exchange_info(symbol_norm)
+        changed = False
+
+        qty = Decimal(str(quantity))
+        px = Decimal(str(price)) if price is not None else None
+
+        lot = filters.get("LOT_SIZE", {})
+        step_size = Decimal(lot.get("stepSize", "0")) if lot else Decimal("0")
+        min_qty = Decimal(lot.get("minQty", "0")) if lot else Decimal("0")
+
+        if step_size and step_size > 0:
+            new_qty = (qty / step_size).to_integral_value(rounding=ROUND_DOWN) * step_size
+            if new_qty != qty:
+                qty = new_qty
+                changed = True
+
+        if min_qty and qty < min_qty:
+            raise ValueError(f"Quantity {qty} is below minQty {min_qty} for {symbol_norm}.")
+
+        price_filter = filters.get("PRICE_FILTER", {})
+        tick_size = Decimal(price_filter.get("tickSize", "0")) if price_filter else Decimal("0")
+        min_price = Decimal(price_filter.get("minPrice", "0")) if price_filter else Decimal("0")
+
+        if px is not None and tick_size and tick_size > 0:
+            new_px = (px / tick_size).to_integral_value(rounding=ROUND_DOWN) * tick_size
+            if new_px != px:
+                px = new_px
+                changed = True
+            if min_price and px < min_price:
+                raise ValueError(f"Price {px} is below minPrice {min_price} for {symbol_norm}.")
+
+        min_notional = filters.get("MIN_NOTIONAL", {}).get("minNotional", None)
+        if min_notional:
+            notional_threshold = Decimal(str(min_notional))
+            if px is None:
+                px = Decimal(str(self.get_price(symbol_norm)))
+            notional = qty * px
+            if notional < notional_threshold:
+                raise ValueError(
+                    f"Order notional {notional} below minNotional {notional_threshold} for {symbol_norm}."
+                )
+
+        return float(qty), float(px) if px is not None else None, changed
+
+    def create_order(
+        self,
+        symbol: str,
+        side: str,
+        type: str,
+        quantity: float,
+        price: Optional[float] = None,
+    ) -> Dict[str, Any]:
+        symbol_norm = self._normalize_symbol(symbol)
+        side = side.upper().strip()
+        order_type = type.upper().strip()
+
+        adj_qty, adj_price, _ = self.adjust_order_params(symbol_norm, quantity, price)
+        params: Dict[str, Any] = {
+            "symbol": symbol_norm,
+            "side": side,
+            "type": order_type,
+            "quantity": _format_decimal(Decimal(str(adj_qty))),
+        }
+
+        if order_type == "LIMIT":
+            if adj_price is None:
+                raise ValueError("LIMIT orders require price.")
+            params["price"] = _format_decimal(Decimal(str(adj_price)))
+            params["timeInForce"] = "GTC"
+
+        return self._request("POST", "/api/v3/order", params=params, signed=True)
+
+    def cancel_order(self, symbol: str, order_id: str) -> Dict[str, Any]:
+        symbol_norm = self._normalize_symbol(symbol)
+        return self._request(
+            "DELETE",
+            "/api/v3/order",
+            params={"symbol": symbol_norm, "orderId": order_id},
+            signed=True,
+        )
+
+    def get_open_orders(self, symbol: Optional[str] = None) -> List[Dict[str, Any]]:
+        params: Dict[str, Any] = {}
+        if symbol:
+            params["symbol"] = self._normalize_symbol(symbol)
+        return self._request("GET", "/api/v3/openOrders", params=params, signed=True)
+
+    def get_order(self, symbol: str, order_id: str) -> Dict[str, Any]:
+        symbol_norm = self._normalize_symbol(symbol)
+        return self._request(
+            "GET",
+            "/api/v3/order",
+            params={"symbol": symbol_norm, "orderId": order_id},
+            signed=True,
+        )
+
+    def get_order_history(self, symbol: str, limit: int = 100) -> List[Dict[str, Any]]:
+        symbol_norm = self._normalize_symbol(symbol)
+        return self._request(
+            "GET",
+            "/api/v3/allOrders",
+            params={"symbol": symbol_norm, "limit": int(limit)},
+            signed=True,
+        )
+
+
+class BinancePaperExchangeClient(ExchangeClient):
+    def __init__(
+        self,
+        base_url: Optional[str] = None,
+        testnet: Optional[bool] = None,
+        timeout: int = 10,
+        recv_window: int = 5000,
+        max_retries: int = 4,
+        logger: Optional[logging.Logger] = None,
+        default_quote: str = "USDT",
+        rate_limit_per_sec: Optional[float] = None,
+        time_sync_interval: int = 60,
+        starting_balance: Optional[float] = None,
+    ) -> None:
+        self.logger = logger or logging.getLogger("powertrader.exchange.binance.paper")
+        self._public = BinanceExchangeClient(
+            api_key="",
+            api_secret="",
+            base_url=base_url,
+            testnet=testnet,
+            timeout=timeout,
+            recv_window=recv_window,
+            max_retries=max_retries,
+            logger=logger,
+            default_quote=default_quote,
+            rate_limit_per_sec=rate_limit_per_sec,
+            time_sync_interval=time_sync_interval,
+            public_only=True,
+        )
+        self.default_quote = self._public.default_quote
+
+        env_balance = os.environ.get("BINANCE_PAPER_BALANCE", None)
+        if starting_balance is None:
+            starting_balance = float(env_balance) if env_balance else 1000.0
+
+        self._balances: Dict[str, Dict[str, Decimal]] = {
+            self.default_quote: {"free": Decimal(str(starting_balance)), "locked": Decimal("0")}
+        }
+        self._orders: List[Dict[str, Any]] = []
+        self._next_order_id = 1
+        fee_rate_env = os.environ.get("BINANCE_PAPER_FEE_RATE", "").strip()
+        self.taker_fee_rate = float(os.environ.get("BINANCE_TAKER_FEE_RATE", fee_rate_env or "0.001"))
+        self.maker_fee_rate = float(os.environ.get("BINANCE_MAKER_FEE_RATE", fee_rate_env or "0.001"))
+        self.slippage_pct = float(os.environ.get("BINANCE_PAPER_SLIPPAGE_PCT", "0.0") or 0.0)
+        self.partial_fill_enabled = _env_flag("BINANCE_PAPER_PARTIAL_FILL", False)
+        self.partial_fill_min = float(os.environ.get("BINANCE_PAPER_PARTIAL_FILL_MIN", "0.6") or 0.6)
+        self.partial_fill_max = float(os.environ.get("BINANCE_PAPER_PARTIAL_FILL_MAX", "1.0") or 1.0)
+
+    def _split_symbol(self, symbol_norm: str) -> Tuple[str, str]:
+        known_quotes = [self.default_quote, "USDT", "USDC", "BUSD", "BTC", "ETH", "BNB", "USD"]
+        for quote in known_quotes:
+            if symbol_norm.endswith(quote) and len(symbol_norm) > len(quote):
+                return symbol_norm[: -len(quote)], quote
+        return symbol_norm[: -len(self.default_quote)], self.default_quote
+
+    def _get_balance(self, asset: str) -> Dict[str, Decimal]:
+        asset = asset.strip().upper()
+        if asset not in self._balances:
+            self._balances[asset] = {"free": Decimal("0"), "locked": Decimal("0")}
+        return self._balances[asset]
+
+    def _record_order(self, order: Dict[str, Any]) -> None:
+        self._orders.append(order)
+
+    def _new_order_id(self) -> int:
+        oid = self._next_order_id
+        self._next_order_id += 1
+        return oid
+
+    def get_price(self, symbol: str) -> float:
+        return self._public.get_price(symbol)
+
+    def get_klines(self, symbol: str, interval: str, limit: int) -> List[Dict[str, Any]]:
+        return self._public.get_klines(symbol, interval, limit)
+
+    def get_balances(self) -> Dict[str, Dict[str, float]]:
+        out: Dict[str, Dict[str, float]] = {}
+        for asset, bal in self._balances.items():
+            free = float(bal.get("free", Decimal("0")))
+            locked = float(bal.get("locked", Decimal("0")))
+            out[asset] = {"free": free, "locked": locked, "total": free + locked}
+        return out
+
+    def create_order(
+        self,
+        symbol: str,
+        side: str,
+        type: str,
+        quantity: float,
+        price: Optional[float] = None,
+    ) -> Dict[str, Any]:
+        symbol_norm = self._public._normalize_symbol(symbol)
+        side = side.upper().strip()
+        order_type = type.upper().strip()
+
+        adj_qty, adj_price, _ = self._public.adjust_order_params(symbol_norm, quantity, price)
+        qty = Decimal(str(adj_qty))
+
+        fill_price = Decimal(str(adj_price)) if adj_price is not None else Decimal(str(self.get_price(symbol_norm)))
+        if self.slippage_pct > 0:
+            slip = Decimal(str(random.uniform(0.0, float(self.slippage_pct))))
+            if side == "BUY":
+                fill_price *= (Decimal("1") + slip)
+            else:
+                fill_price *= (Decimal("1") - slip)
+
+        filled_qty = qty
+        if self.partial_fill_enabled:
+            pf_min = max(0.01, min(self.partial_fill_min, self.partial_fill_max))
+            pf_max = max(pf_min, self.partial_fill_max)
+            filled_qty = qty * Decimal(str(random.uniform(pf_min, pf_max)))
+            filled_qty = max(Decimal("0"), min(qty, filled_qty))
+
+        notional = filled_qty * fill_price
+
+        base, quote = self._split_symbol(symbol_norm)
+        fee_rate = Decimal(str(self.taker_fee_rate if order_type == "MARKET" else self.maker_fee_rate))
+        fee = Decimal("0")
+        fee_asset = ""
+        executed_qty = filled_qty
+
+        if side == "BUY":
+            quote_bal = self._get_balance(quote)
+            if quote_bal["free"] < notional:
+                raise ValueError(f"Insufficient {quote} balance for paper buy.")
+            quote_bal["free"] -= notional
+            base_bal = self._get_balance(base)
+            fee = (filled_qty * fee_rate)
+            executed_qty = filled_qty - fee
+            if executed_qty < 0:
+                executed_qty = Decimal("0")
+            base_bal["free"] += executed_qty
+            fee_asset = base
+        elif side == "SELL":
+            base_bal = self._get_balance(base)
+            if base_bal["free"] < filled_qty:
+                raise ValueError(f"Insufficient {base} balance for paper sell.")
+            base_bal["free"] -= filled_qty
+            quote_bal = self._get_balance(quote)
+            fee = (notional * fee_rate)
+            quote_bal["free"] += (notional - fee)
+            fee_asset = quote
+        else:
+            raise ValueError("Order side must be BUY or SELL.")
+
+        order_id = self._new_order_id()
+        order = {
+            "orderId": order_id,
+            "symbol": symbol_norm,
+            "side": side,
+            "type": order_type,
+            "status": "FILLED" if filled_qty == qty else "PARTIALLY_FILLED",
+            "price": _format_decimal(fill_price),
+            "origQty": _format_decimal(qty),
+            "executedQty": _format_decimal(executed_qty),
+            "cummulativeQuoteQty": _format_decimal(notional),
+            "fee": _format_decimal(fee),
+            "feeAsset": fee_asset,
+            "time": int(time.time() * 1000),
+        }
+        self._record_order(order)
+        return order
+
+    def cancel_order(self, symbol: str, order_id: str) -> Dict[str, Any]:
+        symbol_norm = self._public._normalize_symbol(symbol)
+        return {"orderId": order_id, "symbol": symbol_norm, "status": "CANCELED"}
+
+    def get_open_orders(self, symbol: Optional[str] = None) -> List[Dict[str, Any]]:
+        return []
+
+    def get_order(self, symbol: str, order_id: str) -> Dict[str, Any]:
+        for order in self._orders:
+            if str(order.get("orderId")) == str(order_id):
+                return dict(order)
+        symbol_norm = self._public._normalize_symbol(symbol)
+        return {"orderId": order_id, "symbol": symbol_norm, "status": "UNKNOWN"}
+
+    def get_order_history(self, symbol: str, limit: int = 100) -> List[Dict[str, Any]]:
+        symbol_norm = self._public._normalize_symbol(symbol)
+        out = [o for o in self._orders if o.get("symbol") == symbol_norm]
+        return out[-int(limit) :] if limit else out
diff --git a/explication.md b/explication.md
new file mode 100644
index 000000000..fd3671f4b
--- /dev/null
+++ b/explication.md
@@ -0,0 +1,183 @@
+# Explication du projet PowerTrader_AI
+
+## Vue d'ensemble
+PowerTrader_AI est un bot de trading crypto avec:
+- un Runner (pt_thinker.py) qui produit les signaux et les niveaux
+- un Trader (pt_trader.py) qui execute les ordres + DCA + trailing
+- un Trainer (pt_trainer.py) qui genere les fichiers de memoire
+- une UI (pt_hub.py) pour tout piloter
+
+Le flux standard est:
+Train -> Runner -> Trader.
+
+## Composants
+- pt_hub.py: interface principale (Start All, Train, charts, logs)
+- pt_trainer.py: entraine les modeles par coin/timeframe (memories_*.txt)
+- pt_thinker.py: calcule les niveaux (low/high bounds) + signaux long/short
+- pt_trader.py: gere les ordres, DCA, trailing, ledger
+- exchanges/binance_client.py: client Binance (live/testnet/paper)
+- indicators.py: indicateurs (RSI, MACD, etc) utilises par la strategie
+
+## Modes d'execution
+- Binance live: ordres reels (BINANCE_API_KEY/SECRET)
+- Binance testnet: ordres sur testnet (BINANCE_TESTNET=true)
+- Binance paper: simulation locale (BINANCE_PAPER=true)
+
+Paper mode:
+- utilise les prix Binance publics
+- frais simules (voir ci-dessous)
+- les soldes sont locaux (BINANCE_PAPER_BALANCE)
+
+Paper test (force des cycles buy/dca/sell):
+- BINANCE_PAPER_TEST=true
+- BINANCE_PAPER_TEST_COIN=BNB
+- BINANCE_PAPER_TEST_ALLOC_USD=50
+- BINANCE_PAPER_TEST_DCA_SECONDS=60
+- BINANCE_PAPER_TEST_HOLD_SECONDS=120
+
+## Training
+Le Trainer cree les fichiers:
+- memories_*.txt
+- memory_weights_*.txt
+- memory_weights_high_*.txt
+- memory_weights_low_*.txt
+- neural_perfect_threshold_*.txt
+
+Si un timeframe affiche INACTIVE (training data issue), il faut re-trainer le coin.
+
+## Runner (pt_thinker.py)
+Le Runner lit les fichiers de training et genere:
+- low_bound_prices.html (niveaux long)
+- high_bound_prices.html (niveaux short)
+- long_dca_signal.txt / short_dca_signal.txt (compteurs 0..7)
+
+Le runner ecrit aussi runner_ready.json pour que Start All sache quand demarrer le Trader.
+
+## Trader (pt_trader.py)
+Le Trader:
+- lit les signaux long/short
+- decide l'entree (neural ou strategie)
+- gere DCA
+- gere trailing profit margin pour la sortie
+
+### Entree (buy)
+Par defaut:
+- entree seulement si long >= 3 et short == 0
+
+Si Strategy est activee:
+- selector: tous les indicateurs coches doivent etre OK
+- super: score moyen >= 0.6
+- replace_neural=true: ignore le signal neural et ne garde que les indicateurs
+
+Important: la strategie n'affecte PAS le DCA ni le trailing. Elle ne change que l'entree.
+
+### DCA
+Niveaux de pertes (en % vs cost basis):
+- -2.5, -5, -10, -20, -30, -40, -50
+
+Regles:
+- DCA limite a 2 achats par 24h et par coin
+- DCA peut etre declenche par le niveau neural (N4..N7)
+- apres un DCA, la ligne de trailing est recalcul?e
+
+### Sortie (sell)
+Il n'y a pas de stop loss dur.
+La sortie se fait via le trailing profit margin:
+- demarre a +5% sans DCA
+- demarre a +2.5% avec DCA
+- trailing_gap_pct = 0.5%
+
+Quand le prix repasse sous la ligne, le sell est execute.
+
+## Strategie (indicateurs)
+Indicateurs supportes:
+- RSI, MACD, Stochastique, Momentum, OBV
+- Bollinger Bands, EMA, ATR, Volume Profile
+- ADX, Pivots, Ichimoku Cloud
+
+Rules par defaut (resume):
+- RSI: buy si RSI < 30
+- MACD: cross haussier
+- Stochastique: %K < 20 + cross
+- Momentum: > 0
+- OBV: pente positive
+- Bollinger: prix <= lower band
+- EMA: prix > EMA21 ou cross EMA8 > EMA21
+- ATR: filtre non bloquant (score 0.5)
+- Volume Profile: volume local > moyenne
+- ADX: > 20
+- Pivots: rebond proche S1
+- Ichimoku: prix au-dessus du cloud + tenkan > kijun
+
+## PnL et account value
+- Les valeurs sont en USD/USDT.
+- Les colonnes DCA PnL % et Sell PnL % sont des pourcentages.
+- Total Account Value = cash + valeur des positions (mark-to-market).
+- Les gains reels apparaissent dans Total realized apres un SELL.
+
+Si le trade est petit (ex: 74 USD), une variation de 0.05% donne quelques centimes.
+Ce n'est pas un probleme de fees, c'est juste la taille de la position.
+
+## Fees (paper mode)
+Le paper mode applique des frais sur chaque trade:
+- BUY: fee prise sur l'asset recu (base)
+- SELL: fee prise sur la devise de cotation (quote)
+
+Par defaut:
+- taker_fee = 0.001 (0.1%)
+- maker_fee = 0.001 (0.1%)
+
+Tu peux forcer un taux moyen dans .env:
+- BINANCE_PAPER_FEE_RATE=0.001
+- BINANCE_TAKER_FEE_RATE=0.001
+- BINANCE_MAKER_FEE_RATE=0.001
+
+Note: c'est une approximation realiste, mais pas identique au matching engine live
+(slippage/partial fills optionnels).
+
+Slippage / partial fills (paper mode):
+- BINANCE_PAPER_SLIPPAGE_PCT=0.001 -> +/-0.1% de slippage max
+- BINANCE_PAPER_PARTIAL_FILL=true -> remplissages partiels
+- BINANCE_PAPER_PARTIAL_FILL_MIN=0.6
+- BINANCE_PAPER_PARTIAL_FILL_MAX=1.0
+
+## Testnet vs Paper
+- Testnet: simule l'exchange Binance (matching engine + ordres), mais avec des fonds factices.
+- Paper: simulation locale, plus rapide, mais moins realiste (pas d'order book).
+
+Si tu veux la simulation la plus proche du reel: utilise le testnet.
+
+## Pine signals (TradingView)
+Le bot ne peut pas executer un script Pine directement. Il peut lire des signaux
+exportes dans un fichier JSONL (une ligne JSON par signal).
+
+Exemple de ligne JSONL:
+{"symbol":"BNB","action":"buy","ts":1700000000,"strength":"strong"}
+
+Variables .env:
+- PINE_SIGNAL_ENABLED=true
+- PINE_SIGNAL_MODE=filter (filter|replace|off)
+- PINE_SIGNAL_USE_EXIT=false
+- PINE_SIGNAL_FILE=hub_data/pine_signals.jsonl
+- PINE_SIGNAL_MAX_AGE_SECONDS=300
+
+Mode:
+- filter: un signal Pine non-buy bloque l'entree; buy autorise avec neural/strategie.
+- replace: l'entree depend uniquement de Pine (buy requis).
+- exit: si PINE_SIGNAL_USE_EXIT=true, un signal sell/stop force la sortie.
+
+## Pourquoi pas de difference avec/sans strategie?
+- La strategie ne change que l'entree.
+- Si tu es deja en position, le DCA/trailing continue pareil.
+- Avec tous les indicateurs, le score peut rester sous le seuil -> moins d'entrees.
+- Pas besoin de retrain pour activer la strategie: les indicateurs utilisent les candles en live.
+
+## Conseils PnL
+- Commence par 1 coin + 1 timeframe pour valider la logique.
+- Ajuste la taille d'allocation si tu veux des variations plus visibles.
+- Observe la difference entre selector et super, et teste des sous-ensembles d'indicateurs.
+
+## Commandes utiles
+- UI: python pt_hub.py
+- Tests: python -m pytest -q
+
diff --git a/indicators.py b/indicators.py
new file mode 100644
index 000000000..30e8fd454
--- /dev/null
+++ b/indicators.py
@@ -0,0 +1,193 @@
+import math
+from typing import Dict, List, Optional, Tuple
+
+
+def sma(values: List[float], period: int) -> Optional[float]:
+    if period <= 0 or len(values) < period:
+        return None
+    return sum(values[-period:]) / float(period)
+
+
+def ema(values: List[float], period: int) -> Optional[float]:
+    if period <= 0 or len(values) < period:
+        return None
+    k = 2.0 / (period + 1.0)
+    ema_val = sum(values[:period]) / float(period)
+    for v in values[period:]:
+        ema_val = (v * k) + (ema_val * (1.0 - k))
+    return ema_val
+
+
+def rsi(closes: List[float], period: int = 14) -> Optional[float]:
+    if period <= 0 or len(closes) < (period + 1):
+        return None
+    gains = []
+    losses = []
+    for i in range(-period, 0):
+        diff = closes[i] - closes[i - 1]
+        if diff >= 0:
+            gains.append(diff)
+            losses.append(0.0)
+        else:
+            gains.append(0.0)
+            losses.append(abs(diff))
+    avg_gain = sum(gains) / float(period)
+    avg_loss = sum(losses) / float(period)
+    if avg_loss == 0:
+        return 100.0
+    rs = avg_gain / avg_loss
+    return 100.0 - (100.0 / (1.0 + rs))
+
+
+def macd(closes: List[float], fast: int = 12, slow: int = 26, signal: int = 9) -> Tuple[Optional[float], Optional[float], Optional[float]]:
+    if len(closes) < slow:
+        return None, None, None
+    ema_fast = _ema_series(closes, fast)
+    ema_slow = _ema_series(closes, slow)
+    if not ema_fast or not ema_slow:
+        return None, None, None
+    macd_series = [f - s for f, s in zip(ema_fast[-len(ema_slow):], ema_slow)]
+    signal_series = _ema_series(macd_series, signal)
+    if not signal_series:
+        return None, None, None
+    macd_line = macd_series[-1]
+    signal_line = signal_series[-1]
+    hist = macd_line - signal_line
+    return macd_line, signal_line, hist
+
+
+def stochastic(highs: List[float], lows: List[float], closes: List[float], k_period: int = 14, d_period: int = 3) -> Tuple[Optional[float], Optional[float]]:
+    if len(closes) < k_period or len(highs) < k_period or len(lows) < k_period:
+        return None, None
+    recent_high = max(highs[-k_period:])
+    recent_low = min(lows[-k_period:])
+    if recent_high == recent_low:
+        return 50.0, 50.0
+    k = ((closes[-1] - recent_low) / (recent_high - recent_low)) * 100.0
+    k_series = []
+    for i in range(-k_period, 0):
+        h = max(highs[:i + len(highs) + 1][-k_period:])
+        l = min(lows[:i + len(lows) + 1][-k_period:])
+        if h == l:
+            k_series.append(50.0)
+        else:
+            k_series.append(((closes[i] - l) / (h - l)) * 100.0)
+    d = sma(k_series, d_period) if k_series else None
+    return k, d
+
+
+def momentum(closes: List[float], period: int = 10) -> Optional[float]:
+    if len(closes) < (period + 1):
+        return None
+    return closes[-1] - closes[-1 - period]
+
+
+def obv(closes: List[float], volumes: List[float]) -> Optional[float]:
+    if len(closes) < 2 or len(volumes) < 2:
+        return None
+    obv_val = 0.0
+    for i in range(1, min(len(closes), len(volumes))):
+        if closes[i] > closes[i - 1]:
+            obv_val += volumes[i]
+        elif closes[i] < closes[i - 1]:
+            obv_val -= volumes[i]
+    return obv_val
+
+
+def bollinger_bands(closes: List[float], period: int = 20, std_mult: float = 2.0) -> Tuple[Optional[float], Optional[float], Optional[float]]:
+    if len(closes) < period:
+        return None, None, None
+    window = closes[-period:]
+    mean = sum(window) / float(period)
+    variance = sum((x - mean) ** 2 for x in window) / float(period)
+    std = math.sqrt(variance)
+    upper = mean + std_mult * std
+    lower = mean - std_mult * std
+    return upper, mean, lower
+
+
+def atr(highs: List[float], lows: List[float], closes: List[float], period: int = 14) -> Optional[float]:
+    if len(closes) < (period + 1) or len(highs) < (period + 1) or len(lows) < (period + 1):
+        return None
+    trs = []
+    for i in range(-period, 0):
+        high = highs[i]
+        low = lows[i]
+        prev_close = closes[i - 1]
+        tr = max(high - low, abs(high - prev_close), abs(low - prev_close))
+        trs.append(tr)
+    return sum(trs) / float(period)
+
+
+def volume_profile(volumes: List[float], period: int = 20) -> Optional[float]:
+    if len(volumes) < period:
+        return None
+    avg_vol = sum(volumes[-period:]) / float(period)
+    if avg_vol == 0:
+        return 0.0
+    return volumes[-1] / avg_vol
+
+
+def adx(highs: List[float], lows: List[float], closes: List[float], period: int = 14) -> Optional[float]:
+    if len(closes) < (period + 1):
+        return None
+    plus_dm = []
+    minus_dm = []
+    tr_list = []
+    for i in range(-period, 0):
+        up_move = highs[i] - highs[i - 1]
+        down_move = lows[i - 1] - lows[i]
+        plus_dm.append(up_move if up_move > down_move and up_move > 0 else 0.0)
+        minus_dm.append(down_move if down_move > up_move and down_move > 0 else 0.0)
+        tr = max(
+            highs[i] - lows[i],
+            abs(highs[i] - closes[i - 1]),
+            abs(lows[i] - closes[i - 1]),
+        )
+        tr_list.append(tr)
+    tr_sum = sum(tr_list)
+    if tr_sum == 0:
+        return 0.0
+    plus_di = 100.0 * (sum(plus_dm) / tr_sum)
+    minus_di = 100.0 * (sum(minus_dm) / tr_sum)
+    denom = plus_di + minus_di
+    if denom == 0:
+        return 0.0
+    dx = (abs(plus_di - minus_di) / denom) * 100.0
+    return dx
+
+
+def pivots(highs: List[float], lows: List[float], closes: List[float]) -> Optional[Dict[str, float]]:
+    if not highs or not lows or not closes:
+        return None
+    h = highs[-1]
+    l = lows[-1]
+    c = closes[-1]
+    p = (h + l + c) / 3.0
+    r1 = 2 * p - l
+    s1 = 2 * p - h
+    r2 = p + (h - l)
+    s2 = p - (h - l)
+    return {"pivot": p, "r1": r1, "s1": s1, "r2": r2, "s2": s2}
+
+
+def ichimoku(highs: List[float], lows: List[float]) -> Optional[Dict[str, float]]:
+    if len(highs) < 52 or len(lows) < 52:
+        return None
+    tenkan = (max(highs[-9:]) + min(lows[-9:])) / 2.0
+    kijun = (max(highs[-26:]) + min(lows[-26:])) / 2.0
+    senkou_a = (tenkan + kijun) / 2.0
+    senkou_b = (max(highs[-52:]) + min(lows[-52:])) / 2.0
+    return {"tenkan": tenkan, "kijun": kijun, "senkou_a": senkou_a, "senkou_b": senkou_b}
+
+
+def _ema_series(values: List[float], period: int) -> List[float]:
+    if period <= 0 or len(values) < period:
+        return []
+    k = 2.0 / (period + 1.0)
+    ema_val = sum(values[:period]) / float(period)
+    out = [ema_val]
+    for v in values[period:]:
+        ema_val = (v * k) + (ema_val * (1.0 - k))
+        out.append(ema_val)
+    return out
diff --git a/pt_hub.py b/pt_hub.py
index 8d28fea06..f19d7197f 100644
--- a/pt_hub.py
+++ b/pt_hub.py
@@ -20,6 +20,9 @@
 from matplotlib.patches import Rectangle
 from matplotlib.ticker import FuncFormatter
 from matplotlib.transforms import blended_transform_factory
+from env_loader import load_env
+
+load_env()
 
 DARK_BG = "#070B10"
 DARK_BG2 = "#0B1220"
@@ -54,20 +57,20 @@ def add(self, widget: tk.Widget, padx=(0, 0), pady=(0, 0)) -> None:
         self._items.append(_WrapItem(widget, padx=padx, pady=pady))
         self._schedule_reflow()
 
-    def clear(self, destroy_widgets: bool = True) -> None:
-
-        for it in list(self._items):
-            try:
-                it.w.grid_forget()
-            except Exception:
-                pass
-            if destroy_widgets:
-                try:
-                    it.w.destroy()
-                except Exception:
-                    pass
-        self._items = []
-        self._schedule_reflow()
+    def clear(self, destroy_widgets: bool = True) -> None:
+
+        for it in list(self._items):
+            try:
+                it.w.grid_forget()
+            except Exception:
+                pass
+            if destroy_widgets:
+                try:
+                    it.w.destroy()
+                except Exception:
+                    pass
+        self._items = []
+        self._schedule_reflow()
 
     def _schedule_reflow(self, event=None) -> None:
         if self._reflow_pending:
@@ -287,6 +290,25 @@ def set_values(self, long_sig: Any, short_sig: Any) -> None:
     "script_neural_trainer": "pt_trainer.py",
     "script_trader": "pt_trader.py",
     "auto_start_scripts": False,
+    "strategy": {
+        "mode": "selector",
+        "indicators": {
+            "macd": False,
+            "stochastic": False,
+            "momentum": False,
+            "obv": False,
+            "rsi": False,
+            "bollinger": False,
+            "ema": False,
+            "atr": False,
+            "volume_profile": False,
+            "adx": False,
+            "pivots": False,
+            "ichimoku": False,
+        },
+        "check_all": False,
+        "replace_neural": True,
+    },
 }
 
 
@@ -310,6 +332,39 @@ def _safe_write_json(path: str, data: dict) -> None:
     os.replace(tmp, path)
 
 
+def _normalize_strategy_settings(data: dict) -> dict:
+    default = DEFAULT_SETTINGS.get("strategy", {})
+    out = {
+        "mode": default.get("mode", "selector"),
+        "indicators": dict(default.get("indicators", {})),
+        "check_all": bool(default.get("check_all", False)),
+        "replace_neural": True,
+    }
+
+    if not isinstance(data, dict):
+        return out
+
+    mode = str(data.get("mode", out["mode"])).lower().strip()
+    if mode in ("selector", "super"):
+        out["mode"] = mode
+
+    out["check_all"] = bool(data.get("check_all", out["check_all"]))
+    out["replace_neural"] = True
+
+    indicators = data.get("indicators", {})
+    if isinstance(indicators, dict):
+        for k in out["indicators"].keys():
+            if k in indicators:
+                out["indicators"][k] = bool(indicators.get(k))
+
+    if out["check_all"]:
+        for k in out["indicators"].keys():
+            out["indicators"][k] = True
+        out["mode"] = "super"
+
+    return out
+
+
 def _read_trade_history_jsonl(path: str) -> List[dict]:
     """
     Reads hub_data/trade_history.jsonl written by pt_trader.py.
@@ -467,21 +522,21 @@ def read_price_levels_from_html(path: str) -> List[float]:
                .replace("'", " ")
         )
 
-        vals: List[float] = []
-        for tok in raw.split():
-            try:
-                v = float(tok)
+        vals: List[float] = []
+        for tok in raw.split():
+            try:
+                v = float(tok)
 
                 # Filter obvious sentinel values used by pt_thinker for "inactive" slots
                 if v <= 0:
                     continue
                 if v >= 9e15:  # pt_thinker uses 99999999999999999
                     continue
-
-
-                vals.append(v)
-            except Exception:
-                pass
+
+
+                vals.append(v)
+            except Exception:
+                pass
 
         # De-dupe while preserving order (small rounding to avoid float-noise duplicates)
         out: List[float] = []
@@ -1804,6 +1859,7 @@ def _load_settings(self) -> dict:
         merged.update(data)
         # normalize
         merged["coins"] = [c.upper().strip() for c in merged.get("coins", [])]
+        merged["strategy"] = _normalize_strategy_settings(merged.get("strategy", {}))
         return merged
 
     def _save_settings(self) -> None:
@@ -1812,6 +1868,61 @@ def _save_settings(self) -> None:
     def _settings_getter(self) -> dict:
         return self.settings
 
+    def _on_strategy_mode_change(self) -> None:
+        try:
+            mode = str(self.strategy_mode_var.get()).strip().lower()
+            if mode == "super":
+                try:
+                    for var in self.strategy_vars.values():
+                        var.set(True)
+                except Exception:
+                    pass
+                try:
+                    self.strategy_check_all_var.set(True)
+                except Exception:
+                    pass
+                self._strategy_mode_auto = True
+            else:
+                self._strategy_mode_auto = False
+                try:
+                    self.strategy_check_all_var.set(False)
+                except Exception:
+                    pass
+            self._update_strategy_settings()
+        except Exception:
+            pass
+
+    def _update_strategy_settings(self) -> None:
+        try:
+            indicators = {}
+            for key, var in self.strategy_vars.items():
+                indicators[key] = bool(var.get())
+            check_all = all(indicators.values()) if indicators else False
+            try:
+                self.strategy_check_all_var.set(bool(check_all))
+            except Exception:
+                pass
+            mode = str(self.strategy_mode_var.get()).strip().lower()
+            if mode not in ("selector", "super"):
+                mode = "selector"
+            replace_neural = True
+
+            if check_all:
+                for k in indicators.keys():
+                    indicators[k] = True
+                mode = "super"
+                self._strategy_mode_auto = True
+
+            self.settings["strategy"] = {
+                "mode": mode,
+                "indicators": indicators,
+                "check_all": check_all,
+                "replace_neural": replace_neural,
+            }
+            self._save_settings()
+        except Exception:
+            pass
+
     def _ensure_alt_coin_folders_and_trainer_on_startup(self) -> None:
         """
         Startup behavior (mirrors Settings-save behavior):
@@ -2161,6 +2272,9 @@ def _btn_canvas_on_configure(event=None):
 
         self.lbl_last_status = ttk.Label(controls_left, text="Last status: N/A")
         self.lbl_last_status.pack(anchor="w", padx=6, pady=(0, 2))
+        self.lbl_trade_mode = ttk.Label(controls_left, text="Trade mode: N/A")
+        self.lbl_trade_mode.pack(anchor="w", padx=6, pady=(0, 6))
+        self._set_trade_mode_label()
 
 
         # ----------------------------
@@ -2192,6 +2306,118 @@ def _btn_canvas_on_configure(event=None):
         )
         self.training_list.pack(fill="both", expand=True, padx=6, pady=(0, 6))
 
+        # ----------------------------
+        # Strategy section
+        # ----------------------------
+        strategy_box = ttk.LabelFrame(top_controls, text="Strategy")
+        strategy_box.pack(fill="x", padx=6, pady=(0, 6))
+
+        indicators_frame = ttk.Frame(strategy_box)
+        indicators_frame.pack(side="left", fill="both", expand=True, padx=6, pady=6)
+
+        controls_frame = ttk.Frame(strategy_box)
+        controls_frame.pack(side="right", fill="y", padx=6, pady=6)
+
+        strat_settings = self.settings.get("strategy", {})
+        strat_settings = _normalize_strategy_settings(strat_settings)
+
+        self.strategy_vars = {}
+        self._strategy_mode_auto = False
+        indicator_defs = [
+            ("macd", "MACD"),
+            ("stochastic", "Stochastique"),
+            ("momentum", "Momentum"),
+            ("obv", "OBV"),
+            ("rsi", "RSI"),
+            ("bollinger", "Bollinger Bands"),
+            ("ema", "EMA"),
+            ("atr", "ATR"),
+            ("volume_profile", "Volume Profile"),
+            ("adx", "ADX"),
+            ("pivots", "Pivots"),
+            ("ichimoku", "Ichimoku Cloud"),
+        ]
+
+        def _on_strategy_indicator_change() -> None:
+            try:
+                all_on = all(v.get() for v in self.strategy_vars.values())
+                self.strategy_check_all_var.set(bool(all_on))
+                if all_on:
+                    self.strategy_mode_var.set("super")
+                    self._strategy_mode_auto = True
+                elif self._strategy_mode_auto:
+                    self.strategy_mode_var.set("selector")
+                    self._strategy_mode_auto = False
+                self._update_strategy_settings()
+            except Exception:
+                pass
+
+        for col in range(2):
+            indicators_frame.grid_columnconfigure(col, weight=1)
+
+        for idx, (key, label) in enumerate(indicator_defs):
+            var = tk.BooleanVar(value=bool(strat_settings["indicators"].get(key, False)))
+            self.strategy_vars[key] = var
+            row = idx % 6
+            col = 0 if idx < 6 else 1
+            ttk.Checkbutton(
+                indicators_frame,
+                text=label,
+                variable=var,
+                command=_on_strategy_indicator_change,
+            ).grid(row=row, column=col, sticky="w", padx=(0, 12), pady=(0, 4))
+
+        self.strategy_check_all_var = tk.BooleanVar(value=bool(strat_settings.get("check_all", False)))
+
+        def _toggle_check_all() -> None:
+            try:
+                all_on = all(v.get() for v in self.strategy_vars.values())
+                new_state = not all_on
+                for v in self.strategy_vars.values():
+                    v.set(new_state)
+                self.strategy_check_all_var.set(new_state)
+                if new_state:
+                    self.strategy_mode_var.set("super")
+                    self._strategy_mode_auto = True
+                elif self._strategy_mode_auto:
+                    self.strategy_mode_var.set("selector")
+                    self._strategy_mode_auto = False
+                self._update_strategy_settings()
+            except Exception:
+                pass
+
+        ttk.Button(controls_frame, text="Check all", command=_toggle_check_all).pack(anchor="w", pady=(0, 6))
+
+        mode_row = ttk.Frame(controls_frame)
+        mode_row.pack(anchor="w")
+        ttk.Label(mode_row, text="Mode").pack(side="left")
+        self.strategy_mode_var = tk.StringVar(value=strat_settings.get("mode", "selector"))
+        ttk.Radiobutton(
+            mode_row,
+            text="selector",
+            value="selector",
+            variable=self.strategy_mode_var,
+            command=self._on_strategy_mode_change,
+        ).pack(side="left", padx=(6, 0))
+        ttk.Radiobutton(
+            mode_row,
+            text="super",
+            value="super",
+            variable=self.strategy_mode_var,
+            command=self._on_strategy_mode_change,
+        ).pack(side="left", padx=(6, 0))
+
+        self.strategy_replace_var = tk.BooleanVar(value=True)
+        ttk.Checkbutton(
+            controls_frame,
+            text="replace_neural",
+            variable=self.strategy_replace_var,
+            command=self._update_strategy_settings,
+            state="disabled",
+        ).pack(anchor="w", pady=(6, 0))
+
+        self._update_strategy_settings()
+
 
         # Start All (moved here: LEFT side of the dual section, directly above Account)
         start_all_row = ttk.Frame(controls_left)
@@ -2204,6 +2430,14 @@ def _btn_canvas_on_configure(event=None):
             command=self.toggle_all_scripts,
         )
         self.btn_toggle_all.pack(side="left")
+        self.paper_mode_var = tk.BooleanVar(value=self._env_flag("BINANCE_PAPER", False))
+        self.chk_paper_mode = ttk.Checkbutton(
+            start_all_row,
+            text="Paper mode",
+            variable=self.paper_mode_var,
+            command=self._on_paper_toggle,
+        )
+        self.chk_paper_mode.pack(side="left", padx=(8, 0))
 
 
         # Account info (LEFT column, under status)
@@ -2666,9 +2900,9 @@ def _do_refresh_visible():
             "value": "Value",
             "avg_cost": "Avg Cost",
             "buy_price": "Ask Price",
-            "buy_pnl": "DCA PnL",
+            "buy_pnl": "DCA PnL %",
             "sell_price": "Bid Price",
-            "sell_pnl": "Sell PnL",
+            "sell_pnl": "Sell PnL %",
             "dca_stages": "DCA Stage",
             "dca_24h": "DCA 24h",
             "next_dca": "Next DCA",
@@ -2983,6 +3217,99 @@ def _reader_thread(self, proc: subprocess.Popen, q: "queue.Queue[str]", prefix:
         finally:
             q.put(f"{prefix}[process exited]")
 
+    @staticmethod
+    def _env_flag(name: str, default: bool = False) -> bool:
+        raw = os.environ.get(name, None)
+        if raw is None:
+            return default
+        return str(raw).strip().lower() in {"1", "true", "yes", "y", "on"}
+
+    def _set_trade_mode_label(self) -> None:
+        label = getattr(self, "lbl_trade_mode", None)
+        if not label:
+            return
+        mode = getattr(self, "_selected_trade_mode", None)
+        if not mode:
+            if self._env_flag("BINANCE_PAPER", False):
+                mode = "paper"
+            elif self._env_flag("BINANCE_TESTNET", False):
+                mode = "testnet"
+            else:
+                mode = "live"
+        label.config(text=f"Trade mode: {mode}")
+
+    def _on_paper_toggle(self) -> None:
+        try:
+            enabled = bool(self.paper_mode_var.get())
+        except Exception:
+            enabled = False
+        os.environ["BINANCE_PAPER"] = "true" if enabled else "false"
+        if enabled:
+            os.environ["BINANCE_TESTNET"] = "true"
+            self._selected_trade_mode = "paper"
+        else:
+            self._selected_trade_mode = None
+        self._set_trade_mode_label()
+
+    def _binance_keys_present(self) -> bool:
+        key = (os.environ.get("BINANCE_API_KEY") or "").strip()
+        secret = (os.environ.get("BINANCE_API_SECRET") or "").strip()
+        if not key or not secret:
+            return False
+        placeholders = {"your_key_here", "your_secret_here", "changeme"}
+        if key.lower() in placeholders or secret.lower() in placeholders:
+            return False
+        return True
+
+    def _ensure_binance_trade_mode(self) -> bool:
+        provider = (os.environ.get("EXCHANGE_PROVIDER") or "robinhood").strip().lower()
+        if provider != "binance":
+            return True
+
+        if getattr(self, "paper_mode_var", None) is not None:
+            if bool(self.paper_mode_var.get()):
+                os.environ["BINANCE_PAPER"] = "true"
+        if self._env_flag("BINANCE_PAPER", False):
+            self._selected_trade_mode = "paper"
+            self._set_trade_mode_label()
+            return True
+
+        if not self._binance_keys_present():
+            resp = messagebox.askyesnocancel(
+                "Binance keys missing",
+                "BINANCE_API_KEY and BINANCE_API_SECRET are missing.\n\n"
+                "Yes = Start PAPER trading (no real orders)\n"
+                "No = Cancel",
+            )
+            if resp is None or resp is False:
+                return False
+            os.environ["BINANCE_PAPER"] = "true"
+            self._selected_trade_mode = "paper"
+            try:
+                self.paper_mode_var.set(True)
+            except Exception:
+                pass
+            self._set_trade_mode_label()
+            return True
+
+        resp = messagebox.askyesnocancel(
+            "Binance trade mode",
+            "Start Trader in TESTNET mode?\n\nYes = Testnet\nNo = Live (real funds)\nCancel = Abort",
+        )
+        if resp is None:
+            return False
+
+        use_testnet = bool(resp)
+        os.environ["BINANCE_TESTNET"] = "true" if use_testnet else "false"
+        os.environ["BINANCE_PAPER"] = "false"
+        self._selected_trade_mode = "testnet" if use_testnet else "live"
+        try:
+            self.paper_mode_var.set(False)
+        except Exception:
+            pass
+        self._set_trade_mode_label()
+        return True
+
     def _start_process(self, p: ProcInfo, log_q: Optional["queue.Queue[str]"] = None, prefix: str = "") -> None:
         if p.proc and p.proc.poll() is None:
             return
@@ -3030,6 +3357,9 @@ def start_neural(self) -> None:
 
 
     def start_trader(self) -> None:
+        if not self._ensure_binance_trade_mode():
+            self._auto_start_trader_pending = False
+            return
         self._start_process(self.proc_trader, log_q=self.trader_log_q, prefix="[TRADER] ")
 
 
@@ -3064,38 +3394,49 @@ def _read_runner_ready(self) -> Dict[str, Any]:
             pass
         return {"ready": False}
 
-    def _poll_runner_ready_then_start_trader(self) -> None:
-        # Cancelled or already started
-        if not bool(getattr(self, "_auto_start_trader_pending", False)):
-            return
+    def _poll_runner_ready_then_start_trader(self) -> None:
+        # Cancelled or already started
+        if not bool(getattr(self, "_auto_start_trader_pending", False)):
+            return
 
         # If runner died, stop waiting
         if not (self.proc_neural.proc and self.proc_neural.proc.poll() is None):
             self._auto_start_trader_pending = False
             return
 
-        st = self._read_runner_ready()
-        if bool(st.get("ready", False)):
-            self._auto_start_trader_pending = False
-
-            # Start trader if not already running
-            if not (self.proc_trader.proc and self.proc_trader.proc.poll() is None):
-                self.start_trader()
-            return
-
-        # Not ready yet — keep polling
-        try:
-            self.after(250, self._poll_runner_ready_then_start_trader)
-        except Exception:
+        st = self._read_runner_ready()
+        if bool(st.get("ready", False)):
+            self._auto_start_trader_pending = False
+
+            # Start trader if not already running
+            if not (self.proc_trader.proc and self.proc_trader.proc.poll() is None):
+                self.start_trader()
+            return
+
+        # If strategy replaces neural signals, don't block trader on runner readiness.
+        try:
+            strat = self.settings.get("strategy", {})
+            if bool(strat.get("replace_neural", False)):
+                self._auto_start_trader_pending = False
+                if not (self.proc_trader.proc and self.proc_trader.proc.poll() is None):
+                    self.start_trader()
+                return
+        except Exception:
+            pass
+
+        # Not ready yet — keep polling
+        try:
+            self.after(250, self._poll_runner_ready_then_start_trader)
+        except Exception:
             pass
 
     def start_all_scripts(self) -> None:
         # Enforce flow: Train → Neural → (wait for runner READY) → Trader
-        all_trained = all(self._coin_is_trained(c) for c in self.coins) if self.coins else False
-        if not all_trained:
+        has_trained = any(self._coin_is_trained(c) for c in self.coins) if self.coins else False
+        if not has_trained:
             messagebox.showwarning(
                 "Training required",
-                "All coins must be trained before starting Neural Runner.\n\nUse Train All first."
+                "At least one coin must be trained before starting Neural Runner.\n\nUse Train Selected or Train All first."
             )
             return
 
@@ -3138,15 +3479,29 @@ def _coin_is_trained(self, coin: str) -> bool:
 
     def _running_trainers(self) -> List[str]:
         running: List[str] = []
+        to_remove: List[str] = []
 
         # Trainers launched by this GUI instance
         for c, lp in self.trainers.items():
             try:
                 if lp.info.proc and lp.info.proc.poll() is None:
+                    if self._trainer_marked_finished(c):
+                        try:
+                            lp.info.proc.terminate()
+                        except Exception:
+                            pass
+                        to_remove.append(c)
+                        continue
                     running.append(c)
             except Exception:
                 pass
 
+        for c in to_remove:
+            try:
+                self.trainers.pop(c, None)
+            except Exception:
+                pass
+
         # Trainers launched elsewhere: look at per-coin status file
         for c in self.coins:
             try:
@@ -3182,6 +3537,20 @@ def _running_trainers(self) -> List[str]:
                 out.append(cc)
         return out
 
+    def _trainer_marked_finished(self, coin: str) -> bool:
+        coin = (coin or "").strip().upper()
+        folder = self.coin_folders.get(coin, "")
+        if not folder or not os.path.isdir(folder):
+            return False
+        try:
+            st = _safe_read_json(os.path.join(folder, "trainer_status.json"))
+            if isinstance(st, dict) and str(st.get("state", "")).upper() == "FINISHED":
+                stamp_path = os.path.join(folder, "trainer_last_training_time.txt")
+                return os.path.isfile(stamp_path)
+        except Exception:
+            return False
+        return False
+
 
 
     def _training_status_map(self) -> Dict[str, str]:
@@ -3422,11 +3791,12 @@ def _tick(self) -> None:
         # --- flow gating: Train -> Start All ---
         status_map = self._training_status_map()
         all_trained = all(v == "TRAINED" for v in status_map.values()) if status_map else False
+        has_trained = any(v == "TRAINED" for v in status_map.values()) if status_map else False
 
         # Disable Start All until training is done (but always allow it if something is already running/pending,
         # so the user can still stop everything).
         can_toggle_all = True
-        if (not all_trained) and (not neural_running) and (not trader_running) and (not self._auto_start_trader_pending):
+        if (not has_trained) and (not neural_running) and (not trader_running) and (not self._auto_start_trader_pending):
             can_toggle_all = False
 
         try:
@@ -3441,6 +3811,8 @@ def _tick(self) -> None:
 
             if training_running:
                 self.lbl_training_overview.config(text=f"Training: RUNNING ({', '.join(training_running)})")
+            elif not_trained and has_trained:
+                self.lbl_training_overview.config(text=f"Training: PARTIAL ({len(not_trained)} not trained)")
             elif not_trained:
                 self.lbl_training_overview.config(text=f"Training: REQUIRED ({len(not_trained)} not trained)")
             else:
@@ -3455,17 +3827,18 @@ def _tick(self) -> None:
                     self.training_list.insert("end", f"{c}: {st}")
 
             # show gating hint (Start All handles the runner->ready->trader sequence)
-            if not all_trained:
-                self.lbl_flow_hint.config(text="Flow: Train All required → then Start All")
+            if not has_trained:
+                self.lbl_flow_hint.config(text="Flow: Train All required -> then Start All")
+            elif not all_trained:
+                self.lbl_flow_hint.config(text="Flow: Start All (will trade trained coins only)")
             elif self._auto_start_trader_pending:
-                self.lbl_flow_hint.config(text="Flow: Starting runner → waiting for ready → trader will auto-start")
+                self.lbl_flow_hint.config(text="Flow: Starting runner -> waiting for ready -> trader will auto-start")
             elif neural_running or trader_running:
                 self.lbl_flow_hint.config(text="Flow: Running (use the button to stop)")
             else:
                 self.lbl_flow_hint.config(text="Flow: Start All")
         except Exception:
             pass
-
         # neural overview bars (mtime-cached inside)
         self._refresh_neural_overview()
 
@@ -3575,7 +3948,11 @@ def _refresh_trader_status(self) -> None:
 
         data = _safe_read_json(self.trader_status_path)
         if not data:
-            self.lbl_last_status.config(text="Last status: N/A (no trader_status.json yet)")
+            trader_running = bool(self.proc_trader.proc and self.proc_trader.proc.poll() is None)
+            if trader_running:
+                self.lbl_last_status.config(text="Last status: N/A (waiting for trader_status.json)")
+            else:
+                self.lbl_last_status.config(text="Last status: N/A (trader not started)")
 
             # account summary (right-side status area)
             try:
diff --git a/pt_thinker.py b/pt_thinker.py
index c3a59f467..fc916237b 100644
--- a/pt_thinker.py
+++ b/pt_thinker.py
@@ -14,23 +14,30 @@
 import hmac
 from datetime import datetime
 import psutil
-import logging
-import json
-import uuid
-
-from nacl.signing import SigningKey
+import logging
+import json
+import uuid
+from typing import Optional
+from env_loader import load_env
+
+load_env()
+
+from nacl.signing import SigningKey
+from exchanges.binance_client import BinanceExchangeClient
 
 # -----------------------------
 # Robinhood market-data (current ASK), same source as rhcb.py trader:
 #   GET /api/v1/crypto/marketdata/best_bid_ask/?symbol=BTC-USD
 #   use result["ask_inclusive_of_buy_spread"]
 # -----------------------------
-ROBINHOOD_BASE_URL = "https://trading.robinhood.com"
-
-_RH_MD = None  # lazy-init so import doesn't explode if creds missing
-
-
-class RobinhoodMarketData:
+ROBINHOOD_BASE_URL = "https://trading.robinhood.com"
+EXCHANGE_PROVIDER = (os.environ.get("EXCHANGE_PROVIDER") or "robinhood").strip().lower()
+
+_RH_MD = None  # lazy-init so import doesn't explode if creds missing
+_EXCHANGE_MD = None
+
+
+class RobinhoodMarketData:
     def __init__(self, api_key: str, base64_private_key: str, base_url: str = ROBINHOOD_BASE_URL, timeout: int = 10):
         self.api_key = (api_key or "").strip()
         self.base_url = (base_url or "").rstrip("/")
@@ -88,7 +95,7 @@ def get_current_ask(self, symbol: str) -> float:
         return float(result["ask_inclusive_of_buy_spread"])
 
 
-def robinhood_current_ask(symbol: str) -> float:
+def robinhood_current_ask(symbol: str) -> float:
     """
     Returns Robinhood current BUY price (ask_inclusive_of_buy_spread) for symbols like 'BTC-USD'.
     Reads creds from r_key.txt and r_secret.txt in the same folder as this script.
@@ -113,7 +120,51 @@ def robinhood_current_ask(symbol: str) -> float:
 
         _RH_MD = RobinhoodMarketData(api_key=api_key, base64_private_key=priv_b64)
 
-    return _RH_MD.get_current_ask(symbol)
+    return _RH_MD.get_current_ask(symbol)
+
+
+class ExchangeMarketData:
+    def __init__(self, provider: Optional[str] = None):
+        self.provider = (provider or EXCHANGE_PROVIDER or "robinhood").strip().lower()
+        self._client = None
+
+        if self.provider == "binance":
+            try:
+                self._client = BinanceExchangeClient()
+            except ValueError:
+                self._client = BinanceExchangeClient(public_only=True)
+        else:
+            base_dir = os.path.dirname(os.path.abspath(__file__))
+            key_path = os.path.join(base_dir, "r_key.txt")
+            secret_path = os.path.join(base_dir, "r_secret.txt")
+
+            if not os.path.isfile(key_path) or not os.path.isfile(secret_path):
+                raise RuntimeError(
+                    "Missing r_key.txt and/or r_secret.txt next to pt_thinker.py. "
+                    "Run pt_trader.py once to create them (and to set your Robinhood API key)."
+                )
+
+            with open(key_path, "r", encoding="utf-8") as f:
+                api_key = f.read()
+            with open(secret_path, "r", encoding="utf-8") as f:
+                priv_b64 = f.read()
+
+            self._client = RobinhoodMarketData(api_key=api_key, base64_private_key=priv_b64)
+
+    def get_current_ask(self, symbol: str) -> float:
+        if self.provider == "binance":
+            return float(self._client.get_price(symbol))
+        return float(self._client.get_current_ask(symbol))
+
+
+def current_ask(symbol: str) -> float:
+    """
+    Exchange-agnostic current ask. Uses Robinhood by default, Binance when EXCHANGE_PROVIDER=binance.
+    """
+    global _EXCHANGE_MD
+    if _EXCHANGE_MD is None:
+        _EXCHANGE_MD = ExchangeMarketData()
+    return _EXCHANGE_MD.get_current_ask(symbol)
 
 
 def restart_program():
@@ -600,13 +651,26 @@ def step_coin(sym: str):
 		high_weight_list = file.read().replace("'", "").replace(',', '').replace('"', '').replace(']', '').replace('[', '').split(' ')
 		file.close()
 
-		file = open('memory_weights_low_' + tf_choices[tf_choice_index] + '.txt', 'r')
-		low_weight_list = file.read().replace("'", "").replace(',', '').replace('"', '').replace(']', '').replace('[', '').split(' ')
-		file.close()
-
-		mem_ind = 0
-		diffs_list = []
-		any_perfect = 'no'
+		file = open('memory_weights_low_' + tf_choices[tf_choice_index] + '.txt', 'r')
+		low_weight_list = file.read().replace("'", "").replace(',', '').replace('"', '').replace(']', '').replace('[', '').split(' ')
+		file.close()
+
+		# sanitize memory + weights (avoid empty entries)
+		memory_list = [m for m in memory_list if str(m).strip() != ""]
+		mem_len = len(memory_list)
+		if mem_len == 0:
+			memory_list = ["0{}0{}0"]
+			mem_len = 1
+		if len(weight_list) < mem_len:
+			weight_list += ['1.0'] * (mem_len - len(weight_list))
+		if len(high_weight_list) < mem_len:
+			high_weight_list += ['1.0'] * (mem_len - len(high_weight_list))
+		if len(low_weight_list) < mem_len:
+			low_weight_list += ['1.0'] * (mem_len - len(low_weight_list))
+
+		mem_ind = 0
+		diffs_list = []
+		any_perfect = 'no'
 		perfect_dexs = []
 		perfect_diffs = []
 		moves = []
@@ -615,12 +679,41 @@ def step_coin(sym: str):
 		high_unweighted = []
 		low_unweighted = []
 		high_moves = []
-		low_moves = []
-
-		while True:
-			memory_pattern = memory_list[mem_ind].split('{}')[0].replace("'", "").replace(',', '').replace('"', '').replace(']', '').replace('[', '').split(' ')
-			check_dex = 0
-			memory_candle = float(memory_pattern[check_dex])
+		low_moves = []
+
+		while True:
+			raw_pattern = memory_list[mem_ind].split('{}')[0].replace("'", "").replace(',', '').replace('"', '').replace(']', '').replace('[', '').split(' ')
+			memory_pattern = [p for p in raw_pattern if p]
+			if not memory_pattern:
+				diffs_list.append(100.0)
+				mem_ind += 1
+				if mem_ind >= len(memory_list):
+					if any_perfect == 'no':
+						final_moves = 0.0
+						high_final_moves = 0.0
+						low_final_moves = 0.0
+						del perfects[tf_choice_index]
+						perfects.insert(tf_choice_index, 'inactive')
+					else:
+						try:
+							final_moves = sum(moves) / len(moves)
+							high_final_moves = sum(high_moves) / len(high_moves)
+							low_final_moves = sum(low_moves) / len(low_moves)
+							del perfects[tf_choice_index]
+							perfects.insert(tf_choice_index, 'active')
+						except:
+							final_moves = 0.0
+							high_final_moves = 0.0
+							low_final_moves = 0.0
+							del perfects[tf_choice_index]
+							perfects.insert(tf_choice_index, 'inactive')
+					break
+				continue
+			check_dex = 0
+			try:
+				memory_candle = float(memory_pattern[check_dex])
+			except:
+				memory_candle = 0.0
 
 			if current_candle == 0.0 and memory_candle == 0.0:
 				difference = 0.0
@@ -734,7 +827,7 @@ def step_coin(sym: str):
 		rh_symbol = f"{sym}-USD"
 		while True:
 			try:
-				current = robinhood_current_ask(rh_symbol)
+				current = current_ask(rh_symbol)
 				break
 			except Exception:
 				time.sleep(1)
diff --git a/pt_trader.py b/pt_trader.py
index 5673fe4bb..018897fbb 100644
--- a/pt_trader.py
+++ b/pt_trader.py
@@ -8,11 +8,16 @@
 import requests
 from nacl.signing import SigningKey
 import os
-import colorama
-from colorama import Fore, Style
-import traceback
-from cryptography.hazmat.primitives.asymmetric import ed25519
-from cryptography.hazmat.primitives import serialization
+import colorama
+from colorama import Fore, Style
+import traceback
+from cryptography.hazmat.primitives.asymmetric import ed25519
+from cryptography.hazmat.primitives import serialization
+from exchanges.binance_client import BinanceExchangeClient, BinanceAPIError, BinancePaperExchangeClient
+from env_loader import load_env
+import indicators
+
+load_env()
 
 # -----------------------------
 # GUI HUB OUTPUTS
@@ -38,13 +43,67 @@
 	"gui_settings.json"
 )
 
-_gui_settings_cache = {
-	"mtime": None,
-	"coins": ['BTC', 'ETH', 'XRP', 'BNB', 'DOGE'],  # fallback defaults
-	"main_neural_dir": None,
-}
-
-def _load_gui_settings() -> dict:
+_STRATEGY_DEFAULT = {
+	"mode": "selector",
+	"indicators": {
+		"macd": False,
+		"stochastic": False,
+		"momentum": False,
+		"obv": False,
+		"rsi": False,
+		"bollinger": False,
+		"ema": False,
+		"atr": False,
+		"volume_profile": False,
+		"adx": False,
+		"pivots": False,
+		"ichimoku": False,
+	},
+	"check_all": False,
+	"replace_neural": False,
+}
+
+_gui_settings_cache = {
+	"mtime": None,
+	"coins": ['BTC', 'ETH', 'XRP', 'BNB', 'DOGE'],  # fallback defaults
+	"main_neural_dir": None,
+	"strategy": dict(_STRATEGY_DEFAULT),
+}
+
+def _normalize_strategy(data: dict) -> dict:
+	out = {
+		"mode": _STRATEGY_DEFAULT["mode"],
+		"indicators": dict(_STRATEGY_DEFAULT["indicators"]),
+		"check_all": _STRATEGY_DEFAULT["check_all"],
+		"replace_neural": _STRATEGY_DEFAULT["replace_neural"],
+	}
+
+	if not isinstance(data, dict):
+		return out
+
+	strat = data.get("strategy", {})
+	if isinstance(strat, dict):
+		mode = str(strat.get("mode", out["mode"])).lower().strip()
+		if mode in ("selector", "super"):
+			out["mode"] = mode
+
+		out["check_all"] = bool(strat.get("check_all", out["check_all"]))
+		out["replace_neural"] = bool(strat.get("replace_neural", out["replace_neural"]))
+
+		ind = strat.get("indicators", {})
+		if isinstance(ind, dict):
+			for k in out["indicators"].keys():
+				if k in ind:
+					out["indicators"][k] = bool(ind.get(k))
+
+	if out["check_all"]:
+		for k in out["indicators"].keys():
+			out["indicators"][k] = True
+		out["mode"] = "super"
+
+	return out
+
+def _load_gui_settings() -> dict:
 	"""
 	Reads gui_settings.json and returns a dict with:
 	- coins: uppercased list
@@ -75,17 +134,19 @@ def _load_gui_settings() -> dict:
 		else:
 			main_neural_dir = None
 
-		_gui_settings_cache["mtime"] = mtime
-		_gui_settings_cache["coins"] = coins
-		_gui_settings_cache["main_neural_dir"] = main_neural_dir
-
-		return {
-			"mtime": mtime,
-			"coins": list(coins),
-			"main_neural_dir": main_neural_dir,
-		}
-	except Exception:
-		return dict(_gui_settings_cache)
+		_gui_settings_cache["mtime"] = mtime
+		_gui_settings_cache["coins"] = coins
+		_gui_settings_cache["main_neural_dir"] = main_neural_dir
+		_gui_settings_cache["strategy"] = _normalize_strategy(data)
+
+		return {
+			"mtime": mtime,
+			"coins": list(coins),
+			"main_neural_dir": main_neural_dir,
+			"strategy": dict(_gui_settings_cache["strategy"]),
+		}
+	except Exception:
+		return dict(_gui_settings_cache)
 
 def _build_base_paths(main_dir_in: str, coins_in: list) -> dict:
 	"""
@@ -152,36 +213,77 @@ def _refresh_paths_and_symbols():
 
 
 #API STUFF
+EXCHANGE_PROVIDER = (os.environ.get("EXCHANGE_PROVIDER") or "robinhood").strip().lower()
 API_KEY = ""
 BASE64_PRIVATE_KEY = ""
 
-try:
-    with open('r_key.txt', 'r', encoding='utf-8') as f:
-        API_KEY = (f.read() or "").strip()
-    with open('r_secret.txt', 'r', encoding='utf-8') as f:
-        BASE64_PRIVATE_KEY = (f.read() or "").strip()
-except Exception:
-    API_KEY = ""
-    BASE64_PRIVATE_KEY = ""
-
-if not API_KEY or not BASE64_PRIVATE_KEY:
-    print(
-        "\n[PowerTrader] Robinhood API credentials not found.\n"
-        "Open the GUI and go to Settings → Robinhood API → Setup / Update.\n"
-        "That wizard will generate your keypair, tell you where to paste the public key on Robinhood,\n"
-        "and will save r_key.txt + r_secret.txt so this trader can authenticate.\n"
-    )
-    raise SystemExit(1)
-
-class CryptoAPITrading:
-    def __init__(self):
-        # keep a copy of the folder map (same idea as trader.py)
-        self.path_map = dict(base_paths)
-
-        self.api_key = API_KEY
-        private_key_seed = base64.b64decode(BASE64_PRIVATE_KEY)
-        self.private_key = SigningKey(private_key_seed)
-        self.base_url = "https://trading.robinhood.com"
+if EXCHANGE_PROVIDER == "robinhood":
+    try:
+        with open("r_key.txt", "r", encoding="utf-8") as f:
+            API_KEY = (f.read() or "").strip()
+        with open("r_secret.txt", "r", encoding="utf-8") as f:
+            BASE64_PRIVATE_KEY = (f.read() or "").strip()
+    except Exception:
+        API_KEY = ""
+        BASE64_PRIVATE_KEY = ""
+
+    if not API_KEY or not BASE64_PRIVATE_KEY:
+        print(
+            "\n[PowerTrader] Robinhood API credentials not found.\n"
+            "Open the GUI and go to Settings -> Robinhood API -> Setup / Update.\n"
+            "That wizard will generate your keypair, tell you where to paste the public key on Robinhood,\n"
+            "and will save r_key.txt + r_secret.txt so this trader can authenticate.\n"
+        )
+        raise SystemExit(1)
+
+class CryptoAPITrading:
+    @staticmethod
+    def _binance_keys_present() -> bool:
+        key = (os.environ.get("BINANCE_API_KEY") or "").strip()
+        secret = (os.environ.get("BINANCE_API_SECRET") or "").strip()
+        if not key or not secret:
+            return False
+        placeholders = {"your_key_here", "your_secret_here", "changeme"}
+        if key.lower() in placeholders or secret.lower() in placeholders:
+            return False
+        return True
+
+    @staticmethod
+    def _env_flag(name: str, default: bool = False) -> bool:
+        raw = os.environ.get(name, None)
+        if raw is None:
+            return default
+        return str(raw).strip().lower() in {"1", "true", "yes", "y", "on"}
+
+    def __init__(self):
+        # keep a copy of the folder map (same idea as trader.py)
+        self.path_map = dict(base_paths)
+
+        self.exchange_provider = EXCHANGE_PROVIDER
+        self.exchange = None
+
+        if self.exchange_provider == "binance":
+            use_paper = self._env_flag("BINANCE_PAPER", False)
+            keys_present = self._binance_keys_present()
+            if not keys_present and self._env_flag("BINANCE_TESTNET", False):
+                use_paper = True
+
+            if use_paper:
+                self.exchange = BinancePaperExchangeClient()
+            else:
+                try:
+                    self.exchange = BinanceExchangeClient()
+                except ValueError as e:
+                    print(f"\n[PowerTrader] Binance API credentials not found.\n{e}\n")
+                    raise SystemExit(1)
+            self.api_key = ""
+            self.private_key = None
+            self.base_url = ""
+        else:
+            self.api_key = API_KEY
+            private_key_seed = base64.b64decode(BASE64_PRIVATE_KEY)
+            self.private_key = SigningKey(private_key_seed)
+            self.base_url = "https://trading.robinhood.com"
 
         self.dca_levels_triggered = {}  # Track DCA levels for each crypto
         self.dca_levels = [-2.5, -5.0, -10.0, -20.0, -30.0, -40.0, -50.0]  # Moved to instance variable
@@ -196,8 +298,10 @@ def __init__(self):
         self.cost_basis = self.calculate_cost_basis()  # Initialize cost basis at startup
         self.initialize_dca_levels()  # Initialize DCA levels based on historical buy orders
 
-        # GUI hub persistence
-        self._pnl_ledger = self._load_pnl_ledger()
+        # GUI hub persistence
+        self._pnl_ledger = self._load_pnl_ledger()
+        if not os.path.isfile(PNL_LEDGER_PATH):
+            self._save_pnl_ledger()
 
         # Cache last known bid/ask per symbol so transient API misses don't zero out account value
         self._last_good_bid_ask = {}
@@ -213,11 +317,41 @@ def __init__(self):
 
         # --- DCA rate-limit (per trade, per coin, rolling 24h window) ---
         self.max_dca_buys_per_24h = 2
-        self.dca_window_seconds = 24 * 60 * 60
-        self._dca_buy_ts = {}         # { "BTC": [ts, ts, ...] } (DCA buys only)
-        self._dca_last_sell_ts = {}   # { "BTC": ts_of_last_sell }
-        self._seed_dca_window_from_history()
-
+        self.dca_window_seconds = 24 * 60 * 60
+        self._dca_buy_ts = {}         # { "BTC": [ts, ts, ...] } (DCA buys only)
+        self._dca_last_sell_ts = {}   # { "BTC": ts_of_last_sell }
+        self._seed_dca_window_from_history()
+
+        # --- Paper test mode (forced entry/exit cycle) ---
+        try:
+            self.paper_test_mode = self._env_flag("BINANCE_PAPER_TEST", False)
+            self.paper_test_hold_seconds = int(os.environ.get("BINANCE_PAPER_TEST_HOLD_SECONDS", "120"))
+            self.paper_test_dca_seconds = int(os.environ.get("BINANCE_PAPER_TEST_DCA_SECONDS", "60"))
+            self.paper_test_alloc_usd = float(os.environ.get("BINANCE_PAPER_TEST_ALLOC_USD", "50"))
+            self.paper_test_coin = (os.environ.get("BINANCE_PAPER_TEST_COIN") or "").strip().upper()
+        except Exception:
+            self.paper_test_mode = False
+            self.paper_test_hold_seconds = 120
+            self.paper_test_dca_seconds = 60
+            self.paper_test_alloc_usd = 50.0
+            self.paper_test_coin = ""
+        self._paper_test_state = {}
+
+        # --- Strategy settings ---
+        self.strategy_super_threshold = 0.6
+
+        # --- Pine signal settings ---
+        self.pine_signal_enabled = self._env_flag("PINE_SIGNAL_ENABLED", False)
+        self.pine_signal_mode = (os.environ.get("PINE_SIGNAL_MODE", "filter") or "filter").strip().lower()
+        if self.pine_signal_mode not in {"filter", "replace", "off"}:
+            self.pine_signal_mode = "filter"
+        self.pine_signal_use_exit = self._env_flag("PINE_SIGNAL_USE_EXIT", False)
+        self.pine_signal_max_age = int(os.environ.get("PINE_SIGNAL_MAX_AGE_SECONDS", "300") or 300)
+        self.pine_signal_file = (os.environ.get("PINE_SIGNAL_FILE") or "").strip()
+        if not self.pine_signal_file and self.pine_signal_enabled:
+            self.pine_signal_file = os.path.join(HUB_DATA_DIR, "pine_signals.jsonl")
+        self._pine_signal_state = {"pos": 0, "signals": {}}
+
 
 
 
@@ -366,10 +500,10 @@ def _read_long_dca_signal(symbol: str) -> int:
             return 0
 
 
-    @staticmethod
-    def _read_short_dca_signal(symbol: str) -> int:
-        """
-        Reads short_dca_signal.txt from the per-coin folder (same folder rules as trader.py).
+    @staticmethod
+    def _read_short_dca_signal(symbol: str) -> int:
+        """
+        Reads short_dca_signal.txt from the per-coin folder (same folder rules as trader.py).
 
         Used for:
         - Start gate: start trades at level 3+
@@ -383,8 +517,281 @@ def _read_short_dca_signal(symbol: str) -> int:
                 raw = f.read().strip()
             val = int(float(raw))
             return val
-        except Exception:
-            return 0
+        except Exception:
+            return 0
+
+    @staticmethod
+    def _normalize_signal_symbol(raw: str) -> str:
+        sym = str(raw or "").strip().upper()
+        if not sym:
+            return ""
+        if "-" in sym:
+            base, _ = sym.split("-", 1)
+            return base
+        if "_" in sym:
+            base, _ = sym.split("_", 1)
+            return base
+        if "/" in sym:
+            base, _ = sym.split("/", 1)
+            return base
+        for quote in ("USDT", "USDC", "BUSD", "USD", "BTC", "ETH", "BNB"):
+            if sym.endswith(quote) and len(sym) > len(quote):
+                return sym[: -len(quote)]
+        return sym
+
+    def _refresh_pine_signals(self) -> None:
+        if not self.pine_signal_enabled or not self.pine_signal_file:
+            return
+        if not os.path.isfile(self.pine_signal_file):
+            return
+        try:
+            pos = int(self._pine_signal_state.get("pos", 0))
+            with open(self.pine_signal_file, "r", encoding="utf-8") as f:
+                f.seek(pos)
+                for line in f:
+                    raw = line.strip()
+                    if not raw:
+                        continue
+                    try:
+                        payload = json.loads(raw)
+                    except Exception:
+                        continue
+                    symbol = self._normalize_signal_symbol(payload.get("symbol") or payload.get("ticker") or "")
+                    if not symbol:
+                        continue
+                    action = str(payload.get("action") or payload.get("signal") or "").strip().lower()
+                    if action not in {"buy", "sell", "hold", "stop"}:
+                        continue
+                    ts_val = payload.get("ts") or payload.get("time") or payload.get("timestamp")
+                    try:
+                        ts = float(ts_val)
+                        if ts > 1e12:
+                            ts = ts / 1000.0
+                    except Exception:
+                        ts = time.time()
+                    strength = payload.get("strength")
+                    self._pine_signal_state.setdefault("signals", {})[symbol] = {
+                        "action": action,
+                        "ts": ts,
+                        "strength": strength,
+                    }
+                self._pine_signal_state["pos"] = f.tell()
+        except Exception:
+            pass
+
+    def _get_pine_signal(self, symbol: str) -> Optional[dict]:
+        if not self.pine_signal_enabled or self.pine_signal_mode == "off":
+            return None
+        self._refresh_pine_signals()
+        sym = self._normalize_signal_symbol(symbol)
+        signals = self._pine_signal_state.get("signals", {}) if isinstance(self._pine_signal_state, dict) else {}
+        sig = signals.get(sym)
+        if not isinstance(sig, dict):
+            return None
+        try:
+            ts = float(sig.get("ts", 0.0) or 0.0)
+        except Exception:
+            ts = 0.0
+        if self.pine_signal_max_age > 0 and ts > 0:
+            if (time.time() - ts) > float(self.pine_signal_max_age):
+                return None
+        return dict(sig)
+
+    def _get_strategy_settings(self) -> dict:
+        try:
+            s = _load_gui_settings()
+            strat = s.get("strategy", None)
+            if isinstance(strat, dict):
+                return dict(strat)
+        except Exception:
+            pass
+        return dict(_STRATEGY_DEFAULT)
+
+    def _fetch_strategy_candles(self, symbol: str, limit: int = 120) -> list:
+        if self.exchange_provider != "binance" or not self.exchange:
+            return []
+        settings = _load_gui_settings()
+        tf = str(settings.get("default_timeframe", "1hour")).lower().strip()
+        limit = int(settings.get("candles_limit", limit) or limit)
+        tf_map = {
+            "1min": "1m",
+            "5min": "5m",
+            "15min": "15m",
+            "30min": "30m",
+            "1hour": "1h",
+            "2hour": "2h",
+            "4hour": "4h",
+            "8hour": "8h",
+            "12hour": "12h",
+            "1day": "1d",
+            "1week": "1w",
+        }
+        interval = tf_map.get(tf, "1h")
+        try:
+            return self.exchange.get_klines(symbol, interval=interval, limit=limit)
+        except Exception:
+            return []
+
+    @staticmethod
+    def _extract_series(candles: list) -> dict:
+        closes = []
+        highs = []
+        lows = []
+        volumes = []
+        for c in candles or []:
+            try:
+                closes.append(float(c.get("close", 0.0)))
+                highs.append(float(c.get("high", 0.0)))
+                lows.append(float(c.get("low", 0.0)))
+                volumes.append(float(c.get("volume", 0.0)))
+            except Exception:
+                continue
+        return {"closes": closes, "highs": highs, "lows": lows, "volumes": volumes}
+
+    def _indicator_condition_score(self, name: str, series: dict) -> tuple:
+        closes = series["closes"]
+        highs = series["highs"]
+        lows = series["lows"]
+        volumes = series["volumes"]
+        price = closes[-1] if closes else 0.0
+
+        if name == "rsi":
+            val = indicators.rsi(closes)
+            ok = val is not None and val < 30.0
+            return ok, 1.0 if ok else 0.0
+
+        if name == "macd":
+            macd_line, signal_line, _ = indicators.macd(closes)
+            if macd_line is None or signal_line is None or len(closes) < 2:
+                return False, 0.0
+            # detect bullish cross using last two MACD values
+            macd_series = indicators._ema_series(closes, 12)
+            slow_series = indicators._ema_series(closes, 26)
+            if not macd_series or not slow_series:
+                return False, 0.0
+            macd_vals = [f - s for f, s in zip(macd_series[-len(slow_series):], slow_series)]
+            signal_vals = indicators._ema_series(macd_vals, 9)
+            if len(macd_vals) < 2 or len(signal_vals) < 2:
+                return False, 0.0
+            prev_cross = macd_vals[-2] <= signal_vals[-2]
+            now_cross = macd_vals[-1] > signal_vals[-1]
+            ok = prev_cross and now_cross
+            return ok, 1.0 if ok else 0.0
+
+        if name == "stochastic":
+            k, d = indicators.stochastic(highs, lows, closes)
+            if k is None or d is None:
+                return False, 0.0
+            if len(closes) < 2:
+                return False, 0.0
+            # compute previous k/d using series without last close
+            k_prev, d_prev = indicators.stochastic(highs[:-1], lows[:-1], closes[:-1])
+            if k_prev is None or d_prev is None:
+                return False, 0.0
+            ok = (k < 20.0) and (k_prev <= d_prev) and (k > d)
+            return ok, 1.0 if ok else 0.0
+
+        if name == "momentum":
+            val = indicators.momentum(closes)
+            ok = val is not None and val > 0.0
+            return ok, 1.0 if ok else 0.0
+
+        if name == "obv":
+            if len(closes) < 2 or len(volumes) < 2:
+                return False, 0.0
+            obv_now = indicators.obv(closes, volumes)
+            obv_prev = indicators.obv(closes[:-1], volumes[:-1])
+            ok = obv_now is not None and obv_prev is not None and obv_now > obv_prev
+            return ok, 1.0 if ok else 0.0
+
+        if name == "bollinger":
+            upper, mid, lower = indicators.bollinger_bands(closes)
+            ok = lower is not None and price <= lower
+            return ok, 1.0 if ok else 0.0
+
+        if name == "ema":
+            ema_fast = indicators.ema(closes, 8)
+            ema_slow = indicators.ema(closes, 21)
+            if ema_slow is None:
+                return False, 0.0
+            ok = (ema_fast is not None and ema_fast > ema_slow) or (price > ema_slow)
+            return ok, 1.0 if ok else 0.0
+
+        if name == "atr":
+            val = indicators.atr(highs, lows, closes)
+            ok = val is not None
+            return True, 0.5 if ok else 0.0
+
+        if name == "volume_profile":
+            ratio = indicators.volume_profile(volumes)
+            ok = ratio is not None and ratio > 1.0
+            return ok, 1.0 if ok else 0.0
+
+        if name == "adx":
+            val = indicators.adx(highs, lows, closes)
+            ok = val is not None and val > 20.0
+            return ok, 1.0 if ok else 0.0
+
+        if name == "pivots":
+            piv = indicators.pivots(highs, lows, closes)
+            if not piv:
+                return False, 0.0
+            s1 = piv.get("s1", None)
+            if not s1:
+                return False, 0.0
+            ok = (price >= s1 * 0.99) and (price <= s1 * 1.01)
+            return ok, 1.0 if ok else 0.0
+
+        if name == "ichimoku":
+            ichi = indicators.ichimoku(highs, lows)
+            if not ichi:
+                return False, 0.0
+            cloud_top = max(ichi["senkou_a"], ichi["senkou_b"])
+            ok = (price > cloud_top) and (ichi["tenkan"] > ichi["kijun"])
+            return ok, 1.0 if ok else 0.0
+
+        return False, 0.0
+
+    def _strategy_should_enter(self, symbol: str, long_level: int, short_level: int, candles: list) -> tuple:
+        cfg = self._get_strategy_settings()
+        indicators_selected = [k for k, v in (cfg.get("indicators") or {}).items() if v]
+        neural_ok = (long_level >= 3) and (short_level == 0)
+        neural_score = (max(0.0, min(7.0, float(long_level))) / 7.0) if short_level == 0 else 0.0
+
+        if not indicators_selected and not cfg.get("replace_neural", False):
+            return neural_ok, neural_score
+        if not indicators_selected and cfg.get("replace_neural", False):
+            return False, 0.0
+
+        series = self._extract_series(candles)
+        if not series["closes"] or len(series["closes"]) < 30:
+            if cfg.get("replace_neural", False):
+                return False, 0.0
+            return neural_ok, neural_score
+
+        conditions = []
+        scores = []
+        for ind in indicators_selected:
+            ok, score = self._indicator_condition_score(ind, series)
+            conditions.append(ok)
+            scores.append(score)
+
+        mode = str(cfg.get("mode", "selector")).lower().strip()
+        replace_neural = bool(cfg.get("replace_neural", False))
+
+        if mode == "selector":
+            indicators_ok = all(conditions) if conditions else True
+            if replace_neural:
+                return indicators_ok, 1.0 if indicators_ok else 0.0
+            return (neural_ok and indicators_ok), neural_score
+
+        # super mode
+        if not replace_neural:
+            scores.append(neural_score)
+        if not scores:
+            return neural_ok, neural_score
+        score = sum(scores) / float(len(scores))
+        return (score >= float(self.strategy_super_threshold)), score
 
     @staticmethod
     def _read_long_price_levels(symbol: str) -> list:
@@ -609,20 +1016,122 @@ def _note_dca_buy(self, base_symbol: str, ts: Optional[float] = None) -> None:
         self._dca_window_count(base, now_ts=t)  # prune in-place
 
 
-    def _reset_dca_window_for_trade(self, base_symbol: str, sold: bool = False, ts: Optional[float] = None) -> None:
-        base = str(base_symbol).upper().strip()
-        if not base:
-            return
-        if sold:
-            self._dca_last_sell_ts[base] = float(ts if ts is not None else time.time())
-        self._dca_buy_ts[base] = []
-
-
-    def make_api_request(self, method: str, path: str, body: Optional[str] = "") -> Any:
-
-        timestamp = self._get_current_timestamp()
-        headers = self.get_authorization_header(method, path, body, timestamp)
-        url = self.base_url + path
+    def _reset_dca_window_for_trade(self, base_symbol: str, sold: bool = False, ts: Optional[float] = None) -> None:
+        base = str(base_symbol).upper().strip()
+        if not base:
+            return
+        if sold:
+            self._dca_last_sell_ts[base] = float(ts if ts is not None else time.time())
+        self._dca_buy_ts[base] = []
+
+    def _paper_test_tick(
+        self,
+        holdings_list: list,
+        buying_power: float,
+        current_buy_prices: Dict[str, float],
+        current_sell_prices: Dict[str, float],
+    ) -> bool:
+        traded = False
+        if not (self.paper_test_mode and self.exchange_provider == "binance"):
+            return False
+        if not isinstance(self.exchange, BinancePaperExchangeClient):
+            return False
+
+        target = self.paper_test_coin or (crypto_symbols[0] if crypto_symbols else "")
+        target = str(target).upper().strip()
+        if not target:
+            return False
+
+        full_symbol = f"{target}-USD"
+        price = float(current_buy_prices.get(full_symbol, 0.0) or 0.0)
+        if price <= 0.0:
+            return False
+
+        holding = None
+        for h in holdings_list:
+            if str(h.get("asset_code", "")).upper().strip() == target:
+                holding = h
+                break
+
+        state = self._paper_test_state.setdefault(
+            target, {"stage": "idle", "buy_ts": None, "dca_done": False}
+        )
+        now = time.time()
+
+        if not holding or float(holding.get("total_quantity", 0.0) or 0.0) <= 0.0:
+            if state.get("stage") != "buying":
+                alloc = min(float(buying_power or 0.0), float(self.paper_test_alloc_usd))
+                if alloc <= 0.0:
+                    return False
+                resp = self.place_buy_order(
+                    str(uuid.uuid4()),
+                    "buy",
+                    "market",
+                    full_symbol,
+                    alloc,
+                    tag="PAPER_TEST_ENTRY",
+                )
+                if resp and "errors" not in resp:
+                    state["stage"] = "holding"
+                    state["buy_ts"] = now
+                    state["dca_done"] = False
+                    traded = True
+            return traded
+
+        buy_ts = float(state.get("buy_ts") or now)
+        held_for = now - buy_ts
+
+        if (not state.get("dca_done")) and (held_for >= float(self.paper_test_dca_seconds)):
+            alloc = min(float(buying_power or 0.0), float(self.paper_test_alloc_usd) * 0.5)
+            if alloc > 0.0:
+                resp = self.place_buy_order(
+                    str(uuid.uuid4()),
+                    "buy",
+                    "market",
+                    full_symbol,
+                    alloc,
+                    tag="PAPER_TEST_DCA",
+                )
+                if resp and "errors" not in resp:
+                    state["dca_done"] = True
+                    traded = True
+
+        if held_for >= float(self.paper_test_hold_seconds):
+            qty = float(holding.get("total_quantity", 0.0) or 0.0)
+            sell_price = float(current_sell_prices.get(full_symbol, price) or price)
+            avg_cost_basis = None
+            try:
+                avg_cost_basis = float(self.cost_basis.get(target, 0.0))
+                if avg_cost_basis <= 0.0:
+                    avg_cost_basis = None
+            except Exception:
+                avg_cost_basis = None
+            if qty > 0.0:
+                resp = self.place_sell_order(
+                    str(uuid.uuid4()),
+                    "sell",
+                    "market",
+                    full_symbol,
+                    qty,
+                    expected_price=sell_price,
+                    avg_cost_basis=avg_cost_basis,
+                    tag="PAPER_TEST_EXIT",
+                )
+                if resp and "errors" not in resp:
+                    state["stage"] = "idle"
+                    state["buy_ts"] = None
+                    state["dca_done"] = False
+                    traded = True
+        return traded
+
+
+    def make_api_request(self, method: str, path: str, body: Optional[str] = "") -> Any:
+        if self.exchange_provider != "robinhood":
+            raise RuntimeError("Robinhood API request attempted while EXCHANGE_PROVIDER=binance.")
+
+        timestamp = self._get_current_timestamp()
+        headers = self.get_authorization_header(method, path, body, timestamp)
+        url = self.base_url + path
 
         try:
             if method == "GET":
@@ -642,29 +1151,115 @@ def make_api_request(self, method: str, path: str, body: Optional[str] = "") ->
         except Exception:
             return None
 
-    def get_authorization_header(
-            self, method: str, path: str, body: str, timestamp: int
-    ) -> Dict[str, str]:
-        message_to_sign = f"{self.api_key}{timestamp}{path}{method}{body}"
-        signed = self.private_key.sign(message_to_sign.encode("utf-8"))
-
-        return {
-            "x-api-key": self.api_key,
-            "x-signature": base64.b64encode(signed.signature).decode("utf-8"),
-            "x-timestamp": str(timestamp),
-        }
-
-    def get_account(self) -> Any:
-        path = "/api/v1/crypto/trading/accounts/"
-        return self.make_api_request("GET", path)
-
-    def get_holdings(self) -> Any:
-        path = "/api/v1/crypto/trading/holdings/"
-        return self.make_api_request("GET", path)
-
-    def get_trading_pairs(self) -> Any:
-        path = "/api/v1/crypto/trading/trading_pairs/"
-        response = self.make_api_request("GET", path)
+    def get_authorization_header(
+            self, method: str, path: str, body: str, timestamp: int
+    ) -> Dict[str, str]:
+        if self.exchange_provider != "robinhood":
+            raise RuntimeError("Robinhood authorization requested while EXCHANGE_PROVIDER=binance.")
+        message_to_sign = f"{self.api_key}{timestamp}{path}{method}{body}"
+        signed = self.private_key.sign(message_to_sign.encode("utf-8"))
+
+        return {
+            "x-api-key": self.api_key,
+            "x-signature": base64.b64encode(signed.signature).decode("utf-8"),
+            "x-timestamp": str(timestamp),
+        }
+
+    def _binance_account(self) -> Dict[str, Any]:
+        if not self.exchange:
+            return {}
+        try:
+            balances = self.exchange.get_balances()
+            quote = getattr(self.exchange, "default_quote", "USDT")
+            buying_power = float(balances.get(quote, {}).get("free", 0.0))
+            return {"buying_power": buying_power, "balances": balances}
+        except BinanceAPIError:
+            return {}
+
+    def _binance_holdings(self) -> Dict[str, Any]:
+        if not self.exchange:
+            return {"results": []}
+        try:
+            balances = self.exchange.get_balances()
+            quote = getattr(self.exchange, "default_quote", "USDT")
+            results = []
+            for asset, info in balances.items():
+                if asset == quote:
+                    continue
+                total = float(info.get("total", 0.0))
+                if total > 0.0:
+                    results.append({"asset_code": asset, "total_quantity": total})
+            return {"results": results}
+        except BinanceAPIError:
+            return {"results": []}
+
+    def _binance_orders(self, symbol: str) -> Dict[str, Any]:
+        if not self.exchange:
+            return {"results": []}
+        try:
+            orders = self.exchange.get_order_history(symbol, limit=1000)
+        except BinanceAPIError:
+            return {"results": []}
+
+        results = []
+        for order in orders or []:
+            side = str(order.get("side", "")).lower()
+            status = str(order.get("status", "")).upper()
+            if status in {"FILLED", "PARTIALLY_FILLED"}:
+                state = "filled"
+            elif status in {"CANCELED", "REJECTED", "EXPIRED"}:
+                state = "canceled"
+            else:
+                state = "open"
+
+            ts_ms = order.get("time", None)
+            created_at = ""
+            try:
+                created_at = datetime.datetime.utcfromtimestamp(int(ts_ms) / 1000).isoformat() + "Z"
+            except Exception:
+                created_at = ""
+
+            executions = []
+            try:
+                exec_qty = float(order.get("executedQty", 0.0))
+                exec_quote = float(order.get("cummulativeQuoteQty", 0.0))
+                if exec_qty > 0:
+                    executions.append(
+                        {
+                            "quantity": str(exec_qty),
+                            "effective_price": str(exec_quote / exec_qty),
+                        }
+                    )
+            except Exception:
+                pass
+
+            results.append(
+                {
+                    "side": side,
+                    "state": state,
+                    "created_at": created_at,
+                    "executions": executions,
+                }
+            )
+        return {"results": results}
+
+    def get_account(self) -> Any:
+        if self.exchange_provider == "binance":
+            return self._binance_account()
+        path = "/api/v1/crypto/trading/accounts/"
+        return self.make_api_request("GET", path)
+
+    def get_holdings(self) -> Any:
+        if self.exchange_provider == "binance":
+            return self._binance_holdings()
+        path = "/api/v1/crypto/trading/holdings/"
+        return self.make_api_request("GET", path)
+
+    def get_trading_pairs(self) -> Any:
+        if self.exchange_provider == "binance":
+            return [{"symbol": f"{sym}-{getattr(self.exchange, 'default_quote', 'USDT')}"} for sym in crypto_symbols]
+        path = "/api/v1/crypto/trading/trading_pairs/"
+        response = self.make_api_request("GET", path)
 
         if not response or "results" not in response:
             return []
@@ -675,9 +1270,11 @@ def get_trading_pairs(self) -> Any:
 
         return trading_pairs
 
-    def get_orders(self, symbol: str) -> Any:
-        path = f"/api/v1/crypto/trading/orders/?symbol={symbol}"
-        return self.make_api_request("GET", path)
+    def get_orders(self, symbol: str) -> Any:
+        if self.exchange_provider == "binance":
+            return self._binance_orders(symbol)
+        path = f"/api/v1/crypto/trading/orders/?symbol={symbol}"
+        return self.make_api_request("GET", path)
 
     def calculate_cost_basis(self):
         holdings = self.get_holdings()
@@ -733,14 +1330,47 @@ def calculate_cost_basis(self):
 
         return cost_basis
 
-    def get_price(self, symbols: list) -> Dict[str, float]:
-        buy_prices = {}
-        sell_prices = {}
-        valid_symbols = []
-
-        for symbol in symbols:
-            if symbol == "USDC-USD":
-                continue
+    def get_price(self, symbols: list) -> Dict[str, float]:
+        buy_prices = {}
+        sell_prices = {}
+        valid_symbols = []
+
+        if self.exchange_provider == "binance":
+            for symbol in symbols:
+                if symbol == "USDC-USD":
+                    continue
+                try:
+                    price = float(self.exchange.get_price(symbol))
+                    if price > 0.0:
+                        buy_prices[symbol] = price
+                        sell_prices[symbol] = price
+                        valid_symbols.append(symbol)
+                        try:
+                            self._last_good_bid_ask[symbol] = {"ask": price, "bid": price, "ts": time.time()}
+                        except Exception:
+                            pass
+                        continue
+                except Exception:
+                    pass
+
+                cached = None
+                try:
+                    cached = self._last_good_bid_ask.get(symbol)
+                except Exception:
+                    cached = None
+
+                if cached:
+                    ask = float(cached.get("ask", 0.0) or 0.0)
+                    bid = float(cached.get("bid", 0.0) or 0.0)
+                    if ask > 0.0 and bid > 0.0:
+                        buy_prices[symbol] = ask
+                        sell_prices[symbol] = bid
+                        valid_symbols.append(symbol)
+            return buy_prices, sell_prices, valid_symbols
+
+        for symbol in symbols:
+            if symbol == "USDC-USD":
+                continue
 
             path = f"/api/v1/crypto/marketdata/best_bid_ask/?symbol={symbol}"
             response = self.make_api_request("GET", path)
@@ -778,20 +1408,69 @@ def get_price(self, symbols: list) -> Dict[str, float]:
         return buy_prices, sell_prices, valid_symbols
 
 
-    def place_buy_order(
-        self,
-        client_order_id: str,
-        side: str,
-        order_type: str,
-        symbol: str,
-        amount_in_usd: float,
-        avg_cost_basis: Optional[float] = None,
-        pnl_pct: Optional[float] = None,
-        tag: Optional[str] = None,
-    ) -> Any:
-        # Fetch the current price of the asset
-        current_buy_prices, current_sell_prices, valid_symbols = self.get_price([symbol])
-        current_price = current_buy_prices[symbol]
+    def place_buy_order(
+        self,
+        client_order_id: str,
+        side: str,
+        order_type: str,
+        symbol: str,
+        amount_in_usd: float,
+        avg_cost_basis: Optional[float] = None,
+        pnl_pct: Optional[float] = None,
+        tag: Optional[str] = None,
+    ) -> Any:
+        if self.exchange_provider == "binance":
+            try:
+                current_buy_prices, _, _ = self.get_price([symbol])
+                current_price = float(current_buy_prices.get(symbol, 0.0) or 0.0)
+                if current_price <= 0.0 or not self.exchange:
+                    return None
+
+                asset_quantity = amount_in_usd / current_price
+                response = self.exchange.create_order(
+                    symbol=symbol,
+                    side="BUY",
+                    type=order_type.upper(),
+                    quantity=asset_quantity,
+                )
+                fill_price = float(current_price)
+                try:
+                    exec_qty = response.get("executedQty")
+                    if exec_qty is not None:
+                        asset_quantity = float(exec_qty)
+                except Exception:
+                    pass
+                try:
+                    resp_price = float(response.get("price", 0.0) or 0.0)
+                    if resp_price > 0.0:
+                        fill_price = resp_price
+                except Exception:
+                    pass
+                try:
+                    exec_qty = float(response.get("executedQty", 0.0) or 0.0)
+                    exec_quote = float(response.get("cummulativeQuoteQty", 0.0) or 0.0)
+                    if exec_qty > 0.0 and exec_quote > 0.0:
+                        fill_price = exec_quote / exec_qty
+                except Exception:
+                    pass
+                order_id = response.get("orderId") or response.get("clientOrderId")
+                self._record_trade(
+                    side="buy",
+                    symbol=symbol,
+                    qty=float(asset_quantity),
+                    price=float(fill_price),
+                    avg_cost_basis=float(avg_cost_basis) if avg_cost_basis is not None else None,
+                    pnl_pct=float(pnl_pct) if pnl_pct is not None else None,
+                    tag=tag,
+                    order_id=order_id,
+                )
+                return response
+            except Exception as e:
+                return {"errors": [{"detail": str(e)}]}
+
+        # Fetch the current price of the asset
+        current_buy_prices, current_sell_prices, valid_symbols = self.get_price([symbol])
+        current_price = current_buy_prices[symbol]
         asset_quantity = amount_in_usd / current_price
 
         max_retries = 5
@@ -854,21 +1533,66 @@ def place_buy_order(
         return None
 
 
-    def place_sell_order(
-        self,
-        client_order_id: str,
-        side: str,
-        order_type: str,
-        symbol: str,
-        asset_quantity: float,
-        expected_price: Optional[float] = None,
-        avg_cost_basis: Optional[float] = None,
-        pnl_pct: Optional[float] = None,
-        tag: Optional[str] = None,
-    ) -> Any:
-        body = {
-            "client_order_id": client_order_id,
-            "side": side,
+    def place_sell_order(
+        self,
+        client_order_id: str,
+        side: str,
+        order_type: str,
+        symbol: str,
+        asset_quantity: float,
+        expected_price: Optional[float] = None,
+        avg_cost_basis: Optional[float] = None,
+        pnl_pct: Optional[float] = None,
+        tag: Optional[str] = None,
+    ) -> Any:
+        if self.exchange_provider == "binance":
+            try:
+                if not self.exchange:
+                    return None
+                response = self.exchange.create_order(
+                    symbol=symbol,
+                    side="SELL",
+                    type=order_type.upper(),
+                    quantity=asset_quantity,
+                )
+                fill_price = float(expected_price) if expected_price is not None else None
+                try:
+                    exec_qty = response.get("executedQty")
+                    if exec_qty is not None:
+                        asset_quantity = float(exec_qty)
+                except Exception:
+                    pass
+                try:
+                    resp_price = float(response.get("price", 0.0) or 0.0)
+                    if resp_price > 0.0:
+                        fill_price = resp_price
+                except Exception:
+                    pass
+                try:
+                    exec_qty = float(response.get("executedQty", 0.0) or 0.0)
+                    exec_quote = float(response.get("cummulativeQuoteQty", 0.0) or 0.0)
+                    if exec_qty > 0.0 and exec_quote > 0.0:
+                        fill_price = exec_quote / exec_qty
+                except Exception:
+                    pass
+                order_id = response.get("orderId") or response.get("clientOrderId")
+                self._record_trade(
+                    side="sell",
+                    symbol=symbol,
+                    qty=float(asset_quantity),
+                    price=float(fill_price) if fill_price is not None else None,
+                    avg_cost_basis=float(avg_cost_basis) if avg_cost_basis is not None else None,
+                    pnl_pct=float(pnl_pct) if pnl_pct is not None else None,
+                    tag=tag,
+                    order_id=order_id,
+                )
+                return response
+            except Exception as e:
+                return {"errors": [{"detail": str(e)}]}
+
+        body = {
+            "client_order_id": client_order_id,
+            "side": side,
             "type": order_type,
             "symbol": symbol,
             "market_order_config": {
@@ -938,17 +1662,39 @@ def manage_trades(self):
             snapshot_ok = False
 
         # holdings list (treat missing/invalid holdings payload as transient error)
-        try:
-            holdings_list = holdings.get("results", None) if isinstance(holdings, dict) else None
-            if not isinstance(holdings_list, list):
-                holdings_list = []
-                snapshot_ok = False
-        except Exception:
-            holdings_list = []
-            snapshot_ok = False
-
-        holdings_buy_value = 0.0
-        holdings_sell_value = 0.0
+        try:
+            holdings_list = holdings.get("results", None) if isinstance(holdings, dict) else None
+            if not isinstance(holdings_list, list):
+                holdings_list = []
+                snapshot_ok = False
+        except Exception:
+            holdings_list = []
+            snapshot_ok = False
+
+        # Paper test mode can trigger simulated trades regardless of signals.
+        try:
+            paper_traded = self._paper_test_tick(
+                holdings_list,
+                buying_power,
+                current_buy_prices,
+                current_sell_prices,
+            )
+        except Exception:
+            paper_traded = False
+
+        if paper_traded:
+            trades_made = True
+            # Refresh account/holdings so UI reflects the simulated trade immediately.
+            try:
+                account = self.get_account()
+                holdings = self.get_holdings()
+                buying_power = float(account.get("buying_power", 0))
+                holdings_list = holdings.get("results", []) if isinstance(holdings, dict) else []
+            except Exception:
+                pass
+
+        holdings_buy_value = 0.0
+        holdings_sell_value = 0.0
 
         for holding in holdings_list:
             try:
@@ -1129,28 +1875,51 @@ def manage_trades(self):
             file = open(symbol+'_current_price.txt', 'w+')
             file.write(str(current_buy_price))
             file.close()
-            positions[symbol] = {
-                "quantity": quantity,
-                "avg_cost_basis": avg_cost_basis,
-                "current_buy_price": current_buy_price,
-                "current_sell_price": current_sell_price,
-                "gain_loss_pct_buy": gain_loss_percentage_buy,
-                "gain_loss_pct_sell": gain_loss_percentage_sell,
-                "value_usd": value,
-                "dca_triggered_stages": int(triggered_levels_count),
-                "next_dca_display": next_dca_display,
-                "dca_line_price": float(dca_line_price) if dca_line_price else 0.0,
-                "dca_line_source": dca_line_source,
-                "dca_line_pct": float(dca_line_pct) if dca_line_pct else 0.0,
-                "trail_active": True if (trail_status == "ON") else False,
-                "trail_line": float(trail_line_disp) if trail_line_disp else 0.0,
-                "trail_peak": float(trail_peak_disp) if trail_peak_disp else 0.0,
-                "dist_to_trail_pct": float(dist_to_trail_pct) if dist_to_trail_pct else 0.0,
-            }
-
-
-            print(
-                f"\nSymbol: {symbol}"
+            positions[symbol] = {
+                "quantity": quantity,
+                "avg_cost_basis": avg_cost_basis,
+                "current_buy_price": current_buy_price,
+                "current_sell_price": current_sell_price,
+                "gain_loss_pct_buy": gain_loss_percentage_buy,
+                "gain_loss_pct_sell": gain_loss_percentage_sell,
+                "value_usd": value,
+                "dca_triggered_stages": int(triggered_levels_count),
+                "next_dca_display": next_dca_display,
+                "dca_line_price": float(dca_line_price) if dca_line_price else 0.0,
+                "dca_line_source": dca_line_source,
+                "dca_line_pct": float(dca_line_pct) if dca_line_pct else 0.0,
+                "trail_active": True if (trail_status == "ON") else False,
+                "trail_line": float(trail_line_disp) if trail_line_disp else 0.0,
+                "trail_peak": float(trail_peak_disp) if trail_peak_disp else 0.0,
+                "dist_to_trail_pct": float(dist_to_trail_pct) if dist_to_trail_pct else 0.0,
+            }
+
+            pine_sig = self._get_pine_signal(symbol)
+            if self.pine_signal_use_exit and pine_sig:
+                action = str(pine_sig.get("action") or "").strip().lower()
+                if action in {"sell", "stop"} and quantity > 0:
+                    response = self.place_sell_order(
+                        str(uuid.uuid4()),
+                        "sell",
+                        "market",
+                        full_symbol,
+                        quantity,
+                        expected_price=current_sell_price,
+                        avg_cost_basis=avg_cost_basis,
+                        pnl_pct=gain_loss_percentage_sell,
+                        tag="PINE_STOP" if action == "stop" else "PINE_SELL",
+                    )
+                    trades_made = True
+                    self.trailing_pm.pop(symbol, None)
+                    self._reset_dca_window_for_trade(symbol, sold=True)
+                    print(f"  Pine signal {action} for {symbol}. Sell response: {response}")
+                    time.sleep(2)
+                    holdings = self.get_holdings()
+                    continue
+
+
+            print(
+                f"\nSymbol: {symbol}"
                 f"  |  DCA: {color}{dca_line_pct:+.2f}%{Style.RESET_ALL} @ {self._fmt_price(current_buy_price)} (Line: {dca_line_price_disp} {dca_line_source} | Next: {next_dca_display})"
                 f"  |  Gain/Loss SELL: {color2}{gain_loss_percentage_sell:.2f}%{Style.RESET_ALL} @ {self._fmt_price(current_sell_price)}"
                 f"  |  DCA Levels Triggered: {triggered_levels}"
@@ -1393,14 +2162,38 @@ def manage_trades(self):
                 start_index += 1
                 continue
 
-            # Neural signals are used as a "permission to start" gate.
-            buy_count = self._read_long_dca_signal(base_symbol)
-            sell_count = self._read_short_dca_signal(base_symbol)
-
-            # Default behavior: long must be >= 3 and short must be 0
-            if not (buy_count >= 3 and sell_count == 0):
-                start_index += 1
-                continue
+            # Neural signals are used as a "permission to start" gate.
+            buy_count = self._read_long_dca_signal(base_symbol)
+            sell_count = self._read_short_dca_signal(base_symbol)
+
+            pine_sig = self._get_pine_signal(base_symbol)
+            pine_action = ""
+            if pine_sig:
+                pine_action = str(pine_sig.get("action") or "").strip().lower()
+            if self.pine_signal_enabled and self.pine_signal_mode == "replace":
+                if pine_action != "buy":
+                    start_index += 1
+                    continue
+            elif self.pine_signal_enabled and self.pine_signal_mode == "filter":
+                if pine_action and pine_action != "buy":
+                    start_index += 1
+                    continue
+
+            strategy_cfg = self._get_strategy_settings()
+            indicators_selected = [k for k, v in (strategy_cfg.get("indicators") or {}).items() if v]
+            use_strategy = bool(indicators_selected or strategy_cfg.get("replace_neural") or strategy_cfg.get("mode") == "super")
+
+            if use_strategy:
+                candles = self._fetch_strategy_candles(base_symbol)
+                allowed, _ = self._strategy_should_enter(base_symbol, buy_count, sell_count, candles)
+                if not allowed:
+                    start_index += 1
+                    continue
+            else:
+                # Default behavior: long must be >= 3 and short must be 0
+                if not (buy_count >= 3 and sell_count == 0):
+                    start_index += 1
+                    continue
 
 
 
diff --git a/pt_trainer.py b/pt_trainer.py
index e02bd5b9d..2a801c6cf 100644
--- a/pt_trainer.py
+++ b/pt_trainer.py
@@ -209,7 +209,21 @@ def PrintException():
 	linecache.checkcache(filename)
 	line = linecache.getline(filename, lineno, f.f_globals)
 	print ('EXCEPTION IN (LINE {} "{}"): {}'.format(lineno, line.strip(), exc_obj))
-how_far_to_look_back = 100000
+def _env_int(name: str, default: int) -> int:
+	try:
+		return int(os.environ.get(name, default))
+	except Exception:
+		return default
+
+def _env_flag(name: str, default: bool = False) -> bool:
+	raw = os.environ.get(name, None)
+	if raw is None:
+		return default
+	return str(raw).strip().lower() in {"1", "true", "yes", "y", "on"}
+
+how_far_to_look_back = _env_int("TRAIN_LOOKBACK", 100000)
+if _env_flag("TRAIN_FAST", False) and "TRAIN_LOOKBACK" not in os.environ:
+	how_far_to_look_back = 20000
 number_of_candles = [2]
 number_of_candles_index = 0
 def restart_program():
@@ -843,18 +857,28 @@ def PrintException():
 					memory_diffs = []
 					if 1 == 1:
 						try:
-							file = open('memories_'+tf_choice+'.txt','r')
-							memory_list = file.read().replace("'","").replace(',','').replace('"','').replace(']','').replace('[','').split('~')
-							file.close()
-							file = open('memory_weights_'+tf_choice+'.txt','r')
-							weight_list = file.read().replace("'","").replace(',','').replace('"','').replace(']','').replace('[','').split(' ')
-							file.close()							
-							file = open('memory_weights_high_'+tf_choice+'.txt','r')
-							high_weight_list = file.read().replace("'","").replace(',','').replace('"','').replace(']','').replace('[','').split(' ')
-							file.close()
-							file = open('memory_weights_low_'+tf_choice+'.txt','r')
-							low_weight_list = file.read().replace("'","").replace(',','').replace('"','').replace(']','').replace('[','').split(' ')
-							file.close()
+							mem_data = load_memory(tf_choice)
+							memory_list = list(mem_data.get('memory_list', []))
+							weight_list = list(mem_data.get('weight_list', []))
+							high_weight_list = list(mem_data.get('high_weight_list', []))
+							low_weight_list = list(mem_data.get('low_weight_list', []))
+							memory_list = [m for m in memory_list if str(m).strip() != '']
+							mem_len = len(memory_list)
+							if not mem_len:
+								pattern_len = len(current_pattern) if 'current_pattern' in locals() else 0
+								zero_pattern = ' '.join(['0'] * pattern_len) if pattern_len else '0'
+								memory_list = [f"{zero_pattern}{{}}0{{}}0"]
+								weight_list = ['1.0']
+								high_weight_list = ['1.0']
+								low_weight_list = ['1.0']
+								mem_len = 1
+							if mem_len:
+								if len(weight_list) < mem_len:
+									weight_list += ['1.0'] * (mem_len - len(weight_list))
+								if len(high_weight_list) < mem_len:
+									high_weight_list += ['1.0'] * (mem_len - len(high_weight_list))
+								if len(low_weight_list) < mem_len:
+									low_weight_list += ['1.0'] * (mem_len - len(low_weight_list))
 							mem_ind = 0
 							diffs_list = []
 							any_perfect = 'no'
@@ -1474,94 +1498,102 @@ def PrintException():
 												except:
 													difference = 100.0
 												try:
-													direction = 'down'
-													try:
-														indy = 0
-														while True:
-															new_memory = 'no'
-															var3 = (moves[indy]*100)
-															high_var3 = (high_moves[indy]*100)
-															low_var3 = (low_moves[indy]*100)
-															if high_perc_diff_now_actual > high_var3+(high_var3*0.1):
-																high_new_weight = high_move_weights[indy] + 0.25
-																if high_new_weight > 2.0:
-																	high_new_weight = 2.0
+														direction = 'down'
+														try:
+															indy = 0
+															while True:
+																new_memory = 'no'
+																if (
+																	indy >= len(moves)
+																	or indy >= len(high_moves)
+																	or indy >= len(low_moves)
+																	or indy >= len(high_move_weights)
+																	or indy >= len(low_move_weights)
+																):
+																	break
+																var3 = (moves[indy]*100)
+																high_var3 = (high_moves[indy]*100)
+																low_var3 = (low_moves[indy]*100)
+																if high_perc_diff_now_actual > high_var3+(high_var3*0.1):
+																	high_new_weight = high_move_weights[indy] + 0.25
+																	if high_new_weight > 2.0:
+																		high_new_weight = 2.0
+																	else:
+																		pass
+																elif high_perc_diff_now_actual < high_var3-(high_var3*0.1):
+																	high_new_weight = high_move_weights[indy] - 0.25
+																	if high_new_weight < 0.0:
+																		high_new_weight = 0.0
+																	else:
+																		pass
 																else:
-																	pass
-															elif high_perc_diff_now_actual < high_var3-(high_var3*0.1):
-																high_new_weight = high_move_weights[indy] - 0.25
-																if high_new_weight < 0.0:
-																	high_new_weight = 0.0
+																	high_new_weight = high_move_weights[indy]
+																if low_perc_diff_now_actual < low_var3-(low_var3*0.1):
+																	low_new_weight = low_move_weights[indy] + 0.25
+																	if low_new_weight > 2.0:
+																		low_new_weight = 2.0
+																	else:
+																		pass
+																elif low_perc_diff_now_actual > low_var3+(low_var3*0.1):
+																	low_new_weight = low_move_weights[indy] - 0.25
+																	if low_new_weight < 0.0:
+																		low_new_weight = 0.0
+																	else:
+																		pass
 																else:
-																	pass
-															else:
-																high_new_weight = high_move_weights[indy]
-															if low_perc_diff_now_actual < low_var3-(low_var3*0.1):
-																low_new_weight = low_move_weights[indy] + 0.25
-																if low_new_weight > 2.0:
-																	low_new_weight = 2.0
+																	low_new_weight = low_move_weights[indy]
+																if perc_diff_now_actual > var3+(var3*0.1):
+																	new_weight = move_weights[indy] + 0.25
+																	if new_weight > 2.0:
+																		new_weight = 2.0
+																	else:
+																		pass
+																elif perc_diff_now_actual < var3-(var3*0.1):
+																	new_weight = move_weights[indy] - 0.25
+																	if new_weight < (0.0-2.0):
+																		new_weight = (0.0-2.0)
+																	else:
+																		pass
 																else:
-																	pass
-															elif low_perc_diff_now_actual > low_var3+(low_var3*0.1):
-																low_new_weight = low_move_weights[indy] - 0.25
-																if low_new_weight < 0.0:
-																	low_new_weight = 0.0
-																else:
-																	pass
-															else:
-																low_new_weight = low_move_weights[indy]
-															if perc_diff_now_actual > var3+(var3*0.1):
-																new_weight = move_weights[indy] + 0.25
-																if new_weight > 2.0:
-																	new_weight = 2.0
-																else:
-																	pass
-															elif perc_diff_now_actual < var3-(var3*0.1):
-																new_weight = move_weights[indy] - 0.25
-																if new_weight < (0.0-2.0):
-																	new_weight = (0.0-2.0)
+																	new_weight = move_weights[indy]
+																del weight_list[perfect_dexs[indy]]
+																weight_list.insert(perfect_dexs[indy],new_weight)
+																del high_weight_list[perfect_dexs[indy]]
+																high_weight_list.insert(perfect_dexs[indy],high_new_weight)
+																del low_weight_list[perfect_dexs[indy]]
+																low_weight_list.insert(perfect_dexs[indy],low_new_weight)
+
+																# mark dirty (we will flush in batches)
+																_mem = load_memory(tf_choice)
+																_mem["dirty"] = True
+
+																# occasional batch flush
+																if loop_i % 200 == 0:
+																	flush_memory(tf_choice)
+
+																indy += 1
+																if indy >= len(unweighted):
+																	break
 																else:
 																	pass
-															else:
-																new_weight = move_weights[indy]
-															del weight_list[perfect_dexs[indy]]
-															weight_list.insert(perfect_dexs[indy],new_weight)
-															del high_weight_list[perfect_dexs[indy]]
-															high_weight_list.insert(perfect_dexs[indy],high_new_weight)
-															del low_weight_list[perfect_dexs[indy]]
-															low_weight_list.insert(perfect_dexs[indy],low_new_weight)
+														except:
+															PrintException()
+															all_current_patterns[highlowind].append(this_diff)
+
+															# build the same memory entry format, but store in RAM
+															mem_entry = str(all_current_patterns[highlowind]).replace("'","").replace(',','').replace('"','').replace(']','').replace('[','')+'{}'+str(high_this_diff)+'{}'+str(low_this_diff)
 
-															# mark dirty (we will flush in batches)
 															_mem = load_memory(tf_choice)
+															_mem["memory_list"].append(mem_entry)
+															_mem["weight_list"].append('1.0')
+															_mem["high_weight_list"].append('1.0')
+															_mem["low_weight_list"].append('1.0')
 															_mem["dirty"] = True
 
 															# occasional batch flush
 															if loop_i % 200 == 0:
 																flush_memory(tf_choice)
 
-															indy += 1
-															if indy >= len(unweighted):
-																break
-															else:
-																pass
-													except:
-														PrintException()
-														all_current_patterns[highlowind].append(this_diff)
-
-														# build the same memory entry format, but store in RAM
-														mem_entry = str(all_current_patterns[highlowind]).replace("'","").replace(',','').replace('"','').replace(']','').replace('[','')+'{}'+str(high_this_diff)+'{}'+str(low_this_diff)
-
-														_mem = load_memory(tf_choice)
-														_mem["memory_list"].append(mem_entry)
-														_mem["weight_list"].append('1.0')
-														_mem["high_weight_list"].append('1.0')
-														_mem["low_weight_list"].append('1.0')
-														_mem["dirty"] = True
-
-														# occasional batch flush
-														if loop_i % 200 == 0:
-															flush_memory(tf_choice)
-
 												except:
 													PrintException()
 													pass										
diff --git a/requirements.txt b/requirements.txt
index 6c718916f..52c7b058d 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -5,3 +5,5 @@ colorama
 cryptography
 PyNaCl
 kucoin-python
+pytest
+responses
diff --git a/tests/__pycache__/test_binance_client.cpython-313-pytest-9.0.2.pyc b/tests/__pycache__/test_binance_client.cpython-313-pytest-9.0.2.pyc
new file mode 100644
index 000000000..dd8c4a95f
Binary files /dev/null and b/tests/__pycache__/test_binance_client.cpython-313-pytest-9.0.2.pyc differ
diff --git a/tests/__pycache__/test_indicators.cpython-313-pytest-9.0.2.pyc b/tests/__pycache__/test_indicators.cpython-313-pytest-9.0.2.pyc
new file mode 100644
index 000000000..e49dc001d
Binary files /dev/null and b/tests/__pycache__/test_indicators.cpython-313-pytest-9.0.2.pyc differ
diff --git a/tests/__pycache__/test_strategy_integration.cpython-313-pytest-9.0.2.pyc b/tests/__pycache__/test_strategy_integration.cpython-313-pytest-9.0.2.pyc
new file mode 100644
index 000000000..e79992447
Binary files /dev/null and b/tests/__pycache__/test_strategy_integration.cpython-313-pytest-9.0.2.pyc differ
diff --git a/tests/test_binance_client.py b/tests/test_binance_client.py
new file mode 100644
index 000000000..2f2178fc8
--- /dev/null
+++ b/tests/test_binance_client.py
@@ -0,0 +1,169 @@
+import hashlib
+import hmac
+import json
+import time
+from urllib.parse import parse_qs, urlencode, urlparse
+
+import responses
+
+from exchanges.binance_client import BinanceExchangeClient
+
+
+BASE_URL = "https://api.binance.com"
+
+
+@responses.activate
+def test_get_price_public():
+    client = BinanceExchangeClient(
+        api_key="key",
+        api_secret="secret",
+        base_url=BASE_URL,
+    )
+    responses.add(
+        responses.GET,
+        f"{BASE_URL}/api/v3/ticker/price?symbol=BTCUSDT",
+        json={"symbol": "BTCUSDT", "price": "50000.00"},
+        status=200,
+    )
+    price = client.get_price("BTC")
+    assert price == 50000.0
+
+
+@responses.activate
+def test_get_klines():
+    client = BinanceExchangeClient(
+        api_key="key",
+        api_secret="secret",
+        base_url=BASE_URL,
+    )
+    responses.add(
+        responses.GET,
+        f"{BASE_URL}/api/v3/klines?symbol=BTCUSDT&interval=1m&limit=2",
+        json=[
+            [1700000000000, "1.0", "2.0", "0.5", "1.5", "100", 0, 0, 0, 0, 0, 0],
+            [1700000060000, "1.5", "2.5", "1.0", "2.0", "120", 0, 0, 0, 0, 0, 0],
+        ],
+        status=200,
+    )
+    candles = client.get_klines("BTC", "1m", 2)
+    assert candles == [
+        {"ts": 1700000000, "open": 1.0, "high": 2.0, "low": 0.5, "close": 1.5, "volume": 100.0},
+        {"ts": 1700000060, "open": 1.5, "high": 2.5, "low": 1.0, "close": 2.0, "volume": 120.0},
+    ]
+
+
+@responses.activate
+def test_signed_request_signature_and_headers():
+    client = BinanceExchangeClient(
+        api_key="key",
+        api_secret="secret",
+        base_url=BASE_URL,
+        recv_window=5000,
+    )
+    client._timestamp_ms = lambda: 1700000000000
+    client._last_time_sync = time.time()
+
+    def account_callback(request):
+        parsed = urlparse(request.url)
+        qs = {k: v[0] for k, v in parse_qs(parsed.query).items()}
+        signature = qs.pop("signature")
+        expected_query = urlencode(sorted(qs.items()), doseq=True)
+        expected_sig = hmac.new(
+            b"secret",
+            expected_query.encode("utf-8"),
+            hashlib.sha256,
+        ).hexdigest()
+        assert signature == expected_sig
+        assert request.headers.get("X-MBX-APIKEY") == "key"
+        assert qs["recvWindow"] == "5000"
+        assert qs["timestamp"] == "1700000000000"
+
+        body = {"balances": [{"asset": "USDT", "free": "12.3", "locked": "0"}]}
+        return (200, {}, json.dumps(body))
+
+    responses.add_callback(
+        responses.GET,
+        f"{BASE_URL}/api/v3/account",
+        callback=account_callback,
+        content_type="application/json",
+    )
+
+    balances = client.get_balances()
+    assert balances["USDT"]["total"] == 12.3
+
+
+@responses.activate
+def test_create_order_market_and_limit():
+    client = BinanceExchangeClient(
+        api_key="key",
+        api_secret="secret",
+        base_url=BASE_URL,
+    )
+    client._timestamp_ms = lambda: 1700000000000
+    client._last_time_sync = time.time()
+
+    exchange_info = {
+        "symbols": [
+            {
+                "symbol": "BTCUSDT",
+                "filters": [
+                    {"filterType": "PRICE_FILTER", "tickSize": "0.1", "minPrice": "0.1"},
+                    {"filterType": "LOT_SIZE", "stepSize": "0.0001", "minQty": "0.0001"},
+                    {"filterType": "MIN_NOTIONAL", "minNotional": "10"},
+                ],
+            }
+        ]
+    }
+
+    responses.add(
+        responses.GET,
+        f"{BASE_URL}/api/v3/exchangeInfo?symbol=BTCUSDT",
+        json=exchange_info,
+        status=200,
+    )
+    responses.add(
+        responses.GET,
+        f"{BASE_URL}/api/v3/ticker/price?symbol=BTCUSDT",
+        json={"symbol": "BTCUSDT", "price": "50000.0"},
+        status=200,
+    )
+
+    order_queries = []
+
+    def order_callback(request):
+        parsed = urlparse(request.url)
+        qs = {k: v[0] for k, v in parse_qs(parsed.query).items()}
+        order_queries.append(qs)
+        body = {"orderId": 123, "symbol": qs.get("symbol", "")}
+        return (200, {}, json.dumps(body))
+
+    responses.add_callback(
+        responses.POST,
+        f"{BASE_URL}/api/v3/order",
+        callback=order_callback,
+        content_type="application/json",
+    )
+    responses.add_callback(
+        responses.POST,
+        f"{BASE_URL}/api/v3/order",
+        callback=order_callback,
+        content_type="application/json",
+    )
+
+    market_order = client.create_order("BTC", side="BUY", type="MARKET", quantity=0.001)
+    limit_order = client.create_order("BTC", side="SELL", type="LIMIT", quantity=0.00123, price=12345.67)
+
+    assert market_order["orderId"] == 123
+    assert limit_order["orderId"] == 123
+    assert order_queries[0]["type"] == "MARKET"
+    assert order_queries[0]["side"] == "BUY"
+    assert order_queries[0]["symbol"] == "BTCUSDT"
+    assert order_queries[0]["quantity"] == "0.001"
+    assert "signature" in order_queries[0]
+
+    assert order_queries[1]["type"] == "LIMIT"
+    assert order_queries[1]["side"] == "SELL"
+    assert order_queries[1]["symbol"] == "BTCUSDT"
+    assert order_queries[1]["quantity"] == "0.0012"
+    assert order_queries[1]["price"] == "12345.6"
+    assert order_queries[1]["timeInForce"] == "GTC"
diff --git a/tests/test_indicators.py b/tests/test_indicators.py
new file mode 100644
index 000000000..0aeb7aa4b
--- /dev/null
+++ b/tests/test_indicators.py
@@ -0,0 +1,49 @@
+import math
+
+import indicators
+
+
+def test_sma():
+    values = [1, 2, 3, 4, 5]
+    assert indicators.sma(values, 5) == 3.0
+
+
+def test_ema():
+    values = [1, 2, 3, 4, 5]
+    ema_val = indicators.ema(values, 3)
+    assert ema_val is not None
+    assert math.isclose(ema_val, 4.0, rel_tol=1e-6)
+
+
+def test_rsi():
+    up = list(range(1, 20))
+    down = list(range(20, 1, -1))
+    assert indicators.rsi(up, period=14) > 70
+    assert indicators.rsi(down, period=14) < 30
+
+
+def test_macd():
+    values = list(range(1, 60))
+    macd_line, signal_line, hist = indicators.macd(values)
+    assert macd_line is not None
+    assert signal_line is not None
+    assert hist is not None
+
+
+def test_stochastic():
+    closes = list(range(1, 21))
+    highs = [c + 1 for c in closes]
+    lows = [c - 1 for c in closes]
+    k, d = indicators.stochastic(highs, lows, closes)
+    assert k is not None
+    assert k > 80
+    assert d is not None
+
+
+def test_atr():
+    highs = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]
+    lows = [9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23]
+    closes = [9.5, 10.5, 11.5, 12.5, 13.5, 14.5, 15.5, 16.5, 17.5, 18.5, 19.5, 20.5, 21.5, 22.5, 23.5]
+    atr_val = indicators.atr(highs, lows, closes, period=14)
+    assert atr_val is not None
+    assert atr_val > 0
diff --git a/tests/test_strategy_integration.py b/tests/test_strategy_integration.py
new file mode 100644
index 000000000..ccdf3a933
--- /dev/null
+++ b/tests/test_strategy_integration.py
@@ -0,0 +1,108 @@
+import importlib
+import json
+from pathlib import Path
+
+
+def _make_candles(descending: bool = True, count: int = 60):
+    candles = []
+    base = 100.0
+    for i in range(count):
+        price = base - i if descending else base + i
+        candles.append(
+            {
+                "open": price,
+                "high": price + 1.0,
+                "low": price - 1.0,
+                "close": price,
+                "volume": 100.0 + i,
+            }
+        )
+    return candles
+
+
+def _write_gui_settings(tmp_path: Path, strategy: dict) -> None:
+    data = {
+        "main_neural_dir": str(tmp_path),
+        "coins": ["BNB"],
+        "default_timeframe": "1hour",
+        "candles_limit": 120,
+        "strategy": strategy,
+    }
+    (tmp_path / "gui_settings.json").write_text(json.dumps(data), encoding="utf-8")
+
+
+def test_selector_mode_with_neural(tmp_path, monkeypatch):
+    strategy = {
+        "mode": "selector",
+        "indicators": {
+            "rsi": True,
+        },
+        "check_all": False,
+        "replace_neural": False,
+    }
+    _write_gui_settings(tmp_path, strategy)
+    monkeypatch.setenv("POWERTRADER_GUI_SETTINGS", str(tmp_path / "gui_settings.json"))
+    monkeypatch.setenv("EXCHANGE_PROVIDER", "binance")
+    monkeypatch.setenv("BINANCE_PAPER", "true")
+
+    import pt_trader
+    importlib.reload(pt_trader)
+    trader = pt_trader.CryptoAPITrading()
+    candles = _make_candles(descending=True)
+    allowed, _ = trader._strategy_should_enter("BNB", long_level=3, short_level=0, candles=candles)
+    assert allowed is True
+
+    allowed, _ = trader._strategy_should_enter("BNB", long_level=3, short_level=1, candles=candles)
+    assert allowed is False
+
+
+def test_selector_replace_neural(tmp_path, monkeypatch):
+    strategy = {
+        "mode": "selector",
+        "indicators": {
+            "rsi": True,
+        },
+        "check_all": False,
+        "replace_neural": True,
+    }
+    _write_gui_settings(tmp_path, strategy)
+    monkeypatch.setenv("POWERTRADER_GUI_SETTINGS", str(tmp_path / "gui_settings.json"))
+    monkeypatch.setenv("EXCHANGE_PROVIDER", "binance")
+    monkeypatch.setenv("BINANCE_PAPER", "true")
+
+    import pt_trader
+    importlib.reload(pt_trader)
+    trader = pt_trader.CryptoAPITrading()
+    candles = _make_candles(descending=True)
+    allowed, _ = trader._strategy_should_enter("BNB", long_level=0, short_level=1, candles=candles)
+    assert allowed is True
+
+
+def test_super_mode_score(monkeypatch, tmp_path):
+    strategy = {
+        "mode": "super",
+        "indicators": {
+            "rsi": True,
+            "momentum": True,
+        },
+        "check_all": False,
+        "replace_neural": False,
+    }
+    _write_gui_settings(tmp_path, strategy)
+    monkeypatch.setenv("POWERTRADER_GUI_SETTINGS", str(tmp_path / "gui_settings.json"))
+    monkeypatch.setenv("EXCHANGE_PROVIDER", "binance")
+    monkeypatch.setenv("BINANCE_PAPER", "true")
+
+    import pt_trader
+    importlib.reload(pt_trader)
+    trader = pt_trader.CryptoAPITrading()
+    candles = _make_candles(descending=True)
+    allowed, score = trader._strategy_should_enter("BNB", long_level=7, short_level=0, candles=candles)
+    assert allowed is True
+    assert score >= 0.6
+
+    strategy["replace_neural"] = True
+    _write_gui_settings(tmp_path, strategy)
+    allowed, score = trader._strategy_should_enter("BNB", long_level=7, short_level=0, candles=candles)
+    assert allowed is False
+    assert score < 0.6