Fix 5 bugs: safety sell-check, Alpaca timeout cancel, LightGBM label contamination, backtest fees & look-ahead bias

- safety.py: sell orders now subtract from position value instead of adding
- alpaca_broker.py: cancel unfilled orders on timeout to prevent position drift
- lgbm_strategy.py, strategy_ensemble.py: remove nan_to_num(0.5), let _flatten() filter NaN targets
- engine.py: reserve fee buffer before computing target shares to avoid negative cash
- engine.py: execute trades at T+1 close (signal day T, execution day T+1)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: yingwang

quant/backtest/engine.py

@@ -85,32 +85,35 @@ def run(self, prices: pd.DataFrame, target_weights_by_date: dict[str, pd.Series]
             if rd in dates:
                 rebalance_dates.add(rd)
 
+        pending_target = None  # Target weights waiting for T+1 execution
+
         for date in dates:
             px = prices_ffilled.loc[date, symbols]
             portfolio_value = cash + (holdings * px).sum()
 
-            # Rebalance if this is a rebalance date
-            if date in rebalance_dates:
-                target = target_weights_by_date.get(str(date.date()),
-                         target_weights_by_date.get(date, pd.Series(dtype=float)))
-                target = target.reindex(symbols).fillna(0)
+            # Execute pending rebalance at T+1 close (signal was computed at T)
+            if pending_target is not None:
+                target = pending_target
+                pending_target = None
+
+                # Reserve a fee buffer so target allocation doesn't push cash negative
+                fee_reserve_bps = self.txn_cost_bps + self.slippage_bps + self.impact_coeff
+                allocable = portfolio_value * (1 - fee_reserve_bps / 10000)
 
-                target_shares = (portfolio_value * target / px).fillna(0).apply(np.floor)
+                target_shares = (allocable * target / px).fillna(0).apply(np.floor)
                 trades = target_shares - holdings
 
                 # Apply transaction costs with market impact model
-                # cost = fixed_bps * trade_value + impact_coeff * sqrt(trade_value / portfolio) * trade_value
                 trade_value = (trades.abs() * px).sum()
                 fixed_cost = trade_value * (self.txn_cost_bps + self.slippage_bps) / 10000
                 participation = trade_value / portfolio_value if portfolio_value > 0 else 0
                 impact_cost = trade_value * self.impact_coeff * np.sqrt(participation) / 10000
                 cost = fixed_cost + impact_cost
                 cash -= cost
 
-                # Execute trades
+                # Execute trades at T+1 close price
                 trade_cash = (trades * px).sum()
                 cash -= trade_cash
-                # Update entry prices: set for new/increased positions, clear for sold
                 new_positions = (holdings == 0) & (target_shares > 0)
                 entry_prices[new_positions] = px[new_positions]
                 closed_positions = target_shares == 0
@@ -124,6 +127,12 @@ def run(self, prices: pd.DataFrame, target_weights_by_date: dict[str, pd.Series]
                     "cost": cost,
                 })
 
+            # On signal day, capture target weights for next-day execution
+            if date in rebalance_dates:
+                target = target_weights_by_date.get(str(date.date()),
+                         target_weights_by_date.get(date, pd.Series(dtype=float)))
+                pending_target = target.reindex(symbols).fillna(0)
+
             portfolio_value = cash + (holdings * px).sum()
 
             # Daily stop-loss check: sell positions that dropped below threshold

quant/execution/alpaca_broker.py

@@ -238,12 +238,18 @@ def _execute_single(self, order: Order, signal_price: float) -> Order:
             self.exec_log.log_order_filled(order, signal_price)
             self.safety.record_fill(order.quantity * order.filled_price)
         else:
-            order.status = "submitted"
             order.order_id = alpaca_order.id
-            logger.warning(
-                "Order for %s not filled within timeout, status=%s",
-                order.symbol, "submitted",
-            )
+            # Cancel unfilled/partially-filled order to prevent position drift
+            try:
+                self.api.cancel_order(alpaca_order.id)
+                logger.info("Cancelled timed-out order %s for %s", alpaca_order.id, order.symbol)
+                order.status = "cancelled"
+            except Exception as cancel_err:
+                logger.warning(
+                    "Failed to cancel timed-out order %s for %s: %s",
+                    alpaca_order.id, order.symbol, cancel_err,
+                )
+                order.status = "submitted"
 
         return order
 

quant/execution/safety.py

@@ -143,7 +143,11 @@ def validate(
 
         # 5. Position concentration check
         if portfolio_value > 0:
-            position_pct = (current_position_value + order_value) / portfolio_value
+            if order.side == "sell":
+                projected_position = max(0, current_position_value - order_value)
+            else:
+                projected_position = current_position_value + order_value
+            position_pct = projected_position / portfolio_value
             if position_pct > self.config.max_position_pct_of_portfolio:
                 reason = (
                     f"Position in {order.symbol} would be {position_pct:.1%} of portfolio, "

quant/signals/lgbm_strategy.py

@@ -300,7 +300,7 @@ def run_backtest(self, start: str = None, end: str = None) -> BacktestResult:
             returns, self.pred_horizon
         )
         y = cs_targets.reindex(index=dates, columns=symbols).values
-        y = np.nan_to_num(y, nan=0.5)
+        # Keep NaN — _flatten() filters them via np.isfinite()
 
         if not ML_BACKEND_AVAILABLE:
             logger.error(
@@ -436,7 +436,7 @@ def get_current_signal(self) -> pd.Series:
             returns, self.pred_horizon
         )
         y = cs_targets.reindex(index=dates, columns=symbols).values
-        y = np.nan_to_num(y, nan=0.5)
+        # Keep NaN — _flatten() filters them via np.isfinite()
 
         # Train on all available data
         date_idx = len(dates) - 1
@@ -494,7 +494,7 @@ def get_current_portfolio(self, capital: float = None) -> pd.DataFrame:
                 returns, self.pred_horizon
             )
             y = cs_targets.reindex(index=dates, columns=symbols).values
-            y = np.nan_to_num(y, nan=0.5)
+            # Keep NaN — _flatten() filters them via np.isfinite()
 
             date_idx = len(dates) - 1
             self._train_model(X, y, date_idx, feature_names)

quant/strategy_ensemble.py

@@ -233,7 +233,7 @@ def run_backtest(self, start: str = None, end: str = None) -> BacktestResult:
                     returns, 21  # pred_horizon
                 )
                 y_ml = cs_targets.reindex(index=ml_dates, columns=ml_symbols).values
-                y_ml = np.nan_to_num(y_ml, nan=0.5)
+                # Keep NaN — _flatten() filters them via np.isfinite()
 
                 lgbm_model = LGBMRankingModel(
                     num_leaves=31,
@@ -412,7 +412,7 @@ def get_current_signal(self) -> pd.Series:
                 )
                 cs_targets = self.feature_engine.get_cross_sectional_target(returns, 21)
                 y = cs_targets.reindex(index=dates, columns=syms).values
-                y = np.nan_to_num(y, nan=0.5)
+                # Keep NaN — _flatten() filters them via np.isfinite()
 
                 lgbm_model = LGBMRankingModel(
                     num_leaves=31, learning_rate=0.05,