Fix live trade P/L bugs, improve UI refresh, add balance toggle

Key fixes:
- Add price validation to detect/correct doubled filled_price from broker
- Emit position_closed socket event to refresh UI after closing positions
- Fix statistics not updating when positions are closed
- Filter out zero-size positions from display
- Add USD/USDT toggle for balance display (click to switch)

Trade system improvements:
- Refactor Trade class P/L calculation with realized/unrealized tracking
- Add settle() method for proper position closing
- Improve trade_filled() to use current filled qty for averaging
- Add fallback to exchange balances when broker balance unavailable

Paper broker enhancements:
- Add exchange-qualified price storage for multi-exchange support
- Add price_source tracking for positions
- Improve state persistence

Tests:
- Add comprehensive tests for trade P/L calculations
- Add tests for paper broker price source tracking

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

src/BrighterTrades.py

@@ -1690,12 +1690,14 @@ class BrighterTrades:
             if trade.status in ['pending', 'open', 'unfilled']:
                 # Cancel the unfilled order
                 result = self.trades.cancel_order(str(trade_id))
-                reply_type = "order_cancelled" if result.get('success') else "trade_error"
             else:
                 # Close the position for this trade's symbol
                 broker_key = 'paper' if trade.broker_kind == 'paper' else f"{trade.broker_exchange}_{trade.broker_mode}"
                 result = self.trades.close_position(trade.creator, trade.symbol, broker_key)
-                reply_type = "position_closed" if result.get('success') else "trade_error"
+
+            # Always include trade_id and use consistent event name for frontend
+            result['trade_id'] = str(trade_id)
+            reply_type = "trade_closed" if result.get('success') else "trade_error"
 
             return standard_reply(reply_type, result)
 

src/Exchange.py

@@ -85,7 +85,13 @@ class Exchange:
                 client.set_sandbox_mode(True)
                 logger.info(f"Sandbox mode enabled for {self.exchange_id}")
             except Exception as e:
-                logger.warning(f"Could not enable sandbox mode for {self.exchange_id}: {e}")
+                # CRITICAL: Do NOT continue with production if testnet was requested
+                # This prevents users from accidentally trading real money
+                logger.error(f"TESTNET UNAVAILABLE: {self.exchange_id} does not support sandbox mode: {e}")
+                raise ValueError(
+                    f"Testnet/sandbox mode is not available for {self.exchange_id}. "
+                    f"Please use paper trading mode instead, or trade on production with caution."
+                )
 
         return client
 

src/ExchangeInterface.py

@@ -126,6 +126,9 @@ class ExchangeInterface:
                 pass  # No existing entry, that's fine
 
             # Create new exchange with explicit testnet setting
+            if not exchange_name:
+                logger.error("Cannot create exchange: exchange_name is required")
+                return False
             logger.info(f"Creating {exchange_name} for {user_name} with testnet={testnet}")
             exchange = Exchange(name=exchange_name, api_keys=api_keys, exchange_id=exchange_name.lower(),
                                testnet=testnet)

src/app.py

@@ -186,30 +186,35 @@ def strategy_execution_loop():
             # This is the only place where brokers are polled for order fills
             if brighter_trades.manual_broker_manager:
                 try:
-                    # Collect prices for broker updates
+                    # Collect prices for broker updates from positions/orders (not Trade.exchange)
-                    # Paper trades use symbol-only keys (single synthetic market)
-                    # Live trades use exchange:symbol keys
                     broker_price_updates = {}
-                    for trade in brighter_trades.trades.active_trades.values():
-                        if trade.broker_order_id:  # Only broker-managed trades
-                            try:
-                                is_paper = trade.broker_kind == 'paper'
-                                exchange = getattr(trade, 'exchange', None) or trade.target
 
-                                if is_paper:
+                    # Get required price feeds from paper broker positions/orders
-                                    # Paper trades: single synthetic market, use first available exchange
+                    paper_user_ids = brighter_trades.manual_broker_manager.get_active_paper_user_ids()
-                                    price = brighter_trades.exchanges.get_price(trade.symbol)
+                    for user_id in paper_user_ids:
-                                    if price:
+                        feeds = brighter_trades.manual_broker_manager.get_required_price_feeds(user_id)
-                                        # Paper uses symbol-only key
+                        for exchange, symbol in feeds:
-                                        broker_price_updates[trade.symbol] = price
+                            if exchange:
-                                else:
+                                # Exchange-qualified: fetch from specific exchange
-                                    # Live trades: use specific exchange
+                                price = brighter_trades.exchanges.get_price(symbol, exchange)
+                                if price and price > 0:
+                                    broker_price_updates[f"{exchange.lower()}:{symbol}"] = price
+                            else:
+                                # No exchange: use default price source
+                                price = brighter_trades.exchanges.get_price(symbol)
+                                if price and price > 0:
+                                    broker_price_updates[symbol] = price
+
+                    # Also collect for live trades (unchanged logic)
+                    for trade in brighter_trades.trades.active_trades.values():
+                        if trade.broker_order_id and trade.broker_kind == 'live':
+                            try:
+                                exchange = getattr(trade, 'exchange', None) or trade.target
+                                if exchange:
                                     price = brighter_trades.exchanges.get_price(trade.symbol, exchange)
-                                    if price:
+                                    if price and price > 0:
-                                        # Live uses exchange:symbol key
                                         price_key = f"{exchange.lower()}:{trade.symbol}"
                                         broker_price_updates[price_key] = price
-                                        # Also add symbol-only as fallback
                                         broker_price_updates[trade.symbol] = price
                             except Exception:
                                 pass
@@ -221,34 +226,26 @@ def strategy_execution_loop():
                         event_type = event.get('type', 'fill')
 
                         if event_type == 'sltp_triggered':
-                            # SL/TP triggered - find and settle related trades
+                            # SL/TP triggered - reconcile matching paper trades only.
                             symbol = event.get('symbol')
                             trigger_price = event.get('trigger_price', 0)
                             user_id = event.get('user_id')
-
+                            trade_ids = []
-                            # Find ALL matching paper trades for this symbol and settle them
+                            if user_id and trigger_price:
-                            trades_to_settle = []
+                                trade_ids = brighter_trades.trades.settle_broker_closed_position(
-                            for trade in list(brighter_trades.trades.active_trades.values()):
+                                    user_id=user_id,
-                                if trade.symbol == symbol and (trade.is_paper or trade.broker_kind == 'paper'):
+                                    symbol=symbol,
-                                    trades_to_settle.append(trade)
+                                    broker_key='paper',
-                                    user_id = user_id or trade.creator
+                                    close_price=trigger_price
-
+                                )
-                            # Settle each matching trade
+                                _loop_debug.debug(
-                            for trade in trades_to_settle:
+                                    f"Reconciled SL/TP close for user={user_id} symbol={symbol}: {trade_ids}"
-                                # Settle the trade at the trigger price
+                                )
-                                trade.settle(qty=trade.stats.get('qty_filled', trade.base_order_qty), price=trigger_price)
-                                # Move from active to settled
-                                if trade.unique_id in brighter_trades.trades.active_trades:
-                                    del brighter_trades.trades.active_trades[trade.unique_id]
-                                brighter_trades.trades.settled_trades[trade.unique_id] = trade
-                                brighter_trades.trades._save_trade(trade)
-                                _loop_debug.debug(f"Settled trade {trade.unique_id} via SL/TP at {trigger_price}")
 
                             # Notify user
                             if user_id:
                                 user_name = brighter_trades.users.get_username(user_id=user_id)
                                 if user_name:
-                                    trade_ids = [t.unique_id for t in trades_to_settle]
                                     socketio.emit('message', {
                                         'reply': 'sltp_triggered',
                                         'data': sanitize_for_json({
@@ -295,6 +292,52 @@ def strategy_execution_loop():
                                         })
                                     }, room=user_name)
                                     _loop_debug.debug(f"Emitted order_filled to room={user_name}")
+                        else:
+                            user_id = event.get('user_id')
+                            broker_key = event.get('broker_key')
+                            symbol = event.get('symbol')
+                            side = str(event.get('side') or '').lower()
+                            filled_price = event.get('filled_price', event.get('price', 0))
+
+                            if user_id:
+                                user_name = brighter_trades.users.get_username(user_id=user_id)
+
+                                # Always emit order_filled so broker-backed panels refresh even when
+                                # the fill belongs to a close order that has no local opening trade ID.
+                                if user_name:
+                                    socketio.emit('message', {
+                                        'reply': 'order_filled',
+                                        'data': sanitize_for_json({
+                                            'order_id': event.get('order_id'),
+                                            'trade_id': None,
+                                            'symbol': symbol,
+                                            'side': event.get('side'),
+                                            'filled_qty': event.get('filled_qty', event.get('size', 0)),
+                                            'filled_price': filled_price,
+                                            'status': 'filled',
+                                            'broker_kind': event.get('broker_kind'),
+                                            'broker_key': broker_key
+                                        })
+                                    }, room=user_name)
+
+                                # A live sell fill without a matching opening trade is typically a
+                                # broker-initiated close order from the position-close flow.
+                                if side == 'sell' and broker_key and symbol and filled_price:
+                                    settled_ids = brighter_trades.trades.settle_broker_closed_position(
+                                        user_id=user_id,
+                                        symbol=symbol,
+                                        broker_key=broker_key,
+                                        close_price=filled_price
+                                    )
+                                    if settled_ids and user_name:
+                                        socketio.emit('message', {
+                                            'reply': 'position_closed',
+                                            'data': sanitize_for_json({
+                                                'symbol': symbol,
+                                                'broker_key': broker_key,
+                                                'closed_trades': settled_ids
+                                            })
+                                        }, room=user_name)
 
                 except Exception as e:
                     _loop_debug.debug(f"Exception in broker update: {e}")
@@ -317,6 +360,9 @@ def strategy_execution_loop():
                             exchange_symbols.add((None, trade.symbol))
 
                     _loop_debug.debug(f"Exchange+symbols to fetch: {exchange_symbols}")
+                    # Log at INFO level for live trades debugging
+                    if any(ex and ex.lower() not in ['paper', 'test_exchange'] for ex, _ in exchange_symbols):
+                        logger.info(f"[PRICE FETCH] exchange_symbols to fetch: {exchange_symbols}")
                     price_updates = {}
                     for exchange, symbol in exchange_symbols:
                         try:
@@ -1251,6 +1297,20 @@ def close_manual_position(symbol):
 
     try:
         result = brighter_trades.trades.close_position(user_id, symbol, broker_key)
+
+        # Emit position_closed event to refresh UI
+        if result.get('success'):
+            user_name = brighter_trades.users.get_username(user_id=user_id)
+            if user_name:
+                socketio.emit('message', {
+                    'reply': 'position_closed',
+                    'data': {
+                        'symbol': symbol,
+                        'broker_key': broker_key,
+                        'closed_trades': result.get('closed_trades', [])
+                    }
+                }, room=user_name)
+
         return jsonify(result)
     except Exception as e:
         logger.error(f"Error closing position {symbol}: {e}", exc_info=True)
@@ -1265,15 +1325,44 @@ def get_manual_balance():
         return jsonify({'success': False, 'message': 'Not authenticated'}), 401
 
     broker_key = request.args.get('broker_key', 'paper')
+    chart_exchange = (request.args.get('exchange') or '').strip().lower() or None
 
     try:
         total = brighter_trades.manual_broker_manager.get_broker_balance(user_id, broker_key)
         available = brighter_trades.manual_broker_manager.get_available_balance(user_id, broker_key)
+
+        # Fallback for live mode: if manual broker balance is unavailable/stale, use the
+        # cached direct exchange balances for the exchange currently shown in the chart.
+        fallback_source = None
+        if broker_key != 'paper' and chart_exchange and total == 0.0 and available == 0.0:
+            user_name = brighter_trades.users.get_username(user_id=user_id)
+            exchange_balances = brighter_trades.exchanges.get_exchange_balances(user_name, chart_exchange)
+
+            quote_balance = 0.0
+            if exchange_balances is not None:
+                for asset in ('USDT', 'USD', 'BUSD', 'USDC'):
+                    match = next(
+                        (
+                            bal for bal in exchange_balances
+                            if str(bal.get('asset', '')).upper() == asset
+                        ),
+                        None
+                    )
+                    if match:
+                        quote_balance = float(match.get('balance', 0.0) or 0.0)
+                        break
+
+            if quote_balance > 0:
+                total = quote_balance
+                available = quote_balance
+                fallback_source = 'exchange'
+
         return jsonify({
             'success': True,
             'total': total,
             'available': available,
-            'broker_key': broker_key
+            'broker_key': broker_key,
+            'source': fallback_source or 'broker'
         })
     except Exception as e:
         logger.error(f"Error getting balance: {e}", exc_info=True)
@@ -1315,6 +1404,21 @@ def get_trade_history():
         return jsonify({'success': False, 'message': str(e)}), 500
 
 
+@app.route('/api/manual/paper/reset', methods=['POST'])
+def reset_paper_balance():
+    """Reset the paper trading broker to initial state."""
+    user_id = _get_current_user_id()
+    if not user_id:
+        return jsonify({'success': False, 'message': 'Not authenticated'}), 401
+
+    try:
+        result = brighter_trades.manual_broker_manager.reset_paper_broker(user_id)
+        return jsonify(result)
+    except Exception as e:
+        logger.error(f"Error resetting paper broker: {e}", exc_info=True)
+        return jsonify({'success': False, 'message': str(e)}), 500
+
+
 # =============================================================================
 # External Sources API Routes
 # =============================================================================

src/brokers/base_broker.py

@@ -62,6 +62,8 @@ class Position:
     current_price: float
     unrealized_pnl: float
     realized_pnl: float = 0.0
+    entry_commission: float = 0.0  # Fee paid on entry, included in P&L
+    price_source: Optional[str] = None  # Exchange to use for price lookups (e.g., 'kucoin')
 
     def to_dict(self) -> Dict[str, Any]:
         """Convert position to dictionary for persistence."""
@@ -72,6 +74,8 @@ class Position:
             'current_price': self.current_price,
             'unrealized_pnl': self.unrealized_pnl,
             'realized_pnl': self.realized_pnl,
+            'entry_commission': self.entry_commission,
+            'price_source': self.price_source,
         }
 
     @classmethod
@@ -84,6 +88,8 @@ class Position:
             current_price=data['current_price'],
             unrealized_pnl=data['unrealized_pnl'],
             realized_pnl=data.get('realized_pnl', 0.0),
+            entry_commission=data.get('entry_commission', 0.0),
+            price_source=data.get('price_source'),
         )
 
 

src/brokers/live_broker.py

@@ -425,8 +425,8 @@ class LiveBroker(BaseBroker):
 
                 # Create local order tracking
                 symbol = ex_order['symbol']
-                side = OrderSide.BUY if ex_order['side'].lower() == 'buy' else OrderSide.SELL
+                side = OrderSide.BUY if (ex_order.get('side') or 'buy').lower() == 'buy' else OrderSide.SELL
-                order_type = OrderType.LIMIT if ex_order.get('type', 'limit').lower() == 'limit' else OrderType.MARKET
+                order_type = OrderType.LIMIT if (ex_order.get('type') or 'limit').lower() == 'limit' else OrderType.MARKET
                 size = float(ex_order['quantity'])
                 price = float(ex_order.get('price', 0) or 0)
 
@@ -640,13 +640,20 @@ class LiveBroker(BaseBroker):
             )
 
             # Parse order status from exchange response
-            ex_status = exchange_order.get('status', 'open').lower()
+            # Use 'or' to handle case where status key exists but value is None
+            ex_status = (exchange_order.get('status') or 'open').lower()
             if ex_status == 'closed' or ex_status == 'filled':
                 order.status = OrderStatus.FILLED
                 order.filled_qty = float(exchange_order.get('filled', size))
-                order.filled_price = float(exchange_order.get('average', price or 0))
+                raw_avg = exchange_order.get('average')
+                order.filled_price = float(raw_avg if raw_avg is not None else (price or 0))
                 order.filled_at = datetime.now(timezone.utc)
 
+                # DEBUG: Log exchange response for price validation
+                logger.info(f"[FILL DEBUG] Exchange response: average={raw_avg}, price={price}, "
+                           f"filled={order.filled_qty}, cost={exchange_order.get('cost')}, "
+                           f"final filled_price={order.filled_price}")
+
                 # Calculate commission
                 fee = exchange_order.get('fee', {})
                 if fee:
@@ -752,7 +759,8 @@ class LiveBroker(BaseBroker):
 
     def _update_order_from_exchange(self, order: LiveOrder, ex_order: Dict[str, Any]):
         """Update local order with exchange data."""
-        ex_status = ex_order.get('status', 'open').lower()
+        # Use 'or' to handle case where status key exists but value is None
+        ex_status = (ex_order.get('status') or 'open').lower()
 
         if ex_status == 'closed' or ex_status == 'filled':
             order.status = OrderStatus.FILLED

src/brokers/paper_broker.py

@@ -32,7 +32,8 @@ class PaperOrder:
         price: Optional[float] = None,
         stop_loss: Optional[float] = None,
         take_profit: Optional[float] = None,
-        time_in_force: str = 'GTC'
+        time_in_force: str = 'GTC',
+        exchange: Optional[str] = None
     ):
         self.order_id = order_id
         self.symbol = symbol
@@ -43,6 +44,7 @@ class PaperOrder:
         self.stop_loss = stop_loss
         self.take_profit = take_profit
         self.time_in_force = time_in_force
+        self.exchange = exchange  # Exchange for price feed (e.g., 'kucoin')
         self.status = OrderStatus.PENDING
         self.filled_qty = 0.0
         self.filled_price = 0.0
@@ -68,7 +70,8 @@ class PaperOrder:
             'commission': self.commission,
             'locked_funds': self.locked_funds,
             'created_at': self.created_at.isoformat(),
-            'filled_at': self.filled_at.isoformat() if self.filled_at else None
+            'filled_at': self.filled_at.isoformat() if self.filled_at else None,
+            'exchange': self.exchange,
         }
 
 
@@ -123,10 +126,21 @@ class PaperBroker(BaseBroker):
         """Set the price provider callable."""
         self._price_provider = provider
 
-    def update_price(self, symbol: str, price: float):
+    def update_price(self, symbol: str, price: float, exchange: Optional[str] = None):
-        """Update the current price for a symbol."""
+        """Update price, optionally qualified by exchange."""
+        if exchange:
+            # Store exchange-qualified price
+            self._current_prices[f"{exchange}:{symbol}"] = price
+        # Always store symbol-only for backward compat
         self._current_prices[symbol] = price
 
+    @staticmethod
+    def _should_fill_limit_order(side: OrderSide, current_price: float, limit_price: float) -> bool:
+        """Return True when the current price crosses a limit order's fill threshold."""
+        if side == OrderSide.BUY:
+            return current_price <= limit_price
+        return current_price >= limit_price
+
     def place_order(
         self,
         symbol: str,
@@ -136,13 +150,14 @@ class PaperBroker(BaseBroker):
         price: Optional[float] = None,
         stop_loss: Optional[float] = None,
         take_profit: Optional[float] = None,
-        time_in_force: str = 'GTC'
+        time_in_force: str = 'GTC',
+        exchange: Optional[str] = None
     ) -> OrderResult:
         """Place a paper trading order."""
         order_id = str(uuid.uuid4())[:8]
 
-        # Validate order
+        # Validate order - use exchange-aware price lookup
-        current_price = self.get_current_price(symbol)
+        current_price = self.get_current_price(symbol, exchange)
         if current_price <= 0:
             return OrderResult(
                 success=False,
@@ -189,7 +204,8 @@ class PaperBroker(BaseBroker):
             price=price,
             stop_loss=stop_loss,
             take_profit=take_profit,
-            time_in_force=time_in_force
+            time_in_force=time_in_force,
+            exchange=exchange
         )
 
         # For market orders, fill immediately
@@ -198,6 +214,39 @@ class PaperBroker(BaseBroker):
             self._fill_order(order, fill_price)
             logger.info(f"PaperBroker: Market order filled: {side.value} {size} {symbol} @ {fill_price:.4f}")
         else:
+            is_marketable = self._should_fill_limit_order(side, current_price, execution_price)
+
+            # IOC/FOK must fill immediately or fail immediately.
+            if time_in_force in ['IOC', 'FOK']:
+                if is_marketable:
+                    self._fill_order(order, execution_price)
+                    logger.info(
+                        f"PaperBroker: {time_in_force} limit order filled immediately: "
+                        f"{side.value} {size} {symbol} @ {execution_price}"
+                    )
+                else:
+                    order.status = OrderStatus.CANCELLED if time_in_force == 'IOC' else OrderStatus.EXPIRED
+                    self._orders[order_id] = order
+                    logger.info(
+                        f"PaperBroker: {time_in_force} limit order not fillable immediately: "
+                        f"{side.value} {size} {symbol} @ {price}"
+                    )
+                    return OrderResult(
+                        success=False,
+                        order_id=order_id,
+                        status=order.status,
+                        message=f"{time_in_force} limit order could not be filled immediately"
+                    )
+                return OrderResult(
+                    success=True,
+                    order_id=order_id,
+                    status=order.status,
+                    filled_qty=order.filled_qty,
+                    filled_price=order.filled_price,
+                    commission=order.commission,
+                    message=f"Order {order_id} filled"
+                )
+
             # Store pending order
             order.status = OrderStatus.OPEN
             self._orders[order_id] = order
@@ -253,13 +302,19 @@ class PaperBroker(BaseBroker):
                 new_entry = (existing.entry_price * existing.size + fill_price * order.size) / new_size
                 existing.size = new_size
                 existing.entry_price = new_entry
+                existing.entry_commission += order.commission  # Accumulate entry fees
+                # Most recent fill wins: update price source
+                if order.exchange:
+                    existing.price_source = order.exchange
             else:
                 self._positions[order.symbol] = Position(
                     symbol=order.symbol,
                     size=order.size,
                     entry_price=fill_price,
                     current_price=fill_price,
-                    unrealized_pnl=0.0
+                    unrealized_pnl=-order.commission,  # Start with entry fee as loss
+                    entry_commission=order.commission,
+                    price_source=order.exchange
                 )
 
             # Record SL/TP for this position (if set on order)
@@ -280,10 +335,22 @@ class PaperBroker(BaseBroker):
             if order.symbol in self._positions:
                 position = self._positions[order.symbol]
                 order.entry_price = position.entry_price  # Store for fee calculation
-                realized_pnl = (fill_price - position.entry_price) * order.size - order.commission
+
+                # Calculate proportional entry commission for partial closes
+                if position.size > 0:
+                    proportion = order.size / position.size
+                    proportional_entry_commission = position.entry_commission * proportion
+                else:
+                    proportional_entry_commission = position.entry_commission
+
+                # Realized P&L includes both entry and exit fees
+                realized_pnl = (fill_price - position.entry_price) * order.size - proportional_entry_commission - order.commission
                 position.realized_pnl += realized_pnl
                 position.size -= order.size
 
+                # Reduce remaining entry commission proportionally
+                position.entry_commission -= proportional_entry_commission
+
                 # Track profitability for fee calculation
                 order.realized_pnl = realized_pnl
                 order.is_profitable = realized_pnl > 0
@@ -363,15 +430,30 @@ class PaperBroker(BaseBroker):
         """Get all open positions."""
         return list(self._positions.values())
 
-    def get_current_price(self, symbol: str) -> float:
+    def get_current_price(self, symbol: str, exchange: Optional[str] = None) -> float:
-        """Get current price for a symbol."""
+        """Get price, preferring exchange-qualified if available."""
-        # First check cache
+        # First try exchange-qualified lookup
+        if exchange:
+            key = f"{exchange}:{symbol}"
+            if key in self._current_prices:
+                return self._current_prices[key]
+
+        # Fall back to symbol-only lookup
         if symbol in self._current_prices:
             return self._current_prices[symbol]
 
         # Then try price provider
         if self._price_provider:
             try:
+                # Try exchange-qualified first, then symbol-only
+                if exchange:
+                    try:
+                        price = self._price_provider(f"{exchange}:{symbol}")
+                        if price > 0:
+                            self._current_prices[f"{exchange}:{symbol}"] = price
+                            return price
+                    except Exception:
+                        pass
                 price = self._price_provider(symbol)
                 self._current_prices[symbol] = price
                 return price
@@ -388,12 +470,14 @@ class PaperBroker(BaseBroker):
         """
         events = []
 
-        # Update position P&L
+        # Update position P&L (includes entry commission for accurate fee reflection)
         for symbol, position in self._positions.items():
-            current_price = self.get_current_price(symbol)
+            # Use position's price_source for exchange-aware price lookup
+            current_price = self.get_current_price(symbol, position.price_source)
             if current_price > 0:
                 position.current_price = current_price
-                position.unrealized_pnl = (current_price - position.entry_price) * position.size
+                # P&L = price movement - entry fees already paid
+                position.unrealized_pnl = (current_price - position.entry_price) * position.size - position.entry_commission
 
         # Evaluate SL/TP for all tracked positions
         for symbol, sltp in list(self._position_sltp.items()):
@@ -402,7 +486,8 @@ class PaperBroker(BaseBroker):
                 continue
 
             position = self._positions[symbol]
-            current_price = self.get_current_price(symbol)
+            # Use position's price_source for exchange-aware price lookup
+            current_price = self.get_current_price(symbol, position.price_source)
 
             if position.size <= 0 or current_price <= 0:
                 del self._position_sltp[symbol]
@@ -444,17 +529,15 @@ class PaperBroker(BaseBroker):
             if order.status != OrderStatus.OPEN:
                 continue
 
-            current_price = self.get_current_price(order.symbol)
+            # Use order's exchange for price lookup
+            current_price = self.get_current_price(order.symbol, order.exchange)
             if current_price <= 0:
                 continue
 
-            should_fill = False
-
             if order.order_type == OrderType.LIMIT:
-                if order.side == OrderSide.BUY and current_price <= order.price:
+                should_fill = self._should_fill_limit_order(order.side, current_price, order.price)
-                    should_fill = True
+            else:
-                elif order.side == OrderSide.SELL and current_price >= order.price:
+                should_fill = False
-                    should_fill = True
 
             if should_fill:
                 # Release locked funds first (for buy orders)
@@ -497,6 +580,7 @@ class PaperBroker(BaseBroker):
         self._positions.clear()
         self._trade_history.clear()
         self._current_prices.clear()
+        self._position_sltp.clear()  # Clear SL/TP state to prevent stale triggers
         logger.info(f"PaperBroker: Reset with balance {self.initial_balance}")
 
     # ==================== State Persistence Methods ====================
@@ -609,6 +693,8 @@ class PaperBroker(BaseBroker):
                 price=order_dict.get('price'),
                 stop_loss=order_dict.get('stop_loss'),
                 take_profit=order_dict.get('take_profit'),
+                time_in_force=order_dict.get('time_in_force', 'GTC'),
+                exchange=order_dict.get('exchange'),
             )
             order.status = OrderStatus(order_dict['status'])
             order.filled_qty = order_dict.get('filled_qty', 0.0)

src/candles.py

@@ -1,12 +1,11 @@
 import datetime as dt
-import logging as log
+import logging
 
 import pytz
 
 from shared_utilities import timeframe_to_minutes, ts_of_n_minutes_ago
 
-
+logger = logging.getLogger(__name__)
-# log.basicConfig(level=log.ERROR)
 
 class Candles:
     def __init__(self, exchanges, users, datacache, config, edm_client=None):
@@ -24,6 +23,8 @@ class Candles:
 
         # Cache the last received candle to detect duplicates
         self.cached_last_candle = None
+        # Avoid repeating the same expected EDM cap warning on every refresh.
+        self._edm_cap_warned_scopes: set[tuple[str, str, str]] = set()
 
         # size_limit is the max number of lists of candle(ohlc) data allowed.
         self.data.create_cache(name='candles', cache_type='row', default_expiration=dt.timedelta(days=5),
@@ -57,10 +58,21 @@ class Candles:
         # EDM API has a maximum limit of 1000 candles
         EDM_MAX_CANDLES = 1000
         if num_candles > EDM_MAX_CANDLES:
-            log.warning(f'Requested {num_candles} candles, capping to EDM limit of {EDM_MAX_CANDLES}')
+            warning_scope = (asset, exchange, timeframe)
+            if warning_scope not in self._edm_cap_warned_scopes:
+                logger.warning(
+                    "Requested %s candles for %s/%s/%s, capping to EDM limit of %s",
+                    num_candles, asset, timeframe, exchange, EDM_MAX_CANDLES
+                )
+                self._edm_cap_warned_scopes.add(warning_scope)
+            else:
+                logger.debug(
+                    "Requested %s candles for %s/%s/%s, capped to %s",
+                    num_candles, asset, timeframe, exchange, EDM_MAX_CANDLES
+                )
             num_candles = EDM_MAX_CANDLES
 
-        log.info(f'[GET CANDLES] {asset} {exchange} {timeframe} limit={num_candles}')
+        logger.debug("Fetching candles from EDM: %s %s %s limit=%s", asset, exchange, timeframe, num_candles)
 
         if self.edm is None:
             raise RuntimeError("EDM client not initialized. Cannot fetch candle data.")
@@ -76,10 +88,10 @@ class Candles:
         )
 
         if candles.empty:
-            log.warning(f"No candles returned from EDM for {asset}/{timeframe}/{exchange}")
+            logger.warning("No candles returned from EDM for %s/%s/%s", asset, timeframe, exchange)
             return self.convert_candles(candles)
 
-        log.info(f"Fetched {len(candles)} candles from EDM for {asset}/{timeframe}/{exchange}")
+        logger.debug("Fetched %s candles from EDM for %s/%s/%s", len(candles), asset, timeframe, exchange)
         return self.convert_candles(candles[-num_candles:])
 
     def set_new_candle(self, cdata: dict) -> bool:
@@ -93,7 +105,7 @@ class Candles:
         """
         # Update the cached last candle
         self.cached_last_candle = cdata
-        log.debug(f"Candle updated: {cdata.get('symbol', 'unknown')} @ {cdata.get('close', 0)}")
+        logger.debug("Candle updated: %s @ %s", cdata.get('symbol', 'unknown'), cdata.get('close', 0))
         return True
     def set_cache(self, symbol=None, interval=None, exchange_name=None, user_name=None):
         """
@@ -110,24 +122,24 @@ class Candles:
         if not symbol:
             assert user_name is not None
             symbol = self.users.get_chart_view(user_name=user_name, prop='market')
-            log.info(f'set_candle_history(): No symbol provided. Using{symbol}')
+            logger.info('set_candle_history(): No symbol provided. Using %s', symbol)
         if not interval:
             assert user_name is not None
             interval = self.users.get_chart_view(user_name=user_name, prop='timeframe')
-            log.info(f'set_candle_history(): No timeframe provided. Using{interval}')
+            logger.info('set_candle_history(): No timeframe provided. Using %s', interval)
         if not exchange_name:
             assert user_name is not None
             exchange_name = self.users.get_chart_view(user_name=user_name, prop='exchange_name')
 
         # Log the completion to the console.
-        log.info('set_candle_history(): Loading candle data...')
+        logger.info('set_candle_history(): Loading candle data...')
 
         # Load candles from database
         _cdata = self.get_last_n_candles(num_candles=self.max_records,
                                          asset=symbol, timeframe=interval, exchange=exchange_name, user_name=user_name)
 
         # Log the completion to the console.
-        log.info('set_candle_history(): Candle data Loaded.')
+        logger.info('set_candle_history(): Candle data Loaded.')
         return
 
     @staticmethod
@@ -213,17 +225,17 @@ class Candles:
         if not symbol:
             assert user_name is not None
             symbol = self.users.get_chart_view(user_name=user_name, prop='market')
-            log.info(f'get_candle_history(): No symbol provided. Using {symbol}')
+            logger.info('get_candle_history(): No symbol provided. Using %s', symbol)
 
         if not interval:
             assert user_name is not None
             interval = self.users.get_chart_view(user_name=user_name, prop='timeframe')
-            log.info(f'get_candle_history(): No timeframe provided. Using {interval}')
+            logger.info('get_candle_history(): No timeframe provided. Using %s', interval)
 
         if not exchange_name:
             assert user_name is not None
             exchange_name = self.users.get_chart_view(user_name=user_name, prop='exchange_name')
-            log.info(f'get_candle_history(): No exchange name provided. Using {exchange_name}')
+            logger.info('get_candle_history(): No exchange name provided. Using %s', exchange_name)
 
         candlesticks = self.get_last_n_candles(num_candles=num_records, asset=symbol, timeframe=interval,
                                                exchange=exchange_name, user_name=user_name)

src/manual_trading_broker.py

@@ -101,6 +101,10 @@ class ManualTradingBrokerManager:
         :param user_name: Username for exchange lookup.
         :return: LiveBroker instance or None if not configured or mode conflict.
         """
+        if not exchange_name:
+            logger.error("Cannot create live broker: exchange_name is required")
+            return None
+
         # Use 'testnet'/'production' to match what's stored in trade.broker_mode
         requested_mode = 'testnet' if testnet else 'production'
         broker_key = f"{exchange_name}_{requested_mode}"
@@ -213,16 +217,17 @@ class ManualTradingBrokerManager:
         """
         Update current prices for all paper brokers.
 
-        :param price_updates: Dict mapping symbol to price.
+        :param price_updates: Dict mapping symbol or exchange:symbol to price.
         """
         for broker in self._paper_brokers.values():
-            for symbol, price in price_updates.items():
+            for key, price in price_updates.items():
-                # Handle exchange:symbol format
+                if ':' in key:
-                if ':' in symbol:
+                    # Exchange-qualified key (e.g., 'kucoin:BTC/USDT')
-                    _, sym = symbol.split(':', 1)
+                    exchange, symbol = key.split(':', 1)
+                    broker.update_price(symbol, price, exchange)
                 else:
-                    sym = symbol
+                    # Symbol-only key
-                broker.update_price(sym, price)
+                    broker.update_price(key, price)
 
     def update_all_brokers(self, price_updates: Dict[str, float]) -> List[Dict]:
         """
@@ -394,6 +399,7 @@ class ManualTradingBrokerManager:
                 "success": result.success,
                 "message": result.message,
                 "order_id": result.order_id,
+                "status": getattr(result.status, 'value', result.status),
                 "filled_qty": result.filled_qty,
                 "filled_price": result.filled_price
             }
@@ -466,16 +472,22 @@ class ManualTradingBrokerManager:
             logger.error(f"Error placing order: {e}")
             return OrderResult(success=False, message=str(e))
 
-    def _get_broker(self, user_id: int, broker_key: str):
+    def _get_broker(self, user_id: int, broker_key: str, create_paper: bool = True):
         """
         Get a broker by user_id and broker_key.
 
         :param user_id: The user ID.
         :param broker_key: 'paper' or 'exchange_mode' format.
+        :param create_paper: If True, create paper broker on-demand (loads saved state).
         :return: Broker instance or None.
         """
         if broker_key == 'paper':
-            return self._paper_brokers.get(user_id)
+            if user_id in self._paper_brokers:
+                return self._paper_brokers[user_id]
+            # Create paper broker on-demand (this loads saved state)
+            if create_paper:
+                return self.get_paper_broker(user_id)
+            return None
 
         if user_id in self._live_brokers:
             return self._live_brokers[user_id].get(broker_key)
@@ -495,6 +507,37 @@ class ManualTradingBrokerManager:
             return 0.0
         return broker.get_balance()
 
+    def reset_paper_broker(self, user_id: int) -> Dict:
+        """
+        Reset the paper broker for a user to initial state.
+
+        Clears all positions, orders, and restores the initial balance.
+
+        :param user_id: The user ID.
+        :return: Dict with success status and new balance.
+        """
+        broker = self._paper_brokers.get(user_id)
+        if not broker:
+            # Create a fresh broker if one doesn't exist
+            broker = self.get_paper_broker(user_id)
+
+        try:
+            broker.reset()
+
+            # Save the reset state
+            state_id = f"manual_paper_{user_id}"
+            broker.save_state(state_id)
+
+            logger.info(f"Reset paper broker for user {user_id}, balance: {broker.initial_balance}")
+            return {
+                "success": True,
+                "message": "Paper trading balance reset successfully",
+                "balance": broker.initial_balance
+            }
+        except Exception as e:
+            logger.error(f"Error resetting paper broker for user {user_id}: {e}")
+            return {"success": False, "message": str(e)}
+
     def get_available_balance(self, user_id: int, broker_key: str) -> float:
         """
         Get the available balance (not locked in orders).
@@ -574,3 +617,36 @@ class ManualTradingBrokerManager:
                 logger.error(f"Error recovering broker {broker_key} for user {user_id}: {e}")
 
         return recovered
+
+    def get_active_paper_user_ids(self) -> List[int]:
+        """Return user IDs with active paper brokers."""
+        return list(self._paper_brokers.keys())
+
+    def get_required_price_feeds(self, user_id: int) -> List[tuple]:
+        """
+        Get (exchange, symbol) pairs needed for P&L updates.
+
+        Derived from positions and open orders, NOT from Trade.exchange.
+        Returns list of (exchange, symbol) tuples where exchange may be None
+        for positions/orders without a specified price source.
+
+        :param user_id: The user ID.
+        :return: List of (exchange, symbol) tuples.
+        """
+        feeds = set()
+        broker = self._paper_brokers.get(user_id)
+        if broker:
+            # From positions
+            for pos in broker.get_all_positions():
+                if pos.price_source:
+                    feeds.add((pos.price_source, pos.symbol))
+                else:
+                    # Fallback: no exchange specified, use symbol only
+                    feeds.add((None, pos.symbol))
+            # From open orders
+            for order in broker.get_open_orders():
+                exchange = order.get('exchange')
+                symbol = order.get('symbol')
+                if symbol:
+                    feeds.add((exchange, symbol))
+        return list(feeds)

src/static/charts.js

@@ -36,6 +36,7 @@ class Charts {
         this.candleSeries = this.chart_1.addSeries(LightweightCharts.CandlestickSeries);
 
         // Initialize the candlestick series if price_history is available
+        this.price_history = this._normalizeCandles(this.price_history);
         if (this.price_history && this.price_history.length > 0) {
             this.candleSeries.setData(this.price_history);
             console.log(`Candle series initialized with ${this.price_history.length} candles`);
@@ -48,8 +49,110 @@ class Charts {
     }
 
     update_main_chart(new_candle){
+            const normalizedCandle = this._normalizeCandle(new_candle);
+            if (!normalizedCandle) {
+                console.warn('Skipping invalid candle update:', new_candle);
+                return;
+            }
+
+            const lastCandle = Array.isArray(this.price_history) && this.price_history.length > 0
+                ? this.price_history[this.price_history.length - 1]
+                : null;
+            if (lastCandle && normalizedCandle.time < lastCandle.time) {
+                console.warn('Skipping stale candle update:', normalizedCandle, 'last:', lastCandle);
+                return;
+            }
+
             // Update candlestick series
-	        this.candleSeries.update(new_candle);
+	        this.candleSeries.update(normalizedCandle);
+
+            // Keep local price history aligned with the live chart series.
+            if (!Array.isArray(this.price_history)) {
+                this.price_history = [];
+            }
+
+            const lastIndex = this.price_history.length - 1;
+            if (lastIndex >= 0 && this.price_history[lastIndex].time === normalizedCandle.time) {
+                this.price_history[lastIndex] = normalizedCandle;
+            } else if (lastIndex < 0 || this.price_history[lastIndex].time < normalizedCandle.time) {
+                this.price_history.push(normalizedCandle);
+            }
+    }
+
+    _normalizeCandleTime(rawTime) {
+        if (rawTime === null || rawTime === undefined) {
+            return null;
+        }
+
+        if (typeof rawTime === 'number' && Number.isFinite(rawTime)) {
+            return rawTime > 1e12 ? Math.floor(rawTime / 1000) : Math.floor(rawTime);
+        }
+
+        if (typeof rawTime === 'string') {
+            const numericValue = Number(rawTime);
+            if (Number.isFinite(numericValue)) {
+                return this._normalizeCandleTime(numericValue);
+            }
+
+            const parsedTime = Date.parse(rawTime);
+            if (!Number.isNaN(parsedTime)) {
+                return Math.floor(parsedTime / 1000);
+            }
+            return null;
+        }
+
+        if (rawTime instanceof Date) {
+            return Math.floor(rawTime.getTime() / 1000);
+        }
+
+        if (typeof rawTime === 'object') {
+            if (
+                Object.prototype.hasOwnProperty.call(rawTime, 'year') &&
+                Object.prototype.hasOwnProperty.call(rawTime, 'month') &&
+                Object.prototype.hasOwnProperty.call(rawTime, 'day')
+            ) {
+                return Math.floor(Date.UTC(rawTime.year, rawTime.month - 1, rawTime.day) / 1000);
+            }
+
+            for (const key of ['timestamp', 'time', 'value', '$date']) {
+                if (Object.prototype.hasOwnProperty.call(rawTime, key)) {
+                    return this._normalizeCandleTime(rawTime[key]);
+                }
+            }
+        }
+
+        return null;
+    }
+
+    _normalizeCandle(candle) {
+        if (!candle) {
+            return null;
+        }
+
+        const time = this._normalizeCandleTime(candle.time);
+        if (time === null) {
+            return null;
+        }
+
+        return {
+            ...candle,
+            time,
+            open: parseFloat(candle.open),
+            high: parseFloat(candle.high),
+            low: parseFloat(candle.low),
+            close: parseFloat(candle.close)
+        };
+    }
+
+    _normalizeCandles(candles) {
+        if (!Array.isArray(candles)) {
+            return [];
+        }
+
+        return candles
+            .map(candle => this._normalizeCandle(candle))
+            .filter(candle => candle !== null)
+            .sort((a, b) => a.time - b.time);
     }
 
     create_RSI_chart(){

src/static/communication.js

@@ -216,6 +216,57 @@ class Comms {
         }
     }
 
+    /**
+     * Normalize incoming candle times to UTC seconds for lightweight-charts.
+     * EDM data occasionally arrives nested or as ISO strings.
+     * @param {*} rawTime
+     * @returns {number|null}
+     */
+    _normalizeCandleTime(rawTime) {
+        if (rawTime === null || rawTime === undefined) {
+            return null;
+        }
+
+        if (typeof rawTime === 'number' && Number.isFinite(rawTime)) {
+            return rawTime > 1e12 ? Math.floor(rawTime / 1000) : Math.floor(rawTime);
+        }
+
+        if (typeof rawTime === 'string') {
+            const numericValue = Number(rawTime);
+            if (Number.isFinite(numericValue)) {
+                return this._normalizeCandleTime(numericValue);
+            }
+
+            const parsedTime = Date.parse(rawTime);
+            if (!Number.isNaN(parsedTime)) {
+                return Math.floor(parsedTime / 1000);
+            }
+            return null;
+        }
+
+        if (rawTime instanceof Date) {
+            return Math.floor(rawTime.getTime() / 1000);
+        }
+
+        if (typeof rawTime === 'object') {
+            if (
+                Object.prototype.hasOwnProperty.call(rawTime, 'year') &&
+                Object.prototype.hasOwnProperty.call(rawTime, 'month') &&
+                Object.prototype.hasOwnProperty.call(rawTime, 'day')
+            ) {
+                return Math.floor(Date.UTC(rawTime.year, rawTime.month - 1, rawTime.day) / 1000);
+            }
+
+            for (const key of ['timestamp', 'time', 'value', '$date']) {
+                if (Object.prototype.hasOwnProperty.call(rawTime, key)) {
+                    return this._normalizeCandleTime(rawTime[key]);
+                }
+            }
+        }
+
+        return null;
+    }
+
     /* Callback declarations */
 
     candleUpdate(newCandle) {
@@ -345,14 +396,17 @@ class Comms {
         const candles = data.candles || [];
 
         // EDM already sends time in seconds, no conversion needed
-        return candles.map(c => ({
+        return candles
-            time: c.time,
+            .map(c => ({
-            open: c.open,
+                time: this._normalizeCandleTime(c.time),
-            high: c.high,
+                open: parseFloat(c.open),
-            low: c.low,
+                high: parseFloat(c.high),
-            close: c.close,
+                low: parseFloat(c.low),
-            volume: c.volume
+                close: parseFloat(c.close),
-        }));
+                volume: parseFloat(c.volume)
+            }))
+            .filter(c => c.time !== null)
+            .sort((a, b) => a.time - b.time);
     }
 
     /**
@@ -571,8 +625,13 @@ class Comms {
 
                 if (messageType === 'candle') {
                     const candle = message.data;
+                    const candleTime = this._normalizeCandleTime(candle.time);
+                    if (candleTime === null) {
+                        console.warn('Skipping candle with invalid time payload:', candle.time);
+                        return;
+                    }
                     const newCandle = {
-                        time: candle.time,  // EDM sends time in seconds
+                        time: candleTime,
                         open: parseFloat(candle.open),
                         high: parseFloat(candle.high),
                         low: parseFloat(candle.low),

src/static/trade.js

@@ -23,17 +23,18 @@ class TradeUIManager {
         this.sltpRow = null;
         this.onCloseTrade = null;
 
-        // Exchanges known to support testnet/sandbox mode
+        // Exchanges known to support testnet/sandbox mode in ccxt
+        // IMPORTANT: Only include exchanges with verified working sandbox URLs
+        // KuCoin does NOT have sandbox support - removed to prevent real trades!
         this.testnetSupportedExchanges = [
             'binance', 'binanceus', 'binanceusdm', 'binancecoinm',
-            'kucoin', 'kucoinfutures',
             'bybit',
             'okx', 'okex',
             'bitget',
             'bitmex',
             'deribit',
-            'phemex',
+            'phemex'
-            'mexc'
+            // Removed: 'kucoin', 'kucoinfutures', 'mexc' - no sandbox support
         ];
     }
 
@@ -141,6 +142,7 @@ class TradeUIManager {
                 this._updateTestnetVisibility();
                 this._updateExchangeRowVisibility();
                 this._updateSellAvailability();
+                this._updateSltpVisibility();
             });
         }
 
@@ -332,23 +334,23 @@ class TradeUIManager {
     }
 
     /**
-     * Updates SL/TP row visibility based on order side.
+     * Updates SL/TP row visibility based on supported mode and side.
-     * SL/TP only applies to BUY orders (opening positions).
+     * Manual SL/TP is currently supported for paper BUY orders only.
-     * SELL orders close existing positions, so SL/TP is not applicable.
      */
     _updateSltpVisibility() {
-        if (!this.sltpRow || !this.sideSelect) return;
+        if (!this.sltpRow || !this.sideSelect || !this.targetSelect) return;
 
         const side = this.sideSelect.value.toLowerCase();
+        const isPaperTrade = this.targetSelect.value === 'test_exchange';
 
-        if (side === 'sell') {
+        if (!isPaperTrade || side === 'sell') {
-            // Hide SL/TP for SELL (closing positions)
+            // Hide SL/TP when unsupported or not applicable.
             this.sltpRow.style.display = 'none';
-            // Clear any values
+            // Clear values to avoid submitting stale unsupported inputs.
             if (this.stopLossInput) this.stopLossInput.value = '';
             if (this.takeProfitInput) this.takeProfitInput.value = '';
         } else {
-            // Show SL/TP for BUY (opening positions)
+            // Show SL/TP for paper BUY orders.
             this.sltpRow.style.display = 'contents';
         }
     }
@@ -473,18 +475,16 @@ class TradeUIManager {
         if (this.testnetCheckbox) {
             this.testnetCheckbox.checked = true;
         }
-        // Reset side to BUY and show SL/TP row
+        // Reset side to BUY
         if (this.sideSelect) {
             this.sideSelect.value = 'buy';
         }
-        if (this.sltpRow) {
-            this.sltpRow.style.display = 'contents';
-        }
 
         this.formElement.style.display = 'grid';
 
         // Update SELL availability based on current broker/symbol
         await this._updateSellAvailability();
+        this._updateSltpVisibility();
     }
 
     /**
@@ -737,6 +737,22 @@ class TradeUIManager {
         this.onCloseTrade = callback;
     }
 
+    /**
+     * Sets the callback function for full refresh (trades + statistics).
+     * @param {Function} callback - The callback function.
+     */
+    registerRefreshCallback(callback) {
+        this.onRefresh = callback;
+    }
+
+    /**
+     * Sets the callback function for position-close updates.
+     * @param {Function} callback - The callback function.
+     */
+    registerPositionClosedCallback(callback) {
+        this.onPositionClosed = callback;
+    }
+
     // ============ Broker Event Listeners ============
 
     /**
@@ -759,7 +775,11 @@ class TradeUIManager {
 
         comms.on('position_closed', (data) => {
             console.log('Position closed:', data);
-            this.refreshAll();
+            if (this.onPositionClosed) {
+                this.onPositionClosed(data);
+            } else {
+                this.refreshAll();
+            }
         });
 
         comms.on('sltp_triggered', (data) => {
@@ -834,12 +854,15 @@ class TradeUIManager {
 
         container.innerHTML = '';
 
-        if (!positions || positions.length === 0) {
+        // Filter out closed positions (size <= 0)
+        const openPositions = (positions || []).filter(pos => pos.size && Math.abs(pos.size) > 0);
+
+        if (openPositions.length === 0) {
             container.innerHTML = '<p class="no-data-msg">No open positions</p>';
             return;
         }
 
-        for (const pos of positions) {
+        for (const pos of openPositions) {
             const card = this._createPositionCard(pos);
             container.appendChild(card);
         }
@@ -853,6 +876,10 @@ class TradeUIManager {
         const plClass = pl >= 0 ? 'positive' : 'negative';
         const plSign = pl >= 0 ? '+' : '';
 
+        // Price source for tooltip (shows which exchange's prices are used for P&L)
+        const priceSource = position.price_source || 'default';
+        card.title = `P&L uses ${priceSource} prices`;
+
         card.innerHTML = `
             <div class="position-header">
                 <span class="position-symbol">${position.symbol || 'N/A'}</span>
@@ -1033,6 +1060,10 @@ class TradeUIManager {
         this.refreshPositions();
         this.refreshHistory();
         this.updateBrokerStatus();
+        // Call refresh callback to update trades and statistics
+        if (this.onRefresh) {
+            this.onRefresh();
+        }
     }
 
     // ============ Broker Actions ============
@@ -1121,9 +1152,14 @@ class TradeUIManager {
      */
     async updateBrokerStatus() {
         const brokerKey = this._getCurrentBrokerKey();
+        const chartExchange = this.data?.exchange || '';
 
         try {
-            const response = await fetch(`/api/manual/balance?broker_key=${encodeURIComponent(brokerKey)}`);
+            const params = new URLSearchParams({
+                broker_key: brokerKey,
+                exchange: chartExchange
+            });
+            const response = await fetch(`/api/manual/balance?${params.toString()}`);
             const data = await response.json();
             if (data.success) {
                 const balanceEl = document.getElementById('brokerBalance');
@@ -1131,7 +1167,24 @@ class TradeUIManager {
 
                 if (balanceEl) {
                     const balance = data.available ?? data.total ?? 0;
-                    balanceEl.textContent = `Available: $${balance.toFixed(2)}`;
+                    // Get currency preference from localStorage (default: USD for paper, USDT for live)
+                    const defaultCurrency = brokerKey === 'paper' ? 'USD' : 'USDT';
+                    const currency = localStorage.getItem('balanceCurrency') || defaultCurrency;
+                    balanceEl.textContent = `Available: $${balance.toFixed(2)} ${currency}`;
+                    balanceEl.style.cursor = 'pointer';
+                    balanceEl.title = data.source === 'exchange'
+                        ? `Using ${chartExchange || 'exchange'} chart balance. Click to toggle USD/USDT`
+                        : 'Click to toggle USD/USDT';
+                    // Add click handler if not already added
+                    if (!balanceEl.dataset.clickHandler) {
+                        balanceEl.dataset.clickHandler = 'true';
+                        balanceEl.addEventListener('click', () => {
+                            const current = localStorage.getItem('balanceCurrency') || defaultCurrency;
+                            const newCurrency = current === 'USD' ? 'USDT' : 'USD';
+                            localStorage.setItem('balanceCurrency', newCurrency);
+                            this.updateBrokerStatus();
+                        });
+                    }
                 }
                 if (modeEl) {
                     if (brokerKey === 'paper') {
@@ -1149,6 +1202,40 @@ class TradeUIManager {
         } catch (e) {
             console.warn('Could not fetch balance:', e);
         }
+
+        // Update status bar class for reset button visibility
+        const statusBar = document.getElementById('brokerStatusBar');
+        if (statusBar) {
+            statusBar.className = `broker-status-bar mode-${brokerKey === 'paper' ? 'paper' : brokerKey.includes('testnet') ? 'testnet' : 'live'}`;
+        }
+    }
+
+    /**
+     * Reset paper trading balance to initial state ($10,000).
+     */
+    async resetPaperBalance() {
+        if (!confirm('Reset paper trading? This will clear all positions, orders, and restore your balance to $10,000 USD.')) {
+            return;
+        }
+
+        try {
+            const response = await fetch('/api/manual/paper/reset', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' }
+            });
+            const data = await response.json();
+
+            if (data.success) {
+                console.log('Paper balance reset:', data);
+                alert(`Paper trading reset! New balance: $${data.balance.toFixed(2)} USD`);
+                this.refreshAll();
+            } else {
+                alert(`Reset failed: ${data.message}`);
+            }
+        } catch (e) {
+            console.error('Error resetting paper balance:', e);
+            alert('Failed to reset paper balance');
+        }
     }
 
     // ============ Broker-Aware SELL Disable ============
@@ -1362,6 +1449,13 @@ class Trade {
         // Set up close callback
         this.uiManager.registerCloseTradeCallback(this.closeTrade.bind(this));
 
+        // Set up refresh callback for trades and statistics
+        this.uiManager.registerRefreshCallback(() => {
+            this.fetchTrades();
+            this._updateStatistics();
+        });
+        this.uiManager.registerPositionClosedCallback(this.handlePositionClosed.bind(this));
+
         // Bind methods
         this.submitNewTrade = this.submitNewTrade.bind(this);
 
@@ -1410,7 +1504,7 @@ class Trade {
             this.dataManager.fetchTrades(this.comms, this.data);
 
             // Initialize broker event listeners and refresh broker UI
-            this.initBrokerListeners(this.comms);
+            this.uiManager.initBrokerListeners(this.comms);
             this.refreshAll();
 
             this._initialized = true;
@@ -1420,6 +1514,55 @@ class Trade {
         }
     }
 
+    /**
+     * Refresh all broker-backed panels through the UI manager.
+     */
+    refreshAll() {
+        this.uiManager.refreshAll();
+        // Also refresh trades and statistics
+        this.fetchTrades();
+        this._updateStatistics();
+    }
+
+    /**
+     * Delegate broker balance refresh to the UI manager.
+     */
+    updateBrokerStatus() {
+        return this.uiManager.updateBrokerStatus();
+    }
+
+    /**
+     * Delegate order cancellation to the UI manager.
+     * Kept here because DOM actions call UI.trade.* methods.
+     */
+    cancelOrder(orderId, brokerKey) {
+        return this.uiManager.cancelOrder(orderId, brokerKey);
+    }
+
+    /**
+     * Delegate position close to the UI manager.
+     * Kept here because DOM actions call UI.trade.* methods.
+     */
+    closePosition(symbol, brokerKey) {
+        return this.uiManager.closePosition(symbol, brokerKey);
+    }
+
+    /**
+     * Delegate symbol-wide order cancellation to the UI manager.
+     * Kept here because DOM actions call UI.trade.* methods.
+     */
+    cancelOrdersForSymbol(symbol, brokerKey) {
+        return this.uiManager.cancelOrdersForSymbol(symbol, brokerKey);
+    }
+
+    /**
+     * Delegate paper balance reset to the UI manager.
+     * Kept here because DOM actions call UI.trade.* methods.
+     */
+    resetPaperBalance() {
+        return this.uiManager.resetPaperBalance();
+    }
+
     /**
      * Updates the trading pair display in the form.
      * @private
@@ -1485,6 +1628,23 @@ class Trade {
         }
     }
 
+    /**
+     * Handle position-closed event from the REST close-position flow.
+     * @param {Object} data - Position close payload with affected trade IDs.
+     */
+    handlePositionClosed(data) {
+        console.log("Position closed event received:", data);
+
+        const closedTrades = Array.isArray(data?.closed_trades) ? data.closed_trades : [];
+        for (const tradeId of closedTrades) {
+            this.dataManager.removeTrade(tradeId);
+        }
+
+        this.uiManager.updateTradesHtml(this.dataManager.getAllTrades());
+        this._updateStatistics();
+        this.uiManager.refreshAll();
+    }
+
     /**
      * Handle trade error.
      * @param {Object} data - Error data.
@@ -1673,8 +1833,8 @@ class Trade {
             return;
         }
 
-        // SL/TP validation (only for BUY orders - SELL closes existing positions)
+        // SL/TP validation (paper BUY only)
-        if (side.toUpperCase() === 'BUY') {
+        if (isPaperTrade && side.toUpperCase() === 'BUY') {
             if (stopLoss && stopLoss >= price) {
                 alert('Stop Loss must be below entry price for BUY orders.');
                 return;
@@ -1683,8 +1843,10 @@ class Trade {
                 alert('Take Profit must be above entry price for BUY orders.');
                 return;
             }
+        } else if (!isPaperTrade && (stopLoss || takeProfit)) {
+            alert('Manual live Stop Loss / Take Profit is not supported yet.');
+            return;
         }
-        // Note: SL/TP fields are hidden for SELL orders (inventory-only model)
 
         // Show confirmation for production live trades
         if (!isPaperTrade && !testnet) {

src/templates/trading_hud.html

@@ -2,6 +2,7 @@
         <div class="broker-status-bar" id="brokerStatusBar">
             <span id="brokerModeIndicator" class="mode-badge mode-paper">PAPER</span>
             <span id="brokerBalance">Available: --</span>
+            <button id="resetPaperBalanceBtn" class="btn-reset-paper" onclick="UI.trade.resetPaperBalance()" title="Reset paper trading balance to $10,000">Reset</button>
         </div>
 
         <button class="btn" id="new_trade" onclick="UI.trade.open_tradeForm()">New Order</button>
@@ -276,6 +277,26 @@
             font-family: monospace;
         }
 
+        .btn-reset-paper {
+            display: none;  /* Hidden by default, shown only for paper mode */
+            background: #ff9800;
+            color: white;
+            border: none;
+            padding: 2px 8px;
+            border-radius: 3px;
+            font-size: 10px;
+            cursor: pointer;
+            margin-left: auto;
+        }
+
+        .btn-reset-paper:hover {
+            background: #f57c00;
+        }
+
+        .broker-status-bar.mode-paper .btn-reset-paper {
+            display: inline-block;
+        }
+
         /* Trade sections */
         .trade-section {
             margin-bottom: 15px;

src/trade.py

@@ -76,7 +76,9 @@ class Trade:
                 'qty_settled': 0.0,
                 'profit': 0.0,
                 'profit_pct': 0.0,
-                'fee_paid': 0.0
+                'fee_paid': 0.0,
+                'realized_profit': 0.0,
+                'unrealized_profit': 0.0
             }
             self.order = None
         else:
@@ -140,30 +142,66 @@ class Trade:
         """
         return self.status
 
+    @staticmethod
+    def _percent(part: float, whole: float) -> float:
+        if whole == 0:
+            return 0.0
+        return 100.0 * float(part) / float(whole)
+
+    @staticmethod
+    def _calculate_pl(entry_price: float, exit_price: float, qty: float, side: str, fee: float) -> float:
+        entry_value = qty * entry_price
+        exit_value = qty * exit_price
+        profit = exit_value - entry_value
+        if side == 'SELL':
+            profit *= -1
+        fees = (entry_value * fee) + (exit_value * fee)
+        return profit - fees
+
+    def _filled_qty(self) -> float:
+        return float(self.stats.get('qty_filled', 0.0) or 0.0)
+
+    def _settled_qty(self) -> float:
+        return float(self.stats.get('qty_settled', 0.0) or 0.0)
+
+    def _open_qty(self) -> float:
+        return max(self._filled_qty() - self._settled_qty(), 0.0)
+
     def update_values(self, current_price: float) -> None:
         """
         Updates the P/L values and percentages based on the current price.
         """
-
-        def percent(part: float, whole: float) -> float:
-            if whole == 0:
-                return 0.0
-            return 100.0 * float(part) / float(whole)
-
         self.stats['current_price'] = current_price
-        initial_value = self.stats['opening_value']
+        opening_price = float(self.stats.get('opening_price', self.order_price) or self.order_price or 0.0)
-        self.stats['current_value'] = self.base_order_qty * current_price
+        filled_qty = self._filled_qty()
+        open_qty = self._open_qty()
+        realized_profit = float(self.stats.get('realized_profit', 0.0) or 0.0)
+
+        if open_qty > 0:
+            self.stats['current_value'] = open_qty * current_price
+            unrealized_profit = self._calculate_pl(
+                entry_price=opening_price,
+                exit_price=current_price,
+                qty=open_qty,
+                side=self.side,
+                fee=self.fee
+            )
+        else:
+            # Keep legacy order-notional display for resting orders, but they should not show P/L.
+            if filled_qty <= 0 and self.status in ['inactive', 'pending', 'open', 'unfilled']:
+                self.stats['current_value'] = self.base_order_qty * current_price
+            else:
+                self.stats['current_value'] = 0.0
+            unrealized_profit = 0.0
+
         logger.debug(f"Trade {self.unique_id}: Updated current value to {self.stats['current_value']}")
 
-        self.stats['profit'] = self.stats['current_value'] - initial_value
+        self.stats['unrealized_profit'] = unrealized_profit
+        self.stats['profit'] = realized_profit + unrealized_profit
 
-        if self.side == 'SELL':
+        basis_qty = filled_qty if filled_qty > 0 else 0.0
-            self.stats['profit'] *= -1
+        basis_value = basis_qty * opening_price
-
+        self.stats['profit_pct'] = self._percent(self.stats['profit'], basis_value)
-        projected_fees = (self.stats['current_value'] * self.fee) + (self.stats['opening_value'] * self.fee)
-        self.stats['profit'] -= projected_fees
-
-        self.stats['profit_pct'] = percent(self.stats['profit'], initial_value)
         logger.debug(f"Trade {self.unique_id}: Profit updated to {self.stats['profit']} ({self.stats['profit_pct']}%)")
 
     def update(self, current_price: float) -> str:
@@ -195,28 +233,45 @@ class Trade:
         if self.status == 'inactive':
             self.status = 'unfilled'
 
-        if self.status == 'unfilled':
+        current_filled = self._filled_qty()
+        if current_filled <= 0:
             self.stats['qty_filled'] = qty
             self.stats['opening_price'] = price
         else:
-            sum_of_values = (qty * price) + self.stats['opening_value']
+            sum_of_values = (qty * price) + (current_filled * self.stats['opening_price'])
-            t_qty = self.stats['qty_filled'] + qty
+            t_qty = current_filled + qty
             weighted_average = sum_of_values / t_qty if t_qty != 0 else 0.0
             self.stats['opening_price'] = weighted_average
-            self.stats['qty_filled'] += qty
+            self.stats['qty_filled'] = t_qty
 
         self.stats['opening_value'] = self.stats['qty_filled'] * self.stats['opening_price']
-        self.stats['current_value'] = self.stats['qty_filled'] * self.stats['current_price']
 
         if self.stats['qty_filled'] >= self.base_order_qty:
             self.status = 'filled'
         else:
             self.status = 'part-filled'
 
+        current_price = float(self.stats.get('current_price', 0.0) or 0.0)
+        if current_price <= 0:
+            current_price = price
+        self.update_values(current_price)
+
     def settle(self, qty: float, price: float) -> None:
         """
         Settles all or part of the trade based on the provided quantity and price.
         """
+        qty = float(qty or 0.0)
+        if qty <= 0:
+            return
+
+        filled_qty = self._filled_qty()
+        open_qty = self._open_qty()
+        if filled_qty > 0 and open_qty > 0:
+            qty = min(qty, open_qty)
+
+        if qty <= 0:
+            return
+
         if self.stats['qty_settled'] == 0:
             self.stats['settled_price'] = price
             self.stats['settled_value'] = qty * price
@@ -230,7 +285,28 @@ class Trade:
 
         self.stats['settled_value'] = self.stats['qty_settled'] * self.stats['settled_price']
 
-        if self.stats['qty_settled'] >= self.base_order_qty:
+        realized_increment = self._calculate_pl(
+            entry_price=float(self.stats.get('opening_price', self.order_price) or self.order_price or 0.0),
+            exit_price=price,
+            qty=qty,
+            side=self.side,
+            fee=self.fee
+        )
+        self.stats['realized_profit'] = float(self.stats.get('realized_profit', 0.0) or 0.0) + realized_increment
+
+        if self._open_qty() <= 0:
+            self.stats['current_price'] = price
+            self.stats['current_value'] = 0.0
+            self.stats['unrealized_profit'] = 0.0
+            self.stats['profit'] = self.stats['realized_profit']
+            basis_qty = self._filled_qty() if self._filled_qty() > 0 else self.base_order_qty
+            basis_value = basis_qty * float(self.stats.get('opening_price', self.order_price) or self.order_price or 0.0)
+            self.stats['profit_pct'] = self._percent(self.stats['profit'], basis_value)
+        else:
+            self.update_values(float(self.stats.get('current_price', price) or price))
+
+        close_qty = filled_qty if filled_qty > 0 else self.base_order_qty
+        if self.stats['qty_settled'] >= close_qty:
             self.status = 'closed'
 
 
@@ -380,7 +456,9 @@ class Trades:
                     "broker_mode",
                     "broker_exchange",
                     "broker_order_id",
-                    "exchange_order_id"
+                    "exchange_order_id",
+                    "stop_loss",
+                    "take_profit"
                 ]
             )
         except Exception as e:
@@ -577,6 +655,7 @@ class Trades:
 
         # Determine if this is a paper trade
         is_paper = target in ['test_exchange', 'paper', 'Paper Trade']
+        time_in_force = (time_in_force or 'GTC').upper()
 
         # === PRODUCTION SAFETY GATE (BEFORE any broker/exchange creation) ===
         if not is_paper and not testnet:
@@ -605,14 +684,20 @@ class Trades:
             except ValueError:
                 return 'Error', f'Exchange "{target}" is not connected. Please add it in the Exchanges panel first.'
 
+        if not is_paper and (stop_loss is not None or take_profit is not None):
+            return 'Error', 'Manual live Stop Loss / Take Profit is not supported yet. Use paper trading for SL/TP for now.'
+
         # For market orders, fetch the current price from exchange
+        # For paper trades, use the specified exchange for consistent pricing
         effective_price = float(price) if price else 0.0
         if order_type and order_type.upper() == 'MARKET' and self.exchange_interface:
             try:
-                current_price = self.exchange_interface.get_price(symbol)
+                # Use exchange-aware price lookup for paper trades
+                price_exchange = exchange if is_paper and exchange else (target if not is_paper else None)
+                current_price = self.exchange_interface.get_price(symbol, price_exchange)
                 if current_price:
                     effective_price = float(current_price)
-                    logger.debug(f"Market order: using current price {effective_price} for {symbol}")
+                    logger.debug(f"Market order: using current price {effective_price} for {symbol} from {price_exchange or 'default'}")
             except Exception as e:
                 logger.warning(f"Could not fetch current price for {symbol}: {e}, using provided price {price}")
 
@@ -667,16 +752,22 @@ class Trades:
                 order_side = OrderSide.BUY if side.upper() == 'BUY' else OrderSide.SELL
                 order_type_enum = OrderType.MARKET if order_type.upper() == 'MARKET' else OrderType.LIMIT
 
-                result = broker.place_order(
+                # Build order kwargs - paper trades get exchange for price source tracking
-                    symbol=symbol,
+                order_kwargs = {
-                    side=order_side,
+                    'symbol': symbol,
-                    order_type=order_type_enum,
+                    'side': order_side,
-                    size=float(qty),
+                    'order_type': order_type_enum,
-                    price=effective_price if order_type.upper() == 'LIMIT' else None,
+                    'size': float(qty),
-                    stop_loss=stop_loss,
+                    'price': effective_price if order_type.upper() == 'LIMIT' else None,
-                    take_profit=take_profit,
+                    'stop_loss': stop_loss,
-                    time_in_force=time_in_force
+                    'take_profit': take_profit,
-                )
+                    'time_in_force': time_in_force,
+                }
+                if is_paper and exchange:
+                    # Paper trades track exchange for price source
+                    order_kwargs['exchange'] = exchange
+
+                result = broker.place_order(**order_kwargs)
 
                 if not result.success:
                     return 'Error', result.message or 'Order placement failed'
@@ -703,6 +794,7 @@ class Trades:
                     order_price=effective_price,
                     base_order_qty=float(qty),
                     order_type=order_type.upper() if order_type else 'MARKET',
+                    time_in_force=time_in_force,
                     strategy_id=strategy_id,
                     is_paper=is_paper,
                     testnet=testnet,
@@ -721,10 +813,29 @@ class Trades:
                 # Update stats if order was filled immediately (market orders)
                 if result.status == OrderStatus.FILLED:
                     trade.stats['qty_filled'] = result.filled_qty or float(qty)
-                    trade.stats['opening_price'] = result.filled_price or effective_price
+
+                    # Validate filled_price - detect unreasonable deviations from effective_price
+                    filled_price = result.filled_price or effective_price
+                    if effective_price > 0 and filled_price > 0:
+                        price_ratio = filled_price / effective_price
+                        # Price shouldn't deviate by more than 10% from market price for market orders
+                        if price_ratio > 1.1 or price_ratio < 0.9:
+                            logger.warning(
+                                f"[PRICE VALIDATION] Suspicious filled_price detected! "
+                                f"filled_price={filled_price}, effective_price={effective_price}, "
+                                f"ratio={price_ratio:.2f}. Using effective_price instead."
+                            )
+                            filled_price = effective_price
+
+                    trade.stats['opening_price'] = filled_price
                     trade.stats['opening_value'] = trade.stats['qty_filled'] * trade.stats['opening_price']
                     trade.stats['current_value'] = trade.stats['opening_value']
 
+                    logger.debug(
+                        f"[FILL STATS] trade={trade.unique_id[:8]}, qty_filled={trade.stats['qty_filled']}, "
+                        f"opening_price={trade.stats['opening_price']}, result.filled_price={result.filled_price}"
+                    )
+
                 logger.info(f"Broker trade created: {trade.unique_id} {side} {qty} {symbol} @ {effective_price} "
                            f"(broker_kind={broker_kind}, status={trade_status})")
 
@@ -738,6 +849,7 @@ class Trades:
                     order_price=effective_price,
                     base_order_qty=float(qty),
                     order_type=order_type.upper() if order_type else 'MARKET',
+                    time_in_force=time_in_force,
                     strategy_id=strategy_id,
                     is_paper=is_paper,
                     testnet=testnet,
@@ -781,6 +893,44 @@ class Trades:
             logger.error(f"Error creating new trade: {e}", exc_info=True)
             return 'Error', str(e)
 
+    def settle_broker_closed_position(self, user_id: int, symbol: str, broker_key: str,
+                                      close_price: float) -> list[str]:
+        """
+        Reconcile local trades after a broker-side position close.
+
+        This is used when the broker closes the position outside the normal
+        close_position() API flow, such as paper SL/TP triggers.
+        """
+        settled_ids = []
+
+        for trade_id, trade in list(self.active_trades.items()):
+            if broker_key == 'paper':
+                matches_broker = trade.broker_kind == 'paper'
+            else:
+                trade_broker_key = f"{trade.broker_exchange}_{trade.broker_mode}"
+                matches_broker = (trade.broker_kind == 'live' and trade_broker_key == broker_key)
+
+            if not (trade.creator == user_id and trade.symbol == symbol and matches_broker):
+                continue
+
+            if trade.status not in ['filled', 'part-filled']:
+                continue
+
+            qty_to_settle = trade.stats.get('qty_filled', trade.base_order_qty)
+            if qty_to_settle <= 0:
+                continue
+
+            trade.settle(qty=qty_to_settle, price=close_price)
+            trade.status = 'closed'
+
+            self._save_trade(trade)
+            del self.active_trades[trade_id]
+            self.settled_trades[trade_id] = trade
+            self.stats['num_trades'] -= 1
+            settled_ids.append(trade.unique_id)
+
+        return settled_ids
+
     def get_trades_for_user(self, user_id: int, form: str = 'json') -> list:
         """
         Returns trades visible to a specific user.
@@ -1272,6 +1422,12 @@ class Trades:
             exchange_key = f"{exchange.lower()}:{symbol}" if exchange else None
             current_price = price_updates.get(exchange_key) if exchange_key else None
 
+            # DEBUG: Log price resolution for live trades
+            if trade.broker_kind == 'live':
+                logger.info(f"[PRICE DEBUG] trade={trade_id[:8]}, exchange={exchange}, "
+                           f"exchange_key={exchange_key}, price_updates_keys={list(price_updates.keys())}, "
+                           f"found_price={current_price}")
+
             if current_price is None:
                 current_price = price_updates.get(symbol)
 
@@ -1404,8 +1560,18 @@ class Trades:
         result = self.manual_broker_manager.close_position(user_id, symbol, broker_key)
 
         if result.get('success'):
+            close_status = str(result.get('status') or '').lower()
             close_price = result.get('filled_price', 0.0)
             trades_closed = 0
+            closed_trade_ids = []
+
+            # Live close-position requests may place a market order that is still pending/open.
+            # Only settle/remove the local trade immediately if the broker reports it filled.
+            if close_status not in ['', 'filled', 'partially_filled']:
+                result['trades_closed'] = 0
+                result['closed_trades'] = []
+                result['message'] = result.get('message') or 'Close order submitted.'
+                return result
 
             for trade_id, trade in list(self.active_trades.items()):
                 # Check if this trade belongs to the same broker
@@ -1461,11 +1627,13 @@ class Trades:
                 del self.active_trades[trade_id]
                 self.settled_trades[trade_id] = trade
                 self.stats['num_trades'] -= 1
+                closed_trade_ids.append(trade_id)
 
                 final_pl = trade.stats.get('profit', 0.0)
                 logger.info(f"Trade {trade_id} closed via position close. P/L: {final_pl:.2f}")
 
             result['trades_closed'] = trades_closed
+            result['closed_trades'] = closed_trade_ids
 
         return result
 

tests/test_brokers.py

@@ -119,6 +119,46 @@ class TestPaperBroker:
         assert position is not None
         assert position.size == 0.1
 
+    def test_paper_broker_ioc_limit_cancels_if_not_marketable(self):
+        """IOC limit orders should fail immediately if not marketable."""
+        broker = PaperBroker(initial_balance=10000, commission=0.001)
+        broker.update_price('BTC/USDT', 50000)
+
+        result = broker.place_order(
+            symbol='BTC/USDT',
+            side=OrderSide.BUY,
+            order_type=OrderType.LIMIT,
+            size=0.1,
+            price=49000,
+            time_in_force='IOC'
+        )
+
+        assert not result.success
+        assert result.status == OrderStatus.CANCELLED
+        assert broker.get_open_orders() == []
+        assert broker.get_position('BTC/USDT') is None
+
+    def test_paper_broker_fok_limit_fills_immediately_if_marketable(self):
+        """FOK limit orders should fill immediately when already marketable."""
+        broker = PaperBroker(initial_balance=10000, commission=0.001)
+        broker.update_price('BTC/USDT', 50000)
+
+        result = broker.place_order(
+            symbol='BTC/USDT',
+            side=OrderSide.BUY,
+            order_type=OrderType.LIMIT,
+            size=0.1,
+            price=51000,
+            time_in_force='FOK'
+        )
+
+        assert result.success
+        assert result.status == OrderStatus.FILLED
+        assert broker.get_open_orders() == []
+        position = broker.get_position('BTC/USDT')
+        assert position is not None
+        assert position.size == 0.1
+
     def test_paper_broker_cancel_order(self):
         """Test order cancellation."""
         broker = PaperBroker(initial_balance=10000, commission=0, slippage=0)
@@ -196,6 +236,47 @@ class TestPaperBroker:
         assert broker.get_available_balance() == 9900
         assert broker.get_balance() == 10100
 
+    def test_paper_broker_pnl_includes_fees(self):
+        """Test that P&L accurately reflects both entry and exit fees."""
+        broker = PaperBroker(initial_balance=10000, commission=0.001, slippage=0)
+        broker.update_price('BTC/USDT', 1000)
+
+        # Buy 1 unit at $1000, entry fee = $1
+        broker.place_order(
+            symbol='BTC/USDT',
+            side=OrderSide.BUY,
+            order_type=OrderType.MARKET,
+            size=1.0
+        )
+
+        # Immediately after buy, unrealized P&L should show -$1 (entry fee)
+        position = broker.get_position('BTC/USDT')
+        assert position is not None
+        assert position.entry_commission == 1.0  # 0.1% of $1000
+        assert position.unrealized_pnl == -1.0  # Entry fee already reflected
+
+        # Price hasn't moved, but we're down by entry fee
+        broker.update()
+        position = broker.get_position('BTC/USDT')
+        assert position.unrealized_pnl == -1.0
+
+        # Now sell at same price, exit fee = $1
+        result = broker.place_order(
+            symbol='BTC/USDT',
+            side=OrderSide.SELL,
+            order_type=OrderType.MARKET,
+            size=1.0
+        )
+
+        # Realized P&L should be -$2 (entry + exit fee)
+        assert result.success
+        # The realized_pnl on the order reflects both fees
+        # (price movement 0) - entry_fee ($1) - exit_fee ($1) = -$2
+
+        # Cash balance should reflect the loss
+        # Started with $10000, bought for $1001, sold for $999 = $9998
+        assert broker.get_available_balance() == 9998.0
+
     def test_paper_broker_reset(self):
         """Test broker reset."""
         broker = PaperBroker(initial_balance=10000)

tests/test_trade.py

@@ -166,6 +166,42 @@ class TestTrade:
         assert trade.status == 'part-filled'
         assert trade.stats['qty_filled'] == 0.05
 
+    def test_trade_first_fill_from_open_order_uses_fill_price(self):
+        """First broker fill should not average against the original unfilled order notional."""
+        trade = Trade(
+            target='kucoin',
+            symbol='BTC/USDT',
+            side='BUY',
+            order_price=69394.3,
+            base_order_qty=0.0001
+        )
+        trade.status = 'open'
+
+        trade.trade_filled(qty=5.28e-06, price=69340.8)
+
+        assert trade.status == 'part-filled'
+        assert trade.stats['qty_filled'] == pytest.approx(5.28e-06)
+        assert trade.stats['opening_price'] == pytest.approx(69340.8)
+        assert trade.stats['opening_value'] == pytest.approx(5.28e-06 * 69340.8)
+
+    def test_trade_update_values_uses_filled_quantity_for_pl(self):
+        """Unrealized P/L should be based on filled exposure, not the original order size."""
+        trade = Trade(
+            target='test_exchange',
+            symbol='BTC/USDT',
+            side='BUY',
+            order_price=50000.0,
+            base_order_qty=0.1,
+            fee=0.001
+        )
+
+        trade.trade_filled(qty=0.05, price=50000.0)
+        trade.update_values(55000.0)
+
+        assert trade.stats['current_value'] == pytest.approx(2750.0)
+        assert trade.stats['profit'] == pytest.approx(244.75)
+        assert trade.stats['profit_pct'] == pytest.approx(9.79)
+
     def test_trade_settle(self):
         """Test trade settlement."""
         trade = Trade(
@@ -181,6 +217,8 @@ class TestTrade:
 
         assert trade.status == 'closed'
         assert trade.stats['settled_price'] == 55000.0
+        assert trade.stats['profit'] == pytest.approx(489.5)
+        assert trade.stats['profit_pct'] == pytest.approx(9.79)
 
 
 class TestTrades:
@@ -250,6 +288,25 @@ class TestTrades:
         assert trade.status == 'filled'
         assert trade.creator == 1
 
+    def test_new_paper_trade_persists_time_in_force(self, mock_users):
+        """Manual trades should keep the selected time-in-force on the Trade object."""
+        trades = Trades(mock_users)
+
+        status, trade_id = trades.new_trade(
+            target='test_exchange',
+            symbol='BTC/USDT',
+            price=50000.0,
+            side='buy',
+            order_type='LIMIT',
+            qty=0.1,
+            user_id=1,
+            time_in_force='IOC'
+        )
+
+        assert status == 'Success'
+        trade = trades.get_trade_by_id(trade_id)
+        assert trade.time_in_force == 'IOC'
+
     def test_new_live_trade_no_exchange(self, mock_users):
         """Test creating a live trade without exchange connected."""
         trades = Trades(mock_users)
@@ -269,6 +326,28 @@ class TestTrades:
         assert status == 'Error'
         assert 'No exchange' in msg.lower() or 'no exchange' in msg.lower()
 
+    def test_new_live_trade_rejects_manual_sltp(self, mock_users):
+        """Manual live SL/TP should fail fast until exchange-native support exists."""
+        trades = Trades(mock_users)
+        mock_exchange_interface = MagicMock()
+        mock_exchange_interface.get_exchange.return_value = MagicMock(configured=True)
+        trades.connect_exchanges(mock_exchange_interface)
+
+        status, msg = trades.new_trade(
+            target='binance',
+            symbol='BTC/USDT',
+            price=50000.0,
+            side='buy',
+            order_type='MARKET',
+            qty=0.1,
+            user_id=1,
+            testnet=True,
+            stop_loss=45000.0
+        )
+
+        assert status == 'Error'
+        assert 'not supported yet' in msg.lower()
+
     def test_new_production_trade_blocked_without_env_var(self, mock_users):
         """Test that production trades are blocked without ALLOW_LIVE_PRODUCTION."""
         import config
@@ -368,6 +447,31 @@ class TestTrades:
         assert trade_id not in trades.active_trades
         assert trade_id in trades.settled_trades
 
+    def test_close_trade_recomputes_final_pl_from_close_price(self, mock_users):
+        """Closing should use the settlement price, not the last cached unrealized P/L."""
+        trades = Trades(mock_users)
+        status, trade_id = trades.new_trade(
+            target='test_exchange',
+            symbol='BTC/USDT',
+            price=50000.0,
+            side='buy',
+            order_type='MARKET',
+            qty=0.1
+        )
+
+        assert status == 'Success'
+        trade = trades.get_trade_by_id(trade_id)
+        trade.fee = 0.001
+
+        trade.update_values(45000.0)
+        assert trade.stats['profit'] < 0
+
+        result = trades.close_trade(trade_id, current_price=55000.0)
+
+        assert result['success'] is True
+        assert result['final_pl'] == pytest.approx(489.5)
+        assert result['final_pl_pct'] == pytest.approx(9.79)
+
     def test_close_nonexistent_trade(self, mock_users):
         """Test closing a trade that doesn't exist."""
         trades = Trades(mock_users)
@@ -377,6 +481,136 @@ class TestTrades:
         assert result['success'] is False
         assert 'not found' in result['message']
 
+    def test_settle_broker_closed_position_filters_by_user_and_status(self, mock_users):
+        """Broker-side closes should only settle filled trades for the matching user/broker."""
+        trades = Trades(mock_users)
+
+        filled_trade = Trade(
+            target='test_exchange',
+            symbol='BTC/USDT',
+            side='BUY',
+            order_price=50000.0,
+            base_order_qty=0.1,
+            is_paper=True,
+            creator=1,
+            broker_kind='paper',
+            broker_mode='paper'
+        )
+        filled_trade.trade_filled(qty=0.1, price=50000.0)
+
+        other_user_trade = Trade(
+            target='test_exchange',
+            symbol='BTC/USDT',
+            side='BUY',
+            order_price=50000.0,
+            base_order_qty=0.1,
+            is_paper=True,
+            creator=2,
+            broker_kind='paper',
+            broker_mode='paper'
+        )
+        other_user_trade.trade_filled(qty=0.1, price=50000.0)
+
+        open_trade = Trade(
+            target='test_exchange',
+            symbol='BTC/USDT',
+            side='BUY',
+            order_price=49000.0,
+            base_order_qty=0.1,
+            is_paper=True,
+            creator=1,
+            broker_kind='paper',
+            broker_mode='paper'
+        )
+        open_trade.status = 'open'
+
+        trades.active_trades[filled_trade.unique_id] = filled_trade
+        trades.active_trades[other_user_trade.unique_id] = other_user_trade
+        trades.active_trades[open_trade.unique_id] = open_trade
+        trades.stats['num_trades'] = 3
+
+        settled_ids = trades.settle_broker_closed_position(
+            user_id=1,
+            symbol='BTC/USDT',
+            broker_key='paper',
+            close_price=44000.0
+        )
+
+        assert settled_ids == [filled_trade.unique_id]
+        assert filled_trade.unique_id not in trades.active_trades
+        assert filled_trade.unique_id in trades.settled_trades
+        assert trades.settled_trades[filled_trade.unique_id].status == 'closed'
+        assert other_user_trade.unique_id in trades.active_trades
+        assert open_trade.unique_id in trades.active_trades
+
+    def test_close_position_returns_closed_trade_ids(self, mock_users):
+        """Close-position API flow should report which trade IDs were removed locally."""
+        trades = Trades(mock_users)
+        trades.manual_broker_manager = MagicMock()
+        trades.manual_broker_manager.close_position.return_value = {
+            'success': True,
+            'status': 'filled',
+            'filled_price': 51000.0
+        }
+
+        trade = Trade(
+            target='kucoin',
+            symbol='BTC/USDT',
+            side='BUY',
+            order_price=50000.0,
+            base_order_qty=0.1,
+            creator=1,
+            broker_kind='live',
+            broker_mode='production',
+            broker_exchange='kucoin'
+        )
+        trade.trade_filled(qty=0.1, price=50000.0)
+        trades.active_trades[trade.unique_id] = trade
+        trades.stats['num_trades'] = 1
+
+        result = trades.close_position(1, 'BTC/USDT', 'kucoin_production')
+
+        assert result['success'] is True
+        assert result['trades_closed'] == 1
+        assert result['closed_trades'] == [trade.unique_id]
+        assert trade.unique_id not in trades.active_trades
+        assert trade.unique_id in trades.settled_trades
+
+    def test_close_position_leaves_trade_active_when_close_order_is_still_open(self, mock_users):
+        """Live close-position should not settle/remove the local trade until the close order fills."""
+        trades = Trades(mock_users)
+        trades.manual_broker_manager = MagicMock()
+        trades.manual_broker_manager.close_position.return_value = {
+            'success': True,
+            'status': 'open',
+            'order_id': 'close123',
+            'filled_price': 0.0,
+            'message': 'Close order submitted'
+        }
+
+        trade = Trade(
+            target='kucoin',
+            symbol='BTC/USDT',
+            side='BUY',
+            order_price=50000.0,
+            base_order_qty=0.1,
+            creator=1,
+            broker_kind='live',
+            broker_mode='production',
+            broker_exchange='kucoin'
+        )
+        trade.trade_filled(qty=0.1, price=50000.0)
+        trades.active_trades[trade.unique_id] = trade
+        trades.stats['num_trades'] = 1
+
+        result = trades.close_position(1, 'BTC/USDT', 'kucoin_production')
+
+        assert result['success'] is True
+        assert result['trades_closed'] == 0
+        assert result['closed_trades'] == []
+        assert trade.unique_id in trades.active_trades
+        assert trade.unique_id not in trades.settled_trades
+
     def test_is_valid_trade_id(self, mock_users):
         """Test trade ID validation."""
         trades = Trades(mock_users)

tests/test_trade2.py

@@ -68,10 +68,13 @@ def test_update_values():
     assert position_size == 10
     pl = trade_obj.get_pl()
     print(f'PL reported: {pl}')
-    assert pl == 0
+    # With 0.1% fee (0.001): gross P/L 0, fees = (10*0.001) + (10*0.001) = 0.02
+    # Net PL: -0.02
+    assert pl == pytest.approx(-0.02)
     pl_pct = trade_obj.get_pl_pct()
     print(f'PL% reported: {pl_pct}')
-    assert pl_pct == 0
+    # Should be -0.02/10 * 100 = -0.2%
+    assert pl_pct == pytest.approx(-0.2)
 
     # Divide the price of the quote symbol by 2.
     current_price = 50