finish experiment 51 (exp/51-q21-test-10d-label--weekly-rebalance-q04)

start experiment 51 (exp/51-q21-test-10d-label--weekly-rebalance-q04)
finish experiment 44 (exp/44-q12-long-horizon-22d-label-paired-with-w)
2026-08-20 05:38:35 +00:00 · 2026-08-20 05:35:32 +00:00 · 2026-08-20 04:14:15 +00:00 · 2026-08-20 03:55:47 +00:00
37 changed files with 796 additions and 1767 deletions
@@ -1,34 +1,31 @@
 # TradeAC custom-qlib-code snapshot (auto-generated)
-# parent repo HEAD : ce2e0c1a7cf2277108b3c6e469e225579f9cf259
+# parent repo HEAD : 70589e3766800c984c1e3e2e1e69892d1f10b3c1
 #   tac-qlib/tac_qlib/contrib
 #   tac-qlib/tac_qlib/data
 # per-file hashes (git hash-object):
  1b6298c4a5652f2e863cbdc385a1014a570fcd59  tac-qlib/tac_qlib/contrib/__init__.py
-  6c57851807631dfa1a525f87538a1b0a495fd7b2  tac-qlib/tac_qlib/contrib/__pycache__/__init__.cpython-312.pyc
+  b419ee55ed455a1c45423d1c9025ca5cc0a98576  tac-qlib/tac_qlib/contrib/__pycache__/__init__.cpython-312.pyc
  2224424d0ff193be4f55d1b791f8fce89439c5d2  tac-qlib/tac_qlib/contrib/backtest/__init__.py
  0bf40dee440ddbded357d7bbb4efc67c62c4b084  tac-qlib/tac_qlib/contrib/backtest/tradeac_exchange.py
  c76a9f17f680e74eea766eff27f7624359749ed6  tac-qlib/tac_qlib/contrib/data/__init__.py
-  1acd2cb845eac1bcee54450004a4af36484544ed  tac-qlib/tac_qlib/contrib/data/__pycache__/__init__.cpython-312.pyc
+  2f6c67620aa2f9e6aaaef3369361d9b3eac3d6ca  tac-qlib/tac_qlib/contrib/data/__pycache__/__init__.cpython-312.pyc
-  2ef18965f77e8955580334d2edc09bd381204355  tac-qlib/tac_qlib/contrib/data/__pycache__/handler.cpython-312.pyc
+  fdd5923a70a399e8680913593ff111641947898e  tac-qlib/tac_qlib/contrib/data/__pycache__/handler.cpython-312.pyc
-  3bba0f1696e4ab4b3deebec3f31f269b2e713899  tac-qlib/tac_qlib/contrib/data/handler.py
+  0dd25ef161c6e0f15eafc84886e7e1381deb38c3  tac-qlib/tac_qlib/contrib/data/handler.py
  b151d139a0dcde87d74b21e7c4b729176ba5c39b  tac-qlib/tac_qlib/contrib/model/__init__.py
-  c975d2b978f2cc08a388a5d921938704a3dd592d  tac-qlib/tac_qlib/contrib/model/__pycache__/__init__.cpython-312.pyc
+  08dec87ccdf6bb5d2cf611ca3032a4280aaab8cf  tac-qlib/tac_qlib/contrib/model/__pycache__/__init__.cpython-312.pyc
-  009ebd83c5156ca3d7039a112e0d277dd416ca86  tac-qlib/tac_qlib/contrib/model/__pycache__/rank_ensemble.cpython-312.pyc
+  6fb61946ea9a83dfb560de3717f5fbf482c4c00e  tac-qlib/tac_qlib/contrib/model/__pycache__/rank_ensemble.cpython-312.pyc
-  1716b680b5623394229f7600ad4c81ad07fa6a2b  tac-qlib/tac_qlib/contrib/model/__pycache__/rank_gbdt.cpython-312.pyc
+  3e80f2e08b661ddd2f58ffe5a6196063fa41ae51  tac-qlib/tac_qlib/contrib/model/__pycache__/rank_gbdt.cpython-312.pyc
  d3f051f3a8650c42fedc7b367b966f7c74fb5789  tac-qlib/tac_qlib/contrib/model/rank_ensemble.py
  d03e6611338918d4aac5eea4adf26f85a3763652  tac-qlib/tac_qlib/contrib/model/rank_gbdt.py
-  184f80da8edf944bad3c8fb4d4d3d189bf4f082b  tac-qlib/tac_qlib/contrib/strategy/__init__.py
+  c4ef84ffda2a611262412fe1127689c667f3d0c1  tac-qlib/tac_qlib/contrib/strategy/__init__.py
-  9c9f7743970b1a3827bb72768bb6e8be03040759  tac-qlib/tac_qlib/contrib/strategy/__pycache__/__init__.cpython-312.pyc
+  6ad10c2ebe37c16417e67c7aeb731ad1fcb6da2f  tac-qlib/tac_qlib/contrib/strategy/__pycache__/__init__.cpython-312.pyc
-  6e38a7fa8584b80410ccc88e5feff228a7ece38b  tac-qlib/tac_qlib/contrib/strategy/__pycache__/long_short.cpython-312.pyc
+  8d684b3216b040071d9ee4fa920a0e0c7486d278  tac-qlib/tac_qlib/contrib/strategy/__pycache__/optimal_stop.cpython-312.pyc
  f983d5c2472cd16ef9f14a240674ec0a7f41e81c  tac-qlib/tac_qlib/contrib/strategy/__pycache__/optimal_stop.cpython-312.pyc
  896ef74ae47bcd1ed388e1e5d9c8d70c28097fe9  tac-qlib/tac_qlib/contrib/strategy/kelly_dropout.py
  9090fc6dfbd339f2f4df4b0c9b87f400ecb5c9d5  tac-qlib/tac_qlib/contrib/strategy/long_short.py
  79aaad9e39fcc740a773f4f63c512ce1086cfde0  tac-qlib/tac_qlib/contrib/strategy/optimal_stop.py
  5b9acfb4340111b204249add7760bd53c6ae03f1  tac-qlib/tac_qlib/contrib/strategy/regime_gate.py
  aa1ee880d52ceb5821d65973962099c2254f710a  tac-qlib/tac_qlib/contrib/strategy/top_bottom.py
  fe60bacdfedd48617863be31f24b7c7daebfac5a  tac-qlib/tac_qlib/contrib/strategy/weekly_rebalance.py
  92e6e90eb0cd0a25142034560f27adb6b705b1a8  tac-qlib/tac_qlib/data/__init__.py
-  a0e969bd6504bb8d9220f4641cc01e960c3120e4  tac-qlib/tac_qlib/data/__pycache__/__init__.cpython-312.pyc
+  7c4e6c345fad1978efe8860c0d977d0c02d6f8d9  tac-qlib/tac_qlib/data/__pycache__/__init__.cpython-312.pyc
-  2f8c537d11135155539276bee342d087aad8743e  tac-qlib/tac_qlib/data/__pycache__/config.cpython-312.pyc
+  99e602392d51663cb06d5c425000b1ed1e5a916b  tac-qlib/tac_qlib/data/__pycache__/config.cpython-312.pyc
-  53cf7828c425f6b5032b206b93a238607111a6ed  tac-qlib/tac_qlib/data/__pycache__/providers.cpython-312.pyc
+  020dcdcf288e4832c8cf2386351f78d5ceb4fe13  tac-qlib/tac_qlib/data/__pycache__/providers.cpython-312.pyc
-  1953fb2a6371525db7f7b0e1c9dfbf3492d82110  tac-qlib/tac_qlib/data/config.py
+  53c9007a928841fd3c3b08450f9a6520ce1ac091  tac-qlib/tac_qlib/data/config.py
  8d0644f6f0d1efb94798ed444cc73e63b643459b  tac-qlib/tac_qlib/data/providers.py
@@ -1 +0,0 @@
 from .tradeac_exchange import TradeACExchange
@@ -1,432 +0,0 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT License.
 """
 TradeACExchange
 A short/borrow enabled Exchange implementation built on top of qlib.backtest.exchange.Exchange.
 This exchange adds simple, configurable margin logic (initial/maintenance), borrowing support for
 shorts, a borrow fee, and a lightweight SMA (Special Memorandum Account) concept to emulate
 behaviors similar to brokers such as IBKR and Alpaca for backtesting purposes.
 Notes / limitations
 - This implementation is intentionally lightweight and conservative: it implements the
  key behaviors needed for strategy/backtest experiments (allowing short selling, computing
  margin requirements, performing margin-call checks, and tracking SMA-like excess equity).
 - It makes some simplifying assumptions compared to real brokers (no per-product house margins,
  simplified SMA bookkeeping, borrow availability modeled only by a per-symbol boolean/limit).
 - The Position class in qlib.backtest.position was not changed. To support shorts we update the
  position.position dict directly when necessary. This keeps integration simple but bypasses some
  internal Position helpers. Use with care.
 API additions
 - allow_short: enable short selling (bool)
 - initial_margin_long/short: fraction required to open a position
 - maintenance_margin_long/short: fraction required to keep a position
 - borrow_fee_rate: periodic borrow fee applied on short value (applied at trade time as additional cost)
 - borrowable: dict mapping stock_id -> bool or float (max borrowable shares). Symbols missing from
  the dict follow `borrow_default` (default True = unlimited; set False for a strict whitelist)
 - get_sma(position): returns SMA-like excess equity available as "buying power credit"
 - check_margin_call(position): returns True if position is below maintenance requirement
 """
 from __future__ import annotations
 from typing import Any, Dict, Optional, Tuple
 import numpy as np
 from qlib.backtest.decision import Order
 from qlib.backtest.exchange import Exchange
 from qlib.backtest.position import BasePosition
 class TradeACExchange(Exchange):
    """An exchange that supports short selling / borrowing and basic margin rules.
    The implementation aims to be compatible with the Exchange API used by Account and
    Position classes in qlib.backtest. It overrides only the minimum methods required to
    enable short/borrow behavior and margin calculations.
    """
    def __init__(
        self,
        *args: Any,
        allow_short: bool = True,
        initial_margin_long: float = 0.5,
        initial_margin_short: float = 0.5,
        maintenance_margin_long: float = 0.25,
        maintenance_margin_short: float = 0.3,
        borrow_fee_rate: float = 0.0,
        borrowable: Optional[Dict[str, float]] = None,
        borrow_default: bool = True,
        sma_enabled: bool = True,
        **kwargs: Any,
    ) -> None:
        """Create TradeACExchange.
        Parameters mirror Exchange with additional tradeac-specific options.
        """
        super().__init__(*args, **kwargs)
        self.allow_short = allow_short
        self.initial_margin_long = initial_margin_long
        self.initial_margin_short = initial_margin_short
        self.maintenance_margin_long = maintenance_margin_long
        self.maintenance_margin_short = maintenance_margin_short
        self.borrow_fee_rate = borrow_fee_rate
        # borrowable can be a dict with per-symbol max borrowable amount, or None (unlimited)
        self.borrowable = borrowable or {}
        # borrow_default: policy for symbols absent from `borrowable`.
        #   True  -> unlisted symbols are unlimited-borrowable (legacy behavior)
        #   False -> unlisted symbols are NOT borrowable; only listed ones can be shorted
        self.borrow_default = bool(borrow_default)
        # sma_enabled: whether to expose lightweight SMA calculation
        self.sma_enabled = sma_enabled
    # --------------------------- Helper calculations ---------------------------
    def _initial_margin_requirement(self, position: BasePosition) -> float:
        """Compute the initial margin requirement (money) for the given position.
        We treat longs and shorts separately and sum their required initial margins.
        """
        im_req = 0.0
        for sid in position.get_stock_list():
            amt = position.get_stock_amount(sid)
            price = position.get_stock_price(sid)
            val = amt * price
            if val > 0:
                im_req += abs(val) * self.initial_margin_long
            elif val < 0:
                im_req += abs(val) * self.initial_margin_short
        return im_req
    def _maintenance_margin_requirement(self, position: BasePosition) -> float:
        """Compute the maintenance margin requirement (money) for the given position."""
        mm_req = 0.0
        for sid in position.get_stock_list():
            amt = position.get_stock_amount(sid)
            price = position.get_stock_price(sid)
            val = amt * price
            if val > 0:
                mm_req += abs(val) * self.maintenance_margin_long
            elif val < 0:
                mm_req += abs(val) * self.maintenance_margin_short
        return mm_req
    def get_equity(self, position: BasePosition) -> float:
        """Return account equity (position value + cash)."""
        return position.calculate_value()
    def get_sma(self, position: BasePosition) -> float:
        """Return a simplified SMA: excess equity above initial margin requirement.
        Note: This is a synthetic/Simplified SMA used for strategy/backtest logic. Real-broker
        SMA accounting (e.g. credits/debits across days) can be more complex.
        """
        if not self.sma_enabled:
            return 0.0
        equity = self.get_equity(position)
        im_req = self._initial_margin_requirement(position)
        return max(0.0, equity - im_req)
    def check_margin_call(self, position: BasePosition) -> bool:
        """Return True when the account is under maintenance margin (margin call).
        Margin call condition here is simple: equity < maintenance requirement.
        """
        equity = self.get_equity(position)
        mm_req = self._maintenance_margin_requirement(position)
        return equity < mm_req
    def get_buying_power(self, position: BasePosition) -> float:
        """Estimate buying power for new long positions assuming opening margin requirement.
        Simplified: the maximum notional long value = equity / initial_margin_long.
        """
        equity = self.get_equity(position)
        if self.initial_margin_long <= 0:
            return 0.0
        return equity / self.initial_margin_long
    # --------------------------- Order / execution overrides ---------------------------
    def _borrow_headroom(self, stock_id: str, current_short: float) -> float:
        """Remaining borrowable shares for `stock_id` given an already-open short of `current_short` shares.
        borrowable values: bool (True=unlimited, False=not borrowable) or numeric max shares.
        Missing symbols follow `borrow_default` (True = unlimited when allow_short is enabled).
        """
        if not self.allow_short:
            return 0.0
        v = self.borrowable.get(stock_id, self.borrow_default)
        if isinstance(v, bool):
            return float("inf") if v else 0.0
        try:
            limit = float(v)
        except (TypeError, ValueError):
            return float("inf")
        return max(0.0, limit - max(current_short, 0.0))
    def _calc_trade_info_by_order(
        self,
        order: Order,
        position: Optional[BasePosition],
        dealt_order_amount: Dict[str, float],
    ) -> Tuple[float, float, float]:
        """Override to allow (optionally) short selling and to apply borrow fees.
        The original Exchange implementation forbids selling more than you own. Here we allow
        sell orders to create/expand short positions when allow_short is True. We still rely on
        most base logic (price discovery, impact, cost calculation) by calling super(), but we
        adjust the sell-side clipping behavior before delegating to the base implementation.
        """
        # When selling and shorts are allowed, temporarily relax the clipping logic in the base
        # implementation by monkey-patching current position check. Simpler: replicate minimal
        # parts of logic from Exchange._calc_trade_info_by_order with the key change.
        # Get basic trade price & volume info using Exchange helpers
        trade_price = float(self.get_deal_price(order.stock_id, order.start_time, order.end_time, direction=order.direction))
        total_trade_val = float(self.get_volume(order.stock_id, order.start_time, order.end_time) or 0.0) * trade_price
        order.factor = self.get_factor(order.stock_id, order.start_time, order.end_time)
        order.deal_amount = order.amount  # attempt full
        # volume clipping (same as base)
        self._clip_amount_by_volume(order, dealt_order_amount)
        # approximate adjusted cost ratio based on liquidity
        if not total_trade_val or np.isnan(total_trade_val) or total_trade_val <= 0:
            adj_cost_ratio = self.impact_cost
        else:
            trade_val_tmp = order.deal_amount * trade_price
            adj_cost_ratio = self.impact_cost * (trade_val_tmp / total_trade_val) ** 2
        # Differentiate buy / sell
        if order.direction == Order.SELL:
            cost_ratio = self.close_cost + adj_cost_ratio
            current_amount = (
                position.get_stock_amount(order.stock_id) if (position is not None and position.check_stock(order.stock_id)) else 0.0
            )
            long_held = max(current_amount, 0.0)
            short_open = max(-current_amount, 0.0)
            if position is not None:
                if not self.allow_short:
                    # clip by current holdings only
                    if not np.isclose(order.deal_amount, current_amount):
                        order.deal_amount = self.round_amount_by_trade_unit(
                            min(long_held, order.deal_amount), order.factor
                        )
                else:
                    # allow selling beyond holdings up to the remaining borrow limit;
                    # later when updating the position we create/expand a short if necessary.
                    max_sell = long_held + self._borrow_headroom(order.stock_id, short_open)
                    if order.deal_amount > max_sell and not np.isclose(order.deal_amount, max_sell):
                        order.deal_amount = self.round_amount_by_trade_unit(max_sell, order.factor)
        elif order.direction == Order.BUY:
            cost_ratio = self.open_cost + adj_cost_ratio
            if position is not None:
                cash = position.get_cash()
                trade_val = order.deal_amount * trade_price
                if cash < max(trade_val * cost_ratio, self.min_cost):
                    order.deal_amount = 0
                    self.logger.debug(f"Order clipped due to cost higher than cash: {order}")
                elif cash < trade_val + max(trade_val * cost_ratio, self.min_cost):
                    max_buy_amount = self._get_buy_amount_by_cash_limit(trade_price, cash, cost_ratio)
                    order.deal_amount = self.round_amount_by_trade_unit(min(max_buy_amount, order.deal_amount), order.factor)
                    self.logger.debug(f"Order clipped due to cash limitation: {order}")
                else:
                    order.deal_amount = self.round_amount_by_trade_unit(order.deal_amount, order.factor)
            else:
                order.deal_amount = self.round_amount_by_trade_unit(order.deal_amount, order.factor)
        else:
            raise NotImplementedError("order direction {} error".format(order.direction))
        # compute final trade_val & trade_cost
        trade_val = order.deal_amount * trade_price
        # base trade_cost
        trade_cost = max(trade_val * cost_ratio, self.min_cost)
        # apply borrow fee only on the net-new short portion of the sell
        if order.direction == Order.SELL and self.allow_short:
            new_short = max(0.0, order.deal_amount - long_held)
            trade_cost += new_short * trade_price * self.borrow_fee_rate
        if trade_val <= 1e-5:
            trade_cost = 0
        return trade_price, trade_val, trade_cost
    def deal_order(
        self,
        order: Order,
        trade_account: Optional[Any] = None,
        position: Optional[BasePosition] = None,
        dealt_order_amount: Dict[str, float] = None,
    ) -> Tuple[float, float, float]:
        """Deal order and handle short position bookkeeping.
        This method mirrors Exchange.deal_order but when a position is provided and shorts are
        allowed it will update the Position.position dict directly to support negative amounts.
        """
        if dealt_order_amount is None:
            dealt_order_amount = {}
        if not self.check_order(order):
            order.deal_amount = 0.0
            self.logger.debug(f"Order failed due to trading limitation: {order}")
            return 0.0, 0.0, np.nan
        if trade_account is not None and position is not None:
            raise ValueError("trade_account and position can only choose one")
        pos = position or (trade_account.current_position if trade_account is not None else None)
        trade_price, trade_val, trade_cost = self._calc_trade_info_by_order(order, pos, dealt_order_amount)
        if trade_val > 1e-5:
            if trade_account is not None:
                cp = trade_account.current_position
                if not cp.skip_update():
                    held = cp.check_stock(order.stock_id)
                    # Account-level bookkeeping (turnover/cost/returns). Mirrors
                    # Account._update_state_from_order except for fresh short sales,
                    # where no prior price exists to compute order profit from.
                    if order.direction == Order.SELL and not held:
                        trade_account.accum_info.add_turnover(trade_val)
                        trade_account.accum_info.add_cost(trade_cost)
                        trade_account.accum_info.add_return_value(0.0)
                    if order.direction == Order.SELL:
                        # sell: update account state first (stock entry may be deleted)
                        if held:
                            trade_account._update_state_from_order(order, trade_val, trade_cost, trade_price)
                        self._position_sell(cp, order, trade_val, trade_cost, trade_price)
                    else:
                        # buy: update position first (entry may be created), then account state
                        # A buy that covers a short to exactly flat deletes the entry inside
                        # _position_buy; re-seed a transient zero-amount stub so the
                        # account's order-profit lookup still finds the trade price,
                        # then drop it (_update_state_from_order never mutates entries).
                        sid = order.stock_id
                        had_entry = isinstance(cp.position.get(sid), dict)
                        self._position_buy(cp, order, trade_val, trade_cost, trade_price)
                        covered_to_flat = had_entry and not isinstance(cp.position.get(sid), dict)
                        if covered_to_flat:
                            cp.position[sid] = {"amount": 0.0, "price": trade_price, "weight": 0}
                        trade_account._update_state_from_order(order, trade_val, trade_cost, trade_price)
                        if covered_to_flat:
                            cp.position.pop(sid, None)
            elif position is not None:
                if order.direction == Order.BUY:
                    self._position_buy(position, order, trade_val, trade_cost, trade_price)
                else:
                    self._position_sell(position, order, trade_val, trade_cost, trade_price)
        return trade_val, trade_cost, trade_price
    # --------------------------- Position mutation helpers ---------------------------
    def _position_buy(self, position: BasePosition, order: Order, trade_val: float, cost: float, trade_price: float) -> None:
        """Handle buy order bookkeeping against a BasePosition while supporting shorts.
        Rules implemented (simplified):
        - If there is an existing short (amount < 0), the buy will first cover the short.
        - If covering closes the short completely, the remaining buy becomes a long
        - Cash updates mimic Position._buy_stock/_sell_stock (cash decreases by trade_val+cost for buys)
        """
        trade_amount = trade_val / trade_price
        sid = order.stock_id
        current_amount = position.get_stock_amount(sid) if position.check_stock(sid) else 0.0
        # covering existing short
        if current_amount < -1e-12:
            # amount is negative -> we are short. Buying reduces the short.
            new_amount = current_amount + trade_amount
            if abs(new_amount) <= 1e-8:
                # short fully covered exactly -> remove entry
                if sid in position.position:
                    del position.position[sid]
            elif new_amount > 0:
                # short fully covered with leftover buy amount -> leftover becomes a long position
                position.position[sid] = {"amount": new_amount, "price": trade_price, "weight": 0}
            else:
                # partially cover
                position.position[sid]["amount"] = new_amount
                position.position[sid]["price"] = trade_price
        else:
            # normal or increasing long
            if sid not in position.position or not isinstance(position.position[sid], dict):
                # initialize stock
                position.position[sid] = {"amount": trade_amount, "price": trade_price, "weight": 0}
            else:
                position.position[sid]["amount"] = position.position[sid].get("amount", 0.0) + trade_amount
                position.position[sid]["price"] = trade_price
        # cash effect same as Position._buy_stock
        position.position["cash"] -= trade_val + cost
    def _position_sell(self, position: BasePosition, order: Order, trade_val: float, cost: float, trade_price: float) -> None:
        """Handle sell order bookkeeping against a BasePosition while supporting shorts.
        Rules implemented (simplified):
        - If holding enough long shares, sell will reduce/close the long position normally.
        - If not holding enough long shares and shorts are allowed, the remaining sold amount will create/expand a short position.
        - Cash update for sells follows Position._sell_stock logic (cash increases by trade_val - cost)
        """
        trade_amount = trade_val / trade_price
        sid = order.stock_id
        current_amount = position.get_stock_amount(sid) if position.check_stock(sid) else 0.0
        if current_amount > 1e-12:
            # we have long shares; sell from them first
            if trade_amount >= current_amount - 1e-8:
                # selling all or more than holdings
                # remove long position
                if sid in position.position:
                    del position.position[sid]
                # remaining sold amount becomes short if allowed
                remain = trade_amount - current_amount
                if remain > 1e-8:
                    if not self.allow_short:
                        # should not happen due to clipping earlier, but guard anyway
                        raise ValueError(f"Attempt to short {sid} while shorting disabled")
                    # create short entry
                    position.position[sid] = {"amount": -remain, "price": trade_price, "weight": 0}
            else:
                # partial sell
                position.position[sid]["amount"] = current_amount - trade_amount
                position.position[sid]["price"] = trade_price
        else:
            # currently flat or already short
            if not self.allow_short:
                raise ValueError(f"Attempt to short {sid} while shorting disabled")
            # expand short
            new_amount = current_amount - trade_amount
            if sid not in position.position or not isinstance(position.position[sid], dict):
                position.position[sid] = {"amount": new_amount, "price": trade_price, "weight": 0}
            else:
                position.position[sid]["amount"] = new_amount
                position.position[sid]["price"] = trade_price
        # cash effect same as Position._sell_stock
        new_cash = trade_val - cost
        if getattr(position, "_settle_type", None) == position.ST_CASH:
            position.position["cash_delay"] = position.position.get("cash_delay", 0.0) + new_cash
        else:
            position.position["cash"] = position.position.get("cash", 0.0) + new_cash
    # --------------------------- Borrow availability helpers ---------------------------
    def is_borrowable(self, stock_id: str, amount: float) -> bool:
        """Check whether the requested amount is borrowable for the given stock.
        If a borrowable dict is provided, it may contain either booleans or numeric limits (maximum borrowable shares).
        Symbols absent from the dict follow `borrow_default`.
        """
        if not self.allow_short:
            return False
        if stock_id not in self.borrowable:
            return self.borrow_default
        v = self.borrowable[stock_id]
        if isinstance(v, bool):
            return v
        try:
            limit = float(v)
            return amount <= limit
        except Exception:
            return True
@@ -15,9 +15,6 @@ import os
 from inspect import getfullargspec
 from typing import List, Optional, Tuple, Union
 import numpy as np
 import pandas as pd
 from qlib.data.dataset import processor as processor_module
 from qlib.data.dataset.handler import DataHandlerLP
 from qlib.utils import get_callable_kwargs
@@ -25,7 +22,6 @@ from qlib.utils import get_callable_kwargs
 from ...data.config import (
    LakeConfig,
    timeframe_for_freq,
    FEATURE_FAMILIES,
    NON_FEATURE_COLUMNS,
 )
@@ -96,7 +92,7 @@ def get_common_feature_fields(lake_root=None, market="US", timeframe="1d") -> Li
    common: set = set()
    # family tier: features/market=*/timeframe=*/family=*/symbol=*.parquet
-    for fam in FEATURE_FAMILIES:
+    for fam in ("ta", "sp"):
        fam_dir = feat_dir / f"family={fam}"
        if fam_dir.is_dir():
            common |= _family_common(fam_dir)
@@ -147,174 +143,6 @@ class DropAllNaN(processor_module.Processor):
        return df
 class BenchResidual(processor_module.Processor):
    """Subtract a benchmark instrument's forward return from the label, per datetime.
    Turns the training target from an absolute-return rank into a *residual* rank:
    ``r_i - r_bench`` is ranked cross-sectionally by the downstream ``CSRankNorm`` /
    ``CSZScoreNorm`` processors instead of ``r_i`` alone. Must be inserted BEFORE any
    per-date normalization so the ranking itself is computed on residual returns
    (ordering flips exactly where the benchmark trends).
    Stateless: ``fit`` is a no-op and the benchmark forward return is recomputed from
    the lake parquet on first ``__call__``. Rows whose benchmark value is missing are
    left untouched. Accepts ``fit_start_time``/``fit_end_time`` (ignored) so
    ``check_transform_proc`` can inject the fit window uniformly.
    NOTE: under any cross-sectional normalization downstream (``CSRankNorm`` /
    ``CSZScoreNorm``) this processor is a mathematical no-op: subtracting the same
    per-date constant preserves ranks, and z-scoring absorbs constant shifts. Use
    ``BenchBetaResidual`` for a target that actually reorders.
    """
    def __init__(
        self,
        benchmark="SPY",
        fields_group="label",
        lake_root=None,
        market="US",
        timeframe=None,
        freq="day",
        fit_start_time=None,
        fit_end_time=None,
    ):
        self.benchmark = benchmark
        self.fields_group = fields_group
        self.lake_root = lake_root
        self.market = market
        self.timeframe = timeframe or timeframe_for_freq(freq)
        self.fit_start_time = fit_start_time
        self.fit_end_time = fit_end_time
        self._bench_label = None
    def _load_bench_label(self):
        if self._bench_label is not None:
            return self._bench_label
        cfg = LakeConfig(self.lake_root, self.market)
        p = cfg.bar_path(self.timeframe, self.benchmark)
        if not p.exists():
            raise FileNotFoundError(f"BenchResidual: benchmark bar file not found: {p}")
        df = pd.read_parquet(p)
        s = pd.Series(df["c"].astype(float).values, index=pd.to_datetime(df["t"])).sort_index()
        s.index = s.index.normalize()
        # mirror Ref($close,-6)/Ref($close,-1)-1 on the benchmark's own calendar
        bench_label = s.shift(-6) / s.shift(-1) - 1
        self._bench_label = bench_label[~bench_label.index.duplicated(keep="last")]
        return self._bench_label
    def fit(self, df=None):
        return self
    def __call__(self, df):
        bl = self._load_bench_label()
        cols = processor_module.get_group_columns(df, self.fields_group)
        dt = df.index.get_level_values("datetime")
        aligned = bl.reindex(pd.DatetimeIndex(dt.unique())).reindex(dt)
        mask = aligned.notna().values
        out = df.copy()
        for c in cols:
            vals = df[c].values
            res = vals.copy()
            res[mask] = np.asarray(vals[mask], dtype=float) - aligned[mask].values
            out[c] = res
        return out
 class BenchBetaResidual(processor_module.Processor):
    """Residualize the label against a beta-scaled benchmark move: ``r_i - b_i * r_bench``.
    Unlike a plain constant subtraction (see ``BenchResidual``), the name-specific rolling
    beta ``b_i`` makes this survive cross-sectional normalization: in up-weeks high-beta
    names lose rank, in down-weeks they gain — exactly the relative structure an absolute-
    return ranking hides.
    Beta is estimated from *past* data only (rolling ``window`` trading days of daily close
    returns of each instrument vs the benchmark, both read up to and including ``t``), so
    no lookahead enters the target. The benchmark leg uses the same horizon as the label
    expression (``Ref($close,-6)/Ref($close,-1)-1`` by default via ``horizon``/``base``,
    matching the yaml's 6-day label). Rows with missing beta or benchmark values keep
    their raw label.
    Requires ``$close`` to be present in the feature group (it always is for TACHandler).
    Stateless; accepts ``fit_start_time``/``fit_end_time`` (ignored) for uniform kwargs
    injection. Must be inserted BEFORE any per-date normalization processor.
    """
    def __init__(
        self,
        benchmark="SPY",
        fields_group="label",
        lake_root=None,
        market="US",
        timeframe=None,
        freq="day",
        window=63,
        horizon=6,
        base=1,
        feature_field="$close",
        fit_start_time=None,
        fit_end_time=None,
    ):
        self.benchmark = benchmark
        self.fields_group = fields_group
        self.lake_root = lake_root
        self.market = market
        self.timeframe = timeframe or timeframe_for_freq(freq)
        self.window = int(window)
        self.horizon = int(horizon)
        self.base = int(base)
        self.feature_field = feature_field
        self.fit_start_time = fit_start_time
        self.fit_end_time = fit_end_time
        self._bench = None
    def _load_bench_close(self):
        if self._bench is not None:
            return self._bench
        cfg = LakeConfig(self.lake_root, self.market)
        p = cfg.bar_path(self.timeframe, self.benchmark)
        if not p.exists():
            raise FileNotFoundError(f"BenchBetaResidual: benchmark bar file not found: {p}")
        df = pd.read_parquet(p)
        s = pd.Series(df["c"].astype(float).values, index=pd.to_datetime(df["t"])).sort_index()
        s.index = s.index.normalize()
        self._bench = s[~s.index.duplicated(keep="last")]
        return self._bench
    def fit(self, df=None):
        return self
    def __call__(self, df):
        bench = self._load_bench_close()
        # benchmark forward return over the same horizon as the label expression
        fwd = bench.shift(-(self.base + self.horizon - 1)) / bench.shift(-self.base) - 1
        px_col = ("feature", self.feature_field)
        if px_col not in df.columns:
            raise KeyError(f"BenchBetaResidual: {self.feature_field} not found in features")
        px = df[px_col].unstack("instrument").sort_index()
        rets = px / px.shift(1) - 1
        bret = bench.reindex(px.index).pct_change()
        # rolling beta per instrument using data <= t (no lookahead)
        cov = rets.rolling(self.window, min_periods=max(10, self.window // 2)).cov(bret)
        var = bret.rolling(self.window, min_periods=max(10, self.window // 2)).var()
        beta = cov.div(var, axis=0)
        contrib = beta.mul(fwd.reindex(px.index), axis=0)
        cols = list(processor_module.get_group_columns(df, self.fields_group))
        out = df.copy()
        for c in cols:
            lab = df[c].unstack("instrument").reindex(px.index)
            resid = lab - contrib.where(contrib.notna() & lab.notna(), 0.0)
            new_vals = resid.stack()
            new_vals.index.names = df.index.names
            # residual where available, raw label otherwise (e.g. beta warm-up rows)
            out[c] = new_vals.reindex(out.index).fillna(df[c])
        return out
 class TACHandler(DataHandlerLP):
    """DataHandlerLP backed by the TradeAC parquet lake.
@@ -417,12 +245,10 @@ class TACHandler(DataHandlerLP):
        return get_common_feature_fields(lake_root, market, timeframe_for_freq(freq))
-__all__ = ["TACHandler", "DropAllNaN", "BenchResidual", "BenchBetaResidual", "get_common_feature_fields"]
+__all__ = ["TACHandler", "DropAllNaN", "get_common_feature_fields"]
-# Make `DropAllNaN`/`BenchResidual`/`BenchBetaResidual` resolvable by bare name from processor
+# Make `DropAllNaN` resolvable by bare name from processor configs (e.g. the default
-# configs (e.g. the default ``infer_processors`` and workflow yamls that reference them without a
+# ``infer_processors`` and workflow yamls that reference it without a ``module_path``),
-# ``module_path``), mirroring how qlib registers its own processors in ``qlib.data.dataset.processor``.
+# mirroring how qlib registers its own processors in ``qlib.data.dataset.processor``.
 processor_module.DropAllNaN = DropAllNaN
 processor_module.BenchResidual = BenchResidual
 processor_module.BenchBetaResidual = BenchBetaResidual
@@ -1,4 +1,13 @@
 from .kelly_dropout import FractionalKellyDropoutStrategy  # noqa: F401
 from .optimal_stop import OptimalStopControl  # noqa: F401
-from .long_short import LongShortTopkStrategy  # noqa: F401
+from .regime_gate import RegimeGateDropoutStrategy  # noqa: F401
 from .top_bottom import TopBottomDropoutStrategy  # noqa: F401
 from .weekly_rebalance import WeeklyRebalanceDropoutStrategy  # noqa: F401
-__all__ = ["OptimalStopControl", "LongShortTopkStrategy"]
+__all__ = [
    "OptimalStopControl",
    "FractionalKellyDropoutStrategy",
    "WeeklyRebalanceDropoutStrategy",
    "TopBottomDropoutStrategy",
    "RegimeGateDropoutStrategy",
 ]
@@ -1,361 +0,0 @@
 """Long-short Top-K strategy for cross-sectional signals.
 Each day the strategy ranks the cross-section by prediction score and rebalances
 to an equal-weight two-sided book: the ``topk`` highest-ranked names go long and
 the ``k_short`` lowest-ranked names go short. Net-new shorts are opened by
 selling beyond current holdings, which requires a short-aware exchange such as
 ``tac_qlib.contrib.backtest.tradeac_exchange.TradeACExchange`` with
 ``allow_short=True`` (borrow limits, margin requirements and borrow fees are
 enforced there, not here).
 Sizing deploys ``equity * risk_degree`` as gross notional split evenly across
 all long and short legs, so the book is approximately market neutral.
 ``allow_short=False`` disables the short side entirely (long-only ``topk``).
 Short eligibility can be restricted further, with static or dynamic gates:
 ``short_whitelist`` limits shorts to an explicit symbol set; ``short_vol_top_pct``
 requires a candidate's trailing realized volatility to rank in the top fraction
 of that day's cross-section; ``short_max_mom`` (falling-knife filter) only
 allows shorting names whose own trailing momentum is at/below a threshold;
 ``short_regime_sma`` disables shorts entirely while the benchmark trades above
 its moving average (risk-on). Borrow availability itself is enforced by the
 exchange (``borrowable`` whitelist / per-symbol caps via ``TradeACExchange``).
 Wired into qrun workflows like any ``BaseStrategy`` (see ``PortAnaRecord``
 config). Mirrors the API usage of qlib's ``TopkDropoutStrategy``: ``Order`` /
 ``OrderDir`` from ``qlib.backtest.decision``, ``trade_calendar`` /
 ``trade_exchange`` / ``trade_position`` injected by the backtest executor.
 """
 from __future__ import annotations
 import copy
 from typing import Dict, List, Optional
 import pandas as pd
 from qlib.backtest import Order
 from qlib.backtest.decision import OrderDir, TradeDecisionWO
 from qlib.contrib.strategy.signal_strategy import BaseSignalStrategy
 from qlib.log import get_module_logger
 __all__ = ["LongShortTopkStrategy"]
 class LongShortTopkStrategy(BaseSignalStrategy):
    """Equal-weight long-short Top-K strategy over a cross-sectional signal.
    Parameters
    ----------
    topk : number of long legs (highest-ranked names).
    k_short : number of short legs (lowest-ranked names).
    hold_thresh : minimum holding days before a leg may be closed/reduced.
    only_tradable : only select candidates tradable on the trade date.
    rebalance_tol : skip rebalances smaller than this fraction of a leg's
        target notional (turnover control).
    allow_short : enable/disable the short side. With ``False`` the bottom-ranked
        legs are dropped and the book is long-only ``topk``; pair with
        ``allow_short=False`` on the exchange for a fully borrow-free run.
        Legacy alias ``enable_short`` is accepted.
    short_whitelist : optional list of symbols eligible for shorting; candidates
        outside the list are skipped (``None`` = all names eligible).
    short_vol_window : trailing window (trading days) for realized-vol estimation.
    short_vol_top_pct : if set, a short candidate's trailing realized volatility
        must rank at or above this percentile of that day's cross-section
        (e.g. ``0.5`` = only the more volatile half may be shorted). Candidates
        without measurable vol are never shorted.
    short_mom_window : trailing window (trading days) for the candidate momentum
        used by the falling-knife gate.
    short_max_mom : if set, a candidate's trailing ``short_mom_window``-day return
        must be <= this value to be shortable (e.g. ``0.0`` = only short names
        that are actually falling). Candidates without measurable momentum are
        never shorted.
    short_regime_symbol : benchmark symbol for the regime gate (default SPY).
    short_regime_sma : if set, shorts are only allowed on days where the regime
        symbol's last close (strictly before the execution bar) is BELOW its
        ``short_regime_sma``-day moving average — i.e. shorts are disabled in
        risk-on regimes and enabled in drawdowns.
    """
    def __init__(
        self,
        *,
        signal=None,
        topk: int = 4,
        k_short: int = 2,
        hold_thresh: int = 1,
        only_tradable: bool = True,
        rebalance_tol: float = 0.05,
        allow_short: Optional[bool] = None,
        enable_short: Optional[bool] = None,
        short_whitelist: Optional[List[str]] = None,
        short_vol_window: int = 20,
        short_vol_top_pct: Optional[float] = None,
        short_mom_window: int = 20,
        short_max_mom: Optional[float] = None,
        short_regime_symbol: str = "SPY",
        short_regime_sma: Optional[int] = None,
        risk_degree: float = 0.95,
        trade_exchange=None,
        level_infra=None,
        common_infra=None,
        **kwargs,
    ):
        super().__init__(
            signal=signal,
            risk_degree=risk_degree,
            trade_exchange=trade_exchange,
            level_infra=level_infra,
            common_infra=common_infra,
            **kwargs,
        )
        if allow_short is None:
            allow_short = True if enable_short is None else bool(enable_short)
        self.allow_short = bool(allow_short)
        self.topk = topk
        self.k_short = k_short
        self.hold_thresh = hold_thresh
        self.only_tradable = only_tradable
        self.rebalance_tol = rebalance_tol
        self.short_whitelist = set(short_whitelist) if short_whitelist is not None else None
        if not 0 < float(short_vol_window) <= 1000:
            raise ValueError(f"short_vol_window must be in (0, 1000], got {short_vol_window}")
        self.short_vol_window = int(short_vol_window)
        if short_vol_top_pct is not None and not 0.0 < float(short_vol_top_pct) <= 1.0:
            raise ValueError(f"short_vol_top_pct must be in (0, 1], got {short_vol_top_pct}")
        self.short_vol_top_pct = None if short_vol_top_pct is None else float(short_vol_top_pct)
        if not 0 < float(short_mom_window) <= 1000:
            raise ValueError(f"short_mom_window must be in (0, 1000], got {short_mom_window}")
        self.short_mom_window = int(short_mom_window)
        self.short_max_mom = None if short_max_mom is None else float(short_max_mom)
        self.short_regime_symbol = str(short_regime_symbol)
        if short_regime_sma is not None and not 1 < int(short_regime_sma) <= 1000:
            raise ValueError(f"short_regime_sma must be in (1, 1000], got {short_regime_sma}")
        self.short_regime_sma = None if short_regime_sma is None else int(short_regime_sma)
        # per-day caches (keyed by trade date)
        self._vol_cache_key: Optional[str] = None
        self._vol_cache_val: Dict[str, Dict[str, float]] = {}
        self._regime_cache: Dict[str, bool] = {}
    # ------------------------------------------------------------------ utils
    def _is_tradable(self, code, start, end) -> bool:
        if not self.only_tradable:
            return True
        try:
            return self.trade_exchange.is_stock_tradable(stock_id=code, start_time=start, end_time=end)
        except TypeError:
            return True
    def _mark_price(self, code, start, end) -> Optional[float]:
        try:
            px = self.trade_exchange.get_deal_price(
                stock_id=code, start_time=start, end_time=end, direction=OrderDir.BUY
            )
        except (KeyError, ValueError):
            return None
        if px is None or px != px or px <= 0:
            return None
        return float(px)
    def _day_stats(self, codes: List[str], trade_start) -> Dict[str, Dict[str, float]]:
        """Per-day cross-sectional stats used by the dynamic short gates.
        For each code, returns ``{"vol_rank": r}`` (percentile of trailing
        realized vol over ``short_vol_window`` bars across that day's
        cross-section) when the vol gate is on, and ``{"mom": m}`` (trailing
        ``short_mom_window``-bar return) when the falling-knife gate is on.
        All series end on the last bar strictly BEFORE the execution bar (no
        lookahead). Codes without measurable data are simply absent — such
        candidates are never shorted (fail-closed).
        """
        if self.short_vol_top_pct is None and self.short_max_mom is None:
            return {}
        key = str(pd.Timestamp(trade_start))
        if self._vol_cache_key == key:
            return self._vol_cache_val
        out: Dict[str, Dict[str, float]] = {}
        try:
            from qlib.data import D
            end = pd.Timestamp(trade_start)
            buf = max(self.short_vol_window, self.short_mom_window) * 3 + 30
            df = D.features(
                sorted(codes),
                ["$close"],
                start_time=end - pd.Timedelta(days=buf),
                end_time=end - pd.Timedelta(days=1),
            )
            close = df["$close"].unstack(level="instrument") if isinstance(df.index, pd.MultiIndex) else df["$close"]
            if self.short_vol_top_pct is not None:
                vol = close.pct_change().rolling(self.short_vol_window).std().iloc[-1]
                for code, rank in vol.rank(pct=True).dropna().items():
                    out.setdefault(str(code), {})["vol_rank"] = float(rank)
            if self.short_max_mom is not None:
                w = min(self.short_mom_window, len(close) - 1)
                mom = close.iloc[-1] / close.iloc[-(w + 1)] - 1
                for code, m in mom.items():
                    if m == m:
                        out.setdefault(str(code), {})["mom"] = float(m)
        except Exception as e:  # noqa: BLE001 - degrade to fail-closed (no shorts)
            get_module_logger(self.__class__.__name__).warning(
                f"short gates unavailable ({type(e).__name__}: {e}); no shorts this step"
            )
        self._vol_cache_key, self._vol_cache_val = key, out
        return out
    def _regime_ok(self, trade_start) -> bool:
        """True when shorting is allowed by the benchmark-regime gate.
        With ``short_regime_sma`` set, shorts are permitted only while the
        regime symbol's last close strictly before the execution bar sits below
        its moving average (risk-off). Data failure fails closed (no shorts).
        """
        if self.short_regime_sma is None:
            return True
        key = str(pd.Timestamp(trade_start))
        cached = self._regime_cache.get(key)
        if cached is not None:
            return cached
        ok = False
        try:
            from qlib.data import D
            end = pd.Timestamp(trade_start)
            df = D.features(
                [self.short_regime_symbol],
                ["$close"],
                start_time=end - pd.Timedelta(days=int(self.short_regime_sma * 3 + 30)),
                end_time=end - pd.Timedelta(days=1),
            )
            s = df["$close"]
            if isinstance(s.index, pd.MultiIndex):
                s = s.droplevel("instrument")
            sma = s.rolling(self.short_regime_sma).mean().iloc[-1]
            px = s.iloc[-1]
            ok = bool(px < sma)
        except Exception as e:  # noqa: BLE001 - degrade to fail-closed (no shorts)
            get_module_logger(self.__class__.__name__).warning(
                f"regime gate unavailable ({type(e).__name__}: {e}); no shorts this step"
            )
        self._regime_cache[key] = ok
        return ok
    # ------------------------------------------------------------- decision
    def generate_trade_decision(self, execute_result=None):
        trade_step = self.trade_calendar.get_trade_step()
        trade_start, trade_end = self.trade_calendar.get_step_time(trade_step)
        pred_start, pred_end = self.trade_calendar.get_step_time(trade_step, shift=1)
        pred_score = self.signal.get_signal(start_time=pred_start, end_time=pred_end)
        if isinstance(pred_score, pd.DataFrame):
            pred_score = pred_score.iloc[:, 0]
        if pred_score is None or len(pred_score) == 0:
            return TradeDecisionWO([], self)
        pred_score = pred_score.dropna()
        if pred_score.empty:
            return TradeDecisionWO([], self)
        time_per_step = self.trade_calendar.get_freq()
        current_temp = copy.deepcopy(self.trade_position)
        # ---- signed current holdings ---------------------------------------
        cur_amount: Dict[str, float] = {}
        for code in current_temp.get_stock_list():
            amt = float(current_temp.get_stock_amount(code))
            if abs(amt) > 1e-6:
                cur_amount[code] = amt
        # ---- targets: top-k long, bottom-k_short short ----------------------
        ranked = list(pred_score.sort_values(ascending=False).index)
        longs: List[str] = []
        for code in ranked:
            if len(longs) >= self.topk:
                break
            if self._is_tradable(code, trade_start, trade_end):
                longs.append(code)
        shorts: List[str] = []
        if self.allow_short and self._regime_ok(trade_start):
            stats = self._day_stats(list(ranked), trade_start)
            for code in reversed(ranked):
                if len(shorts) >= self.k_short:
                    break
                if code in longs:
                    continue
                if not self._is_tradable(code, trade_start, trade_end):
                    continue
                if self.short_whitelist is not None and code not in self.short_whitelist:
                    continue
                st = stats.get(code)
                if self.short_vol_top_pct is not None:
                    rank = None if st is None else st.get("vol_rank")
                    if rank is None or rank < self.short_vol_top_pct:
                        continue
                if self.short_max_mom is not None:
                    mom = None if st is None else st.get("mom")
                    if mom is None or mom > self.short_max_mom:
                        continue
                shorts.append(code)
        # ---- marks & equity --------------------------------------------------
        marks: Dict[str, float] = {}
        for code in set(cur_amount) | set(longs) | set(shorts):
            px = self._mark_price(code, trade_start, trade_end)
            if px is not None:
                marks[code] = px
        equity = current_temp.get_cash()
        for code, amt in cur_amount.items():
            if code in marks:
                equity += amt * marks[code]
        if equity <= 0:
            return TradeDecisionWO([], self)
        n_legs = len([c for c in longs if c in marks]) + len([c for c in shorts if c in marks])
        if n_legs == 0:
            return TradeDecisionWO([], self)
        per_leg = equity * self.risk_degree / n_legs
        target_signed: Dict[str, float] = {}
        for code in longs:
            if code in marks:
                target_signed[code] = per_leg / marks[code]
        for code in shorts:
            if code in marks:
                target_signed[code] = -(per_leg / marks[code])
        # ---- order generation -------------------------------------------------
        sell_orders: List[Order] = []
        buy_orders: List[Order] = []
        def submit(code: str, amount: float, direction: int) -> None:
            factor = self.trade_exchange.get_factor(stock_id=code, start_time=trade_start, end_time=trade_end)
            amount = self.trade_exchange.round_amount_by_trade_unit(amount, factor)
            if amount <= 1e-6:
                return
            o = Order(stock_id=code, amount=amount, start_time=trade_start, end_time=trade_end, direction=direction)
            if self.trade_exchange.check_order(o):
                (buy_orders if direction == Order.BUY else sell_orders).append(o)
        # close holdings that are no longer targeted (frees cash / unwinds shorts)
        for code, amt in cur_amount.items():
            if code in target_signed:
                continue
            if marks.get(code) is None:
                continue
            if current_temp.get_stock_count(code, bar=time_per_step) < self.hold_thresh:
                continue
            submit(code, abs(amt), Order.SELL if amt > 0 else Order.BUY)
        # rebalance targeted legs toward their signed target quantity
        for code, tgt in target_signed.items():
            cur = cur_amount.get(code, 0.0)
            delta = tgt - cur
            if abs(delta * marks[code]) < max(self.rebalance_tol * per_leg, 1.0):
                continue
            if delta > 0:
                submit(code, delta, Order.BUY)
            else:
                if cur > 0 and current_temp.get_stock_count(code, bar=time_per_step) < self.hold_thresh:
                    continue
                submit(code, -delta, Order.SELL)
        return TradeDecisionWO(sell_orders + buy_orders, self)
@@ -0,0 +1,169 @@
 """Market-neutral top/bottom long-short strategy for cross-sectional signals.
 Captures the cross-sectional long-short spread net of costs: buys the top-ranked
 ``topk`` names and shorts the bottom-ranked ``topk`` names, equal-weight per
 side, sized to ``risk_degree`` of total value per side. Rebalances daily to the
 current rank (dropout-free: the book converges to the latest top/bottom sets).
 The long and short legs use equal notional per side (gross exposure ~2x
 ``risk_degree`` of NAV, i.e. approximately market neutral before transaction
 costs). Benchmark neutrality (SPY beta ~ 0) is the secondary sanity metric.
 """
 from __future__ import annotations
 from typing import List
 import copy
 import pandas as pd
 from qlib.backtest import Order
 from qlib.backtest.decision import OrderDir, TradeDecisionWO
 from qlib.contrib.strategy.signal_strategy import BaseSignalStrategy
 __all__ = ["TopBottomDropoutStrategy"]
 DEFAULT_SHORT_LEG = True
 DEFAULT_REBALANCE_DAILY = True
 class TopBottomDropoutStrategy(BaseSignalStrategy):
    """Long top-k / short bottom-k equal-weight market-neutral book.
    Parameters
    ----------
    topk : number of names on each side (long top-k and short bottom-k).
    short_leg : whether to open the short side (if False, long-only topk).
    rebalance_daily : if True rebalance to current rank every day; else keep
        positions and only refresh on score changes (dropout-style).
    risk_degree : fraction of total value deployed per side.
    """
    def __init__(
        self,
        *,
        topk: int = 10,
        short_leg: bool = DEFAULT_SHORT_LEG,
        rebalance_daily: bool = DEFAULT_REBALANCE_DAILY,
        **kwargs,
    ):
        super().__init__(**kwargs)
        self.topk = topk
        self.short_leg = short_leg
        self.rebalance_daily = rebalance_daily
        self._prev_longs = set()
        self._prev_shorts = set()
    def generate_trade_decision(self, execute_result=None):
        trade_step = self.trade_calendar.get_trade_step()
        trade_start_time, trade_end_time = self.trade_calendar.get_step_time(trade_step)
        pred_start_time, pred_end_time = self.trade_calendar.get_step_time(trade_step, shift=1)
        pred_score = self.signal.get_signal(start_time=pred_start_time, end_time=pred_end_time)
        if isinstance(pred_score, pd.DataFrame):
            pred_score = pred_score.iloc[:, 0]
        if pred_score is None or len(pred_score) == 0:
            return TradeDecisionWO([], self)
        # rank all names; topk longs and topk shorts
        ranked = pred_score.sort_values(ascending=False)
        longs = list(ranked.index[: self.topk])
        shorts = list(ranked.index[-self.topk :]) if self.short_leg else []
        current_temp: "object" = copy.deepcopy(self.trade_position)
        current_codes = set(current_temp.get_stock_list())
        holdings = {c: current_temp for c in current_codes if abs(current_temp.get_stock_amount(c)) > 1e-6}
        sell_orders: List[Order] = []
        buy_orders: List[Order] = []
        def _tradable(code, direction):
            try:
                return self.trade_exchange.is_stock_tradable(
                    stock_id=code, start_time=trade_start_time, end_time=trade_end_time, direction=direction
                )
            except TypeError:
                return self.trade_exchange.is_stock_tradable(
                    stock_id=code, start_time=trade_start_time, end_time=trade_end_time
                )
        # determine target set (long/short)
        target_longs = set(longs)
        target_shorts = set(shorts)
        # close positions not in the target book
        for code in list(holdings):
            if code in target_longs or code in target_shorts:
                continue
            amt = abs(current_temp.get_stock_amount(code))
            o = Order(
                stock_id=code,
                amount=amt,
                start_time=trade_start_time,
                end_time=trade_end_time,
                direction=Order.SELL if code in target_longs else Order.SELL,
            )
            if self.trade_exchange.check_order(o):
                sell_orders.append(o)
                self.trade_exchange.deal_order(o, position=current_temp)
        # equal-weight notional per side
        total_value = current_temp.get_cash()
        for code, pos in holdings.items():
            if code in target_longs or code in target_shorts:
                mark = self.trade_exchange.get_deal_price(
                    stock_id=code, start_time=trade_start_time, end_time=trade_end_time, direction=Order.SELL
                )
                if mark is not None and mark == mark:
                    total_value += abs(current_temp.get_stock_amount(code)) * mark
        side_notional = total_value * self.risk_degree / max(1, self.topk)
        for code in longs:
            if code in holdings and abs(current_temp.get_stock_amount(code)) > 1e-6:
                continue
            px = self.trade_exchange.get_deal_price(
                stock_id=code, start_time=trade_start_time, end_time=trade_end_time, direction=Order.BUY
            )
            if px is None or px != px or px <= 0:
                continue
            amount = side_notional / px
            factor = self.trade_exchange.get_factor(
                stock_id=code, start_time=trade_start_time, end_time=trade_end_time
            )
            amount = self.trade_exchange.round_amount_by_trade_unit(amount, factor)
            o = Order(
                stock_id=code,
                amount=amount,
                start_time=trade_start_time,
                end_time=trade_end_time,
                direction=Order.BUY,
            )
            if self.trade_exchange.check_order(o):
                buy_orders.append(o)
        if self.short_leg:
            for code in shorts:
                if code in holdings and abs(current_temp.get_stock_amount(code)) > 1e-6:
                    continue
                px = self.trade_exchange.get_deal_price(
                    stock_id=code, start_time=trade_start_time, end_time=trade_end_time, direction=Order.SELL
                )
                if px is None or px != px or px <= 0:
                    continue
                amount = side_notional / px
                factor = self.trade_exchange.get_factor(
                    stock_id=code, start_time=trade_start_time, end_time=trade_end_time
                )
                amount = self.trade_exchange.round_amount_by_trade_unit(amount, factor)
                o = Order(
                    stock_id=code,
                    amount=amount,
                    start_time=trade_start_time,
                    end_time=trade_end_time,
                    direction=Order.SELL,
                )
                if self.trade_exchange.check_order(o):
                    sell_orders.append(o)
        return TradeDecisionWO(sell_orders + buy_orders, self)
@@ -61,11 +61,6 @@ UNKNOWN_FIELD_NAMES = ("factor", "change", "trade_unit", "suspend_flag")
 #: columns in the parquet files that are not features
 NON_FEATURE_COLUMNS = ("t", "date", "market", "timeframe", "symbol")
 #: Feature-family partitions merged by ``LakeConfig.load_features`` and scanned
 #: by the handler's field discovery. ``macro`` holds broadcast market-state
 #: columns (see skills/tac-qlib-custom/examples/persist_macro_broadcast.py).
 FEATURE_FAMILIES = ("ta", "sp", "macro")
 def timeframe_for_freq(freq: str) -> str:
    """Map a qlib frequency (e.g. ``day``, ``1min``) to a lake timeframe (e.g. ``1d``)."""
@@ -118,12 +113,12 @@ class LakeConfig:
        return self.features_dir(timeframe) / f"symbol={str(symbol).upper()}.parquet"
    def load_features(self, timeframe: str, symbol: str) -> pd.DataFrame:
-        """All feature columns for a symbol, merging the `family=ta|sp|macro`
+        """All feature columns for a symbol, merging the `family=ta` and
-        partitions by timestamp. Returns an empty frame when no
+        `family=sp` partitions by timestamp. Returns an empty frame when no
        feature files exist (legacy flat layout falls back transparently)."""
        sym = str(symbol).upper()
        frames = []
-        for family in FEATURE_FAMILIES:
+        for family in ("ta", "sp"):
            p = self.features_dir(timeframe) / f"family={family}" / f"symbol={sym}.parquet"
            if p.exists():
                frames.append(pd.read_parquet(p))
@@ -0,0 +1,69 @@
 # TradeAC Experiment Queue — Series 2 (Q12+)
 **Purpose.** The next pre-registered batch of experiments, continuing Series 1
 (Q01–Q11, exp 33–43, all executed and folded into `book/CLAIMS.md` /
 `book/EVIDENCE.md`). Each entry targets a still-unproven `HYPOTHESIS` from the
 book or an open question flagged in `CLAIMS.md`/`book/README.md`, and follows the
 Series-1 discipline: one variable changed vs the exp-26 reference, acceptance
 fixed BEFORE the run, sequential execution, trace-first, verify-then-close.
 **Reference / control (MUST reproduce first).** exp 26 (`21afc6af…`, mlflow exp
 25) is the campaign baseline; exp 39 (Q07, weekly rebalance) is the best
 construction. Reference config is byte-reproduced in `workflows/exp26/` on the
 `exp/26-…` branch and in this dir's `workflows/*.yaml`.
 | Config element | exp-26 reference value |
 |---|---|
 | Universe | 50-ETF panel (`UNIVERSE` below) |
 | Features | compact stochastic 25-field set (no ou/hmm/moments/garch) |
 | Label | `Ref($close,-6)/Ref($close,-1)-1` (5d) |
 | Model | `RankICEnsembleLGBModel`, seeds `42,7,2026,99,123`, lr 0.02, leaves 31, 3000 rounds, ES 200 |
 | Segments | train 2016-01-04..2025-09-01 / valid 2025-09-03..2026-01-03 / test 2026-01-04..2026-08-10 |
 | Strategy | TopkDropout, topk 10, n_drop 1, risk_degree 0.95 |
 | Costs | open 0.0005 / close 0.0015 / min $5, deal $close, SPY benchmark, $1M |
 **Reference metrics to beat (EVIDENCE#015):** net_ann +2.13%, net_IR 0.21, gross
 +7.02%, maxDD −7.69%, RankIC 0.0663, RankICIR 0.2545, L/S Sharpe 4.54. Weekly
 (Q07, EVIDENCE#028): net +12.51%, IR 1.24, maxDD −4.13%, ~1.1pp cost drag.
 ## The queue (ordered by value × feasibility)
 | ID | Title / hypothesis | Change vs reference (ONE var) | Acceptance | Config | Ready? |
 |----|--------------------|-------------------------------|------------|--------|--------|
 | Q12 | **22d label + weekly recompute** — the untested combo: Q05's label edge (IC 0.097, RankIC 0.117) with Q07's cost relief | label → 22d AND strategy → weekly (two coupled, explicitly pre-registered) | net_IR > 0.5, net_ann > +5%, cost drag ≤ 2pp | `workflows/q12_label22d_weekly.yaml` | ✅ |
 | Q13 | **Weekly rebalance reproduction on a 2nd window** — Q07 was a single OOS window; reproduce on test 2025-01-02..2025-12-31 before promoting to a live round | segments only (shifted) | net_IR > 0.21, net_ann > +2.13% on the new window | `workflows/q13_weekly_second_window.yaml` | ✅ |
 | Q14 | **Out-of-universe validation** — compact stochastic set generalizes off the 50-ETF panel to a single-stock universe | universe → 30 liquid single names | RankIC > 0.03, ICIR > 0.15, net IR > 0 on stocks | `workflows/q14_out_of_universe.yaml` | ⚠️ needs stock-lake backfill (see design) |
 | Q15 | **5-seed vs single-model clean A/B** — seed-count claim (exp 12 idea, re-validated exp 22–24, never a clean A/B) | seeds → 1 (`2026`) | single-model RankIC/IR < 5-seed ref; net_IR ≥ 0.21 acceptable if ≥ single | `workflows/q15_single_seed.yaml` | ✅ |
 | Q16 | **HMM family added as features** — settles "dropping model-specific (ou,hmm) improves signal" (exp 25 tested OU; hmm-as-feature untested) | features += `sp_hmm_p_regime1,sp_hmm_state` | no improvement: RankIC ≤ 0.0663, net_IR ≤ 0.21 | `workflows/q16_hmm_features.yaml` | ✅ |
 | Q17 | **Realized-moments family added** — settles "moment/volatility families regress" (exp 11 idea, never clean A/B) | features += `sp_rskew_5,sp_rskew_22,sp_rkurt_5,sp_rkurt_22,sp_dsv_5,sp_dsv_22` | no improvement: RankIC ≤ 0.0663, net_IR ≤ 0.21 | `workflows/q17_moments_features.yaml` | ✅ |
 | Q18 | **OptimalStopControl clean re-test** — exp 13/14 claim (TopkDropout > stop-control) never re-tested post-reset | strategy → `OptimalStopControl` (exp-13 params) | TopkDropout net_IR ≥ stop-control net_IR; document cost drag | `workflows/q18_optstop.yaml` | ✅ (module verified in venv) |
 | Q19 | **Martingale / variance-ratio study close-out** — exp 19 never closed; VR<1 at 5–20d on clean lake | ad-hoc script (no qrun) | VR stats + drift decomposition on 50-ETF panel | `designs/q19_martingale_vr.md` | ✅ script |
 | Q20 | **Effective independent names (≈4)** — eigenvalue analysis on clean-lake covariance | ad-hoc script | eigenvalue spectrum + effective-rank count | `designs/q20_effective_names.md` | ✅ script |
 ### Deferred (methodology / infra, P3)
 - Purged / walk-forward CV (was queue's old Q12) — methodology, not an alpha lever.
 - PSI-based drift-aware retraining cadence — needs a drift-gate module + a retrain decision rule.
 - No-trade buffer band / notional-vs-qty sizing — siblings of Q12/Q13; queue only if weekly reproduces.
 - Macro/drift overlays (SPY>200d regime gate, momentum tilt) — needs new data pipeline.
 ## Execution protocol (per queued run)
 1. **Validate the lake first** (`validate_lake_dataset` + `rd_status`) — clean-lake lesson: silent NaN-drops and hollow coverage invalidate a run. Q14 additionally requires backfilling the single-stock universe (bars + sp/ta features, full range, explicit `start`/`end`).
 2. **Trace before running** (`rd_trace_start` with the hypothesis as `rational`, fresh `experiment_name`, `evolved_from=auto`).
 3. **Run** `rd_run_workflow config_path=<abs path to the queue YAML> experiment_name=<fresh name>` — `wait=false`, poll `rd_exp_get_run` until `FINISHED`.
 4. **Verify against acceptance** via `rd_exp_result` (headline + backtest risk).
 5. **Finish the trace** (`rd_trace_finish` with `metrics` + `evaluation`), snapshot any changed contrib modules.
 6. **Report to the book** — PROVE/REFUTE → update `book/CLAIMS.md` + `book/EVIDENCE.md`.
 Sequential execution only (concurrent runs hang — chat-ideas.md ops lesson). Any
 custom strategy/module changed here must be copied into the venv site-packages
 snapshot before `rd_run_workflow` can import it (see `/app/AGENTS.md`). As of
 2026-08-20 `WeeklyRebalanceDropoutStrategy` and `OptimalStopControl` are verified
 in sync with the venv snapshot; the lake already persists the `sp_hmm_*` and
 `sp_moments` families on the 50-ETF panel.
 ## Provenance
 Mined 2026-08-20 from `book/CLAIMS.md`, `book/EVIDENCE.md`, `book/README.md`,
 `book/references/chat-ideas.md`, and Series-1 `queue/` (Q01–Q11, executed exp
 33–43). Reference numbers are post-clean-lake (exp 21+).
@@ -0,0 +1,26 @@
 # QUEUE-19 — Martingale / variance-ratio study close-out (no qrun)
 **Status:** QUEUED · **Priority:** P2 · **Effort:** ad-hoc script under `book/data/`
 ## Hypothesis (settle)
 Assets are submartingales long-horizon / mean-reverting short-horizon
 (`VR < 1` at 5–20d). CLAIMS.md marks this HYPOTHESIS (chat-derived martingale
 study; exp 19 was opened but never closed). It is a market-structure claim, not a
 trading claim — settle it with a clean-lake script, then close exp 19 or open a
 scripted EVIDENCE entry.
 ## Method (persist everything under `book/data/evidence/q19-vr/`)
 1. Load the 50-ETF panel 1d bars from the lake for 2015-01-01..2026-08-19.
 2. Compute the Lo–MacKinlay variance ratio at horizons 5 / 10 / 20d per symbol,
   with heteroskedasticity-robust z-stats.
 3. Report: per-horizon VR distribution, fraction of symbols with VR < 1 and the
   z-significance, pooled drift vs daily variance (submartingale check).
 4. Cross-check the pooled `sp_trend_slope_5` regression beta claim (β ≈ −0.53,
   t ≈ −24) on the clean lake.
 5. Write `VR_stats.csv` + a one-page summary into the evidence dir.
 ## Acceptance
 - VR < 1 at 5–20d for a material fraction of the panel with |z| > 2 → supports
  the mean-reversion HYPOTHESIS; else mark REFUTED or REFERENCED.
 - The result updates CLAIMS.md's "Assets are submartingales…" row and closes the
  exp-19 open thread.
@@ -0,0 +1,22 @@
 # QUEUE-20 — Effective independent names in the 50-ETF book (no qrun)
 **Status:** QUEUED · **Priority:** P2 · **Effort:** ad-hoc script under `book/data/`
 ## Hypothesis (settle)
 The 50-ETF book has only ~4 effective independent names (CLAIMS.md HYPOTHESIS,
 chat-derived eigenvalue analysis, pre-reset). This is a concentration/diversification
 claim with direct sizing relevance; verify it on the clean lake.
 ## Method (persist everything under `book/data/evidence/q20-effective-names/`)
 1. Load the 50-ETF panel 1d returns from the lake for the test window 2026-01-04..2026-08-10.
 2. Standardize returns; compute the correlation matrix and its eigendecomposition.
 3. Count eigenvalues above the Marchenko–Pastur bound (N=50, T≈150) and report the
   cumulative-variance share of the top k components.
 4. Effective-rank measures: participation ratio `(Σλ)² / Σλ²` and cumulative 80%
   variance count.
 5. Write `eigenanalysis.csv` + a one-page summary.
 ## Acceptance
 - If effective rank ≈ 4 (top-4 explain ~80%+ variance), the concentration claim is
  PROVEN and feeds chapter 08 sizing guidance (why topk 10→20 adds no breadth).
 - If effective rank is much larger, mark the claim REFUTED.
@@ -1,140 +0,0 @@
 # -----------------------------------------------------------------------------
 # QUEUE-01 — M2 reproduction: risk-adjusted 22d Sharpe drift (sp_sharpe_22).
 #
 # Hypothesis (book ch.01/ch.07, EVIDENCE#018 -> exp 30): adding the
 # risk-adjusted 22d Sharpe drift feature (sp_sharpe_22) to the compact
 # stochastic reference IMPROVES net portfolio performance (exp 30: net +6.53%
 # IR 0.62 vs reference +2.13% IR 0.21) while rank metrics dip (RankIC 0.0576 vs
 # 0.0663). exp 30 is a SINGLE clean-lake run, unreproduced -> HYPOTHESIS.
 #
 # Change vs exp-26 reference (EVIDENCE#015, run 21afc6af...): ONE feature added,
 # feature_fields = compact set + sp_sharpe_22. Everything else byte-identical.
 #
 # Acceptance: net_ann_return > +2.13% AND net_IR > 0.21 (else HYPOTHESIS -> REFUTED).
 # Run: rd_run_workflow config_path=<repo>/experiments/queue/workflows/q01_m2_sharpe22_repro.yaml \
 #        experiment_name=tac-rd-q01-m2-sharpe22-repro
 # -----------------------------------------------------------------------------
 {%- set LAKE = TAC_LAKE_DIR %}
 {%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
 {%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sharpe_22" %}
 qlib_init:
    provider_uri: "{{ LAKE }}"
    region: us
    expression_cache: null
    dataset_cache: null
    calendar_provider:
        class: tac_qlib.data.providers.LakeCalendarProvider
        kwargs:
            lake_root: "{{ LAKE }}"
            market: US
    instrument_provider:
        class: tac_qlib.data.providers.LakeInstrumentProvider
        kwargs:
            lake_root: "{{ LAKE }}"
            market: US
            markets: {}
    feature_provider:
        class: tac_qlib.data.providers.LakeFeatureProvider
        kwargs:
            lake_root: "{{ LAKE }}"
            market: US
    exp_manager:
        class: MLflowExpManager
        module_path: qlib.workflow.expm
        kwargs:
            uri: "sqlite:///{{ LAKE }}/mlruns.db"
            default_exp_name: "tac-rd-q01-m2-sharpe22-repro"
 task:
    model:
        class: RankICEnsembleLGBModel
        module_path: tac_qlib.contrib.model.rank_ensemble
        kwargs:
            loss: mse
            learning_rate: 0.02
            num_leaves: 31
            n_estimators: 3000
            num_boost_round: 3000
            early_stopping_rounds: 200
            min_data_in_leaf: 20
            lambda_l2: 0.5
            colsample_bytree: 0.8
            subsample: 0.8
            subsample_freq: 1
            reg_alpha: 0.1
            reg_lambda: 1.0
            seeds: "42,7,2026,99,123"
            parallel: 5
    dataset:
        class: DatasetH
        module_path: qlib.data.dataset
        kwargs:
            handler:
                class: TACHandler
                module_path: tac_qlib.contrib.data.handler
                kwargs:
                    instruments: "{{ UNIVERSE }}"
                    start_time: 2015-01-03
                    end_time: 2026-08-10
                    fit_start_time: 2016-01-04
                    fit_end_time: 2025-09-01
                    freq: day
                    lake_root: "{{ LAKE }}"
                    market: US
                    label: "Ref($close,-6)/Ref($close,-1)-1"
                    feature_fields: "{{ FEATURES }}"
                    infer_processors:
                        - class: DropAllNaN
                          kwargs: {}
                        - class: ProcessInf
                          kwargs: {}
                        - class: CSRankNorm
                          kwargs: {}
                        - class: ZScoreNorm
                          kwargs: {}
                        - class: Fillna
                          kwargs: {}
            segments:
                train: [2016-01-04, 2025-09-01]
                valid: [2025-09-03, 2026-01-03]
                test: [2026-01-04, 2026-08-10]
    record:
        - class: SignalRecord
          module_path: qlib.workflow.record_temp
          kwargs: {}
        - class: SigAnaRecord
          module_path: qlib.workflow.record_temp
          kwargs:
              ana_long_short: true
              ann_scaler: 252
        - class: PortAnaRecord
          module_path: qlib.workflow.record_temp
          kwargs:
              config:
                  strategy:
                      class: TopkDropoutStrategy
                      module_path: qlib.contrib.strategy
                      kwargs:
                          signal: "<PRED>"
                          topk: 10
                          n_drop: 1
                          only_tradable: true
                          risk_degree: 0.95
                  backtest:
                      start_time: 2026-01-04
                      end_time: 2026-08-10
                      account: 1000000
                      benchmark: SPY
                      exchange_kwargs:
                          codes: "{{ UNIVERSE }}"
                          deal_price: $close
                          freq: day
                          open_cost: 0.0005
                          close_cost: 0.0015
                          min_cost: 5.0
              risk_analysis_freq: 1d
@@ -1,4 +1,12 @@
-# Exact compact stochastic feature set requested for a new run in MLflow exp 25.
+# QUEUE-12 — Long-horizon label (22d) + weekly recompute construction.
 # Untested combination from book/CLAIMS.md open questions: Q05 (exp 37) proved the
 # 22d label has the strongest signal (IC 0.097, RankIC 0.117) but daily turnover
 # killed the book (net -4.60%); Q07 (exp 39) proved weekly recompute is the cost
 # lever (net +12.51%). Hypothesis: pairing them monetizes the label edge.
 # Change vs exp-26 reference: label 5d -> 22d AND strategy -> WeeklyRebalanceDropoutStrategy.
 # Acceptance: net_IR > 0.5, net_ann > +5%, cost drag <= 2pp.
 # Run: rd_run_workflow config_path=<repo>/experiments/queue/workflows/q12_label22d_weekly.yaml \
 #        experiment_name=tac-rd-q12-label22d-weekly
 {%- set LAKE = TAC_LAKE_DIR %}
 {%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
 {%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead" %}
@@ -20,7 +28,7 @@ qlib_init:
    exp_manager:
        class: MLflowExpManager
        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-exp22-stochastic-general" }
+        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-q12-label22d-weekly" }
 task:
    model:
@@ -58,7 +66,7 @@ task:
                    freq: day
                    lake_root: "{{ LAKE }}"
                    market: US
-                    label: "Ref($close,-6)/Ref($close,-1)-1"
+                    label: "Ref($close,-23)/Ref($close,-1)-1"
                    feature_fields: "{{ FEATURES }}"
                    infer_processors:
                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
@@ -79,9 +87,9 @@ task:
          kwargs:
              config:
                  strategy:
-                      class: TopkDropoutStrategy
+                      class: WeeklyRebalanceDropoutStrategy
-                      module_path: qlib.contrib.strategy
+                      module_path: tac_qlib.contrib.strategy.weekly_rebalance
-                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 2, only_tradable: true, risk_degree: 0.95 }
+                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
                  backtest:
                      start_time: 2026-01-04
                      end_time: 2026-08-10
@@ -0,0 +1,106 @@
 # QUEUE-13 — Weekly rebalance reproduction on a second OOS window.
 # Q07 (exp 39) proved weekly recompute on test 2026-01-04..2026-08-10 (net +12.51%,
 # IR 1.24) but that is a single OOS window. Before promoting the weekly construction
 # to a live round, reproduce it on a disjoint window: test 2025-01-02..2025-12-31
 # with train/valid shifted to end 2024.
 # Change vs exp-26 reference: segments shifted only (train ends 2024-08, test = 2025);
 # strategy is the SAME weekly recompute as exp 39. Label stays 5d.
 # Acceptance: net_IR > 0.21 AND net_ann > +2.13% on the 2025 window.
 # Run: rd_run_workflow config_path=<repo>/experiments/queue/workflows/q13_weekly_second_window.yaml \
 #        experiment_name=tac-rd-q13-weekly-second-window
 {%- set LAKE = TAC_LAKE_DIR %}
 {%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
 {%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead" %}
 qlib_init:
    provider_uri: "{{ LAKE }}"
    region: us
    expression_cache: null
    dataset_cache: null
    calendar_provider:
        class: tac_qlib.data.providers.LakeCalendarProvider
        kwargs: { lake_root: "{{ LAKE }}", market: US }
    instrument_provider:
        class: tac_qlib.data.providers.LakeInstrumentProvider
        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
    feature_provider:
        class: tac_qlib.data.providers.LakeFeatureProvider
        kwargs: { lake_root: "{{ LAKE }}", market: US }
    exp_manager:
        class: MLflowExpManager
        module_path: qlib.workflow.expm
        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-q13-weekly-second-window" }
 task:
    model:
        class: RankICEnsembleLGBModel
        module_path: tac_qlib.contrib.model.rank_ensemble
        kwargs:
            loss: mse
            learning_rate: 0.02
            num_leaves: 31
            n_estimators: 3000
            num_boost_round: 3000
            early_stopping_rounds: 200
            min_data_in_leaf: 20
            lambda_l2: 0.5
            colsample_bytree: 0.8
            subsample: 0.8
            subsample_freq: 1
            reg_alpha: 0.1
            reg_lambda: 1.0
            seeds: "42,7,2026,99,123"
    dataset:
        class: DatasetH
        module_path: qlib.data.dataset
        kwargs:
            handler:
                class: TACHandler
                module_path: tac_qlib.contrib.data.handler
                kwargs:
                    instruments: "{{ UNIVERSE }}"
                    start_time: 2015-01-03
                    end_time: 2025-12-31
                    fit_start_time: 2016-01-04
                    fit_end_time: 2024-08-30
                    freq: day
                    lake_root: "{{ LAKE }}"
                    market: US
                    label: "Ref($close,-6)/Ref($close,-1)-1"
                    feature_fields: "{{ FEATURES }}"
                    infer_processors:
                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2024-08-30" } }
                        - { class: ProcessInf, kwargs: {} }
                        - { class: CSRankNorm, kwargs: {} }
                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2024-08-30" } }
                        - { class: Fillna, kwargs: {} }
            segments:
                train: [2016-01-04, 2024-08-30]
                valid: [2024-09-03, 2024-12-31]
                test: [2025-01-02, 2025-12-31]
    record:
        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
        - class: PortAnaRecord
          module_path: qlib.workflow.record_temp
          kwargs:
              config:
                  strategy:
                      class: WeeklyRebalanceDropoutStrategy
                      module_path: tac_qlib.contrib.strategy.weekly_rebalance
                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
                  backtest:
                      start_time: 2025-01-02
                      end_time: 2025-12-31
                      account: 1000000
                      benchmark: SPY
                      exchange_kwargs:
                          codes: "{{ UNIVERSE }}"
                          deal_price: $close
                          freq: day
                          open_cost: 0.0005
                          close_cost: 0.0015
                          min_cost: 5.0
              risk_analysis_freq: 1d
@@ -0,0 +1,107 @@
 # QUEUE-14 — Out-of-universe validation: compact stochastic set on single-stock names.
 # The 50-ETF panel results (compact feature set, RankIC 0.0663) are panel-specific;
 # book/CLAIMS.md marks "generalizes to other universes" HYPOTHESIS - TODO(evidence-needed).
 # Change vs exp-26 reference: universe -> 30 liquid US single-stock names.
 # PREREQUISITE: backfill lake bars + sp/ta features for these symbols (full range,
 # explicit start/end) — the stock panel currently has only ~180d of data (2025-12-01+).
 # Backfill: get_lake_bars symbols=... start=2000-01-03 then
 #   get_lake_sp symbol=<s> start=2000-01-03 end=<today> fit_end=<train-end> persist=true
 # Acceptance: RankIC > 0.03, ICIR > 0.15, net IR > 0 on the stock universe.
 # Run: rd_run_workflow config_path=<repo>/experiments/queue/workflows/q14_out_of_universe.yaml \
 #        experiment_name=tac-rd-q14-out-of-universe
 {%- set LAKE = TAC_LAKE_DIR %}
 {%- set UNIVERSE = "AAPL,MSFT,NVDA,AMZN,GOOGL,META,TSLA,AVGO,AMD,JPM,UNH,PG,JNJ,MA,V,WMT,DIS,HD,KO,PEP,BAC,XOM,MCD,ABBV,COST,CRM,NFLX,ORCL,IBM,T" %}
 {%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead" %}
 qlib_init:
    provider_uri: "{{ LAKE }}"
    region: us
    expression_cache: null
    dataset_cache: null
    calendar_provider:
        class: tac_qlib.data.providers.LakeCalendarProvider
        kwargs: { lake_root: "{{ LAKE }}", market: US }
    instrument_provider:
        class: tac_qlib.data.providers.LakeInstrumentProvider
        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
    feature_provider:
        class: tac_qlib.data.providers.LakeFeatureProvider
        kwargs: { lake_root: "{{ LAKE }}", market: US }
    exp_manager:
        class: MLflowExpManager
        module_path: qlib.workflow.expm
        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-q14-out-of-universe" }
 task:
    model:
        class: RankICEnsembleLGBModel
        module_path: tac_qlib.contrib.model.rank_ensemble
        kwargs:
            loss: mse
            learning_rate: 0.02
            num_leaves: 31
            n_estimators: 3000
            num_boost_round: 3000
            early_stopping_rounds: 200
            min_data_in_leaf: 20
            lambda_l2: 0.5
            colsample_bytree: 0.8
            subsample: 0.8
            subsample_freq: 1
            reg_alpha: 0.1
            reg_lambda: 1.0
            seeds: "42,7,2026,99,123"
    dataset:
        class: DatasetH
        module_path: qlib.data.dataset
        kwargs:
            handler:
                class: TACHandler
                module_path: tac_qlib.contrib.data.handler
                kwargs:
                    instruments: "{{ UNIVERSE }}"
                    start_time: 2015-01-03
                    end_time: 2026-08-10
                    fit_start_time: 2016-01-04
                    fit_end_time: 2025-09-01
                    freq: day
                    lake_root: "{{ LAKE }}"
                    market: US
                    label: "Ref($close,-6)/Ref($close,-1)-1"
                    feature_fields: "{{ FEATURES }}"
                    infer_processors:
                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
                        - { class: ProcessInf, kwargs: {} }
                        - { class: CSRankNorm, kwargs: {} }
                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
                        - { class: Fillna, kwargs: {} }
            segments:
                train: [2016-01-04, 2025-09-01]
                valid: [2025-09-03, 2026-01-03]
                test: [2026-01-04, 2026-08-10]
    record:
        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
        - class: PortAnaRecord
          module_path: qlib.workflow.record_temp
          kwargs:
              config:
                  strategy:
                      class: TopkDropoutStrategy
                      module_path: qlib.contrib.strategy
                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
                  backtest:
                      start_time: 2026-01-04
                      end_time: 2026-08-10
                      account: 1000000
                      benchmark: SPY
                      exchange_kwargs:
                          codes: "{{ UNIVERSE }}"
                          deal_price: $close
                          freq: day
                          open_cost: 0.0005
                          close_cost: 0.0015
                          min_cost: 5.0
              risk_analysis_freq: 1d
@@ -1,9 +1,14 @@
-# M3 isolation run: base compact set + GARCH(1,1) vol-regime trio.
+# QUEUE-15 — 5-seed vs single-model clean A/B on the compact stochastic set.
-# Exact copy of exp26 (reference: expId=25 run=21afc6afdb674a399b59dd76c97628ce)
+# CLAIMS.md HYPOTHESIS: "5-seed RankIC ensemble raises performance vs single model
-# except feature_fields. 5-seed ensemble.
+# on ablated set" — pre-clean-lake exp 12 idea, re-validated directionally by exp
 # 22–24, never a clean A/B post-reset. Seed count is load-bearing (exp 28: 2<5).
 # Change vs exp-26 reference: seeds "42,7,2026,99,123" -> single seed "2026".
 # Acceptance: single-model RankIC < 0.0663, net_IR < 0.21 (ensemble beats single).
 # Run: rd_run_workflow config_path=<repo>/experiments/queue/workflows/q15_single_seed.yaml \
 #        experiment_name=tac-rd-q15-single-seed
 {%- set LAKE = TAC_LAKE_DIR %}
 {%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
-{%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_garch_cond_var,sp_garch_persistence,sp_garch_std_resid" %}
+{%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead" %}
 qlib_init:
    provider_uri: "{{ LAKE }}"
@@ -22,7 +27,7 @@ qlib_init:
    exp_manager:
        class: MLflowExpManager
        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-exp31-m3-garch" }
+        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-q15-single-seed" }
 task:
    model:
@@ -42,7 +47,7 @@ task:
            subsample_freq: 1
            reg_alpha: 0.1
            reg_lambda: 1.0
-            seeds: "42,7,2026,99,123"
+            seeds: "2026"
    dataset:
        class: DatasetH
@@ -1,9 +1,15 @@
-# M2 isolation run: base compact set + risk-adjusted drift sp_sharpe_22.
+# QUEUE-16 — HMM family added as model features to the compact set.
-# Exact copy of exp26 (reference: expId=25 run=21afc6afdb674a399b59dd76c97628ce)
+# CLAIMS.md HYPOTHESIS: "Dropping model-specific feature families (ou, hmm)
-# except feature_fields. 5-seed ensemble.
+# improves the rank signal" — exp 25 cleanly tested OU (adding it hurts: IC 0.0511->0.0343);
 # hmm-as-features has NOT been clean A/B'd post-reset (exp 42 tested hmm as an entry
 # GATE overlay, refuted). This run adds the hmm family columns to the compact set.
 # Change vs exp-26 reference: features += sp_hmm_p_regime1, sp_hmm_state.
 # Acceptance (prune-hypothesis): no improvement — RankIC <= 0.0663, net_IR <= 0.21.
 # Run: rd_run_workflow config_path=<repo>/experiments/queue/workflows/q16_hmm_features.yaml \
 #        experiment_name=tac-rd-q16-hmm-features
 {%- set LAKE = TAC_LAKE_DIR %}
 {%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
-{%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sharpe_22" %}
+{%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_hmm_p_regime1,sp_hmm_state" %}
 qlib_init:
    provider_uri: "{{ LAKE }}"
@@ -22,7 +28,7 @@ qlib_init:
    exp_manager:
        class: MLflowExpManager
        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-exp30-m2-sharpe" }
+        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-q16-hmm-features" }
 task:
    model:
@@ -1,8 +1,15 @@
-# Compact stochastic feature set with reduced turnover: n_drop=1 instead of 2.
+# QUEUE-17 — Realized-moments family added to the compact set.
-# Same setup as exp24 (compact baseline) but replacing the TopkDropout n_drop 2 with 1.
+# CLAIMS.md HYPOTHESIS: "Adding moment/volatility families regresses the signal"
 # (idea: pre-clean-lake exp 11). M1 momentum bundle (exp 29) and M3 GARCH (exp 31)
 # were refuted post-reset; the realized-moments family (sp_rskew/sp_rkurt/sp_dsv)
 # has NOT been clean A/B'd. This run adds the moments columns to the compact set.
 # Change vs exp-26 reference: features += sp_rskew_5,sp_rskew_22,sp_rkurt_5,sp_rkurt_22,sp_dsv_5,sp_dsv_22.
 # Acceptance (prune-hypothesis): no improvement — RankIC <= 0.0663, net_IR <= 0.21.
 # Run: rd_run_workflow config_path=<repo>/experiments/queue/workflows/q17_moments_features.yaml \
 #        experiment_name=tac-rd-q17-moments-features
 {%- set LAKE = TAC_LAKE_DIR %}
 {%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
-{%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead" %}
+{%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_rskew_5,sp_rskew_22,sp_rkurt_5,sp_rkurt_22,sp_dsv_5,sp_dsv_22" %}
 qlib_init:
    provider_uri: "{{ LAKE }}"
@@ -21,7 +28,7 @@ qlib_init:
    exp_manager:
        class: MLflowExpManager
        module_path: qlib.workflow.expm
-        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-exp22-stochastic-general" }
+        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-q17-moments-features" }
 task:
    model:
@@ -0,0 +1,106 @@
 # QUEUE-18 — OptimalStopControl clean re-test vs TopkDropout (exp 13/14 claim).
 # CLAIMS.md HYPOTHESIS: "TopkDropout beats stochastic-control OptimalStopControl on
 # the ensemble signal" — exp 13/14 were pre-clean-lake; never re-tested post-reset.
 # Same compact signal as the exp-26 reference; ONLY the strategy changes to
 # OptimalStopControl with exp-13 params (entry 0.85 / exit 0.7 / hold 10 / sl -0.08).
 # PREREQUISITE: tac_qlib/contrib/strategy/optimal_stop.py must be synced to the venv
 # site-packages snapshot before running (see /app/AGENTS.md).
 # Acceptance: TopkDropout net_IR >= stop-control net_IR; document cost drag of both.
 # Run: rd_run_workflow config_path=<repo>/experiments/queue/workflows/q18_optstop.yaml \
 #        experiment_name=tac-rd-q18-optstop
 {%- set LAKE = TAC_LAKE_DIR %}
 {%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
 {%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead" %}
 qlib_init:
    provider_uri: "{{ LAKE }}"
    region: us
    expression_cache: null
    dataset_cache: null
    calendar_provider:
        class: tac_qlib.data.providers.LakeCalendarProvider
        kwargs: { lake_root: "{{ LAKE }}", market: US }
    instrument_provider:
        class: tac_qlib.data.providers.LakeInstrumentProvider
        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
    feature_provider:
        class: tac_qlib.data.providers.LakeFeatureProvider
        kwargs: { lake_root: "{{ LAKE }}", market: US }
    exp_manager:
        class: MLflowExpManager
        module_path: qlib.workflow.expm
        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-q18-optstop" }
 task:
    model:
        class: RankICEnsembleLGBModel
        module_path: tac_qlib.contrib.model.rank_ensemble
        kwargs:
            loss: mse
            learning_rate: 0.02
            num_leaves: 31
            n_estimators: 3000
            num_boost_round: 3000
            early_stopping_rounds: 200
            min_data_in_leaf: 20
            lambda_l2: 0.5
            colsample_bytree: 0.8
            subsample: 0.8
            subsample_freq: 1
            reg_alpha: 0.1
            reg_lambda: 1.0
            seeds: "42,7,2026,99,123"
    dataset:
        class: DatasetH
        module_path: qlib.data.dataset
        kwargs:
            handler:
                class: TACHandler
                module_path: tac_qlib.contrib.data.handler
                kwargs:
                    instruments: "{{ UNIVERSE }}"
                    start_time: 2015-01-03
                    end_time: 2026-08-10
                    fit_start_time: 2016-01-04
                    fit_end_time: 2025-09-01
                    freq: day
                    lake_root: "{{ LAKE }}"
                    market: US
                    label: "Ref($close,-6)/Ref($close,-1)-1"
                    feature_fields: "{{ FEATURES }}"
                    infer_processors:
                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
                        - { class: ProcessInf, kwargs: {} }
                        - { class: CSRankNorm, kwargs: {} }
                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
                        - { class: Fillna, kwargs: {} }
            segments:
                train: [2016-01-04, 2025-09-01]
                valid: [2025-09-03, 2026-01-03]
                test: [2026-01-04, 2026-08-10]
    record:
        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
        - class: PortAnaRecord
          module_path: qlib.workflow.record_temp
          kwargs:
              config:
                  strategy:
                      class: OptimalStopControl
                      module_path: tac_qlib.contrib.strategy.optimal_stop
                      kwargs: { signal: "<PRED>", topk: 10, entry_pct: 0.85, exit_pct: 0.7, max_hold_days: 10, min_hold_days: 2, sl: -0.08 }
                  backtest:
                      start_time: 2026-01-04
                      end_time: 2026-08-10
                      account: 1000000
                      benchmark: SPY
                      exchange_kwargs:
                          codes: "{{ UNIVERSE }}"
                          deal_price: $close
                          freq: day
                          open_cost: 0.0005
                          close_cost: 0.0015
                          min_cost: 5.0
              risk_analysis_freq: 1d
@@ -0,0 +1,107 @@
 # QUEUE-21 — Long-horizon label (10d) + weekly recompute construction.
 # Untested combination from book/CLAIMS.md open questions: Q04 (exp 36) proved the
 # 10d label has strong signal (IC 0.093, RankIC 0.096, L/S Sharpe 5.89) but daily
 # turnover killed the book (net -9.92%); Q07 (exp 39) proved weekly recompute is
 # the cost lever (net +12.51%). Q12 already tested 22d+weekly and failed (net -4.88%),
 # so the 22d label's problem is not just turnover. Hypothesis: the 10d label's edge
 # survives weekly rebalance because it captures a shorter, more actionable horizon.
 # Change vs exp-26 reference: label 5d -> 10d AND strategy -> WeeklyRebalanceDropoutStrategy.
 # Acceptance: net_IR > 0.5, net_ann > +5%, cost drag <= 2pp.
 # Run: rd_run_workflow config_path=<repo>/experiments/queue/workflows/q21_label10d_weekly.yaml \
 #        experiment_name=tac-rd-q21-label10d-weekly
 {%- set LAKE = TAC_LAKE_DIR %}
 {%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
 {%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead" %}
 qlib_init:
    provider_uri: "{{ LAKE }}"
    region: us
    expression_cache: null
    dataset_cache: null
    calendar_provider:
        class: tac_qlib.data.providers.LakeCalendarProvider
        kwargs: { lake_root: "{{ LAKE }}", market: US }
    instrument_provider:
        class: tac_qlib.data.providers.LakeInstrumentProvider
        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
    feature_provider:
        class: tac_qlib.data.providers.LakeFeatureProvider
        kwargs: { lake_root: "{{ LAKE }}", market: US }
    exp_manager:
        class: MLflowExpManager
        module_path: qlib.workflow.expm
        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-q21-label10d-weekly" }
 task:
    model:
        class: RankICEnsembleLGBModel
        module_path: tac_qlib.contrib.model.rank_ensemble
        kwargs:
            loss: mse
            learning_rate: 0.02
            num_leaves: 31
            n_estimators: 3000
            num_boost_round: 3000
            early_stopping_rounds: 200
            min_data_in_leaf: 20
            lambda_l2: 0.5
            colsample_bytree: 0.8
            subsample: 0.8
            subsample_freq: 1
            reg_alpha: 0.1
            reg_lambda: 1.0
            seeds: "42,7,2026,99,123"
    dataset:
        class: DatasetH
        module_path: qlib.data.dataset
        kwargs:
            handler:
                class: TACHandler
                module_path: tac_qlib.contrib.data.handler
                kwargs:
                    instruments: "{{ UNIVERSE }}"
                    start_time: 2015-01-03
                    end_time: 2026-08-10
                    fit_start_time: 2016-01-04
                    fit_end_time: 2025-09-01
                    freq: day
                    lake_root: "{{ LAKE }}"
                    market: US
                    label: "Ref($close,-11)/Ref($close,-1)-1"
                    feature_fields: "{{ FEATURES }}"
                    infer_processors:
                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
                        - { class: ProcessInf, kwargs: {} }
                        - { class: CSRankNorm, kwargs: {} }
                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
                        - { class: Fillna, kwargs: {} }
            segments:
                train: [2016-01-04, 2025-09-01]
                valid: [2025-09-03, 2026-01-03]
                test: [2026-01-04, 2026-08-10]
    record:
        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
        - class: PortAnaRecord
          module_path: qlib.workflow.record_temp
          kwargs:
              config:
                  strategy:
                      class: WeeklyRebalanceDropoutStrategy
                      module_path: tac_qlib.contrib.strategy.weekly_rebalance
                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 1, only_tradable: true, risk_degree: 0.95 }
                  backtest:
                      start_time: 2026-01-04
                      end_time: 2026-08-10
                      account: 1000000
                      benchmark: SPY
                      exchange_kwargs:
                          codes: "{{ UNIVERSE }}"
                          deal_price: $close
                          freq: day
                          open_cost: 0.0005
                          close_cost: 0.0015
                          min_cost: 5.0
              risk_analysis_freq: 1d
@@ -1,133 +0,0 @@
 # -----------------------------------------------------------------------------
 # ABLATION A (baseline): LightGBM with RankIC early-stopping on the 50-ETF SP-5d
 # panel, using ALL 24 sp_* feature columns (ou,hmm,jump,har,trend,hurst,
 # signature). Copy of the canonical workflow_lgb_sp5d_rankic.yaml with a
 # distinct experiment name so the ablation runs are isolated.
 #
 # Run:
 #   rd_run_workflow config_path=tac-qlib/workflows/ablate_baseline_all_sp_fields.yaml \
 #       experiment_name=tac-rd-rank-ablate
 # -----------------------------------------------------------------------------
 {%- set LAKE = TAC_LAKE_DIR %}
 {%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
 {%- set SP_FIELDS = "sp_ret,sp_ou_zscore,sp_ou_half_life,sp_ou_revert,sp_hmm_p_regime1,sp_hmm_state,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead" %}
 qlib_init:
    provider_uri: "{{ LAKE }}"
    region: us
    expression_cache: null
    dataset_cache: null
    calendar_provider:
        class: tac_qlib.data.providers.LakeCalendarProvider
        kwargs:
            lake_root: "{{ LAKE }}"
            market: US
    instrument_provider:
        class: tac_qlib.data.providers.LakeInstrumentProvider
        kwargs:
            lake_root: "{{ LAKE }}"
            market: US
            markets: {}
    feature_provider:
        class: tac_qlib.data.providers.LakeFeatureProvider
        kwargs:
            lake_root: "{{ LAKE }}"
            market: US
    exp_manager:
        class: MLflowExpManager
        module_path: qlib.workflow.expm
        kwargs:
            uri: "sqlite:///{{ LAKE }}/mlruns.db"
            default_exp_name: "tac-rd-rank-ablate"
 task:
    model:
        class: RankICLGBModel
        module_path: tac_qlib.contrib.model.rank_gbdt
        kwargs:
            loss: mse
            learning_rate: 0.02
            num_leaves: 31
            n_estimators: 3000
            num_boost_round: 3000
            early_stopping_rounds: 200
            min_data_in_leaf: 20
            lambda_l2: 0.5
            colsample_bytree: 0.8
            subsample: 0.8
            subsample_freq: 1
            reg_alpha: 0.1
            reg_lambda: 1.0
            seed: 42
    dataset:
        class: DatasetH
        module_path: qlib.data.dataset
        kwargs:
            handler:
                class: TACHandler
                module_path: tac_qlib.contrib.data.handler
                kwargs:
                    instruments: "{{ UNIVERSE }}"
                    start_time: 2015-01-03
                    end_time: 2026-08-10
                    fit_start_time: 2015-01-03
                    fit_end_time: 2025-09-01
                    freq: day
                    lake_root: "{{ LAKE }}"
                    market: US
                    label: "Ref($close,-6)/Ref($close,-1)-1"
                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,{{ SP_FIELDS }}"
                    infer_processors:
                        - class: DropAllNaN
                          kwargs: {}
                        - class: ProcessInf
                          kwargs: {}
                        - class: CSRankNorm
                          kwargs: {}
                        - class: ZScoreNorm
                          kwargs: {}
                        - class: Fillna
                          kwargs: {}
            segments:
                train: [2015-01-03, 2025-09-01]
                valid: [2025-09-03, 2026-01-03]
                test: [2026-01-04, 2026-08-10]
    record:
        - class: SignalRecord
          module_path: qlib.workflow.record_temp
          kwargs: {}
        - class: SigAnaRecord
          module_path: qlib.workflow.record_temp
          kwargs:
              ana_long_short: true
              ann_scaler: 252
        - class: PortAnaRecord
          module_path: qlib.workflow.record_temp
          kwargs:
              config:
                  strategy:
                      class: TopkDropoutStrategy
                      module_path: qlib.contrib.strategy
                      kwargs:
                          signal: "<PRED>"
                          topk: 10
                          n_drop: 2
                          only_tradable: true
                          risk_degree: 0.95
                  backtest:
                      start_time: 2026-01-04
                      end_time: 2026-08-10
                      account: 1000000
                      benchmark: SPY
                      exchange_kwargs:
                          codes: "{{ UNIVERSE }}"
                          deal_price: $close
                          freq: day
                          open_cost: 0.0005
                          close_cost: 0.0015
                          min_cost: 5.0
              risk_analysis_freq: 1d
@@ -1,134 +0,0 @@
 # -----------------------------------------------------------------------------
 # ABLATION B (generic-only): same panel/model as the baseline, but feature
 # fields restricted to the model-free / generic stochastic-process families
 # (jump,har,trend,hurst,signature). Drops the model-specific ou (OU/AR-1
 # half-life) and hmm (2-state regime) families to test whether the generic
 # families alone dominate the rank dimension.
 #
 # Run:
 #   rd_run_workflow config_path=tac-qlib/workflows/ablate_generic_only_sp_fields.yaml \
 #       experiment_name=tac-rd-rank-ablate
 # -----------------------------------------------------------------------------
 {%- set LAKE = TAC_LAKE_DIR %}
 {%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
 {%- set SP_FIELDS = "sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead" %}
 qlib_init:
    provider_uri: "{{ LAKE }}"
    region: us
    expression_cache: null
    dataset_cache: null
    calendar_provider:
        class: tac_qlib.data.providers.LakeCalendarProvider
        kwargs:
            lake_root: "{{ LAKE }}"
            market: US
    instrument_provider:
        class: tac_qlib.data.providers.LakeInstrumentProvider
        kwargs:
            lake_root: "{{ LAKE }}"
            market: US
            markets: {}
    feature_provider:
        class: tac_qlib.data.providers.LakeFeatureProvider
        kwargs:
            lake_root: "{{ LAKE }}"
            market: US
    exp_manager:
        class: MLflowExpManager
        module_path: qlib.workflow.expm
        kwargs:
            uri: "sqlite:///{{ LAKE }}/mlruns.db"
            default_exp_name: "tac-rd-rank-ablate"
 task:
    model:
        class: RankICLGBModel
        module_path: tac_qlib.contrib.model.rank_gbdt
        kwargs:
            loss: mse
            learning_rate: 0.02
            num_leaves: 31
            n_estimators: 3000
            num_boost_round: 3000
            early_stopping_rounds: 200
            min_data_in_leaf: 20
            lambda_l2: 0.5
            colsample_bytree: 0.8
            subsample: 0.8
            subsample_freq: 1
            reg_alpha: 0.1
            reg_lambda: 1.0
            seed: 42
    dataset:
        class: DatasetH
        module_path: qlib.data.dataset
        kwargs:
            handler:
                class: TACHandler
                module_path: tac_qlib.contrib.data.handler
                kwargs:
                    instruments: "{{ UNIVERSE }}"
                    start_time: 2015-01-03
                    end_time: 2026-08-10
                    fit_start_time: 2015-01-03
                    fit_end_time: 2025-09-01
                    freq: day
                    lake_root: "{{ LAKE }}"
                    market: US
                    label: "Ref($close,-6)/Ref($close,-1)-1"
                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,{{ SP_FIELDS }}"
                    infer_processors:
                        - class: DropAllNaN
                          kwargs: {}
                        - class: ProcessInf
                          kwargs: {}
                        - class: CSRankNorm
                          kwargs: {}
                        - class: ZScoreNorm
                          kwargs: {}
                        - class: Fillna
                          kwargs: {}
            segments:
                train: [2015-01-03, 2025-09-01]
                valid: [2025-09-03, 2026-01-03]
                test: [2026-01-04, 2026-08-10]
    record:
        - class: SignalRecord
          module_path: qlib.workflow.record_temp
          kwargs: {}
        - class: SigAnaRecord
          module_path: qlib.workflow.record_temp
          kwargs:
              ana_long_short: true
              ann_scaler: 252
        - class: PortAnaRecord
          module_path: qlib.workflow.record_temp
          kwargs:
              config:
                  strategy:
                      class: TopkDropoutStrategy
                      module_path: qlib.contrib.strategy
                      kwargs:
                          signal: "<PRED>"
                          topk: 10
                          n_drop: 2
                          only_tradable: true
                          risk_degree: 0.95
                  backtest:
                      start_time: 2026-01-04
                      end_time: 2026-08-10
                      account: 1000000
                      benchmark: SPY
                      exchange_kwargs:
                          codes: "{{ UNIVERSE }}"
                          deal_price: $close
                          freq: day
                          open_cost: 0.0005
                          close_cost: 0.0015
                          min_cost: 5.0
              risk_analysis_freq: 1d
@@ -1,141 +0,0 @@
 # -----------------------------------------------------------------------------
 # ISOLATION: multi-seed RankIC ensemble, ablate-B generic-only feature set.
 #
 # Isolates the ensemble effect on the SP-5d rank signal. Same panel, segments,
 # history (full backfilled 2016+) and feature set as the exp-9 ablate-B winner
 # (generic-only sp_* families: jump,har,trend,hurst,signature), but replaces the
 # single RankICLGBModel with a 5-seed RankICEnsembleLGBModel (42,7,2026,99,123)
 # that averages per-day predictions.
 #
 # Differs from exp-15 (tac-rd-rank-ensemble, mlflow exp 15) ONLY by dropping the
 # TA subset (rsi_14,roc_10,macd_hist,willr_14,atr_14) and the inter-asset xr_*
 # features, so any change vs exp-15 is attributable to the feature set alone,
 # and any change vs exp-9 is attributable to the ensemble + full history alone.
 #
 # Run:
 #   rd_run_workflow config_path=experiments/workflows/exp12_isolation_ensemble.yaml \
 #       experiment_name=tac-rd-rank-ensemble-isolated
 # -----------------------------------------------------------------------------
 {%- set LAKE = TAC_LAKE_DIR %}
 {%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
 {%- set SP_FIELDS = "sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_move,sp_rv1,sp_rv5,sp_rv22,sp_vol_ratio_5_22,sp_vol_ratio_1_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead" %}
 qlib_init:
    provider_uri: "{{ LAKE }}"
    region: us
    expression_cache: null
    dataset_cache: null
    calendar_provider:
        class: tac_qlib.data.providers.LakeCalendarProvider
        kwargs:
            lake_root: "{{ LAKE }}"
            market: US
    instrument_provider:
        class: tac_qlib.data.providers.LakeInstrumentProvider
        kwargs:
            lake_root: "{{ LAKE }}"
            market: US
            markets: {}
    feature_provider:
        class: tac_qlib.data.providers.LakeFeatureProvider
        kwargs:
            lake_root: "{{ LAKE }}"
            market: US
    exp_manager:
        class: MLflowExpManager
        module_path: qlib.workflow.expm
        kwargs:
            uri: "sqlite:///mlruns.db"
            default_exp_name: "tac-rd-rank-ensemble-isolated"
 task:
    model:
        class: RankICEnsembleLGBModel
        module_path: tac_qlib.contrib.model.rank_ensemble
        kwargs:
            loss: mse
            learning_rate: 0.02
            num_leaves: 31
            n_estimators: 3000
            num_boost_round: 3000
            early_stopping_rounds: 200
            min_data_in_leaf: 20
            lambda_l2: 0.5
            colsample_bytree: 0.8
            subsample: 0.8
            subsample_freq: 1
            reg_alpha: 0.1
            reg_lambda: 1.0
            seeds: "42,7,2026,99,123"
    dataset:
        class: DatasetH
        module_path: qlib.data.dataset
        kwargs:
            handler:
                class: TACHandler
                module_path: tac_qlib.contrib.data.handler
                kwargs:
                    instruments: "{{ UNIVERSE }}"
                    start_time: 2015-01-03
                    end_time: 2026-08-14
                    fit_start_time: 2016-01-04
                    fit_end_time: 2025-09-01
                    freq: day
                    lake_root: "{{ LAKE }}"
                    market: US
                    label: "Ref($close,-6)/Ref($close,-1)-1"
                    feature_fields: "$open,$high,$low,$close,$vwap,$volume,{{ SP_FIELDS }}"
                    infer_processors:
                        - class: DropAllNaN
                          kwargs: {}
                        - class: ProcessInf
                          kwargs: {}
                        - class: CSRankNorm
                          kwargs: {}
                        - class: ZScoreNorm
                          kwargs: {}
                        - class: Fillna
                          kwargs: {}
            segments:
                train: [2016-01-04, 2025-09-01]
                valid: [2025-09-03, 2026-01-03]
                test: [2026-01-04, 2026-08-10]
    record:
        - class: SignalRecord
          module_path: qlib.workflow.record_temp
          kwargs: {}
        - class: SigAnaRecord
          module_path: qlib.workflow.record_temp
          kwargs:
              ana_long_short: true
              ann_scaler: 252
        - class: PortAnaRecord
          module_path: qlib.workflow.record_temp
          kwargs:
              config:
                  strategy:
                      class: TopkDropoutStrategy
                      module_path: qlib.contrib.strategy
                      kwargs:
                          signal: "<PRED>"
                          topk: 10
                          n_drop: 2
                          only_tradable: true
                          risk_degree: 0.95
                  backtest:
                      start_time: 2026-01-04
                      end_time: 2026-08-10
                      account: 1000000
                      benchmark: SPY
                      exchange_kwargs:
                          codes: "{{ UNIVERSE }}"
                          deal_price: $close
                          freq: day
                          open_cost: 0.0005
                          close_cost: 0.0015
                          min_cost: 5.0
              risk_analysis_freq: 1d
@@ -1,97 +0,0 @@
 # Re-run of experiment 16 with validated family=ta and family=sp lake features.
 {%- set LAKE = TAC_LAKE_DIR %}
 {%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
 {%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sma_5,sma_20,ema_12,ema_26,rsi_14,macd,macd_signal,macd_hist,bb_upper,bb_middle,bb_lower,atr_14,adx_14,sp_ret,sp_ou_half_life,sp_ou_revert,sp_ou_zscore,sp_hmm_p_regime1,sp_hmm_state,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_down,sp_max_move,sp_max_up,sp_rv1,sp_rv5,sp_rv22,sp_rv_ac1,sp_rv_cv_22,sp_vol_ratio_1_22,sp_vol_ratio_5_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_rskew_5,sp_rskew_22,sp_rkurt_5,sp_rkurt_22,sp_dsv_1,sp_dsv_5,sp_dsv_22,sp_dsv_ratio_1,sp_dsv_ratio_5,sp_dsv_ratio_22,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sig_level2_lead_lag_5,sp_sig_level2_lag_lead_5" %}
 qlib_init:
    provider_uri: "{{ LAKE }}"
    region: us
    expression_cache: null
    dataset_cache: null
    calendar_provider:
        class: tac_qlib.data.providers.LakeCalendarProvider
        kwargs: { lake_root: "{{ LAKE }}", market: US }
    instrument_provider:
        class: tac_qlib.data.providers.LakeInstrumentProvider
        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
    feature_provider:
        class: tac_qlib.data.providers.LakeFeatureProvider
        kwargs: { lake_root: "{{ LAKE }}", market: US }
    exp_manager:
        class: MLflowExpManager
        module_path: qlib.workflow.expm
        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-exp16-db-ta-sp" }
 task:
    model:
        class: RankICEnsembleLGBModel
        module_path: tac_qlib.contrib.model.rank_ensemble
        kwargs:
            loss: mse
            learning_rate: 0.02
            num_leaves: 31
            n_estimators: 3000
            num_boost_round: 3000
            early_stopping_rounds: 200
            min_data_in_leaf: 20
            lambda_l2: 0.5
            colsample_bytree: 0.8
            subsample: 0.8
            subsample_freq: 1
            reg_alpha: 0.1
            reg_lambda: 1.0
            seeds: "42,7,2026,99,123"
    dataset:
        class: DatasetH
        module_path: qlib.data.dataset
        kwargs:
            handler:
                class: TACHandler
                module_path: tac_qlib.contrib.data.handler
                kwargs:
                    instruments: "{{ UNIVERSE }}"
                    start_time: 2015-01-03
                    end_time: 2026-08-10
                    fit_start_time: 2016-01-04
                    fit_end_time: 2025-09-01
                    freq: day
                    lake_root: "{{ LAKE }}"
                    market: US
                    label: "Ref($close,-6)/Ref($close,-1)-1"
                    feature_fields: "{{ FEATURES }}"
                    infer_processors:
                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
                        - { class: ProcessInf, kwargs: {} }
                        - { class: CSRankNorm, kwargs: {} }
                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
                        - { class: Fillna, kwargs: {} }
            segments:
                train: [2016-01-04, 2025-09-01]
                valid: [2025-09-03, 2026-01-03]
                test: [2026-01-04, 2026-08-10]
    record:
        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
        - class: PortAnaRecord
          module_path: qlib.workflow.record_temp
          kwargs:
              config:
                  strategy:
                      class: TopkDropoutStrategy
                      module_path: qlib.contrib.strategy
                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 2, only_tradable: true, risk_degree: 0.95 }
                  backtest:
                      start_time: 2026-01-04
                      end_time: 2026-08-10
                      account: 1000000
                      benchmark: SPY
                      exchange_kwargs:
                          codes: "{{ UNIVERSE }}"
                          deal_price: $close
                          freq: day
                          open_cost: 0.0005
                          close_cost: 0.0015
                          min_cost: 5.0
              risk_analysis_freq: 1d
@@ -1,97 +0,0 @@
 # General stochastic-process feature ablation: no TA, HMM, or OU fields.
 {%- set LAKE = TAC_LAKE_DIR %}
 {%- set UNIVERSE = "SPY,QQQ,DIA,IWM,MDY,VTI,VOO,VEA,VWO,VT,EFA,EEM,TLT,IEF,SHY,AGG,BND,LQD,HYG,JNK,EMB,GLD,SLV,USO,UNG,DBA,DBC,XLK,XLF,XLE,XLV,XLI,XLY,XLP,XLU,XLB,XLRE,ARKK,SMH,SOXX,IBB,XBI,ITA,XAR,ICLN,TAN,FDN,IGV,ESPO,REM" %}
 {%- set FEATURES = "$open,$high,$low,$close,$vwap,$volume,sp_ret,sp_jump_ratio,sp_jump_flag,sp_jump_tail,sp_max_down,sp_max_move,sp_max_up,sp_rv1,sp_rv5,sp_rv22,sp_rv_ac1,sp_rv_cv_22,sp_vol_ratio_1_22,sp_vol_ratio_5_22,sp_trend_slope_5,sp_trend_slope_20,sp_trend_slope_60,sp_logp,sp_hurst_exponent,sp_rskew_5,sp_rskew_22,sp_rkurt_5,sp_rkurt_22,sp_dsv_1,sp_dsv_5,sp_dsv_22,sp_dsv_ratio_1,sp_dsv_ratio_5,sp_dsv_ratio_22,sp_sig_level1_lead,sp_sig_level1_lag,sp_sig_level2_lead_lag,sp_sig_level2_lag_lead,sp_sig_level2_lead_lag_5,sp_sig_level2_lag_lead_5" %}
 qlib_init:
    provider_uri: "{{ LAKE }}"
    region: us
    expression_cache: null
    dataset_cache: null
    calendar_provider:
        class: tac_qlib.data.providers.LakeCalendarProvider
        kwargs: { lake_root: "{{ LAKE }}", market: US }
    instrument_provider:
        class: tac_qlib.data.providers.LakeInstrumentProvider
        kwargs: { lake_root: "{{ LAKE }}", market: US, markets: {} }
    feature_provider:
        class: tac_qlib.data.providers.LakeFeatureProvider
        kwargs: { lake_root: "{{ LAKE }}", market: US }
    exp_manager:
        class: MLflowExpManager
        module_path: qlib.workflow.expm
        kwargs: { uri: "sqlite:///mlruns.db", default_exp_name: "tac-rd-exp22-stochastic-general" }
 task:
    model:
        class: RankICEnsembleLGBModel
        module_path: tac_qlib.contrib.model.rank_ensemble
        kwargs:
            loss: mse
            learning_rate: 0.02
            num_leaves: 31
            n_estimators: 3000
            num_boost_round: 3000
            early_stopping_rounds: 200
            min_data_in_leaf: 20
            lambda_l2: 0.5
            colsample_bytree: 0.8
            subsample: 0.8
            subsample_freq: 1
            reg_alpha: 0.1
            reg_lambda: 1.0
            seeds: "42,7,2026,99,123"
    dataset:
        class: DatasetH
        module_path: qlib.data.dataset
        kwargs:
            handler:
                class: TACHandler
                module_path: tac_qlib.contrib.data.handler
                kwargs:
                    instruments: "{{ UNIVERSE }}"
                    start_time: 2015-01-03
                    end_time: 2026-08-10
                    fit_start_time: 2016-01-04
                    fit_end_time: 2025-09-01
                    freq: day
                    lake_root: "{{ LAKE }}"
                    market: US
                    label: "Ref($close,-6)/Ref($close,-1)-1"
                    feature_fields: "{{ FEATURES }}"
                    infer_processors:
                        - { class: DropAllNaN, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
                        - { class: ProcessInf, kwargs: {} }
                        - { class: CSRankNorm, kwargs: {} }
                        - { class: ZScoreNorm, kwargs: { fit_start_time: "2016-01-04", fit_end_time: "2025-09-01" } }
                        - { class: Fillna, kwargs: {} }
            segments:
                train: [2016-01-04, 2025-09-01]
                valid: [2025-09-03, 2026-01-03]
                test: [2026-01-04, 2026-08-10]
    record:
        - { class: SignalRecord, module_path: qlib.workflow.record_temp, kwargs: {} }
        - { class: SigAnaRecord, module_path: qlib.workflow.record_temp, kwargs: { ana_long_short: true, ann_scaler: 252 } }
        - class: PortAnaRecord
          module_path: qlib.workflow.record_temp
          kwargs:
              config:
                  strategy:
                      class: TopkDropoutStrategy
                      module_path: qlib.contrib.strategy
                      kwargs: { signal: "<PRED>", topk: 10, n_drop: 2, only_tradable: true, risk_degree: 0.95 }
                  backtest:
                      start_time: 2026-01-04
                      end_time: 2026-08-10
                      account: 1000000
                      benchmark: SPY
                      exchange_kwargs:
                          codes: "{{ UNIVERSE }}"
                          deal_price: $close
                          freq: day
                          open_cost: 0.0005
                          close_cost: 0.0015
                          min_cost: 5.0
              risk_analysis_freq: 1d
Author	SHA1	Message	Date
zhaoli	6b7276678b	finish experiment 51 (exp/51-q21-test-10d-label--weekly-rebalance-q04)	2026-08-20 05:38:35 +00:00
zhaoli	70589e3766	start experiment 51 (exp/51-q21-test-10d-label--weekly-rebalance-q04)	2026-08-20 05:35:32 +00:00
zhaoli	b2f5c24f4f	finish experiment 44 (exp/44-q12-long-horizon-22d-label-paired-with-w)	2026-08-20 04:14:15 +00:00
zhaoli	25b4e59295	start experiment 44 (exp/44-q12-long-horizon-22d-label-paired-with-w)	2026-08-20 03:55:47 +00:00
		`@@ -1 +0,0 @@`
			`from .tradeac_exchange import TradeACExchange`