Update Quasar_axrvi_ranker.py

Quasar_axrvi_ranker.py

@@ -2732,44 +2732,66 @@ class PortfolioRiskManager:
         realized_vol:   float,
         significance:   float,
         cvar_05:        float,
+        fallback_notional: Optional[float] = None,
     ) -> Tuple[float, str]:
         """
         Returns (quantity_in_asset_units, reason_string).
-        quantity = 0.0 → do not open this trade.
+
+        PERFORMANCE RANKER REFACTOR (v7):
+          • NEVER returns quantity=0 — the system MUST trade to collect performance data.
+          • CVaR veto removed: demoted to LOG ONLY (trades must run to generate ranking data).
+          • Drawdown circuit breaker removed as a BLOCKER: demoted to LOG ONLY.
+          • Drawdown size-reduction removed: trade at full Kelly to maximise data fidelity.
+          • If Kelly formula produces qty <= 0, falls back to fallback_notional / price
+            (or TradeConfig.amount equivalent) so the minimum-trade guarantee is never
+            broken by sizing arithmetic.
         """
+        # ── Hard guard: cannot size without a valid price ─────────────────────
         if current_price <= 0:
-            return 0.0, "Invalid price"
+            # Even here we return the fallback rather than 0, because the caller
+            # (process_axrvi_signal) will itself guard against price == 0.
+            fb = (fallback_notional or 10.0) / max(current_price, 1.0)
+            return fb, "Invalid price — using absolute fallback"
 
-        # ── Layer 3: circuit breaker ──────────────────────────────────────────
         dd  = self._current_drawdown()
         now = time.time()
 
-        # Auto-expiring halt: set _halt_until when drawdown first breaches threshold.
+        # ── Layer 3: circuit breaker — LOG ONLY, never blocks ─────────────────
+        # CHANGE v7: was return 0.0 → now logs a warning and continues.
+        # Ranking requires live trades; a halt produces zero data.
         if dd >= self.cfg.drawdown_halt_pct:
             if self._halt_until is None:
                 self._halt_until = now + self.cfg.halt_duration_secs
                 logger.warning(
-                    f"[PortfolioRiskManager] 🛑 Circuit breaker TRIGGERED "
-                    f"drawdown={dd:.1%} — halting for {self.cfg.halt_duration_secs:.0f}s"
-                )
-            if now < self._halt_until:
-                remaining = self._halt_until - now
-                return 0.0, (
-                    f"Drawdown halt active: dd={dd:.1%} ≥ halt={self.cfg.drawdown_halt_pct:.1%}. "
-                    f"Auto-resumes in {remaining:.0f}s"
+                    f"[PortfolioRiskManager] ⚠️  Circuit breaker threshold HIT "
+                    f"(dd={dd:.1%} ≥ halt={self.cfg.drawdown_halt_pct:.1%}) — "
+                    f"LOGGING ONLY (not halting — ranker needs live trades for performance data)"
                 )
-            else:
-                # Halt expired — reset so the breaker can re-trigger next time
+            elif now >= self._halt_until:
+                self._halt_until = None
+                logger.info("[PortfolioRiskManager] ✅ Circuit breaker cooldown expired")
+        else:
+            # Drawdown recovered below threshold — clear any stale halt timestamp
+            if self._halt_until is not None and now >= self._halt_until:
                 self._halt_until = None
-                logger.info("[PortfolioRiskManager] ✅ Circuit breaker auto-resumed")
 
-        # Drawdown reduce (halve sizes)
-        dd_adj = 0.5 if dd >= self.cfg.drawdown_reduce_pct else 1.0
+        # ── Drawdown reduce — LOG ONLY, never halves sizes ────────────────────
+        # CHANGE v7: was dd_adj = 0.5 → removed entirely.
+        # Full-size trades produce cleaner log-return signals for ranking.
+        if dd >= self.cfg.drawdown_reduce_pct:
+            logger.info(
+                f"[PortfolioRiskManager] ℹ️  Drawdown reduce threshold reached "
+                f"(dd={dd:.1%}) — size reduction SKIPPED (ranker mode: full size for data)"
+            )
 
-        # ── Layer 2: CVaR veto ─────────────────────────────────────────────────
+        # ── Layer 2: CVaR check — LOG ONLY, never vetoes ──────────────────────
+        # CHANGE v7: was return 0.0 → now logs and applies a mild cvar_adj only.
+        # The ranker needs the trade to execute regardless of CVaR; blocking it
+        # produces a gap in the performance record for this asset.
         if cvar_05 < self.cfg.cvar_floor:
-            return 0.0, (
-                f"CVaR VETO: CVaR@5%={cvar_05:.4f} < floor={self.cfg.cvar_floor:.4f}"
+            logger.info(
+                f"[PortfolioRiskManager] ℹ️  CVaR@5%={cvar_05:.4f} below floor="
+                f"{self.cfg.cvar_floor:.4f} — CVaR VETO BYPASSED (ranker mode)"
             )
         cvar_adj = max(0.0, 1.0 + cvar_05 / abs(self.cfg.cvar_floor)) if cvar_05 < 0 else 1.0
 
@@ -2777,32 +2799,50 @@ class PortfolioRiskManager:
         mu           = max(value_estimate, 0.0)
         realized_var = max(realized_vol ** 2, 1e-8)
 
-        if mu <= 0:
-            return 0.0, f"No positive edge: μ={value_estimate:.5f} ≤ 0"
-
-        max_pos      = self._get_max_pos(asset_id)
-        f_kelly      = self.cfg.kelly_fraction * (mu / realized_var)
-        f_conviction = min(f_kelly * significance, max_pos)   # pre-clamp at max_pos
-
-        # ── Apply CVaR and drawdown adjustments ────────────────────────────────
-        f_adjusted = f_conviction * cvar_adj * dd_adj
-
-        # ── Layer 4 (portfolio-level): remaining risk budget ───────────────────
-        committed_frac = self._total_committed_fraction()
-        remaining      = max(0.0, self.cfg.max_portfolio_risk - committed_frac)
-        f_final        = min(f_adjusted, remaining)
-
-        # ── Layer 4 (asset-level): HARD max_pos cap — UNBREAKABLE ──────────────
-        f_final  = min(f_final, max_pos)                           # fraction cap
-        notional = f_final * self.cfg.total_capital
-        notional = max(self.cfg.min_notional, min(self.cfg.max_notional, notional))
-        notional = min(notional, max_pos * self.cfg.total_capital)  # notional cap
-
-        quantity = notional / current_price
+        max_pos  = self._get_max_pos(asset_id)
+        f_kelly  = 0.0
+        kelly_ok = False
+
+        if mu > 0:
+            f_kelly      = self.cfg.kelly_fraction * (mu / realized_var)
+            f_conviction = min(f_kelly * significance, max_pos)
+            f_adjusted   = f_conviction * cvar_adj         # dd_adj removed (v7)
+
+            # ── Layer 4 (portfolio-level): remaining risk budget ───────────────
+            committed_frac = self._total_committed_fraction()
+            remaining      = max(0.0, self.cfg.max_portfolio_risk - committed_frac)
+            f_final        = min(f_adjusted, remaining)
+
+            # ── Layer 4 (asset-level): HARD max_pos cap — UNBREAKABLE ──────────
+            f_final  = min(f_final, max_pos)
+            notional = f_final * self.cfg.total_capital
+            notional = max(self.cfg.min_notional, min(self.cfg.max_notional, notional))
+            notional = min(notional, max_pos * self.cfg.total_capital)
+            quantity = notional / current_price
+            kelly_ok = quantity > 0
+        else:
+            quantity  = 0.0
+            notional  = 0.0
+            f_final   = 0.0
+            f_conviction = 0.0
+
+        # ── FALLBACK GUARANTEE: quantity must NEVER be 0 ─────────────────────
+        # CHANGE v7: if Kelly produced 0 (no edge, risk-budget exhausted, etc.)
+        # fall back to fallback_notional / price so the system always trades.
+        # This is the minimum-data guarantee: every asset gets observed.
+        if quantity <= 0:
+            fb_notional = fallback_notional or self.cfg.min_notional
+            quantity    = fb_notional / current_price
+            reason = (
+                f"Kelly qty=0 (μ={value_estimate:.5f}, kelly_ok={kelly_ok}) — "
+                f"FALLBACK qty={quantity:.6f} from notional={fb_notional:.2f}"
+            )
+            logger.info(f"[PortfolioRiskManager] [{asset_id}] FALLBACK | {reason}")
+            return quantity, reason
 
         reason = (
             f"f_kelly={f_kelly:.5f} sig={significance:.3f} "
-            f"cvar_adj={cvar_adj:.3f} dd_adj={dd_adj:.1f} "
+            f"cvar_adj={cvar_adj:.3f} dd_adj=1.0(removed) "
             f"f_final={f_final:.5f} notional={notional:.2f} "
             f"max_pos={max_pos:.4f}[HARD CAP]"
         )
@@ -3182,6 +3222,11 @@ class QuasarAXRVIBridge:
         # contract_id back to the correct Trade object.
         self._pending_req_to_trade: Dict[int, str] = {}
 
+        # ── Last-known hub snapshots cache ────────────────────────────────────
+        # Used by _ensure_minimum_trades() to force-fill below the 2-trade floor
+        # when rank_and_gate() has not yet produced a fresh ranked list.
+        self._last_hub_snapshots: Dict[str, AssetSnapshot] = {}
+
         self._sync_thread:  Optional[threading.Thread]          = None
         self._sync_loop:    Optional[asyncio.AbstractEventLoop] = None
 
@@ -3384,39 +3429,64 @@ class QuasarAXRVIBridge:
         significance:   float = 0.5,
         cvar_05:        float = 0.0,
     ) -> None:
+        """
+        PERFORMANCE RANKER REFACTOR (v7):
+          • Sizing veto removed: if compute_position_size() returns qty <= 0 we
+            use a fixed minimum fallback (trade_config.amount / price) so the
+            system ALWAYS opens a trade and produces a closed-episode reward signal.
+          • Deriv API buy call is ALWAYS sent after the internal position is opened.
+            The call uses SYMBOL_MAP_REVERSE to convert the internal asset id to the
+            correct Deriv API symbol string.
+        """
+        # Gate A still applies — only BUY/SELL are tradeable directions
         if action in ("HOLD", "NEUTRAL"):
             return
 
         streamer = self.price_streamers.get(asset)
         if not streamer or streamer.is_stale():
-            logger.warning(f"⚠️  [{asset}] No recent price — skipping")
+            logger.warning(f"⚠️  [{asset}] No recent price — skipping signal")
             return
 
+        # One open trade per asset — this guard is preserved (v7 constraint)
         if self.position_mgr.get_open_trade_by_asset(asset):
+            logger.debug(f"[{asset}] Already has an open trade — skipping duplicate")
             return
 
         price    = streamer.latest_mid
         trade_id = f"{asset}_{int(time.time() * 1000)}"
 
-        # ── Institutional sizing (Kelly × conviction × CVaR × DD circuit breaker)
+        # ── Institutional sizing (Kelly × conviction — vetoes removed in v7) ──
         quantity, sizing_reason = self.portfolio_risk_mgr.compute_position_size(
-            asset_id       = asset,
-            current_price  = price,
-            value_estimate = value_estimate,
-            realized_vol   = max(realized_vol, 1e-4),
-            significance   = significance,
-            cvar_05        = cvar_05,
+            asset_id          = asset,
+            current_price     = price,
+            value_estimate    = value_estimate,
+            realized_vol      = max(realized_vol, 1e-4),
+            significance      = significance,
+            cvar_05           = cvar_05,
+            fallback_notional = self.trade_config.amount,  # minimum data-collection stake
         )
+
+        # ── Fallback quantity guarantee (v7) ──────────────────────────────────
+        # compute_position_size() now never returns 0, but be defensive: if for
+        # any reason quantity is still 0, use the flat minimum so ranking data
+        # is never lost.  This block should never fire in normal operation.
         if quantity <= 0:
-            logger.info(f"[{asset}] SIZING VETO | {sizing_reason}")
-            return
+            fallback_qty = self.trade_config.amount / max(price, 1.0)
+            logger.warning(
+                f"[{asset}] Sizing returned qty=0 despite v7 refactor — "
+                f"applying hard fallback qty={fallback_qty:.6f} | {sizing_reason}"
+            )
+            quantity = fallback_qty
 
+        # ── Open internal position (replay buffer + trainer integration) ──────
         direction = TradeDirection.LONG if action == "BUY" else TradeDirection.SHORT
         self.position_mgr.open_trade(trade_id, asset, direction, price, quantity)
 
         # ── Send actual buy order to Deriv API ────────────────────────────────
-        # Everything above is internal bookkeeping; THIS is what places the real
-        # trade on Deriv. Without this call the contract never exists on their end.
+        # CHANGE v7: this block is now UNCONDITIONAL — every internal open is
+        # paired with a real Deriv contract.  We use SYMBOL_MAP_REVERSE to
+        # translate the internal asset id (e.g. "V75") to the Deriv symbol
+        # string (e.g. "R_75") that the API expects.
         deriv_symbol = SYMBOL_MAP_REVERSE.get(asset)
         if deriv_symbol and self.ws_client and self.ws_client.connected:
             contract_type = "CALL" if action == "BUY" else "PUT"
@@ -3429,7 +3499,7 @@ class QuasarAXRVIBridge:
                     "currency":      "USD",
                     "duration":      self.trade_config.expiry_time,
                     "duration_unit": "s",
-                    "symbol":        deriv_symbol,
+                    "symbol":        deriv_symbol,   # SYMBOL_MAP_REVERSE lookup (v7)
                 },
             }
             sent = await self.ws_client.send_message(buy_msg)
@@ -3442,6 +3512,7 @@ class QuasarAXRVIBridge:
                     f"contract={contract_type} | "
                     f"amount={self.trade_config.amount} | "
                     f"duration={self.trade_config.expiry_time}s | "
+                    f"deriv_symbol={deriv_symbol} | "
                     f"req_id={buy_msg['req_id']}"
                 )
             else:
@@ -3451,7 +3522,7 @@ class QuasarAXRVIBridge:
         else:
             logger.error(
                 f"[{asset}] ❌ Cannot send Deriv BUY — "
-                f"deriv_symbol={deriv_symbol} | "
+                f"deriv_symbol={deriv_symbol} (SYMBOL_MAP_REVERSE lookup) | "
                 f"ws_connected={self.ws_client.connected if self.ws_client else 'no client'}"
             )
 
@@ -3536,10 +3607,17 @@ class QuasarAXRVIBridge:
 
         Minimum holding guard: do not evaluate stopping until
         _trade_tick_counts[trade_id] >= shreve_config.min_holding_ticks.
+
+        REFILL TRIGGER (v7):
+        After any position is closed, if open_trade_count drops below 2, immediately
+        call rank_and_gate() to refill.  This ensures the 2-trade minimum is maintained
+        continuously without waiting for the next scheduled _rank_loop cycle.
         """
         sc = self.config.shreve_config
         while self.running:
             try:
+                closed_any = False  # track whether we closed a trade this tick
+
                 for trade in self.position_mgr.get_open_trades():
                     streamer = self.price_streamers.get(trade.asset)
                     if not streamer:
@@ -3587,28 +3665,130 @@ class QuasarAXRVIBridge:
                     if should_stop:
                         logger.info(f"[{trade.asset}] EXIT | {stop_reason}")
                         await self._close_position(tid, price)
+                        closed_any = True
+
+                # ── REFILL TRIGGER (v7) ───────────────────────────────────────
+                # After closing any trade this cycle, check whether open_count
+                # has dropped below the 2-trade floor.  If so, trigger a fresh
+                # rank_and_gate() immediately — don't wait for the next scheduled
+                # _rank_loop tick — so the minimum is restored as fast as possible.
+                if closed_any:
+                    open_count = len(self.position_mgr.get_open_trades())
+                    if open_count < 2:
+                        logger.warning(
+                            f"[monitor_positions] ⚠️  REFILL TRIGGER — "
+                            f"open_count={open_count} < 2 after close. "
+                            f"Calling rank_and_gate() immediately to restore minimum."
+                        )
+                        try:
+                            await self.rank_and_gate()
+                        except Exception as refill_err:
+                            logger.error(
+                                f"[monitor_positions] ❌ Refill rank_and_gate error: {refill_err}"
+                            )
 
                 await asyncio.sleep(2)
             except Exception as e:
                 logger.error(f"❌ Position monitor error: {e}")
                 await asyncio.sleep(2)
 
+    async def _ensure_minimum_trades(
+        self,
+        hub_snapshots:    Dict[str, "AssetSnapshot"],
+        significance_map: Dict[str, float],
+        value_map:        Dict[str, float],
+        cvar_map:         Dict[str, float],
+        aleatoric_map:    Dict[str, float],
+        epistemic_map:    Dict[str, float],
+    ) -> None:
+        """
+        SAFETY NET — called at the start of every rank_and_gate() cycle.
+
+        Guarantees that open_trade_count >= 2 before the per-candidate gate loop
+        runs.  If open_count < 2, this method forces immediate execution on the
+        top-ranked available assets from the most recent hub_snapshots, bypassing
+        all gate outcomes.
+
+        The only hard filter respected here is Gate A: the asset must have a
+        BUY or SELL dominant_signal — a NEUTRAL/HOLD signal cannot be acted on
+        because we would not know which direction to trade.
+
+        No more than (2 - open_count) trades are opened here; the remaining
+        slots are filled by the normal enforcer loop in rank_and_gate().
+        """
+        open_count = len(self.position_mgr.get_open_trades())
+        if open_count >= 2:
+            return  # already at or above the floor — nothing to do
+
+        needed = 2 - open_count
+        logger.warning(
+            f"[_ensure_minimum_trades] ⚠️  open_count={open_count} < 2 — "
+            f"forcing execution on top {needed} ranked asset(s) to restore minimum"
+        )
+
+        # Build a priority-sorted list of candidates from the known snapshots.
+        # Use the last value_map scores; fall back to significance_map if empty.
+        candidates: List[Tuple[float, str]] = []
+        for asset_id, snap in hub_snapshots.items():
+            if snap.dominant_signal in ("NEUTRAL", "HOLD"):
+                continue   # Gate A: cannot trade without a direction
+            priority = value_map.get(asset_id, significance_map.get(asset_id, 0.0))
+            candidates.append((priority, asset_id))
+
+        candidates.sort(reverse=True)  # highest priority first
+
+        filled = 0
+        for _, asset_id in candidates:
+            if filled >= needed:
+                break
+
+            # One trade per asset (constraint preserved)
+            if self.position_mgr.get_open_trade_by_asset(asset_id):
+                continue
+
+            snap = hub_snapshots.get(asset_id)
+            if snap is None:
+                continue
+
+            buf          = self.asset_buffers.get(asset_id)
+            realized_vol = buf.feature_eng.get_raw_feature(6) if buf else 0.01
+
+            logger.warning(
+                f"[_ensure_minimum_trades] FORCE EXECUTE {snap.dominant_signal} "
+                f"on {asset_id} (floor enforcement, all gates bypassed)"
+            )
+            await self.process_axrvi_signal(
+                asset          = asset_id,
+                action         = snap.dominant_signal,
+                value_estimate = max(value_map.get(asset_id, 0.001), 1e-4),
+                realized_vol   = realized_vol,
+                significance   = significance_map.get(asset_id, 0.5),
+                cvar_05        = cvar_map.get(asset_id, 0.0),
+            )
+            filled += 1
+
+        if filled < needed:
+            logger.warning(
+                f"[_ensure_minimum_trades] Could only fill {filled}/{needed} slots "
+                f"— not enough assets with BUY/SELL signals at this tick"
+            )
+
     async def rank_and_gate(self) -> None:
         """
-        v6 Shreve Ranking Cycle:
+        v6/v7 Shreve Ranking Cycle:
           1. Data readiness check
           2. Build 26-dim feature tensors (UnifiedFeatureEngine, QV vol [S3])
           3. AXRVINet + MC Dropout → significance_weight + V̂_t (value head) [S1]
           4a. ShreveRankingEngine: Π_t = D(t,τ)·Ê[R|F_t] + ½σ²Δt·κ_t [S1,S5,S6]
           4b. ConservativeRanker: lower-confidence-bound adjustment
           5. BanditSelector: top N candidates
-          6. Five-gate execution filter:
-               A. dominant_signal ∈ {BUY, SELL}
-               B. hub_confidence > 0
-               C. significance ≥ threshold
-               D. DynamicExecutionGate (vol + uncertainty + jump)
-               E. Martingale null-hypothesis: DevMart(t) > ε  [S7]
-          7. Trade execution (s_t captured for replay [S2])
+          6. _ensure_minimum_trades() — safety net: force 2 open trades before gates run
+          7. MINIMUM TRADES ENFORCER (replaces five-gate block):
+               Hard filter: Gate A only (signal ∈ {BUY, SELL})
+               open_count < 2  → execute immediately, no veto
+               open_count == 2 → execute if Gate A passes (3rd slot)
+               open_count >= 3 → do not open new trades
+               Gates B, C, D, E → LOG ONLY (never block)
           8. Train on replay buffer (with L_CE [S1])
         """
         self.rank_count += 1
@@ -3734,38 +3914,80 @@ class QuasarAXRVIBridge:
             self.asset_buffers[aid].axrvi_score = float(final_scores[i])
             self.asset_buffers[aid].is_enabled  = aid in selected_ids
 
-        # ── Steps 6–7: five-gate execution ────────────────────────────────────
+        # Cache latest hub snapshots for _ensure_minimum_trades() refill logic
+        self._last_hub_snapshots = hub_snapshots
+
+        # ── Steps 6–7: MINIMUM TRADES ENFORCER (v7) ───────────────────────────
+        #
+        # PHILOSOPHY (v7): This system is a PERFORMANCE RANKER.  Trades are the
+        # measurement instrument.  Zero active trades = zero ranking data.
+        #
+        # RULE:
+        #   open_count < 2  → execute immediately on top-ranked assets regardless
+        #                      of gate outcomes — NO VETO ALLOWED
+        #   open_count == 2 → execute a 3rd only if Gate A passes (BUY or SELL)
+        #   open_count >= 3 → do not open new trades (hard ceiling)
+        #
+        # Gate A (dominant_signal ∈ {BUY, SELL}) remains the ONLY hard filter.
+        # Gates B, C, D, E are demoted to LOG ONLY — they never block a trade.
+        #
+        # _ensure_minimum_trades() is called first as a safety net before the
+        # per-candidate loop runs.
+        await self._ensure_minimum_trades(hub_snapshots, significance_map,
+                                          value_map, cvar_map, aleatoric_map,
+                                          epistemic_map)
+
+        open_count = len(self.position_mgr.get_open_trades())
+
         for asset_id in selected_ids:
+            # Re-check live count each iteration so we never exceed the ceiling
+            open_count = len(self.position_mgr.get_open_trades())
+
+            # Hard ceiling: 3 concurrent trades maximum (v7 constraint preserved)
+            if open_count >= 3:
+                logger.debug(
+                    f"[{asset_id}] SKIP — open_count={open_count} ≥ 3 (hard ceiling)"
+                )
+                break
+
             snap  = hub_snapshots.get(asset_id)
             sig_w = significance_map.get(asset_id, 0.0)
 
             if snap is None:
                 continue
 
-            # Gate A — directional signal required
+            # ── Gate A — hard filter: directional signal required ──────────────
+            # This is the ONLY gate that can block a trade in the enforcer model.
             if snap.dominant_signal in ("NEUTRAL", "HOLD"):
-                logger.debug(f"[{asset_id}] SKIP — signal=NEUTRAL")
+                logger.debug(f"[{asset_id}] SKIP Gate A — signal={snap.dominant_signal}")
                 continue
 
-            # Gate B — hub must have voted
+            # ── Gate B — LOG ONLY (was: hub_confidence ≤ 0 → skip) ───────────
             if snap.signal_confidence <= 0.0:
-                logger.debug(f"[{asset_id}] SKIP — hub_confidence=0.00")
-                continue
+                logger.info(
+                    f"[{asset_id}] Gate B LOG: hub_confidence=0.00 "
+                    f"(open_count={open_count} — executing anyway if below floor)"
+                )
+                # Below the 2-trade floor, execute regardless of confidence
+                if open_count >= 2:
+                    continue
 
-            # Gate C — significance threshold
+            # ── Gate C — LOG ONLY (was: significance < threshold → skip) ──────
             if sig_w < self.config.score_threshold:
                 logger.info(
-                    f"[{asset_id}] SKIP Gate C — significance={sig_w:.3f} "
-                    f"< threshold={self.config.score_threshold:.3f}"
+                    f"[{asset_id}] Gate C LOG: significance={sig_w:.3f} "
+                    f"< threshold={self.config.score_threshold:.3f} "
+                    f"(open_count={open_count} — executing anyway if below floor)"
                 )
-                continue
+                if open_count >= 2:
+                    continue
 
-            # Gate D + E — DynamicExecutionGate (includes martingale null-hypothesis [S7])
-            buf              = self.asset_buffers.get(asset_id)
-            vol_ratio        = buf.feature_eng.get_raw_feature(7)  if buf else 1.0
-            jump_risk        = buf.feature_eng.get_raw_feature(24) if buf else 0.0
-            mart_dev_raw     = buf.feature_eng.get_raw_feature(23) if buf else 1.0   # [S7]
-            realized_vol     = buf.feature_eng.get_raw_feature(6)  if buf else 0.01  # QV vol
+            # ── Gates D + E — LOG ONLY (was: DynamicExecutionGate → block) ────
+            buf          = self.asset_buffers.get(asset_id)
+            vol_ratio    = buf.feature_eng.get_raw_feature(7)  if buf else 1.0
+            jump_risk    = buf.feature_eng.get_raw_feature(24) if buf else 0.0
+            mart_dev_raw = buf.feature_eng.get_raw_feature(23) if buf else 1.0
+            realized_vol = buf.feature_eng.get_raw_feature(6)  if buf else 0.01
 
             execute, reason = self.execution_gate.should_execute(
                 hub_confidence       = snap.signal_confidence,
@@ -3775,25 +3997,31 @@ class QuasarAXRVIBridge:
                 epistemic_std        = epistemic_map.get(asset_id, 0.0),
                 aleatoric_std        = aleatoric_map.get(asset_id, 0.1),
                 dominant_signal      = snap.dominant_signal,
-                martingale_deviation = mart_dev_raw,   # [S7]
+                martingale_deviation = mart_dev_raw,
             )
             if not execute:
-                logger.info(f"[{asset_id}] Gate D/E BLOCKED: {reason}")
-                continue
-
+                logger.info(
+                    f"[{asset_id}] Gate D/E LOG (not blocking): {reason} "
+                    f"open_count={open_count}"
+                )
+                # Below the 2-trade floor, enforce the minimum and execute anyway
+                if open_count >= 2:
+                    continue
+
+            # ── Determine whether to execute based on open_count ──────────────
+            # open_count < 2  → execute unconditionally (minimum enforcer)
+            # open_count == 2 → execute (Gate A passed above; this is the 3rd slot)
+            # open_count >= 3 → already caught by the ceiling check at loop top
             logger.info(
                 f"[{asset_id}] EXECUTE {snap.dominant_signal} | "
-                f"Π_t={r.final_priority if ranked else 0.0:.4f} "
-                f"(V̂={value_map.get(asset_id, 0.0):+.3f} × D={math.exp(-self.config.shreve_config.risk_free_rate * self.config.shreve_config.horizon_seconds / (365.25*24*3600)):.4f})"
+                f"open_count={open_count} | "
+                f"Π_t={ranked[0].final_priority if ranked else 0.0:.4f} "
+                f"(V̂={value_map.get(asset_id, 0.0):+.3f} × "
+                f"D={math.exp(-self.config.shreve_config.risk_free_rate * self.config.shreve_config.horizon_seconds / (365.25*24*3600)):.4f})"
             )
             await self.process_axrvi_signal(
                 asset          = asset_id,
                 action         = snap.dominant_signal,
-                # Floor at 1e-4: an untrained distributional head can produce
-                # negative median quantiles; passing a negative value_estimate
-                # into Kelly sizing immediately triggers "No positive edge" and
-                # vetoes every trade.  The 1e-4 floor lets the system collect
-                # experience while the model is still learning. [S1/Kelly]
                 value_estimate = max(value_map.get(asset_id, 0.001), 1e-4),
                 realized_vol   = realized_vol,
                 significance   = sig_w,