Merge remote-tracking branch 'origin/main'

crates/fidc-core/src/engine.rs

@@ -1,5 +1,4 @@
 use std::collections::{BTreeMap, BTreeSet};
-use std::sync::Arc;
 
 use chrono::{Datelike, Duration, NaiveDate, NaiveTime};
 use serde::{Deserialize, Serialize};
@@ -473,7 +472,6 @@ pub struct BacktestEngine<S, C, R> {
     futures_cost_model: FuturesTransactionCostModel,
     futures_validation_config: FuturesValidationConfig,
     execution_quote_loader: Option<ExecutionQuoteLoader>,
-    preplanned_decision_quote_symbols_by_date: Option<Arc<BTreeMap<NaiveDate, BTreeSet<String>>>>,
     execution_quote_request_cache:
         BTreeSet<(NaiveDate, String, Option<NaiveTime>, Option<NaiveTime>)>,
     execution_absence_notes: BTreeMap<NaiveDate, Vec<String>>,
@@ -574,7 +572,6 @@ impl<S, C, R> BacktestEngine<S, C, R> {
             futures_cost_model: FuturesTransactionCostModel::default(),
             futures_validation_config: FuturesValidationConfig::default(),
             execution_quote_loader: None,
-            preplanned_decision_quote_symbols_by_date: None,
             execution_quote_request_cache: BTreeSet::new(),
             execution_absence_notes: BTreeMap::new(),
             execution_lifecycle_reported: BTreeSet::new(),
@@ -601,14 +598,6 @@ impl<S, C, R> BacktestEngine<S, C, R> {
         self
     }
 
-    pub fn with_preplanned_decision_quote_symbols_by_date(
-        mut self,
-        symbols_by_date: Arc<BTreeMap<NaiveDate, BTreeSet<String>>>,
-    ) -> Self {
-        self.preplanned_decision_quote_symbols_by_date = Some(symbols_by_date);
-        self
-    }
-
     pub fn with_dividend_reinvestment(mut self, enabled: bool) -> Self {
         self.dividend_reinvestment = enabled;
         self
@@ -2620,46 +2609,31 @@ where
             let on_day_open_orders = self.open_order_views();
             let decision_quote_times = self.strategy.decision_quote_times();
             if self.execution_quote_loader.is_some() && !decision_quote_times.is_empty() {
-                if let Some(preplanned) = self
-                    .preplanned_decision_quote_symbols_by_date
-                    .as_ref()
-                    .map(Arc::clone)
-                {
-                    let empty_symbols = BTreeSet::new();
-                    let decision_quote_symbols =
-                        preplanned.get(&execution_date).unwrap_or(&empty_symbols);
-                    self.ensure_execution_quotes_for_symbols_at_times(
+                let decision_quote_symbols =
+                    self.strategy.decision_quote_symbols(&StrategyContext {
                         execution_date,
-                        decision_quote_symbols,
-                        &decision_quote_times,
-                    )?;
-                } else {
-                    let decision_quote_symbols =
-                        self.strategy.decision_quote_symbols(&StrategyContext {
-                            execution_date,
+                        decision_date,
+                        decision_index,
+                        data: &self.data,
+                        portfolio: &portfolio,
+                        futures_account: self.futures_account.as_ref(),
+                        open_orders: &on_day_open_orders,
+                        dynamic_universe: self.dynamic_universe.as_ref(),
+                        subscriptions: &self.subscriptions,
+                        process_events: &process_events,
+                        active_process_event: None,
+                        active_datetime: stage_datetime(
                             decision_date,
-                            decision_index,
-                            data: &self.data,
-                            portfolio: &portfolio,
-                            futures_account: self.futures_account.as_ref(),
-                            open_orders: &on_day_open_orders,
-                            dynamic_universe: self.dynamic_universe.as_ref(),
-                            subscriptions: &self.subscriptions,
-                            process_events: &process_events,
-                            active_process_event: None,
-                            active_datetime: stage_datetime(
-                                decision_date,
-                                default_stage_time(ScheduleStage::OnDay),
-                            ),
-                            order_events: result.order_events.as_slice(),
-                            fills: result.fills.as_slice(),
-                        })?;
-                    self.ensure_execution_quotes_for_symbols_at_times(
-                        execution_date,
-                        &decision_quote_symbols,
-                        &decision_quote_times,
-                    )?;
-                }
+                            default_stage_time(ScheduleStage::OnDay),
+                        ),
+                        order_events: result.order_events.as_slice(),
+                        fills: result.fills.as_slice(),
+                    })?;
+                self.ensure_execution_quotes_for_symbols_at_times(
+                    execution_date,
+                    &decision_quote_symbols,
+                    &decision_quote_times,
+                )?;
             }
             self.ensure_execution_quotes_for_portfolio_times(
                 execution_date,

crates/fidc-core/tests/decision_quote_preload.rs

@@ -5,7 +5,7 @@ use fidc_core::{
     Instrument, IntradayExecutionQuote, MatchingType, OrderIntent, PriceField, Strategy, StrategyContext,
     StrategyDecision,
 };
-use std::collections::{BTreeMap, BTreeSet};
+use std::collections::BTreeSet;
 use std::sync::{Arc, Mutex};
 
 fn d(year: i32, month: u32, day: u32) -> NaiveDate {
@@ -163,7 +163,48 @@ fn single_day_quote_plan_data(date: NaiveDate) -> DataSet {
 }
 
 #[test]
-fn engine_uses_preplanned_decision_symbols_without_recomputing_strategy_plan() {
+fn runtime_account_dependent_quote_scope_uses_the_actual_account() {
+    struct AccountDependentQuoteReader;
+    impl Strategy for AccountDependentQuoteReader {
+        fn name(&self) -> &str { "account_dependent_quote_reader" }
+        fn decision_quote_times(&self) -> Vec<NaiveTime> { vec![t(10, 18, 0)] }
+        fn decision_quote_symbols(&mut self, ctx: &StrategyContext<'_>) -> Result<BTreeSet<String>, fidc_core::BacktestError> {
+            Ok(if ctx.portfolio.cash() < 50_000.0 {
+                BTreeSet::from(["000001.SZ".into()])
+            } else { BTreeSet::new() })
+        }
+        fn on_day(&mut self, ctx: &StrategyContext<'_>) -> Result<StrategyDecision, fidc_core::BacktestError> {
+            let loaded = ctx.data.execution_quotes_on(ctx.execution_date, "000001.SZ").iter().any(|quote|
+                quote.timestamp.time()==t(10,17,59) && quote.last_price==10.0);
+            assert_eq!(loaded, ctx.portfolio.cash() < 50_000.0,
+                "quote scope must match this account, not a fixed-capital planning account");
+            Ok(StrategyDecision::default())
+        }
+    }
+    let date = d(2026, 1, 5);
+    for initial_cash in [10_000.0, 100_000.0] {
+    let broker = BrokerSimulator::new_with_execution_price(
+        ChinaAShareCostModel::default(), ChinaEquityRuleHooks, PriceField::Close,
+    ).with_volume_capacity_mode(fidc_core::execution_capacity::VolumeCapacityMode::SessionCapacityAudit)
+        .with_matching_type(MatchingType::CurrentBarClose);
+    let config = BacktestConfig {
+        initial_cash, benchmark_code:"000852.SH".into(),
+        start_date:Some(date), end_date:Some(date), decision_lag_trading_days:0,
+        execution_price_field:PriceField::Close,
+    };
+    let mut engine = BacktestEngine::new(single_day_quote_plan_data(date), AccountDependentQuoteReader, broker, config)
+        .with_execution_quote_loader(move |request| Ok(request.symbols.into_iter().map(|symbol| IntradayExecutionQuote {
+            observation_kind:Default::default(), date:request.date, symbol,
+            timestamp:request.date.and_time(t(10,17,59)), last_price:10.0,bid1:10.0,ask1:10.0,
+            bid1_volume:10_000,ask1_volume:10_000,volume_delta:10_000,amount_delta:100_000.0,
+            trading_phase:Some("continuous".into()),
+        }).collect()));
+    engine.run().expect("account-dependent quote planning");
+    }
+}
+
+#[test]
+fn engine_resolves_the_runtime_strategy_scope_when_a_loader_exists() {
     let date = d(2026, 1, 5);
     let data = single_day_quote_plan_data(date);
     let broker = BrokerSimulator::new_with_execution_price(
@@ -186,10 +227,6 @@ fn engine_uses_preplanned_decision_symbols_without_recomputing_strategy_plan() {
         symbol_plan_calls: Arc::clone(&symbol_plan_calls),
     };
     let captured_loader_calls = Arc::clone(&loader_calls);
-    let preplanned = Arc::new(BTreeMap::from([(
-        date,
-        BTreeSet::from(["000001.SZ".to_string()]),
-    )]));
     let mut engine = BacktestEngine::new(data, strategy, broker, config)
         .with_execution_quote_loader(move |request| {
             *captured_loader_calls.lock().expect("loader counter mutex") += 1;
@@ -210,20 +247,19 @@ fn engine_uses_preplanned_decision_symbols_without_recomputing_strategy_plan() {
                     trading_phase: Some("continuous".to_string()),
                 })
                 .collect())
-        })
-        .with_preplanned_decision_quote_symbols_by_date(preplanned);
+        });
 
     engine.run().expect("backtest should run");
 
     assert_eq!(
         *symbol_plan_calls.lock().expect("symbol plan counter mutex"),
-        0,
-        "the strategy plan must not be recomputed after a complete plan is supplied"
+        1,
+        "quote planning must use the actual run context"
     );
     assert_eq!(
         *loader_calls.lock().expect("loader counter mutex"),
-        1,
-        "the supplied symbols must still pass through the normal quote loader"
+        0,
+        "an empty runtime scope must not fetch unrequested symbols"
     );
 }