修复止盈关闭时的延迟卖出误触发

crates/fidc-core/src/broker.rs

@@ -11,7 +11,7 @@ use crate::events::{
     ProcessEventKind,
 };
 use crate::portfolio::PortfolioState;
-use crate::rules::EquityRuleHooks;
+use crate::rules::{EquityRuleHooks, RuleCheck};
 use crate::strategy::{
     AlgoOrderStyle, OpenOrderView, OrderIntent, StrategyDecision, TargetPortfolioOrderPricing,
 };
@@ -111,6 +111,8 @@ pub struct BrokerSimulator<C, R> {
     inactive_limit: bool,
     liquidity_limit: bool,
     strict_value_budget: bool,
+    aiquant_rqalpha_execution_rules: bool,
+    same_day_buy_close_mark_at_fill: bool,
     intraday_execution_start_time: Option<NaiveTime>,
     runtime_intraday_start_time: Cell<Option<NaiveTime>>,
     runtime_intraday_end_time: Cell<Option<NaiveTime>>,
@@ -132,6 +134,8 @@ impl<C, R> BrokerSimulator<C, R> {
             inactive_limit: true,
             liquidity_limit: true,
             strict_value_budget: false,
+            aiquant_rqalpha_execution_rules: false,
+            same_day_buy_close_mark_at_fill: false,
             intraday_execution_start_time: None,
             runtime_intraday_start_time: Cell::new(None),
             runtime_intraday_end_time: Cell::new(None),
@@ -157,6 +161,8 @@ impl<C, R> BrokerSimulator<C, R> {
             inactive_limit: true,
             liquidity_limit: true,
             strict_value_budget: false,
+            aiquant_rqalpha_execution_rules: false,
+            same_day_buy_close_mark_at_fill: false,
             intraday_execution_start_time: None,
             runtime_intraday_start_time: Cell::new(None),
             runtime_intraday_end_time: Cell::new(None),
@@ -185,6 +191,20 @@ impl<C, R> BrokerSimulator<C, R> {
         self
     }
 
+    pub fn with_aiquant_rqalpha_execution_rules(mut self, enabled: bool) -> Self {
+        self.aiquant_rqalpha_execution_rules = enabled;
+        self
+    }
+
+    pub fn with_same_day_buy_close_mark_at_fill(mut self, enabled: bool) -> Self {
+        self.same_day_buy_close_mark_at_fill = enabled;
+        self
+    }
+
+    pub fn same_day_buy_close_mark_at_fill(&self) -> bool {
+        self.same_day_buy_close_mark_at_fill
+    }
+
     pub fn with_volume_percent(mut self, volume_percent: f64) -> Self {
         self.volume_percent = volume_percent;
         self
@@ -252,6 +272,34 @@ where
         snapshot.price(self.execution_price_field)
     }
 
+    fn value_buy_sizing_price(
+        &self,
+        date: NaiveDate,
+        data: &DataSet,
+        symbol: &str,
+        snapshot: &crate::data::DailyMarketSnapshot,
+    ) -> f64 {
+        let start_cursor = self
+            .runtime_intraday_start_time
+            .get()
+            .or(self.intraday_execution_start_time)
+            .map(|start_time| date.and_time(start_time));
+        data.execution_quotes_on(date, symbol)
+            .iter()
+            .filter(|quote| {
+                start_cursor
+                    .map(|cursor| quote.timestamp >= cursor)
+                    .unwrap_or(true)
+            })
+            .next()
+            .and_then(|quote| match self.execution_price_field {
+                PriceField::Last => (quote.last_price.is_finite() && quote.last_price > 0.0)
+                    .then_some(quote.last_price),
+                _ => quote.buy_price(),
+            })
+            .unwrap_or_else(|| self.sizing_price(snapshot))
+    }
+
     fn snapshot_execution_price(
         &self,
         snapshot: &crate::data::DailyMarketSnapshot,
@@ -1785,6 +1833,68 @@ where
         Ok(())
     }
 
+    fn aiquant_limit_check_price(
+        &self,
+        snapshot: &crate::data::DailyMarketSnapshot,
+        side: OrderSide,
+    ) -> f64 {
+        match (self.execution_price_field, side) {
+            (PriceField::Last, _) => snapshot.price(PriceField::Last),
+            (_, OrderSide::Buy) => snapshot.buy_price(self.execution_price_field),
+            (_, OrderSide::Sell) => snapshot.sell_price(self.execution_price_field),
+        }
+    }
+
+    fn buy_rule_check(
+        &self,
+        date: NaiveDate,
+        snapshot: &crate::data::DailyMarketSnapshot,
+        candidate: &crate::data::CandidateEligibility,
+    ) -> RuleCheck {
+        if !self.aiquant_rqalpha_execution_rules {
+            return self
+                .rules
+                .can_buy(date, snapshot, candidate, self.execution_price_field);
+        }
+        if snapshot.paused || candidate.is_paused {
+            return RuleCheck::reject("paused");
+        }
+        let check_price = self.aiquant_limit_check_price(snapshot, OrderSide::Buy);
+        if snapshot.is_at_upper_limit_price(check_price) {
+            return RuleCheck::reject("open at or above upper limit");
+        }
+        RuleCheck::allow()
+    }
+
+    fn sell_rule_check(
+        &self,
+        date: NaiveDate,
+        snapshot: &crate::data::DailyMarketSnapshot,
+        candidate: &crate::data::CandidateEligibility,
+        position: &crate::portfolio::Position,
+    ) -> RuleCheck {
+        if !self.aiquant_rqalpha_execution_rules {
+            return self.rules.can_sell(
+                date,
+                snapshot,
+                candidate,
+                position,
+                self.execution_price_field,
+            );
+        }
+        if snapshot.paused || candidate.is_paused {
+            return RuleCheck::reject("paused");
+        }
+        let check_price = self.aiquant_limit_check_price(snapshot, OrderSide::Sell);
+        if snapshot.is_at_lower_limit_price(check_price) {
+            return RuleCheck::reject("open at or below lower limit");
+        }
+        if position.sellable_qty(date) == 0 {
+            return RuleCheck::reject("t+1 sellable quantity is zero");
+        }
+        RuleCheck::allow()
+    }
+
     fn minimum_target_quantity(
         &self,
         date: NaiveDate,
@@ -1807,13 +1917,7 @@ where
         let Ok(candidate) = data.require_candidate(date, symbol) else {
             return current_qty;
         };
-        let rule = self.rules.can_sell(
+        let rule = self.sell_rule_check(date, snapshot, candidate, position);
-            date,
-            snapshot,
-            candidate,
-            position,
-            self.execution_price_field,
-        );
         if !rule.allowed {
             return current_qty;
         }
@@ -1851,9 +1955,7 @@ where
         let Ok(candidate) = data.require_candidate(date, symbol) else {
             return current_qty;
         };
-        let rule = self
+        let rule = self.buy_rule_check(date, snapshot, candidate);
-            .rules
-            .can_buy(date, snapshot, candidate, self.execution_price_field);
         if !rule.allowed {
             return current_qty;
         }
@@ -1897,13 +1999,7 @@ where
         let position = portfolio.position(symbol)?;
         let snapshot = data.require_market(date, symbol).ok()?;
         let candidate = data.require_candidate(date, symbol).ok()?;
-        let rule = self.rules.can_sell(
+        let rule = self.sell_rule_check(date, snapshot, candidate, position);
-            date,
-            snapshot,
-            candidate,
-            position,
-            self.execution_price_field,
-        );
         if !rule.allowed {
             return rule.reason;
         }
@@ -1943,9 +2039,7 @@ where
     ) -> Option<String> {
         let snapshot = data.require_market(date, symbol).ok()?;
         let candidate = data.require_candidate(date, symbol).ok()?;
-        let rule = self
+        let rule = self.buy_rule_check(date, snapshot, candidate);
-            .rules
-            .can_buy(date, snapshot, candidate, self.execution_price_field);
         if !rule.allowed {
             return rule.reason;
         }
@@ -2015,13 +2109,7 @@ where
             );
         }
 
-        let rule = self.rules.can_sell(
+        let rule = self.sell_rule_check(date, snapshot, candidate, position);
-            date,
-            snapshot,
-            candidate,
-            position,
-            self.execution_price_field,
-        );
         if !rule.allowed {
             let rule_reason = rule.reason.as_deref().unwrap_or_default().to_string();
             let status = match rule.reason.as_deref() {
@@ -2237,7 +2325,12 @@ where
             (fill.quantity, fill.legs)
         } else {
             let execution_price = self.snapshot_execution_price(snapshot, OrderSide::Sell);
-            if !self.price_satisfies_limit(
+            if let Some(reason) =
+                self.execution_limit_rejection_reason(snapshot, OrderSide::Sell, execution_price)
+            {
+                partial_fill_reason = merge_partial_fill_reason(partial_fill_reason, Some(reason));
+                (0, Vec::new())
+            } else if !self.price_satisfies_limit(
                 OrderSide::Sell,
                 execution_price,
                 limit_price,
@@ -2917,9 +3010,11 @@ where
             let round_lot = self.round_lot(data, symbol);
             let minimum_order_quantity = self.minimum_order_quantity(data, symbol);
             let order_step_size = self.order_step_size(data, symbol);
-            let price = self.sizing_price(snapshot);
+            let price = self.value_buy_sizing_price(date, data, symbol, snapshot);
-            let snapshot_requested_qty = self.round_buy_quantity(
+            let snapshot_requested_qty = self.value_buy_quantity(
-                ((value.abs()) / price).floor() as u32,
+                date,
+                value.abs(),
+                price,
                 minimum_order_quantity,
                 order_step_size,
             );
@@ -3012,8 +3107,10 @@ where
             let minimum_order_quantity = self.minimum_order_quantity(data, symbol);
             let order_step_size = self.order_step_size(data, symbol);
             let price = self.sizing_price(snapshot);
-            let snapshot_requested_qty = self.round_buy_quantity(
+            let snapshot_requested_qty = self.value_buy_quantity(
-                ((value.abs()) / price).floor() as u32,
+                date,
+                value.abs(),
+                price,
                 minimum_order_quantity,
                 order_step_size,
             );
@@ -3178,8 +3275,10 @@ where
             let minimum_order_quantity = self.minimum_order_quantity(data, symbol);
             let order_step_size = self.order_step_size(data, symbol);
             let price = self.sizing_price(snapshot);
-            let snapshot_requested_qty = self.round_buy_quantity(
+            let snapshot_requested_qty = self.value_buy_quantity(
-                (value.abs() / price).floor() as u32,
+                date,
+                value.abs(),
+                price,
                 minimum_order_quantity,
                 order_step_size,
             );
@@ -3396,14 +3495,16 @@ where
         requested_qty
     }
 
-    fn value_budget_gross_limit(&self, value_budget: Option<f64>) -> Option<f64> {
+    fn value_buy_gross_limit(
-        value_budget.map(|budget| {
+        &self,
-            if self.strict_value_budget {
+        value_budget: Option<f64>,
-                budget
+        requested_qty: u32,
-            } else {
+        reference_price: f64,
-                budget + 400.0
+    ) -> Option<f64> {
+        if !self.strict_value_budget {
+            return None;
         }
-        })
+        value_budget.map(|budget| budget.max(reference_price * requested_qty as f64))
     }
 
     fn process_buy(
@@ -3441,9 +3542,7 @@ where
             );
         }
 
-        let rule = self
+        let rule = self.buy_rule_check(date, snapshot, candidate);
-            .rules
-            .can_buy(date, snapshot, candidate, self.execution_price_field);
         if !rule.allowed {
             let rule_reason = rule.reason.as_deref().unwrap_or_default().to_string();
             let status = match rule.reason.as_deref() {
@@ -3562,6 +3661,8 @@ where
                 return Ok(());
             }
         };
+        let value_gross_limit =
+            self.value_buy_gross_limit(value_budget, constrained_qty, self.sizing_price(snapshot));
 
         let fill = self.resolve_execution_fill(
             date,
@@ -3577,7 +3678,7 @@ where
             execution_cursors,
             None,
             Some(portfolio.cash()),
-            self.value_budget_gross_limit(value_budget),
+            value_gross_limit,
             algo_request,
             limit_price,
         );
@@ -3591,7 +3692,12 @@ where
             (fill.quantity, fill.legs)
         } else {
             let execution_price = self.snapshot_execution_price(snapshot, OrderSide::Buy);
-            if !self.price_satisfies_limit(
+            if let Some(reason) =
+                self.execution_limit_rejection_reason(snapshot, OrderSide::Buy, execution_price)
+            {
+                partial_fill_reason = merge_partial_fill_reason(partial_fill_reason, Some(reason));
+                (0, Vec::new())
+            } else if !self.price_satisfies_limit(
                 OrderSide::Buy,
                 execution_price,
                 limit_price,
@@ -3608,7 +3714,7 @@ where
                 let filled_qty = self.affordable_buy_quantity(
                     date,
                     portfolio.cash(),
-                    self.value_budget_gross_limit(value_budget),
+                    value_gross_limit,
                     execution_price,
                     constrained_qty,
                     self.minimum_order_quantity(data, symbol),
@@ -3619,7 +3725,7 @@ where
                         partial_fill_reason,
                         self.buy_reduction_reason(
                             portfolio.cash(),
-                            self.value_budget_gross_limit(value_budget),
+                            value_gross_limit,
                             execution_price,
                             constrained_qty,
                             filled_qty,
@@ -3720,7 +3826,7 @@ where
                 .position_mut(symbol)
                 .buy(date, leg.quantity, leg.price);
             if let Some(position) = portfolio.position_mut_if_exists(symbol) {
-                position.record_trade_cost(cost.total());
+                position.record_buy_trade_cost(leg.quantity, cost.total());
             }
 
             report.fill_events.push(FillEvent {
@@ -4054,6 +4160,31 @@ where
         }
     }
 
+    fn value_buy_quantity(
+        &self,
+        date: NaiveDate,
+        value_budget: f64,
+        price: f64,
+        minimum_order_quantity: u32,
+        order_step_size: u32,
+    ) -> u32 {
+        if !value_budget.is_finite() || value_budget <= 0.0 || !price.is_finite() || price <= 0.0 {
+            return 0;
+        }
+        let minimum = minimum_order_quantity.max(1);
+        let raw_quantity = (value_budget / price).floor() as u32;
+        let mut quantity =
+            self.round_buy_quantity(raw_quantity, minimum_order_quantity, order_step_size);
+        while quantity >= minimum {
+            if self.estimated_buy_cash_out(date, price, quantity) <= value_budget + 1e-6 {
+                return quantity;
+            }
+            quantity =
+                self.decrement_order_quantity(quantity, minimum_order_quantity, order_step_size);
+        }
+        0
+    }
+
     fn decrement_order_quantity(
         &self,
         quantity: u32,
@@ -4200,6 +4331,26 @@ where
         }
     }
 
+    fn execution_limit_rejection_reason(
+        &self,
+        snapshot: &crate::data::DailyMarketSnapshot,
+        side: OrderSide,
+        execution_price: f64,
+    ) -> Option<&'static str> {
+        if !execution_price.is_finite() || execution_price <= 0.0 {
+            return None;
+        }
+        match side {
+            OrderSide::Buy if snapshot.is_at_upper_limit_price(execution_price) => {
+                Some("open at or above upper limit")
+            }
+            OrderSide::Sell if snapshot.is_at_lower_limit_price(execution_price) => {
+                Some("open at or below lower limit")
+            }
+            _ => None,
+        }
+    }
+
     fn execution_price_with_limit_slippage(
         &self,
         execution_price: f64,
@@ -4213,7 +4364,10 @@ where
 
     fn limit_order_can_remain_open(partial_reason: Option<&str>) -> bool {
         !partial_reason.is_some_and(|reason| {
-            reason.contains("insufficient cash") || reason.contains("value budget")
+            reason.contains("insufficient cash")
+                || reason.contains("value budget")
+                || reason.contains("open at or above upper limit")
+                || reason.contains("open at or below lower limit")
         })
     }
 
@@ -4334,13 +4488,16 @@ where
             return None;
         }
 
+        let quote_quantity_limited =
+            self.quote_quantity_limited_for_window(matching_type, start_cursor, end_cursor);
         let lot = round_lot.max(1);
         let eligible_quotes: Vec<&IntradayExecutionQuote> = quotes
             .iter()
             .filter(|quote| {
                 !start_cursor.is_some_and(|cursor| quote.timestamp < cursor)
                     && !end_cursor.is_some_and(|cursor| quote.timestamp > cursor)
-                    && quote.volume_delta != 0
+                    && (!quote_quantity_limited
+                        || self.quote_has_executable_liquidity(quote, side, matching_type))
             })
             .collect();
         let mut filled_qty = 0_u32;
@@ -4348,6 +4505,9 @@ where
         let mut last_timestamp = None;
         let mut legs = Vec::new();
         let mut budget_block_reason = None;
+        let mut execution_block_reason = None;
+        let mut execution_block_timestamp = None;
+        let mut saw_non_blocked_execution_price = false;
         let saw_quote_after_cursor = !eligible_quotes.is_empty();
 
         for (quote_index, quote) in eligible_quotes.iter().enumerate() {
@@ -4359,6 +4519,13 @@ where
             else {
                 continue;
             };
+            if let Some(reason) = self.execution_limit_rejection_reason(snapshot, side, quote_price)
+            {
+                execution_block_reason.get_or_insert(reason);
+                execution_block_timestamp = Some(quote.timestamp);
+                continue;
+            }
+            saw_non_blocked_execution_price = true;
             if !self.price_satisfies_limit(
                 side,
                 quote_price,
@@ -4368,21 +4535,26 @@ where
                 continue;
             }
             let quote_price = self.execution_price_with_limit_slippage(quote_price, limit_price);
-            let top_level_liquidity = match side {
-                OrderSide::Buy => quote.ask1_volume,
-                OrderSide::Sell => quote.bid1_volume,
-            };
-            let available_qty = top_level_liquidity
-                .saturating_mul(lot as u64)
-                .min(u32::MAX as u64) as u32;
-            if available_qty == 0 {
-                continue;
-            }
 
             let remaining_qty = requested_qty.saturating_sub(filled_qty);
             if remaining_qty == 0 {
                 break;
             }
+            let available_qty = if quote_quantity_limited {
+                let top_level_liquidity = match side {
+                    OrderSide::Buy => quote.ask1_volume,
+                    OrderSide::Sell => quote.bid1_volume,
+                };
+                top_level_liquidity
+                    .saturating_mul(lot as u64)
+                    .min(u32::MAX as u64) as u32
+            } else {
+                remaining_qty
+            };
+            if available_qty == 0 {
+                continue;
+            }
+
             let mut take_qty = if matching_type == MatchingType::Twap {
                 let remaining_quotes = (eligible_quotes.len() - quote_index) as u32;
                 let scheduled_qty =
@@ -4440,6 +4612,18 @@ where
         }
 
         if filled_qty == 0 {
+            if let Some(reason) = execution_block_reason
+                && !saw_non_blocked_execution_price
+            {
+                return Some(ExecutionFill {
+                    quantity: 0,
+                    next_cursor: execution_block_timestamp
+                        .expect("blocked execution quote timestamp")
+                        + Duration::seconds(1),
+                    legs: Vec::new(),
+                    unfilled_reason: Some(reason),
+                });
+            }
             return None;
         }
 
@@ -4466,6 +4650,45 @@ where
         })
     }
 
+    fn quote_has_executable_liquidity(
+        &self,
+        quote: &IntradayExecutionQuote,
+        side: OrderSide,
+        matching_type: MatchingType,
+    ) -> bool {
+        if quote.volume_delta != 0 {
+            return true;
+        }
+        if matches!(matching_type, MatchingType::Vwap | MatchingType::Twap) {
+            return false;
+        }
+        match side {
+            OrderSide::Buy => quote.ask1_volume > 0,
+            OrderSide::Sell => quote.bid1_volume > 0,
+        }
+    }
+
+    fn quote_quantity_limited(&self, matching_type: MatchingType) -> bool {
+        self.volume_limit || self.liquidity_limit || matching_type != MatchingType::NextTickLast
+    }
+
+    fn quote_quantity_limited_for_window(
+        &self,
+        matching_type: MatchingType,
+        start_cursor: Option<NaiveDateTime>,
+        end_cursor: Option<NaiveDateTime>,
+    ) -> bool {
+        if matching_type == MatchingType::Twap
+            && !self.volume_limit
+            && !self.liquidity_limit
+            && start_cursor.is_some()
+            && start_cursor == end_cursor
+        {
+            return false;
+        }
+        self.quote_quantity_limited(matching_type)
+    }
+
     fn uses_serial_execution_cursor(&self, reason: &str) -> bool {
         let _ = reason;
         false
@@ -4497,7 +4720,9 @@ fn zero_fill_status_for_reason(reason: &str) -> OrderStatus {
         "tick no volume"
         | "tick volume limit"
         | "intraday quote liquidity exhausted"
-        | "no execution quotes after start" => OrderStatus::Canceled,
+        | "no execution quotes after start"
+        | "open at or above upper limit"
+        | "open at or below lower limit" => OrderStatus::Canceled,
         _ => OrderStatus::Rejected,
     }
 }
@@ -4507,7 +4732,9 @@ fn final_partial_fill_status(partial_reason: Option<&str>) -> OrderStatus {
         Some(reason)
             if reason.contains("market liquidity or volume limit")
                 || reason.contains("intraday quote liquidity exhausted")
-                || reason.contains("no execution quotes after start") =>
+                || reason.contains("no execution quotes after start")
+                || reason.contains("open at or above upper limit")
+                || reason.contains("open at or below lower limit") =>
         {
             OrderStatus::Canceled
         }
@@ -4531,3 +4758,226 @@ fn sell_reason(decision: &StrategyDecision, symbol: &str) -> &'static str {
         "rebalance_sell"
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{BrokerSimulator, MatchingType};
+    use crate::cost::ChinaAShareCostModel;
+    use crate::data::{
+        CandidateEligibility, DailyMarketSnapshot, IntradayExecutionQuote, PriceField,
+    };
+    use crate::events::OrderSide;
+    use crate::rules::ChinaEquityRuleHooks;
+
+    fn limit_test_snapshot() -> DailyMarketSnapshot {
+        let date = chrono::NaiveDate::from_ymd_opt(2025, 1, 2).expect("valid date");
+        DailyMarketSnapshot {
+            date,
+            symbol: "000001.SZ".to_string(),
+            timestamp: Some("2025-01-02 09:33:00".to_string()),
+            day_open: 10.0,
+            open: 10.0,
+            high: 10.5,
+            low: 9.5,
+            close: 10.0,
+            last_price: 10.0,
+            bid1: 10.0,
+            ask1: 10.0,
+            prev_close: 10.0,
+            volume: 1_000_000,
+            tick_volume: 10_000,
+            bid1_volume: 1_000,
+            ask1_volume: 1_000,
+            trading_phase: Some("continuous".to_string()),
+            paused: false,
+            upper_limit: 11.0,
+            lower_limit: 9.0,
+            price_tick: 0.01,
+        }
+    }
+
+    fn limit_test_quote(last_price: f64, bid1: f64, ask1: f64) -> IntradayExecutionQuote {
+        let date = chrono::NaiveDate::from_ymd_opt(2025, 1, 2).expect("valid date");
+        IntradayExecutionQuote {
+            date,
+            symbol: "000001.SZ".to_string(),
+            timestamp: date.and_hms_opt(9, 33, 0).expect("valid timestamp"),
+            last_price,
+            bid1,
+            ask1,
+            bid1_volume: 1_000,
+            ask1_volume: 1_000,
+            volume_delta: 1_000,
+            amount_delta: last_price * 1_000.0,
+            trading_phase: Some("continuous".to_string()),
+        }
+    }
+
+    fn limit_test_candidate(allow_buy: bool, allow_sell: bool) -> CandidateEligibility {
+        let date = chrono::NaiveDate::from_ymd_opt(2025, 1, 2).expect("valid date");
+        CandidateEligibility {
+            date,
+            symbol: "000001.SZ".to_string(),
+            is_st: false,
+            is_new_listing: false,
+            is_paused: false,
+            allow_buy,
+            allow_sell,
+            is_kcb: false,
+            is_one_yuan: false,
+        }
+    }
+
+    #[test]
+    fn next_tick_last_without_volume_or_liquidity_limit_does_not_cap_quote_quantity() {
+        let broker = BrokerSimulator::new(ChinaAShareCostModel::default(), ChinaEquityRuleHooks)
+            .with_volume_limit(false)
+            .with_liquidity_limit(false);
+
+        assert!(!broker.quote_quantity_limited(MatchingType::NextTickLast));
+        assert!(broker.quote_quantity_limited(MatchingType::CounterpartyOffer));
+    }
+
+    #[test]
+    fn next_tick_last_keeps_quote_quantity_cap_when_limits_enabled() {
+        let volume_limited =
+            BrokerSimulator::new(ChinaAShareCostModel::default(), ChinaEquityRuleHooks)
+                .with_volume_limit(true)
+                .with_liquidity_limit(false);
+        let liquidity_limited =
+            BrokerSimulator::new(ChinaAShareCostModel::default(), ChinaEquityRuleHooks)
+                .with_volume_limit(false)
+                .with_liquidity_limit(true);
+
+        assert!(volume_limited.quote_quantity_limited(MatchingType::NextTickLast));
+        assert!(liquidity_limited.quote_quantity_limited(MatchingType::NextTickLast));
+    }
+
+    #[test]
+    fn instantaneous_twap_without_limits_does_not_cap_quote_quantity() {
+        let broker = BrokerSimulator::new(ChinaAShareCostModel::default(), ChinaEquityRuleHooks)
+            .with_volume_limit(false)
+            .with_liquidity_limit(false);
+        let cursor = chrono::NaiveDate::from_ymd_opt(2025, 11, 3)
+            .unwrap()
+            .and_hms_opt(9, 31, 0)
+            .unwrap();
+
+        assert!(!broker.quote_quantity_limited_for_window(
+            MatchingType::Twap,
+            Some(cursor),
+            Some(cursor)
+        ));
+        assert!(broker.quote_quantity_limited_for_window(
+            MatchingType::Twap,
+            Some(cursor),
+            Some(cursor + chrono::Duration::minutes(1))
+        ));
+    }
+
+    #[test]
+    fn intraday_execution_rejects_buy_at_upper_limit_price() {
+        let broker = BrokerSimulator::new_with_execution_price(
+            ChinaAShareCostModel::default(),
+            ChinaEquityRuleHooks,
+            PriceField::Last,
+        )
+        .with_volume_limit(false)
+        .with_liquidity_limit(false)
+        .with_inactive_limit(false);
+        let snapshot = limit_test_snapshot();
+        let quote = limit_test_quote(11.0, 10.99, 11.0);
+        let start = quote.timestamp;
+
+        let fill = broker
+            .select_execution_fill(
+                &snapshot,
+                &[quote],
+                OrderSide::Buy,
+                MatchingType::NextTickLast,
+                Some(start),
+                None,
+                100,
+                100,
+                100,
+                100,
+                false,
+                None,
+                None,
+                None,
+            )
+            .expect("zero fill with rejection reason");
+
+        assert_eq!(fill.quantity, 0);
+        assert_eq!(fill.unfilled_reason, Some("open at or above upper limit"));
+    }
+
+    #[test]
+    fn aiquant_rules_allow_buy_when_day_flags_block_but_last_price_is_tradable() {
+        let mut snapshot = limit_test_snapshot();
+        snapshot.open = 11.0;
+        snapshot.day_open = 11.0;
+        snapshot.last_price = 10.98;
+        snapshot.ask1 = 11.0;
+        let candidate = limit_test_candidate(false, true);
+        let date = snapshot.date;
+
+        let default_broker = BrokerSimulator::new_with_execution_price(
+            ChinaAShareCostModel::default(),
+            ChinaEquityRuleHooks,
+            PriceField::Last,
+        );
+        let default_rule = default_broker.buy_rule_check(date, &snapshot, &candidate);
+        assert!(!default_rule.allowed);
+        assert_eq!(
+            default_rule.reason.as_deref(),
+            Some("buy disabled by eligibility flags")
+        );
+
+        let aiquant_broker = BrokerSimulator::new_with_execution_price(
+            ChinaAShareCostModel::default(),
+            ChinaEquityRuleHooks,
+            PriceField::Last,
+        )
+        .with_aiquant_rqalpha_execution_rules(true);
+        let aiquant_rule = aiquant_broker.buy_rule_check(date, &snapshot, &candidate);
+        assert!(aiquant_rule.allowed);
+    }
+
+    #[test]
+    fn intraday_execution_rejects_sell_at_lower_limit_price() {
+        let broker = BrokerSimulator::new_with_execution_price(
+            ChinaAShareCostModel::default(),
+            ChinaEquityRuleHooks,
+            PriceField::Last,
+        )
+        .with_volume_limit(false)
+        .with_liquidity_limit(false)
+        .with_inactive_limit(false);
+        let snapshot = limit_test_snapshot();
+        let quote = limit_test_quote(9.0, 9.0, 9.01);
+        let start = quote.timestamp;
+
+        let fill = broker
+            .select_execution_fill(
+                &snapshot,
+                &[quote],
+                OrderSide::Sell,
+                MatchingType::NextTickLast,
+                Some(start),
+                None,
+                100,
+                100,
+                100,
+                100,
+                false,
+                None,
+                None,
+                None,
+            )
+            .expect("zero fill with rejection reason");
+
+        assert_eq!(fill.quantity, 0);
+        assert_eq!(fill.unfilled_reason, Some("open at or below lower limit"));
+    }
+}

crates/fidc-core/src/cost.rs

@@ -44,7 +44,7 @@ pub struct ChinaAShareCostModel {
 impl Default for ChinaAShareCostModel {
     fn default() -> Self {
         Self {
-            commission_rate: 0.0003,
+            commission_rate: 0.0008,
             stamp_tax_rate_before_change: 0.001,
             stamp_tax_rate_after_change: 0.0005,
             minimum_commission: 5.0,
@@ -53,6 +53,14 @@ impl Default for ChinaAShareCostModel {
 }
 
 impl ChinaAShareCostModel {
+    pub fn aiquant_rqalpha_default() -> Self {
+        Self {
+            stamp_tax_rate_before_change: 0.0005,
+            stamp_tax_rate_after_change: 0.0005,
+            ..Self::default()
+        }
+    }
+
     pub fn commission_for(&self, gross_amount: f64) -> f64 {
         if gross_amount <= 0.0 {
             return 0.0;

crates/fidc-core/src/data.rs

@@ -452,11 +452,11 @@ struct SymbolPriceSeries {
     closes: Vec<f64>,
     prev_closes: Vec<f64>,
     last_prices: Vec<f64>,
+    paused: Vec<bool>,
     open_prefix: Vec<f64>,
     close_prefix: Vec<f64>,
     prev_close_prefix: Vec<f64>,
     last_prefix: Vec<f64>,
-    volume_prefix: Vec<f64>,
 }
 
 impl SymbolPriceSeries {
@@ -469,15 +469,11 @@ impl SymbolPriceSeries {
         let closes = sorted.iter().map(|row| row.close).collect::<Vec<_>>();
         let prev_closes = sorted.iter().map(|row| row.prev_close).collect::<Vec<_>>();
         let last_prices = sorted.iter().map(|row| row.last_price).collect::<Vec<_>>();
-        let volumes = sorted
+        let paused = sorted.iter().map(|row| row.paused).collect::<Vec<_>>();
-            .iter()
-            .map(|row| row.volume as f64)
-            .collect::<Vec<_>>();
         let open_prefix = prefix_sums(&opens);
         let close_prefix = prefix_sums(&closes);
         let prev_close_prefix = prefix_sums(&prev_closes);
         let last_prefix = prefix_sums(&last_prices);
-        let volume_prefix = prefix_sums(&volumes);
 
         Self {
             snapshots: sorted,
@@ -486,11 +482,11 @@ impl SymbolPriceSeries {
             closes,
             prev_closes,
             last_prices,
+            paused,
             open_prefix,
             close_prefix,
             prev_close_prefix,
             last_prefix,
-            volume_prefix,
         }
     }
 
@@ -587,15 +583,24 @@ impl SymbolPriceSeries {
     }
 
     fn decision_volume_moving_average(&self, date: NaiveDate, lookback: usize) -> Option<f64> {
+        let values = self.decision_volume_values(date, lookback)?;
+        if values.len() < lookback {
+            return None;
+        }
+        let sum = values.iter().sum::<f64>();
+        Some(sum / lookback as f64)
+    }
+
+    fn current_volume_moving_average(&self, date: NaiveDate, lookback: usize) -> Option<f64> {
         if lookback == 0 {
             return None;
         }
-        let end = self.previous_completed_end_index(date)?;
+        let end = self.end_index(date)?;
-        if end < lookback {
+        let values = self.trailing_unpaused_volumes(end, lookback)?;
+        if values.len() < lookback {
             return None;
         }
-        let start = end - lookback;
+        let sum = values.iter().sum::<f64>();
-        let sum = self.volume_prefix[end] - self.volume_prefix[start];
         Some(sum / lookback as f64)
     }
 
@@ -604,16 +609,33 @@ impl SymbolPriceSeries {
             return None;
         }
         let end = self.previous_completed_end_index(date)?;
-        if end < lookback {
+        let values = self.trailing_unpaused_volumes(end, lookback)?;
+        if values.len() < lookback {
             return None;
         }
-        let start = end - lookback;
+        Some(values)
-        Some(
+    }
-            self.snapshots[start..end]
+
-                .iter()
+    fn trailing_unpaused_volumes(&self, end: usize, lookback: usize) -> Option<Vec<f64>> {
-                .map(|snapshot| snapshot.volume as f64)
+        if lookback == 0 || end == 0 {
-                .collect(),
+            return None;
-        )
+        }
+        let mut values = Vec::with_capacity(lookback);
+        for idx in (0..end).rev() {
+            if self.paused.get(idx).copied().unwrap_or(false) {
+                continue;
+            }
+            values.push(self.snapshots[idx].volume as f64);
+            if values.len() == lookback {
+                break;
+            }
+        }
+        if values.len() < lookback {
+            None
+        } else {
+            values.reverse();
+            Some(values)
+        }
     }
 
     fn end_index(&self, date: NaiveDate) -> Option<usize> {
@@ -641,6 +663,14 @@ impl SymbolPriceSeries {
         self.values_for(field).get(end - 1).copied()
     }
 
+    fn snapshot_before(&self, date: NaiveDate) -> Option<&DailyMarketSnapshot> {
+        let end = self.previous_completed_end_index(date)?;
+        if end == 0 {
+            return None;
+        }
+        self.snapshots.get(end - 1)
+    }
+
     fn prefix_for(&self, field: PriceField) -> &[f64] {
         match field {
             PriceField::DayOpen => &self.open_prefix,
@@ -1815,6 +1845,12 @@ impl DataSet {
             .and_then(|series| series.price_on_or_before(date, field))
     }
 
+    pub fn market_before(&self, date: NaiveDate, symbol: &str) -> Option<&DailyMarketSnapshot> {
+        self.market_series_by_symbol
+            .get(symbol)
+            .and_then(|series| series.snapshot_before(date))
+    }
+
     pub fn factor_snapshots_on(&self, date: NaiveDate) -> Vec<&DailyFactorSnapshot> {
         self.factor_by_date
             .get(&date)
@@ -2065,6 +2101,36 @@ impl DataSet {
         }
     }
 
+    pub fn market_current_numeric_moving_average(
+        &self,
+        date: NaiveDate,
+        symbol: &str,
+        field: &str,
+        lookback: usize,
+    ) -> Option<f64> {
+        let field = normalize_field(field);
+        match field.as_str() {
+            "close" | "prev_close" | "stock_close" | "price" => {
+                self.market_moving_average(date, symbol, lookback, PriceField::Close)
+            }
+            "volume" | "stock_volume" => self
+                .factor_moving_average(date, symbol, "daily_volume", lookback)
+                .or_else(|| {
+                    self.market_series_by_symbol
+                        .get(symbol)
+                        .and_then(|series| series.current_volume_moving_average(date, lookback))
+                }),
+            "day_open" | "dayopen" => {
+                self.market_moving_average(date, symbol, lookback, PriceField::DayOpen)
+            }
+            "open" => self.market_moving_average(date, symbol, lookback, PriceField::Open),
+            "last" | "last_price" => {
+                self.market_moving_average(date, symbol, lookback, PriceField::Last)
+            }
+            other => self.factor_moving_average(date, symbol, other, lookback),
+        }
+    }
+
     pub fn market_decision_numeric_values(
         &self,
         date: NaiveDate,
@@ -3328,6 +3394,33 @@ mod tests {
         );
     }
 
+    #[test]
+    fn decision_volume_average_skips_paused_days_before_counting_window() {
+        let mut paused = market_row("2025-01-03", 11.0, 0);
+        paused.paused = true;
+        let series = SymbolPriceSeries::new(&[
+            market_row("2025-01-02", 10.0, 100),
+            paused,
+            market_row("2025-01-06", 12.0, 300),
+            market_row("2025-01-07", 13.0, 10_000),
+        ]);
+
+        assert_eq!(
+            series.decision_volume_moving_average(
+                NaiveDate::parse_from_str("2025-01-07", "%Y-%m-%d").unwrap(),
+                2
+            ),
+            Some(200.0)
+        );
+        assert_eq!(
+            series.decision_volume_moving_average(
+                NaiveDate::parse_from_str("2025-01-07", "%Y-%m-%d").unwrap(),
+                3
+            ),
+            None
+        );
+    }
+
     #[test]
     fn reads_mixed_numeric_and_text_extra_factors_from_quoted_csv_json() {
         let path = temp_csv_path("mixed_factor_maps");

crates/fidc-core/src/engine.rs

@@ -313,6 +313,7 @@ pub struct BacktestEngine<S, C, R> {
     broker: BrokerSimulator<C, R>,
     config: BacktestConfig,
     dividend_reinvestment: bool,
+    cash_dividends_enabled: bool,
     process_event_bus: ProcessEventBus,
     dynamic_universe: Option<BTreeSet<String>>,
     subscriptions: BTreeSet<String>,
@@ -338,6 +339,7 @@ impl<S, C, R> BacktestEngine<S, C, R> {
             broker,
             config,
             dividend_reinvestment: false,
+            cash_dividends_enabled: true,
             process_event_bus: ProcessEventBus::new(),
             dynamic_universe: None,
             subscriptions: BTreeSet::new(),
@@ -356,6 +358,11 @@ impl<S, C, R> BacktestEngine<S, C, R> {
         self
     }
 
+    pub fn with_cash_dividends(mut self, enabled: bool) -> Self {
+        self.cash_dividends_enabled = enabled;
+        self
+    }
+
     pub fn with_futures_account(mut self, account: FuturesAccountState) -> Self {
         self.futures_account = Some(account);
         self
@@ -2127,7 +2134,12 @@ where
                 }
             }
 
-            portfolio.update_prices(execution_date, &self.data, PriceField::Close)?;
+            portfolio.update_prices_with_options(
+                execution_date,
+                &self.data,
+                PriceField::Close,
+                self.broker.same_day_buy_close_mark_at_fill(),
+            )?;
 
             let post_trade_open_orders = self.open_order_views();
             let visible_order_events = result
@@ -2516,7 +2528,7 @@ where
                 continue;
             }
 
-            if action.share_cash.abs() > f64::EPSILON {
+            if self.cash_dividends_enabled && action.share_cash.abs() > f64::EPSILON {
                 let cash_before = portfolio.cash();
                 let (cash_delta, quantity_after, average_cost) = {
                     let position = portfolio
@@ -2985,24 +2997,17 @@ where
             }
 
             let quantity = position.quantity;
-            let fallback_reference_price = if position.last_price > 0.0 {
+            let settlement_price = if position.last_price.is_finite() && position.last_price > 0.0 {
                 position.last_price
-            } else {
+            } else if position.average_cost.is_finite() && position.average_cost > 0.0 {
                 position.average_cost
+            } else {
+                0.0
             };
             let effective_delisted_at = instrument
                 .delisted_at
                 .or_else(|| self.data.calendar().previous_day(date))
                 .unwrap_or(date);
-            let settlement_price = self
-                .data
-                .price_on_or_before(effective_delisted_at, &symbol, PriceField::Close)
-                .or_else(|| {
-                    self.data
-                        .price_on_or_before(date, &symbol, PriceField::Close)
-                })
-                .filter(|price| price.is_finite() && *price > 0.0)
-                .unwrap_or(fallback_reference_price);
             if !settlement_price.is_finite() || settlement_price <= 0.0 {
                 return Err(BacktestError::Execution(format!(
                     "missing delisting settlement price for {} on {}",

crates/fidc-core/src/platform_runtime_schema.rs

@@ -223,6 +223,7 @@ const RUNTIME_HELPER_FUNCTIONS: &[&str] = &[
     "factor",
     "day_factor",
     "rolling_mean",
+    "rolling_mean_current",
     "ma",
     "sma",
     "vma",

crates/fidc-core/src/platform_strategy_spec.rs

@@ -52,6 +52,8 @@ pub struct StrategyUniverseSpec {
 #[derive(Debug, Clone, Default, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct StrategyExecutionSpec {
+    #[serde(default)]
+    pub compatibility_profile: Option<String>,
     #[serde(default)]
     pub matching_type: Option<String>,
     #[serde(default)]
@@ -156,6 +158,8 @@ pub struct IndexThrottleConfig {
 #[derive(Debug, Clone, Default, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct SkipWindowConfig {
+    #[serde(default)]
+    pub year: Option<u32>,
     #[serde(default)]
     pub month: Option<u32>,
     #[serde(default)]
@@ -368,6 +372,13 @@ pub fn platform_expr_config_from_spec(
         {
             cfg.rebalance_schedule = Some(schedule);
         }
+        if let Some(time) = engine
+            .rebalance_schedule
+            .as_ref()
+            .and_then(parse_schedule_execution_time)
+        {
+            cfg.intraday_execution_time = Some(time);
+        }
         if let Some(stock_ma_filter) = engine.stock_ma_filter.as_ref() {
             if let Some(days) = stock_ma_filter.short_days.filter(|value| *value > 0) {
                 cfg.stock_short_ma_days = days;
@@ -391,7 +402,14 @@ pub fn platform_expr_config_from_spec(
             cfg.skip_month_day_ranges = engine
                 .skip_windows
                 .iter()
-                .filter_map(|window| Some((window.month?, window.start_day?, window.end_day?)))
+                .filter_map(|window| {
+                    Some((
+                        window.year,
+                        window.month?,
+                        window.start_day?,
+                        window.end_day?,
+                    ))
+                })
                 .collect();
         }
         if let Some(spec_signal_symbol) = engine
@@ -490,6 +508,13 @@ pub fn platform_expr_config_from_spec(
         {
             cfg.rebalance_schedule = Some(schedule);
         }
+        if let Some(time) = runtime_expr
+            .schedule
+            .as_ref()
+            .and_then(parse_schedule_execution_time)
+        {
+            cfg.intraday_execution_time = Some(time);
+        }
         if let Some(selection) = runtime_expr.selection.as_ref() {
             if let Some(expr) = selection
                 .limit_expr
@@ -619,6 +644,13 @@ pub fn platform_expr_config_from_spec(
             {
                 cfg.explicit_action_schedule = Some(schedule);
             }
+            if let Some(time) = trading
+                .schedule
+                .as_ref()
+                .and_then(parse_schedule_execution_time)
+            {
+                cfg.intraday_execution_time = Some(time);
+            }
             cfg.explicit_actions = trading
                 .actions
                 .iter()
@@ -679,6 +711,16 @@ pub fn platform_expr_config_from_spec(
     if !cfg.benchmark_symbol.trim().is_empty() {
         cfg.benchmark_symbol = normalize_symbol(&cfg.benchmark_symbol, None);
     }
+    if spec
+        .execution
+        .as_ref()
+        .and_then(|execution| execution.compatibility_profile.as_deref())
+        .map(|value| value.trim().to_ascii_lowercase())
+        .is_some_and(|value| value == "aiquant_rqalpha" || value == "aiquant")
+    {
+        cfg.calendar_rebalance_interval = true;
+        cfg.aiquant_transaction_cost = true;
+    }
 
     cfg
 }
@@ -735,6 +777,16 @@ fn parse_schedule_time_rule(
     }
 }
 
+fn parse_schedule_execution_time(schedule: &StrategyExpressionScheduleConfig) -> Option<NaiveTime> {
+    match parse_schedule_time_rule(schedule)? {
+        ScheduleTimeRule::BeforeTrading => NaiveTime::from_hms_opt(9, 0, 0),
+        ScheduleTimeRule::MinuteOfDay(minutes) => {
+            let seconds = minutes.checked_mul(60)?;
+            NaiveTime::from_num_seconds_from_midnight_opt(seconds, 0)
+        }
+    }
+}
+
 fn parse_schedule_clock_time(raw: Option<&str>) -> Option<NaiveTime> {
     let value = raw?.trim();
     if value.is_empty() {
@@ -1051,6 +1103,7 @@ mod tests {
             "signalSymbol": "000852.SH",
             "benchmark": { "instrumentId": "000852.SH" },
             "universe": { "exclude": ["paused", "st", "kcb", "one_yuan"] },
+            "execution": { "compatibilityProfile": "aiquant_rqalpha" },
             "runtimeExpressions": {
                 "prelude": "let stocknum = 8;",
                 "selection": {
@@ -1085,10 +1138,32 @@ mod tests {
         assert!(!cfg.rotation_enabled);
         assert!(cfg.daily_top_up_enabled);
         assert!(cfg.retry_empty_rebalance);
+        assert!(cfg.calendar_rebalance_interval);
+        assert!(cfg.aiquant_transaction_cost);
         assert_eq!(cfg.explicit_actions.len(), 1);
         assert_eq!(
             cfg.explicit_action_stage,
             PlatformExplicitActionStage::OpenAuction
         );
     }
+
+    #[test]
+    fn parses_daily_schedule_time_for_aiquant_execution_quotes() {
+        let spec = serde_json::json!({
+            "execution": { "compatibilityProfile": "aiquant_rqalpha" },
+            "runtimeExpressions": {
+                "schedule": { "frequency": "daily", "time": "09:33" }
+            }
+        });
+
+        let cfg = platform_expr_config_from_value("", "", &spec).expect("config");
+
+        assert_eq!(cfg.rebalance_schedule, None);
+        assert_eq!(
+            cfg.intraday_execution_time,
+            Some(NaiveTime::from_hms_opt(9, 33, 0).unwrap())
+        );
+        assert!(cfg.calendar_rebalance_interval);
+        assert!(cfg.aiquant_transaction_cost);
+    }
 }

crates/fidc-core/src/portfolio.rs

@@ -1,7 +1,7 @@
 use chrono::NaiveDate;
 use indexmap::IndexMap;
 use serde::Serialize;
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, BTreeSet};
 
 use crate::data::{DataSet, DataSetError, PriceField};
 
@@ -9,6 +9,7 @@ use crate::data::{DataSet, DataSetError, PriceField};
 pub struct PositionLot {
     pub acquired_date: NaiveDate,
     pub quantity: u32,
+    pub entry_price: f64,
     pub price: f64,
 }
 
@@ -72,6 +73,7 @@ impl Position {
         self.lots.push(PositionLot {
             acquired_date: date,
             quantity,
+            entry_price: price,
             price,
         });
         self.quantity += quantity;
@@ -205,6 +207,22 @@ impl Position {
         }
     }
 
+    pub fn record_buy_trade_cost(&mut self, quantity: u32, value: f64) {
+        if quantity == 0 || !value.is_finite() {
+            return;
+        }
+        let cost = value.max(0.0);
+        if cost <= 0.0 {
+            return;
+        }
+        if let Some(lot) = self.lots.last_mut() {
+            lot.price += cost / quantity as f64;
+            self.recalculate_average_cost();
+        }
+        self.day_trade_cost += cost;
+        self.refresh_day_pnl();
+    }
+
     pub fn set_dividend_receivable(&mut self, value: f64) {
         self.dividend_receivable = if value.is_finite() {
             value.max(0.0)
@@ -214,13 +232,28 @@ impl Position {
     }
 
     pub fn holding_return(&self, price: f64) -> Option<f64> {
-        if self.quantity == 0 || self.average_cost <= 0.0 {
+        let Some(avg_price) = self.average_entry_price() else {
+            return None;
+        };
+        if avg_price <= 0.0 {
             None
         } else {
-            Some((price / self.average_cost) - 1.0)
+            Some((price / avg_price) - 1.0)
         }
     }
 
+    pub fn average_entry_price(&self) -> Option<f64> {
+        if self.quantity == 0 {
+            return None;
+        }
+        let total = self
+            .lots
+            .iter()
+            .map(|lot| lot.entry_price * lot.quantity as f64)
+            .sum::<f64>();
+        Some(total / self.quantity as f64)
+    }
+
     fn recalculate_average_cost(&mut self) {
         if self.quantity == 0 {
             self.average_cost = 0.0;
@@ -242,6 +275,7 @@ impl Position {
         }
 
         for lot in &mut self.lots {
+            lot.entry_price -= dividend_per_share;
             lot.price -= dividend_per_share;
         }
         self.average_cost -= dividend_per_share;
@@ -264,6 +298,7 @@ impl Position {
             .map(|lot| PositionLot {
                 acquired_date: lot.acquired_date,
                 quantity: round_half_up_u32(lot.quantity as f64 * ratio),
+                entry_price: lot.entry_price / ratio,
                 price: lot.price / ratio,
             })
             .collect::<Vec<_>>();
@@ -316,6 +351,7 @@ pub struct PortfolioState {
     positions: IndexMap<String, Position>,
     cash_receivables: Vec<CashReceivable>,
     pending_cash_flows: Vec<PendingCashFlow>,
+    day_sold_symbols: BTreeSet<String>,
 }
 
 #[derive(Debug, Clone)]
@@ -348,6 +384,7 @@ impl PortfolioState {
             positions: IndexMap::new(),
             cash_receivables: Vec::new(),
             pending_cash_flows: Vec::new(),
+            day_sold_symbols: BTreeSet::new(),
         }
     }
 
@@ -402,7 +439,18 @@ impl PortfolioState {
     }
 
     pub fn prune_flat_positions(&mut self) {
-        self.positions.retain(|_, position| !position.is_flat());
+        let mut sold_symbols = Vec::new();
+        self.positions.retain(|symbol, position| {
+            if position.is_flat() {
+                if position.sold_quantity() > 0 {
+                    sold_symbols.push(symbol.clone());
+                }
+                false
+            } else {
+                true
+            }
+        });
+        self.day_sold_symbols.extend(sold_symbols);
     }
 
     pub fn add_cash_receivable(&mut self, receivable: CashReceivable) {
@@ -538,6 +586,7 @@ impl PortfolioState {
     }
 
     pub fn begin_trading_day(&mut self) {
+        self.day_sold_symbols.clear();
         for position in self.positions.values_mut() {
             position.begin_trading_day();
         }
@@ -550,7 +599,31 @@ impl PortfolioState {
         data: &DataSet,
         field: PriceField,
     ) -> Result<(), DataSetError> {
+        self.update_prices_with_options(date, data, field, false)
+    }
+
+    pub fn update_prices_with_options(
+        &mut self,
+        date: NaiveDate,
+        data: &DataSet,
+        field: PriceField,
+        same_day_buy_close_mark_at_fill: bool,
+    ) -> Result<(), DataSetError> {
+        let day_sold_symbols = self.day_sold_symbols.clone();
         for position in self.positions.values_mut() {
+            let sold_today =
+                position.sold_quantity() > 0 || day_sold_symbols.contains(&position.symbol);
+            if same_day_buy_close_mark_at_fill
+                && field == PriceField::Close
+                && position.day_buy_quantity > 0
+                && !sold_today
+                && position.sellable_qty(date) == 0
+                && position.last_price.is_finite()
+                && position.last_price > 0.0
+            {
+                position.refresh_day_pnl();
+                continue;
+            }
             let price = data
                 .price(date, &position.symbol, field)
                 .or_else(|| data.price_on_or_before(date, &position.symbol, field))
@@ -705,6 +778,7 @@ impl PortfolioState {
             .map(|lot| PositionLot {
                 acquired_date: lot.acquired_date,
                 quantity: round_half_up_u32(lot.quantity as f64 * ratio),
+                entry_price: lot.entry_price / ratio,
                 price: lot.price / ratio,
             })
             .collect::<Vec<_>>();
@@ -801,6 +875,18 @@ mod tests {
         );
     }
 
+    #[test]
+    fn strategy_entry_price_excludes_buy_commission_cost_basis() {
+        let date = NaiveDate::from_ymd_opt(2025, 1, 2).unwrap();
+        let mut position = Position::new("600561.SH");
+        position.buy(date, 22_200, 5.66);
+        position.record_buy_trade_cost(22_200, 100.0);
+
+        assert!(position.average_cost > 5.66);
+        assert!((position.average_entry_price().unwrap() - 5.66).abs() < 1e-12);
+        assert!((position.holding_return(6.06).unwrap() - (6.06 / 5.66 - 1.0)).abs() < 1e-12);
+    }
+
     #[test]
     fn portfolio_tracks_dividend_receivable_and_day_pnl() {
         let prev_date = NaiveDate::from_ymd_opt(2025, 1, 2).unwrap();
@@ -1066,6 +1152,132 @@ mod tests {
         assert!(position.position_pnl.abs() < 1e-6);
     }
 
+    #[test]
+    fn portfolio_marks_same_day_buy_at_fill_until_next_trading_day() {
+        let buy_date = NaiveDate::from_ymd_opt(2025, 2, 10).unwrap();
+        let next_date = NaiveDate::from_ymd_opt(2025, 2, 11).unwrap();
+        let symbol = "002652.SZ";
+        let mut portfolio = PortfolioState::new(20_000.0);
+        portfolio.position_mut(symbol).buy(buy_date, 1300, 3.01);
+
+        let dataset = DataSet::from_components(
+            vec![Instrument {
+                symbol: symbol.to_string(),
+                name: "Same Day Buy Test".to_string(),
+                board: "SZ".to_string(),
+                round_lot: 100,
+                listed_at: None,
+                delisted_at: None,
+                status: "active".to_string(),
+            }],
+            vec![
+                DailyMarketSnapshot {
+                    date: buy_date,
+                    symbol: symbol.to_string(),
+                    timestamp: None,
+                    day_open: 2.99,
+                    open: 2.99,
+                    high: 3.06,
+                    low: 2.98,
+                    close: 3.06,
+                    last_price: 3.06,
+                    bid1: 3.01,
+                    ask1: 3.02,
+                    prev_close: 2.98,
+                    volume: 152_975,
+                    tick_volume: 152_975,
+                    bid1_volume: 338,
+                    ask1_volume: 2476,
+                    trading_phase: None,
+                    paused: false,
+                    upper_limit: 3.28,
+                    lower_limit: 2.68,
+                    price_tick: 0.01,
+                },
+                DailyMarketSnapshot {
+                    date: next_date,
+                    symbol: symbol.to_string(),
+                    timestamp: None,
+                    day_open: 3.03,
+                    open: 3.03,
+                    high: 3.08,
+                    low: 3.00,
+                    close: 3.07,
+                    last_price: 3.07,
+                    bid1: 3.06,
+                    ask1: 3.07,
+                    prev_close: 3.06,
+                    volume: 160_000,
+                    tick_volume: 160_000,
+                    bid1_volume: 1000,
+                    ask1_volume: 1000,
+                    trading_phase: None,
+                    paused: false,
+                    upper_limit: 3.37,
+                    lower_limit: 2.75,
+                    price_tick: 0.01,
+                },
+            ],
+            Vec::new(),
+            Vec::new(),
+            vec![
+                BenchmarkSnapshot {
+                    date: buy_date,
+                    benchmark: "000852.SH".to_string(),
+                    open: 1000.0,
+                    close: 1000.0,
+                    prev_close: 999.0,
+                    volume: 1000,
+                },
+                BenchmarkSnapshot {
+                    date: next_date,
+                    benchmark: "000852.SH".to_string(),
+                    open: 1001.0,
+                    close: 1001.0,
+                    prev_close: 1000.0,
+                    volume: 1000,
+                },
+            ],
+        )
+        .expect("dataset");
+
+        portfolio
+            .update_prices_with_options(buy_date, &dataset, PriceField::Close, true)
+            .expect("same day close");
+        let position = portfolio.position(symbol).expect("position");
+        assert!((position.last_price - 3.01).abs() < 1e-9);
+        assert!((position.market_value() - 3913.0).abs() < 1e-6);
+
+        portfolio.begin_trading_day();
+        portfolio
+            .update_prices(next_date, &dataset, PriceField::Close)
+            .expect("next day close");
+        let position = portfolio.position(symbol).expect("position");
+        assert!((position.last_price - 3.07).abs() < 1e-9);
+        assert!((position.market_value() - 3991.0).abs() < 1e-6);
+
+        let prev_date = NaiveDate::from_ymd_opt(2025, 2, 7).unwrap();
+        let mut roundtrip_portfolio = PortfolioState::new(20_000.0);
+        roundtrip_portfolio
+            .position_mut(symbol)
+            .buy(prev_date, 2000, 2.90);
+        roundtrip_portfolio.begin_trading_day();
+        roundtrip_portfolio
+            .position_mut(symbol)
+            .sell(2000, 3.01)
+            .expect("same day sell");
+        roundtrip_portfolio.prune_flat_positions();
+        roundtrip_portfolio
+            .position_mut(symbol)
+            .buy(buy_date, 1800, 3.01);
+        roundtrip_portfolio
+            .update_prices(buy_date, &dataset, PriceField::Close)
+            .expect("same day roundtrip close");
+        let position = roundtrip_portfolio.position(symbol).expect("position");
+        assert!((position.last_price - 3.06).abs() < 1e-9);
+        assert!((position.market_value() - 5508.0).abs() < 1e-6);
+    }
+
     #[test]
     fn position_tracks_day_lifecycle_fields() {
         let prev_date = NaiveDate::from_ymd_opt(2025, 1, 2).unwrap();

crates/fidc-core/src/strategy.rs

@@ -1104,7 +1104,7 @@ pub struct CnSmallCapRotationConfig {
     pub take_profit_pct: f64,
     pub signal_symbol: Option<String>,
     pub skip_months: Vec<u32>,
-    pub skip_month_day_ranges: Vec<(u32, u32, u32)>,
+    pub skip_month_day_ranges: Vec<(Option<u32>, u32, u32, u32)>,
 }
 
 impl CnSmallCapRotationConfig {
@@ -1159,23 +1159,29 @@ impl CnSmallCapRotationConfig {
             signal_symbol: Some("000852.SH".to_string()),
             skip_months: vec![],
             skip_month_day_ranges: vec![
-                (1, 15, 30),
+                (None, 1, 15, 30),
-                (4, 15, 29),
+                (None, 4, 15, 29),
-                (8, 15, 31),
+                (None, 8, 15, 31),
-                (10, 20, 30),
+                (None, 10, 20, 30),
-                (12, 20, 30),
+                (None, 12, 20, 30),
             ],
         }
     }
 
     fn in_skip_window(&self, date: NaiveDate) -> bool {
+        let year = date.year() as u32;
         let month = date.month();
         let day = date.day();
         self.skip_months.contains(&month)
             || self
                 .skip_month_day_ranges
                 .iter()
-                .any(|(m, start_day, end_day)| month == *m && day >= *start_day && day <= *end_day)
+                .any(|(window_year, m, start_day, end_day)| {
+                    window_year.map(|value| value == year).unwrap_or(true)
+                        && month == *m
+                        && day >= *start_day
+                        && day <= *end_day
+                })
     }
 }
 
@@ -1533,7 +1539,7 @@ pub struct OmniMicroCapConfig {
     pub trade_rate: f64,
     pub stop_loss_ratio: f64,
     pub take_profit_ratio: f64,
-    pub skip_month_day_ranges: Vec<(u32, u32, u32)>,
+    pub skip_month_day_ranges: Vec<(Option<u32>, u32, u32, u32)>,
 }
 
 impl OmniMicroCapConfig {
@@ -1592,11 +1598,17 @@ impl OmniMicroCapConfig {
     }
 
     fn in_skip_window(&self, date: NaiveDate) -> bool {
+        let year = date.year() as u32;
         let month = date.month();
         let day = date.day();
         self.skip_month_day_ranges
             .iter()
-            .any(|(m, start_day, end_day)| month == *m && day >= *start_day && day <= *end_day)
+            .any(|(window_year, m, start_day, end_day)| {
+                window_year.map(|value| value == year).unwrap_or(true)
+                    && month == *m
+                    && day >= *start_day
+                    && day <= *end_day
+            })
     }
 }
 
@@ -1768,11 +1780,23 @@ impl OmniMicroCapStrategy {
         if !sizing_price.is_finite() || sizing_price <= 0.0 {
             return 0;
         }
-        let snapshot_requested_qty = self.round_lot_quantity(
+        let mut snapshot_requested_qty = self.round_lot_quantity(
             ((projected.cash().min(order_value)) / sizing_price).floor() as u32,
             minimum_order_quantity,
             order_step_size,
         );
+        while snapshot_requested_qty > 0 {
+            let gross_amount = sizing_price * snapshot_requested_qty as f64;
+            let cash_out = gross_amount + self.buy_commission(gross_amount);
+            if cash_out <= order_value + 1e-6 && cash_out <= projected.cash() + 1e-6 {
+                break;
+            }
+            snapshot_requested_qty = self.decrement_order_quantity(
+                snapshot_requested_qty,
+                minimum_order_quantity,
+                order_step_size,
+            );
+        }
         let projected_execution_price = self.projected_execution_price(market, OrderSide::Buy);
         let projected_fill = self.projected_select_execution_fill(
             ctx,
@@ -1784,14 +1808,15 @@ impl OmniMicroCapStrategy {
             minimum_order_quantity,
             order_step_size,
             false,
-            Some(projected.cash()),
+            Some(projected.cash().min(order_value)),
-            Some(order_value + 400.0),
+            Some(order_value),
             execution_state,
         );
         let mut quantity = snapshot_requested_qty;
         while quantity > 0 {
             let gross_amount = projected_execution_price * quantity as f64;
-            if gross_amount <= order_value + 400.0 && gross_amount <= projected.cash() + 1e-6 {
+            let cash_out = gross_amount + self.buy_commission(gross_amount);
+            if cash_out <= order_value + 1e-6 && cash_out <= projected.cash() + 1e-6 {
                 break;
             }
             quantity =
@@ -1806,7 +1831,8 @@ impl OmniMicroCapStrategy {
             .unwrap_or(projected_execution_price);
         while quantity > 0 {
             let gross_amount = execution_price * quantity as f64;
-            if gross_amount <= projected.cash() + 1e-6 {
+            let cash_out = gross_amount + self.buy_commission(gross_amount);
+            if cash_out <= order_value + 1e-6 && cash_out <= projected.cash() + 1e-6 {
                 break;
             }
             quantity =
@@ -1822,7 +1848,7 @@ impl OmniMicroCapStrategy {
         };
         let gross_amount = fill.price * fill.quantity as f64;
         let cash_out = gross_amount + self.buy_commission(gross_amount);
-        if gross_amount > projected.cash() + 1e-6 {
+        if cash_out > projected.cash() + 1e-6 || cash_out > order_value + 1e-6 {
             return 0;
         }
         projected.apply_cash_delta(-cash_out);
@@ -2242,7 +2268,8 @@ impl OmniMicroCapStrategy {
         };
 
         // MA filter: ma_short > ma_mid * rsi_rate && ma_mid * rsi_rate > ma_long
-        let ma_pass = ma_short > ma_mid * self.config.rsi_rate && ma_mid * self.config.rsi_rate > ma_long;
+        let ma_pass =
+            ma_short > ma_mid * self.config.rsi_rate && ma_mid * self.config.rsi_rate > ma_long;
 
         // Debug logging for ALL stocks on first decision date
         static DEBUG_DATE: std::sync::Mutex<Option<NaiveDate>> = std::sync::Mutex::new(None);
@@ -2255,14 +2282,22 @@ impl OmniMicroCapStrategy {
         };
 
         if should_debug {
-            eprintln!("[MA_FILTER] {} cap={:.2} ma5={:.4} ma10={:.4} ma30={:.4} ma10*rsi={:.4} pass={} ({}>{:.4}? {} && {:.4}>{}? {})",
+            eprintln!(
+                "[MA_FILTER] {} cap={:.2} ma5={:.4} ma10={:.4} ma30={:.4} ma10*rsi={:.4} pass={} ({}>{:.4}? {} && {:.4}>{}? {})",
                 symbol,
                 ctx.data.market_decision_close(date, symbol).unwrap_or(0.0),
-                ma_short, ma_mid, ma_long, 
+                ma_short,
+                ma_mid,
+                ma_long,
                 ma_mid * self.config.rsi_rate,
                 ma_pass,
-                ma_short, ma_mid * self.config.rsi_rate, ma_short > ma_mid * self.config.rsi_rate,
+                ma_short,
-                ma_mid * self.config.rsi_rate, ma_long, ma_mid * self.config.rsi_rate > ma_long);
+                ma_mid * self.config.rsi_rate,
+                ma_short > ma_mid * self.config.rsi_rate,
+                ma_mid * self.config.rsi_rate,
+                ma_long,
+                ma_mid * self.config.rsi_rate > ma_long
+            );
         }
 
         if !ma_pass {
@@ -2270,19 +2305,20 @@ impl OmniMicroCapStrategy {
         }
 
         // Volume filter: V5 < V60 (applied for omni_microcap strategies)
-        if self.config.strategy_name.contains("aiquant") || self.config.strategy_name.contains("AiQuant") || self.config.strategy_name.contains("omni") {
+        if self.config.strategy_name.contains("aiquant")
-            let Some(volume_ma5) = ctx.data.market_decision_volume_moving_average(
+            || self.config.strategy_name.contains("AiQuant")
-                date,
+            || self.config.strategy_name.contains("omni")
-                symbol,
+        {
-                5,
+            let Some(volume_ma5) = ctx
-            ) else {
+                .data
+                .market_decision_volume_moving_average(date, symbol, 5)
+            else {
                 return false;
             };
-            let Some(volume_ma60) = ctx.data.market_decision_volume_moving_average(
+            let Some(volume_ma60) = ctx
-                date,
+                .data
-                symbol,
+                .market_decision_volume_moving_average(date, symbol, 60)
-                60,
+            else {
-            ) else {
                 return false;
             };
 
@@ -2352,11 +2388,6 @@ impl OmniMicroCapStrategy {
         {
             return Ok(Some("upper_limit".to_string()));
         }
-        if market.is_at_lower_limit_price(market.day_open)
-            || market.is_at_lower_limit_price(market.sell_price(PriceField::Last))
-        {
-            return Ok(Some("lower_limit".to_string()));
-        }
         if market.day_open <= 1.0 {
             return Ok(Some("one_yuan".to_string()));
         }
@@ -2662,7 +2693,8 @@ impl Strategy for OmniMicroCapStrategy {
             });
         }
 
-        let (index_level, prev_index_level, ma_short, ma_long, trading_ratio) = match self.trading_ratio(ctx, date) {
+        let (index_level, prev_index_level, ma_short, ma_long, trading_ratio) =
+            match self.trading_ratio(ctx, date) {
                 Ok(value) => value,
                 Err(BacktestError::Execution(message))
                     if message.contains("insufficient benchmark") =>
@@ -2682,8 +2714,10 @@ impl Strategy for OmniMicroCapStrategy {
             };
         // 使用前一交易日的指数价格计算市值区间（模拟实盘场景）
         let (band_low, band_high) = self.market_cap_band(prev_index_level);
-        eprintln!("[DEBUG] date={} current_index={:.2} prev_index={:.2} band=[{:.0}, {:.0}]", 
+        eprintln!(
-            date, index_level, prev_index_level, band_low, band_high);
+            "[DEBUG] date={} current_index={:.2} prev_index={:.2} band=[{:.0}, {:.0}]",
+            date, index_level, prev_index_level, band_low, band_high
+        );
         let (stock_list, selection_notes) = self.select_symbols(ctx, date, band_low, band_high)?;
         let periodic_rebalance = ctx.decision_index % self.config.refresh_rate == 0;
         let mut projected = ctx.portfolio.clone();
@@ -2705,8 +2739,7 @@ impl Strategy for OmniMicroCapStrategy {
             let stop_hit = current_price
                 <= position.average_cost * self.config.stop_loss_ratio
                     + self.stop_loss_tolerance(market);
-            let profit_hit = !market.is_at_upper_limit_price(current_price)
+            let profit_hit = current_price / position.average_cost > self.config.take_profit_ratio;
-                && current_price / position.average_cost > self.config.take_profit_ratio;
             let can_sell = self.can_sell_position(ctx, date, &position.symbol);
             if stop_hit || profit_hit {
                 let sell_reason = if stop_hit {

crates/fidc-core/src/strategy_ai.rs

@@ -546,8 +546,8 @@ pub fn build_optimization_prompt(
     prompt.push_str("你是 OmniQuant 平台策略脚本优化器。必须输出完整、可运行的平台策略脚本，不要输出解释文本。\n");
     prompt.push_str("输出格式硬约束：回复第一行必须是 strategy(\"...\")、let、fn、const 或 //；回复中不得包含 Markdown、解释、思考过程、手册复述、JSON 包装或自然语言总结。\n");
     prompt.push_str("长度硬约束：策略代码目标 80 行以内，只保留必要 let/fn/strategy 块；不要复制下面的手册片段、历史策略全文或字段清单。\n");
-    prompt.push_str("只修改与优化目标相关的少量参数或过滤条件，保留原策略的市场、基准、信号指数和核心风控；不要引入手册未列出的字段或外部平台 API 名称。\n");
+    prompt.push_str("优化不限制在原策略已有参数或少量扰动。只要 OmniQuant/FIDC 已支持，可以自由增加、修改、删除策略代码、参数、候选池、过滤函数、排序、仓位、止盈止损、调仓周期、指标因子和辅助函数；不得引入手册未列出的字段或外部平台 API 名称。\n");
-    prompt.push_str("优化可以调整调仓周期、持仓数、市值带、filter.stock_expr、ordering.rank_expr、allocation.buy_scale、止盈止损；如上一轮无交易或质量分过低，必须先放宽过滤条件并优先使用已入库指标因子、rolling_mean/ma/vma/rolling_stddev/pct_change 等支持函数。\n");
+    prompt.push_str("可以使用所有已入库日频字段、指标因子和表达式函数，例如 rolling_mean/ma/vma/rolling_sum/rolling_stddev/pct_change/factor/factor_value/factors；如上一轮无交易或质量分过低，必须先扩大候选覆盖并修正不可交易过滤，再优化收益。\n");
     prompt.push_str("优化目标：\n");
     prompt.push_str(&format!("- {}\n\n", request.objective));
     prompt.push_str("当前策略代码如下，仅作为输入参考；回复时不要包含 Markdown 代码围栏：\n");

crates/fidc-core/tests/core_rules.rs

@@ -61,7 +61,7 @@ fn china_cost_model_applies_minimum_commission_and_stamp_tax() {
     assert_eq!(buy.stamp_tax, 0.0);
 
     let sell = model.calculate(d(2023, 8, 25), OrderSide::Sell, 100_000.0);
-    assert!((sell.commission - 30.0).abs() < 1e-9);
+    assert!((sell.commission - 80.0).abs() < 1e-9);
     assert!((sell.stamp_tax - 100.0).abs() < 1e-9);
 }
 
@@ -112,7 +112,7 @@ fn china_cost_model_tracks_minimum_commission_per_order_id() {
 
     assert!((first.commission - 5.0).abs() < 1e-9);
     assert!(second.commission.abs() < 1e-9);
-    assert!((third.commission - 1.6).abs() < 1e-9);
+    assert!((third.commission - 12.6).abs() < 1e-9);
     assert!((another_order.commission - 5.0).abs() < 1e-9);
 }
 

crates/fidc-core/tests/delisting.rs

@@ -492,7 +492,7 @@ fn engine_applies_successor_conversion_before_delisted_cash_settlement() {
         .iter()
         .find(|holding| holding.symbol == "000002.SZ")
         .expect("successor holding exists");
-    assert_eq!(successor_holding.quantity, 500);
+    assert_eq!(successor_holding.quantity, 450);
     assert!(
         result
             .holdings_summary
@@ -503,6 +503,6 @@ fn engine_applies_successor_conversion_before_delisted_cash_settlement() {
         event
             .note
             .contains("successor_conversion 000001.SZ->000002.SZ")
-            && event.note.contains("cash=1000.00")
+            && event.note.contains("cash=900.00")
     }));
 }

crates/fidc-core/tests/explicit_order_flow.rs

@@ -7,6 +7,108 @@ use fidc_core::{
 };
 use std::collections::{BTreeMap, BTreeSet};
 
+fn order_value_rounding_data(date: NaiveDate, symbol: &str, price: f64) -> DataSet {
+    DataSet::from_components(
+        vec![Instrument {
+            symbol: symbol.to_string(),
+            name: "Test".to_string(),
+            board: "SZ".to_string(),
+            round_lot: 100,
+            listed_at: None,
+            delisted_at: None,
+            status: "active".to_string(),
+        }],
+        vec![DailyMarketSnapshot {
+            date,
+            symbol: symbol.to_string(),
+            timestamp: Some(format!("{date} 09:33:00")),
+            day_open: price,
+            open: price,
+            high: price,
+            low: price,
+            close: price,
+            last_price: price,
+            bid1: price,
+            ask1: price,
+            prev_close: price,
+            volume: 100_000,
+            tick_volume: 100_000,
+            bid1_volume: 80_000,
+            ask1_volume: 80_000,
+            trading_phase: Some("continuous".to_string()),
+            paused: false,
+            upper_limit: price * 1.1,
+            lower_limit: price * 0.9,
+            price_tick: 0.01,
+        }],
+        vec![DailyFactorSnapshot {
+            date,
+            symbol: symbol.to_string(),
+            market_cap_bn: 50.0,
+            free_float_cap_bn: 45.0,
+            pe_ttm: 15.0,
+            turnover_ratio: Some(2.0),
+            effective_turnover_ratio: Some(1.8),
+            extra_factors: BTreeMap::new(),
+        }],
+        vec![CandidateEligibility {
+            date,
+            symbol: symbol.to_string(),
+            is_st: false,
+            is_new_listing: false,
+            is_paused: false,
+            allow_buy: true,
+            allow_sell: true,
+            is_kcb: false,
+            is_one_yuan: false,
+        }],
+        vec![BenchmarkSnapshot {
+            date,
+            benchmark: "000300.SH".to_string(),
+            open: 100.0,
+            close: 100.0,
+            prev_close: 99.0,
+            volume: 1_000_000,
+        }],
+    )
+    .expect("dataset")
+}
+
+fn execute_single_value_order(
+    date: NaiveDate,
+    data: &DataSet,
+    symbol: &str,
+    value: f64,
+) -> (PortfolioState, fidc_core::BrokerExecutionReport) {
+    let mut portfolio = PortfolioState::new(20_000.0);
+    let broker = BrokerSimulator::new_with_execution_price(
+        ChinaAShareCostModel::default(),
+        ChinaEquityRuleHooks::default(),
+        PriceField::Open,
+    )
+    .with_strict_value_budget(true);
+    let report = broker
+        .execute(
+            date,
+            &mut portfolio,
+            data,
+            &StrategyDecision {
+                rebalance: false,
+                target_weights: BTreeMap::new(),
+                exit_symbols: BTreeSet::new(),
+                order_intents: vec![OrderIntent::Value {
+                    symbol: symbol.to_string(),
+                    value,
+                    reason: "test_order_value_rounding".to_string(),
+                }],
+                notes: Vec::new(),
+                diagnostics: Vec::new(),
+            },
+        )
+        .expect("broker execution");
+    (portfolio, report)
+}
+
 #[test]
 fn broker_executes_explicit_order_value_buy() {
     let date = NaiveDate::from_ymd_opt(2024, 1, 10).unwrap();
@@ -122,6 +224,171 @@ fn broker_executes_explicit_order_value_buy() {
     assert!(portfolio.cash() < 1_000_000.0);
 }
 
+#[test]
+fn broker_order_value_rounds_to_nearest_lot_when_min_lot_is_affordable() {
+    let date = NaiveDate::from_ymd_opt(2025, 1, 24).unwrap();
+    let symbol = "003017.SZ";
+    let data = order_value_rounding_data(date, symbol, 19.97);
+
+    let (portfolio, report) = execute_single_value_order(date, &data, symbol, 3_938.13);
+
+    assert_eq!(report.fill_events.len(), 1);
+    assert_eq!(report.fill_events[0].quantity, 100);
+    assert_eq!(portfolio.position(symbol).expect("position").quantity, 100);
+}
+
+#[test]
+fn broker_order_value_budget_includes_buy_commission() {
+    let date = NaiveDate::from_ymd_opt(2025, 6, 23).unwrap();
+    let symbol = "605303.SH";
+    let data = order_value_rounding_data(date, symbol, 11.93);
+
+    let (portfolio, report) = execute_single_value_order(date, &data, symbol, 4_776.0);
+
+    assert_eq!(report.fill_events.len(), 1);
+    assert_eq!(report.fill_events[0].quantity, 300);
+    assert_eq!(portfolio.position(symbol).expect("position").quantity, 300);
+
+    let (portfolio, report) = execute_single_value_order(date, &data, symbol, 4_848.0);
+
+    assert_eq!(report.fill_events.len(), 1);
+    assert_eq!(report.fill_events[0].quantity, 400);
+    assert_eq!(portfolio.position(symbol).expect("position").quantity, 400);
+}
+
+#[test]
+fn broker_delayed_limit_open_sell_uses_tick_price() {
+    let date = NaiveDate::from_ymd_opt(2025, 6, 27).unwrap();
+    let prev_date = NaiveDate::from_ymd_opt(2025, 6, 26).unwrap();
+    let symbol = "300635.SZ";
+    let data = DataSet::from_components_with_actions_and_quotes(
+        vec![Instrument {
+            symbol: symbol.to_string(),
+            name: "Test".to_string(),
+            board: "SZ".to_string(),
+            round_lot: 100,
+            listed_at: None,
+            delisted_at: None,
+            status: "active".to_string(),
+        }],
+        vec![DailyMarketSnapshot {
+            date,
+            symbol: symbol.to_string(),
+            timestamp: Some("2025-06-27 09:31:00".to_string()),
+            day_open: 12.55,
+            open: 12.55,
+            high: 13.16,
+            low: 12.26,
+            close: 12.36,
+            last_price: 12.39,
+            bid1: 12.39,
+            ask1: 12.40,
+            prev_close: 13.24,
+            volume: 329_575,
+            tick_volume: 10_000,
+            bid1_volume: 10_000,
+            ask1_volume: 10_000,
+            trading_phase: Some("continuous".to_string()),
+            paused: false,
+            upper_limit: 14.56,
+            lower_limit: 11.92,
+            price_tick: 0.01,
+        }],
+        vec![DailyFactorSnapshot {
+            date,
+            symbol: symbol.to_string(),
+            market_cap_bn: 50.0,
+            free_float_cap_bn: 45.0,
+            pe_ttm: 15.0,
+            turnover_ratio: Some(2.0),
+            effective_turnover_ratio: Some(1.8),
+            extra_factors: BTreeMap::new(),
+        }],
+        vec![CandidateEligibility {
+            date,
+            symbol: symbol.to_string(),
+            is_st: false,
+            is_new_listing: false,
+            is_paused: false,
+            allow_buy: true,
+            allow_sell: true,
+            is_kcb: false,
+            is_one_yuan: false,
+        }],
+        vec![BenchmarkSnapshot {
+            date,
+            benchmark: "000300.SH".to_string(),
+            open: 100.0,
+            close: 100.0,
+            prev_close: 99.0,
+            volume: 1_000_000,
+        }],
+        Vec::new(),
+        vec![IntradayExecutionQuote {
+            date,
+            symbol: symbol.to_string(),
+            timestamp: date.and_hms_opt(9, 31, 0).unwrap(),
+            last_price: 12.39,
+            bid1: 12.39,
+            ask1: 12.40,
+            bid1_volume: 10_000,
+            ask1_volume: 10_000,
+            volume_delta: 10_000,
+            amount_delta: 123_900.0,
+            trading_phase: Some("continuous".to_string()),
+        }],
+    )
+    .expect("dataset");
+    let mut portfolio = PortfolioState::new(1_000.0);
+    portfolio.position_mut(symbol).buy(prev_date, 800, 10.92);
+    let broker = BrokerSimulator::new_with_execution_price(
+        ChinaAShareCostModel::default(),
+        ChinaEquityRuleHooks::default(),
+        PriceField::Last,
+    )
+    .with_matching_type(MatchingType::NextTickLast)
+    .with_intraday_execution_start_time(NaiveTime::from_hms_opt(9, 31, 0).unwrap())
+    .with_volume_limit(false)
+    .with_liquidity_limit(false);
+
+    let report = broker
+        .execute(
+            date,
+            &mut portfolio,
+            &data,
+            &StrategyDecision {
+                rebalance: false,
+                target_weights: BTreeMap::new(),
+                exit_symbols: BTreeSet::new(),
+                order_intents: vec![OrderIntent::TargetValue {
+                    symbol: symbol.to_string(),
+                    target_value: 0.0,
+                    reason: "delayed_limit_open_sell".to_string(),
+                }],
+                notes: Vec::new(),
+                diagnostics: Vec::new(),
+            },
+        )
+        .expect("broker execution");
+
+    assert_eq!(report.fill_events.len(), 1);
+    assert_eq!(report.fill_events[0].quantity, 800);
+    assert_eq!(report.fill_events[0].price, 12.39);
+    assert!(portfolio.position(symbol).is_none());
+}
+
+#[test]
+fn broker_order_value_skips_when_one_lot_exceeds_budget() {
+    let date = NaiveDate::from_ymd_opt(2025, 1, 2).unwrap();
+    let symbol = "300321.SZ";
+    let data = order_value_rounding_data(date, symbol, 20.38);
+
+    let (portfolio, report) = execute_single_value_order(date, &data, symbol, 2_000.0);
+
+    assert!(report.fill_events.is_empty());
+    assert!(portfolio.position(symbol).is_none());
+}
+
 #[test]
 fn broker_executes_order_shares_and_order_lots() {
     let date = NaiveDate::from_ymd_opt(2024, 1, 10).unwrap();
@@ -778,7 +1045,7 @@ fn broker_executes_order_percent_and_target_percent() {
         )
         .expect("percent execution");
     assert_eq!(percent_report.fill_events.len(), 1);
-    assert_eq!(percent_report.fill_events[0].quantity, 10_000);
+    assert_eq!(percent_report.fill_events[0].quantity, 9_900);
 
     let mut target_percent_portfolio = PortfolioState::new(1_000_000.0);
     let target_percent_report = broker
@@ -1438,6 +1705,121 @@ fn broker_rejects_intraday_last_order_without_execution_quotes() {
     assert!(portfolio.position("000002.SZ").is_none());
 }
 
+#[test]
+fn broker_executes_intraday_last_on_start_quote_without_trade_delta() {
+    let date = NaiveDate::from_ymd_opt(2024, 1, 10).unwrap();
+    let data = DataSet::from_components_with_actions_and_quotes(
+        vec![Instrument {
+            symbol: "000002.SZ".to_string(),
+            name: "Test".to_string(),
+            board: "SZ".to_string(),
+            round_lot: 100,
+            listed_at: None,
+            delisted_at: None,
+            status: "active".to_string(),
+        }],
+        vec![DailyMarketSnapshot {
+            date,
+            symbol: "000002.SZ".to_string(),
+            timestamp: Some("2024-01-10 09:33:00".to_string()),
+            day_open: 15.0,
+            open: 15.0,
+            high: 15.5,
+            low: 14.8,
+            close: 15.2,
+            last_price: 15.2,
+            bid1: 15.19,
+            ask1: 15.21,
+            prev_close: 15.0,
+            volume: 100_000,
+            tick_volume: 100_000,
+            bid1_volume: 80_000,
+            ask1_volume: 80_000,
+            trading_phase: Some("continuous".to_string()),
+            paused: false,
+            upper_limit: 16.5,
+            lower_limit: 13.5,
+            price_tick: 0.01,
+        }],
+        vec![DailyFactorSnapshot {
+            date,
+            symbol: "000002.SZ".to_string(),
+            market_cap_bn: 50.0,
+            free_float_cap_bn: 45.0,
+            pe_ttm: 15.0,
+            turnover_ratio: Some(2.0),
+            effective_turnover_ratio: Some(1.8),
+            extra_factors: BTreeMap::new(),
+        }],
+        vec![CandidateEligibility {
+            date,
+            symbol: "000002.SZ".to_string(),
+            is_st: false,
+            is_new_listing: false,
+            is_paused: false,
+            allow_buy: true,
+            allow_sell: true,
+            is_kcb: false,
+            is_one_yuan: false,
+        }],
+        vec![BenchmarkSnapshot {
+            date,
+            benchmark: "000300.SH".to_string(),
+            open: 100.0,
+            close: 100.0,
+            prev_close: 99.0,
+            volume: 1_000_000,
+        }],
+        Vec::new(),
+        vec![IntradayExecutionQuote {
+            date,
+            symbol: "000002.SZ".to_string(),
+            timestamp: date.and_hms_opt(9, 33, 0).unwrap(),
+            last_price: 15.2,
+            bid1: 15.19,
+            ask1: 15.21,
+            bid1_volume: 8,
+            ask1_volume: 8,
+            volume_delta: 0,
+            amount_delta: 0.0,
+            trading_phase: Some("continuous".to_string()),
+        }],
+    )
+    .expect("dataset");
+    let mut portfolio = PortfolioState::new(1_000_000.0);
+    let broker = BrokerSimulator::new_with_execution_price(
+        ChinaAShareCostModel::default(),
+        ChinaEquityRuleHooks::default(),
+        PriceField::Last,
+    )
+    .with_intraday_execution_start_time(chrono::NaiveTime::from_hms_opt(9, 33, 0).unwrap());
+
+    let report = broker
+        .execute(
+            date,
+            &mut portfolio,
+            &data,
+            &StrategyDecision {
+                rebalance: false,
+                target_weights: BTreeMap::new(),
+                exit_symbols: BTreeSet::new(),
+                order_intents: vec![OrderIntent::Value {
+                    symbol: "000002.SZ".to_string(),
+                    value: 4_000.0,
+                    reason: "start_quote".to_string(),
+                }],
+                notes: Vec::new(),
+                diagnostics: Vec::new(),
+            },
+        )
+        .expect("broker execution");
+
+    assert_eq!(report.fill_events.len(), 1);
+    assert_eq!(report.fill_events[0].quantity, 200);
+    assert!((report.fill_events[0].price - 15.2).abs() < 1e-9);
+    assert_eq!(report.order_events[0].status, OrderStatus::Filled);
+}
+
 #[test]
 fn broker_cancels_market_order_remainder_when_intraday_quote_liquidity_exhausted() {
     let date = NaiveDate::from_ymd_opt(2024, 1, 10).unwrap();
@@ -2256,7 +2638,7 @@ fn broker_executes_algo_twap_percent_across_window_quotes() {
                 exit_symbols: BTreeSet::new(),
                 order_intents: vec![OrderIntent::AlgoPercent {
                     symbol: "000002.SZ".to_string(),
-                    percent: 0.0036,
+                    percent: 0.0037,
                     style: AlgoOrderStyle::Twap,
                     start_time: Some(NaiveTime::from_hms_opt(10, 0, 0).unwrap()),
                     end_time: Some(NaiveTime::from_hms_opt(10, 30, 0).unwrap()),