修正延迟日待清仓补仓槽位

crates/fidc-core/src/platform_expr_strategy.rs

@@ -8780,6 +8780,37 @@ impl Strategy for PlatformExprStrategy {
                     } else if stop_hit {
                         unresolved_stop_loss_symbols.insert(position.symbol.clone());
                     }
+                    if daily_top_up_active {
+                        self.try_daily_top_up_at_position(
+                            ctx,
+                            &day,
+                            &stock_list,
+                            decision_date,
+                            execution_date,
+                            projection_date,
+                            selection_factor_date,
+                            signal_date,
+                            daily_top_up_target_budget,
+                            selection_limit,
+                            defer_execution_risk,
+                            Some(position.symbol.as_str()),
+                            &mut projected,
+                            &mut projected_execution_state,
+                            &mut order_intents,
+                            &mut aiquant_available_cash,
+                            &mut slot_working_symbols,
+                            &mut same_bar_buy_symbols,
+                            &pending_full_close_symbols,
+                            &slot_blocking_symbols,
+                            &same_day_sold_symbols,
+                            &exit_symbols,
+                            &delayed_sold_symbols,
+                            &mut intraday_attempted_buys,
+                            &mut daily_top_up_pending_buy_value,
+                            debug_daily_top_up,
+                            &mut daily_top_up_debug_notes,
+                        )?;
+                    }
                     continue;
                 }
             }
@@ -23081,6 +23112,236 @@ mod tests {
         );
     }
 
+    #[test]
+    fn platform_delayed_open_day_carried_full_close_releases_second_top_up_slot() {
+        let prev_date = d(2025, 5, 19);
+        let date = d(2025, 5, 20);
+        let buy_first = "000001.SZ";
+        let buy_second = "000002.SZ";
+        let delayed_symbol = "000100.SZ";
+        let take_profit_before = "000101.SZ";
+        let carried_full_close = "000102.SZ";
+        let keep_after = "000103.SZ";
+        let symbols = [
+            buy_first,
+            buy_second,
+            delayed_symbol,
+            take_profit_before,
+            carried_full_close,
+            keep_after,
+        ];
+        let data = DataSet::from_components_with_actions_and_quotes(
+            symbols
+                .iter()
+                .map(|symbol| Instrument {
+                    symbol: (*symbol).to_string(),
+                    name: (*symbol).to_string(),
+                    board: "SZ".to_string(),
+                    round_lot: 100,
+                    listed_at: Some(d(2020, 1, 1)),
+                    delisted_at: None,
+                    status: "active".to_string(),
+                })
+                .collect(),
+            symbols
+                .iter()
+                .map(|symbol| DailyMarketSnapshot {
+                    date,
+                    symbol: (*symbol).to_string(),
+                    timestamp: Some("2025-05-20 10:18:00".to_string()),
+                    day_open: 10.0,
+                    open: 10.0,
+                    high: 11.0,
+                    low: 9.0,
+                    close: 10.0,
+                    last_price: 10.0,
+                    bid1: 10.0,
+                    ask1: 10.0,
+                    prev_close: 10.0,
+                    volume: 1_000_000,
+                    minute_volume: 20_000,
+                    bid1_volume: 20_000,
+                    ask1_volume: 20_000,
+                    trading_phase: Some("continuous".to_string()),
+                    paused: false,
+                    upper_limit: 11.0,
+                    lower_limit: 9.0,
+                    price_tick: 0.01,
+                })
+                .collect(),
+            symbols
+                .iter()
+                .map(|symbol| DailyFactorSnapshot {
+                    date,
+                    symbol: (*symbol).to_string(),
+                    market_cap_bn: match *symbol {
+                        s if s == buy_first => 1.0,
+                        s if s == buy_second => 2.0,
+                        s if s == take_profit_before => 3.0,
+                        s if s == keep_after => 4.0,
+                        s if s == delayed_symbol => 5.0,
+                        _ => 100.0,
+                    },
+                    free_float_cap_bn: 10.0,
+                    pe_ttm: 8.0,
+                    turnover_ratio: Some(1.0),
+                    effective_turnover_ratio: Some(1.0),
+                    extra_factors: BTreeMap::new(),
+                })
+                .collect(),
+            symbols
+                .iter()
+                .map(|symbol| CandidateEligibility {
+                    date,
+                    symbol: (*symbol).to_string(),
+                    is_st: false,
+                    is_star_st: false,
+                    is_new_listing: false,
+                    is_paused: false,
+                    allow_buy: true,
+                    allow_sell: true,
+                    is_kcb: false,
+                    is_one_yuan: false,
+                    risk_level_code: None,
+                })
+                .collect(),
+            vec![BenchmarkSnapshot {
+                date,
+                benchmark: "000852.SH".to_string(),
+                open: 1000.0,
+                close: 1002.0,
+                prev_close: 998.0,
+                volume: 1_000_000,
+            }],
+            Vec::new(),
+            symbols
+                .iter()
+                .flat_map(|symbol| {
+                    let mut quotes = Vec::new();
+                    if *symbol == delayed_symbol {
+                        quotes.push(IntradayExecutionQuote {
+                            date,
+                            symbol: (*symbol).to_string(),
+                            timestamp: date.and_hms_opt(9, 31, 0).expect("valid timestamp"),
+                            last_price: 10.5,
+                            bid1: 10.5,
+                            ask1: 10.51,
+                            bid1_volume: 20_000,
+                            ask1_volume: 20_000,
+                            volume_delta: 20_000,
+                            amount_delta: 210_000.0,
+                            trading_phase: Some("continuous".to_string()),
+                        });
+                    }
+                    quotes.push(IntradayExecutionQuote {
+                        date,
+                        symbol: (*symbol).to_string(),
+                        timestamp: date.and_hms_opt(10, 18, 0).expect("valid timestamp"),
+                        last_price: 10.0,
+                        bid1: 10.0,
+                        ask1: 10.01,
+                        bid1_volume: 20_000,
+                        ask1_volume: 20_000,
+                        volume_delta: 20_000,
+                        amount_delta: 200_000.0,
+                        trading_phase: Some("continuous".to_string()),
+                    });
+                    quotes
+                })
+                .collect(),
+        )
+        .expect("dataset");
+
+        let mut portfolio = PortfolioState::new(30_000.0);
+        portfolio
+            .position_mut(delayed_symbol)
+            .buy(prev_date, 100, 10.0);
+        portfolio
+            .position_mut(take_profit_before)
+            .buy(prev_date, 100, 8.0);
+        portfolio
+            .position_mut(carried_full_close)
+            .buy(prev_date, 100, 8.0);
+        portfolio.position_mut(keep_after).buy(prev_date, 100, 10.0);
+        let subscriptions = BTreeSet::new();
+        let ctx = StrategyContext {
+            execution_date: date,
+            decision_date: date,
+            decision_index: 20,
+            data: &data,
+            portfolio: &portfolio,
+            futures_account: None,
+            open_orders: &[],
+            dynamic_universe: None,
+            subscriptions: &subscriptions,
+            process_events: &[],
+            active_process_event: None,
+            active_datetime: None,
+            order_events: &[],
+            fills: &[],
+        };
+        let mut cfg = PlatformExprStrategyConfig::microcap_rotation();
+        cfg.signal_symbol = delayed_symbol.to_string();
+        cfg.refresh_rate = 99;
+        cfg.max_positions = 4;
+        cfg.benchmark_short_ma_days = 1;
+        cfg.benchmark_long_ma_days = 1;
+        cfg.market_cap_lower_expr = "0".to_string();
+        cfg.market_cap_upper_expr = "1000".to_string();
+        cfg.selection_limit_expr = "4".to_string();
+        cfg.stock_filter_expr = "close > 0".to_string();
+        cfg.exposure_expr = "1.0".to_string();
+        cfg.stop_loss_expr = "false".to_string();
+        cfg.take_profit_expr = "1.1".to_string();
+        cfg.daily_top_up_enabled = true;
+        cfg.release_slot_on_exit_signal = true;
+        cfg.aiquant_transaction_cost = true;
+        cfg.intraday_execution_time = Some(NaiveTime::from_hms_opt(10, 18, 0).unwrap());
+        cfg.delayed_limit_open_exit_enabled = true;
+        cfg.delayed_limit_open_exit_time = Some(NaiveTime::from_hms_opt(9, 31, 0).unwrap());
+        let mut strategy = PlatformExprStrategy::new(cfg);
+        strategy.rebalance_day_counter = 2;
+        strategy
+            .pending_highlimit_holdings
+            .insert(delayed_symbol.to_string());
+        strategy
+            .pending_full_close_symbols
+            .insert(carried_full_close.to_string());
+
+        let decision = strategy.on_day(&ctx).expect("platform decision");
+        let top_up_symbols = decision
+            .order_intents
+            .iter()
+            .filter_map(|intent| match intent {
+                OrderIntent::Value { symbol, reason, .. } if reason == "daily_top_up_buy" => {
+                    Some(symbol.as_str())
+                }
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+
+        assert!(
+            decision.order_intents.iter().any(|intent| matches!(
+                intent,
+                OrderIntent::TargetValue {
+                    symbol,
+                    target_value,
+                    reason,
+                } if symbol == carried_full_close
+                    && *target_value == 0.0
+                    && reason == "pending_full_close_exit"
+            )),
+            "{:?}",
+            decision.order_intents
+        );
+        assert_eq!(
+            top_up_symbols,
+            vec![buy_first, buy_second],
+            "{:?}",
+            decision.order_intents
+        );
+    }
+
     #[test]
     fn platform_daily_top_up_releases_unsellable_stop_loss_slot() {
         let prev_date = d(2026, 3, 31);