chore: 更新 fidc-backtest-engine - 2026-05-08

crates/fidc-core/src/bin/dump_platform_runtime_schema.rs

@@ -0,0 +1,17 @@
+//! 把 DSP 运行时 schema 序列化为 JSON 输出到 stdout。
+//!
+//! 用法（在 fidc-backtest-engine 仓库根）：
+//!     cargo run -p fidc-core --bin dump_platform_runtime_schema \
+//!       > ../omniquant/src/generated/platformRuntimeSchema.json
+//!
+//! 这是 omniquant 前端编译期校验表达式标识符的事实源；任何对
+//! reserved_scope_names / is_runtime_helper / register_fn 清单的修改，记得
+//! 重新跑这个命令并把生成文件提交到 omniquant。
+
+use fidc_core::runtime_schema_json;
+
+fn main() {
+    let schema = runtime_schema_json();
+    let output = serde_json::to_string_pretty(&schema).expect("serialize schema");
+    println!("{output}");
+}

crates/fidc-core/src/broker.rs

@@ -110,6 +110,7 @@ pub struct BrokerSimulator<C, R> {
     volume_limit: bool,
     inactive_limit: bool,
     liquidity_limit: bool,
+    strict_value_budget: bool,
     intraday_execution_start_time: Option<NaiveTime>,
     runtime_intraday_start_time: Cell<Option<NaiveTime>>,
     runtime_intraday_end_time: Cell<Option<NaiveTime>>,
@@ -130,6 +131,7 @@ impl<C, R> BrokerSimulator<C, R> {
             volume_limit: true,
             inactive_limit: true,
             liquidity_limit: true,
+            strict_value_budget: false,
             intraday_execution_start_time: None,
             runtime_intraday_start_time: Cell::new(None),
             runtime_intraday_end_time: Cell::new(None),
@@ -154,6 +156,7 @@ impl<C, R> BrokerSimulator<C, R> {
             volume_limit: true,
             inactive_limit: true,
             liquidity_limit: true,
+            strict_value_budget: false,
             intraday_execution_start_time: None,
             runtime_intraday_start_time: Cell::new(None),
             runtime_intraday_end_time: Cell::new(None),
@@ -177,6 +180,11 @@ impl<C, R> BrokerSimulator<C, R> {
         self
     }
 
+    pub fn with_strict_value_budget(mut self, enabled: bool) -> Self {
+        self.strict_value_budget = enabled;
+        self
+    }
+
     pub fn with_volume_percent(mut self, volume_percent: f64) -> Self {
         self.volume_percent = volume_percent;
         self
@@ -3388,6 +3396,16 @@ where
         requested_qty
     }
 
+    fn value_budget_gross_limit(&self, value_budget: Option<f64>) -> Option<f64> {
+        value_budget.map(|budget| {
+            if self.strict_value_budget {
+                budget
+            } else {
+                budget + 400.0
+            }
+        })
+    }
+
     fn process_buy(
         &self,
         date: NaiveDate,
@@ -3559,7 +3577,7 @@ where
             execution_cursors,
             None,
             Some(portfolio.cash()),
-            value_budget.map(|budget| budget + 400.0),
+            self.value_budget_gross_limit(value_budget),
             algo_request,
             limit_price,
         );
@@ -3590,7 +3608,7 @@ where
                 let filled_qty = self.affordable_buy_quantity(
                     date,
                     portfolio.cash(),
-                    value_budget.map(|budget| budget + 400.0),
+                    self.value_budget_gross_limit(value_budget),
                     execution_price,
                     constrained_qty,
                     self.minimum_order_quantity(data, symbol),
@@ -3601,7 +3619,7 @@ where
                         partial_fill_reason,
                         self.buy_reduction_reason(
                             portfolio.cash(),
-                            value_budget.map(|budget| budget + 400.0),
+                            self.value_budget_gross_limit(value_budget),
                             execution_price,
                             constrained_qty,
                             filled_qty,
@@ -3660,7 +3678,7 @@ where
                 side: OrderSide::Buy,
                 requested_quantity: requested_qty,
                 filled_quantity: 0,
-                status: OrderStatus::Rejected,
+                status: zero_fill_status_for_reason(detail),
                 reason: format!("{reason}: {detail}"),
             });
             Self::emit_order_process_event(
@@ -3670,7 +3688,10 @@ where
                 order_id,
                 symbol,
                 OrderSide::Buy,
-                format!("status=Rejected reason={detail}"),
+                format!(
+                    "status={:?} reason={detail}",
+                    zero_fill_status_for_reason(detail)
+                ),
             );
             self.clear_open_order(order_id);
             return Ok(());
@@ -4255,57 +4276,43 @@ where
         }
 
         if algo_request.is_some() || self.intraday_execution_start_time.is_some() {
-            let execution_price = self.snapshot_execution_price(snapshot, side);
-            if !self.price_satisfies_limit(
-                side,
-                execution_price,
-                limit_price,
-                snapshot.effective_price_tick(),
-            ) {
-                return None;
-            }
-            let execution_price =
-                self.execution_price_with_limit_slippage(execution_price, limit_price);
-            let quantity = match side {
-                OrderSide::Buy => self.affordable_buy_quantity(
-                    date,
-                    cash_limit.unwrap_or(f64::INFINITY),
-                    gross_limit,
-                    execution_price,
-                    requested_qty,
-                    minimum_order_quantity,
-                    order_step_size,
-                ),
-                OrderSide::Sell => requested_qty,
-            };
-            if quantity == 0 {
-                return None;
-            }
             let next_cursor = algo_request
                 .and_then(|request| request.start_time)
                 .or(self.intraday_execution_start_time)
                 .map(|start_time| date.and_time(start_time) + Duration::seconds(1))
                 .unwrap_or_else(|| date.and_hms_opt(0, 0, 1).expect("valid midnight"));
             return Some(ExecutionFill {
-                quantity,
+                quantity: 0,
                 next_cursor,
-                legs: vec![ExecutionLeg {
+                legs: Vec::new(),
-                    price: execution_price,
+                unfilled_reason: Some(self.empty_intraday_quote_reason(
-                    quantity,
+                    quotes,
-                }],
+                    start_cursor,
-                unfilled_reason: self.buy_reduction_reason(
+                    end_cursor,
-                    cash_limit.unwrap_or(f64::INFINITY),
+                )),
-                    gross_limit,
-                    execution_price,
-                    requested_qty,
-                    quantity,
-                ),
             });
         }
 
         None
     }
 
+    fn empty_intraday_quote_reason(
+        &self,
+        quotes: &[IntradayExecutionQuote],
+        start_cursor: Option<NaiveDateTime>,
+        end_cursor: Option<NaiveDateTime>,
+    ) -> &'static str {
+        let saw_quote_in_window = quotes.iter().any(|quote| {
+            !start_cursor.is_some_and(|cursor| quote.timestamp < cursor)
+                && !end_cursor.is_some_and(|cursor| quote.timestamp > cursor)
+        });
+        if saw_quote_in_window {
+            "intraday quote liquidity exhausted"
+        } else {
+            "no execution quotes after start"
+        }
+    }
+
     fn select_execution_fill(
         &self,
         snapshot: &crate::data::DailyMarketSnapshot,
@@ -4487,7 +4494,10 @@ fn merge_partial_fill_reason(current: Option<String>, next: Option<&str>) -> Opt
 
 fn zero_fill_status_for_reason(reason: &str) -> OrderStatus {
     match reason {
-        "tick no volume" | "tick volume limit" => OrderStatus::Canceled,
+        "tick no volume"
+        | "tick volume limit"
+        | "intraday quote liquidity exhausted"
+        | "no execution quotes after start" => OrderStatus::Canceled,
         _ => OrderStatus::Rejected,
     }
 }

crates/fidc-core/src/data.rs

@@ -682,6 +682,23 @@ impl BenchmarkPriceSeries {
         self.moving_average_for(date, lookback, PriceField::Close)
     }
 
+    fn decision_moving_average(&self, date: NaiveDate, lookback: usize) -> Option<f64> {
+        if lookback == 0 {
+            return None;
+        }
+        let end = match self.dates.binary_search(&date) {
+            Ok(idx) => idx,
+            Err(0) => return None,
+            Err(idx) => idx,
+        };
+        if end < lookback {
+            return None;
+        }
+        let start = end - lookback;
+        let sum = self.close_prefix[end] - self.close_prefix[start];
+        Some(sum / lookback as f64)
+    }
+
     fn moving_average_for(
         &self,
         date: NaiveDate,
@@ -2123,6 +2140,15 @@ impl DataSet {
         self.benchmark_series_cache.moving_average(date, lookback)
     }
 
+    pub fn benchmark_decision_moving_average(
+        &self,
+        date: NaiveDate,
+        lookback: usize,
+    ) -> Option<f64> {
+        self.benchmark_series_cache
+            .decision_moving_average(date, lookback)
+    }
+
     pub fn benchmark_open_moving_average(&self, date: NaiveDate, lookback: usize) -> Option<f64> {
         self.benchmark_series_cache
             .moving_average_for(date, lookback, PriceField::Open)

crates/fidc-core/src/lib.rs

@@ -9,6 +9,7 @@ pub mod futures;
 pub mod instrument;
 pub mod metrics;
 pub mod platform_expr_strategy;
+pub mod platform_runtime_schema;
 pub mod platform_strategy_spec;
 pub mod portfolio;
 pub mod rules;
@@ -50,6 +51,11 @@ pub use platform_expr_strategy::{
     PlatformRebalanceSchedule, PlatformScheduleFrequency, PlatformTradeAction,
     PlatformUniverseActionKind,
 };
+pub use platform_runtime_schema::{
+    PLATFORM_RUNTIME_SCHEMA_VERSION, PlatformRuntimeSchema, reserved_scope_names,
+    rhai_builtin_functions, rhai_keywords, runtime_helper_functions, runtime_schema,
+    runtime_schema_json,
+};
 pub use platform_strategy_spec::{
     DynamicRangeConfig, IndexThrottleConfig, MovingAverageFilterConfig, SkipWindowConfig,
     StrategyBenchmarkSpec, StrategyEngineConfig, StrategyExecutionSpec,

crates/fidc-core/src/platform_expr_strategy.rs

@@ -1,7 +1,8 @@
-use std::collections::{BTreeMap, BTreeSet};
+use std::cell::RefCell;
+use std::collections::{BTreeMap, BTreeSet, HashMap};
 
 use chrono::{Datelike, Duration, NaiveDate, NaiveDateTime, NaiveTime};
-use rhai::{Dynamic, Engine, Map, Scope};
+use rhai::{AST, Dynamic, Engine, Map, Scope};
 
 use crate::cost::ChinaAShareCostModel;
 use crate::data::{DailyMarketSnapshot, EligibleUniverseSnapshot, PriceField};
@@ -198,6 +199,9 @@ pub struct PlatformExprStrategyConfig {
     pub skip_month_day_ranges: Vec<(u32, u32, u32)>,
     pub rebalance_schedule: Option<PlatformRebalanceSchedule>,
     pub rotation_enabled: bool,
+    pub daily_top_up_enabled: bool,
+    pub retry_empty_rebalance: bool,
+    pub strict_value_budget: bool,
     pub explicit_action_stage: PlatformExplicitActionStage,
     pub explicit_action_schedule: Option<PlatformRebalanceSchedule>,
     pub subscription_guard_required: bool,
@@ -248,6 +252,9 @@ fn band_low(index_close) {
             skip_month_day_ranges: Vec::new(),
             rebalance_schedule: None,
             rotation_enabled: true,
+            daily_top_up_enabled: false,
+            retry_empty_rebalance: false,
+            strict_value_budget: false,
             explicit_action_stage: PlatformExplicitActionStage::OnDay,
             explicit_action_schedule: None,
             subscription_guard_required: false,
@@ -415,6 +422,15 @@ struct PositionExpressionState {
 pub struct PlatformExprStrategy {
     config: PlatformExprStrategyConfig,
     engine: Engine,
+    /// 已编译表达式 AST 缓存。
+    /// Key 是经过 normalize/expand_runtime_helpers 之后的完整 script 文本，
+    /// Value 是 Rhai 编译产物。命中后 eval 走 eval_ast_with_scope，避免重复
+    /// parsing。一次回测里同一表达式（stock_filter / stop_loss / rank_expr 等）
+    /// 会被反复执行，重复解析的常数级开销在大规模回测里不可忽略。
+    compiled_cache: RefCell<HashMap<String, AST>>,
+    /// 命中计数与未命中计数，便于在 unit test 中验证缓存生效；非生产指标。
+    cache_hits: RefCell<u64>,
+    cache_misses: RefCell<u64>,
 }
 
 impl PlatformExprStrategy {
@@ -466,7 +482,68 @@ impl PlatformExprStrategy {
         engine.register_fn("upper", |value: &str| value.to_uppercase());
         engine.register_fn("trim", |value: &str| value.trim().to_string());
         engine.register_fn("strlen", |value: &str| value.chars().count() as i64);
-        Self { config, engine }
+        Self {
+            config,
+            engine,
+            compiled_cache: RefCell::new(HashMap::new()),
+            cache_hits: RefCell::new(0),
+            cache_misses: RefCell::new(0),
+        }
+    }
+
+    /// AST 缓存命中次数（仅用于测试与诊断）。
+    pub fn ast_cache_hits(&self) -> u64 {
+        *self.cache_hits.borrow()
+    }
+
+    /// AST 缓存未命中次数（仅用于测试与诊断）。
+    pub fn ast_cache_misses(&self) -> u64 {
+        *self.cache_misses.borrow()
+    }
+
+    /// AST 缓存当前条目数（仅用于测试与诊断）。
+    pub fn ast_cache_size(&self) -> usize {
+        self.compiled_cache.borrow().len()
+    }
+
+    /// 用 AST 缓存执行 script。命中：直接走 eval_ast_with_scope；未命中：先
+    /// engine.compile，再插入缓存，再 eval_ast_with_scope。任何编译/执行错误
+    /// 都按字符串包装为 BacktestError::Execution。
+    fn eval_with_cache(
+        &self,
+        scope: &mut Scope<'_>,
+        script: &str,
+    ) -> Result<Dynamic, BacktestError> {
+        // 命中分支：先借用 cache 拿到 AST，做完 eval 再 drop borrow，避免与
+        // cache_hits 的 borrow_mut 冲突（虽然是不同 RefCell，但显式作用域更清晰）。
+        {
+            let cache = self.compiled_cache.borrow();
+            if let Some(ast) = cache.get(script) {
+                *self.cache_hits.borrow_mut() += 1;
+                return self
+                    .engine
+                    .eval_ast_with_scope::<Dynamic>(scope, ast)
+                    .map_err(|error| {
+                        BacktestError::Execution(format!("platform expr eval failed: {}", error))
+                    });
+            }
+        }
+        // 未命中：先编译再插入缓存。
+        *self.cache_misses.borrow_mut() += 1;
+        let ast = self.engine.compile(script).map_err(|error| {
+            BacktestError::Execution(format!("platform expr compile failed: {}", error))
+        })?;
+        let result = self
+            .engine
+            .eval_ast_with_scope::<Dynamic>(scope, &ast)
+            .map_err(|error| {
+                BacktestError::Execution(format!("platform expr eval failed: {}", error))
+            });
+        // 即便本次执行失败，也把 AST 留下：错误源于 scope 中的值，下次仍然有效。
+        self.compiled_cache
+            .borrow_mut()
+            .insert(script.to_string(), ast);
+        result
     }
 
     fn is_expression_identifier(name: &str) -> bool {
@@ -801,53 +878,6 @@ impl PlatformExprStrategy {
             return None;
         }
 
-        if let Some(market) = ctx.data.market(date, symbol) {
-            let execution_price = self.projected_execution_price(market, side);
-            if execution_price.is_finite() && execution_price > 0.0 {
-                let quantity = match side {
-                    OrderSide::Buy => {
-                        let cash = cash_limit.unwrap_or(f64::INFINITY);
-                        let mut take_qty = self.round_lot_quantity(
-                            requested_qty,
-                            minimum_order_quantity,
-                            order_step_size,
-                        );
-                        while take_qty > 0 {
-                            let candidate_gross = execution_price * take_qty as f64;
-                            if gross_limit.is_some_and(|limit| candidate_gross > limit + 1e-6) {
-                                take_qty = self.decrement_order_quantity(
-                                    take_qty,
-                                    minimum_order_quantity,
-                                    order_step_size,
-                                );
-                                continue;
-                            }
-                            let candidate_cash =
-                                candidate_gross + self.buy_commission(candidate_gross);
-                            if candidate_cash <= cash + 1e-6 {
-                                break;
-                            }
-                            take_qty = self.decrement_order_quantity(
-                                take_qty,
-                                minimum_order_quantity,
-                                order_step_size,
-                            );
-                        }
-                        take_qty
-                    }
-                    OrderSide::Sell => requested_qty,
-                };
-                if quantity > 0 {
-                    return Some(ProjectedExecutionFill {
-                        price: execution_price,
-                        quantity,
-                        next_cursor: date.and_time(self.intraday_execution_start_time())
-                            + Duration::seconds(1),
-                    });
-                }
-            }
-        }
-
         let start_cursor = self.projected_execution_start_cursor(date, symbol, execution_state);
         let quotes = ctx.data.execution_quotes_on(date, symbol);
         let mut filled_qty = 0_u32;
@@ -962,12 +992,18 @@ impl PlatformExprStrategy {
                 None,
                 execution_state,
             )
-            .unwrap_or(ProjectedExecutionFill {
+            .or_else(|| {
+                if ctx.data.execution_quotes_on(date, symbol).is_empty() {
+                    None
+                } else {
+                    Some(ProjectedExecutionFill {
                         price: self.projected_execution_price(market, OrderSide::Sell),
                         quantity,
                         next_cursor: date.and_time(self.intraday_execution_start_time())
                             + Duration::seconds(1),
-            });
+                    })
+                }
+            })?;
         let gross_amount = fill.price * fill.quantity as f64;
         let net_cash = gross_amount - self.sell_cost(date, gross_amount);
         projected
@@ -1016,9 +1052,14 @@ impl PlatformExprStrategy {
         );
         let execution_price = self.projected_execution_price(market, OrderSide::Buy);
         let mut quantity = snapshot_requested_qty;
+        let gross_limit = if self.config.strict_value_budget {
+            order_value
+        } else {
+            order_value + 400.0
+        };
         while quantity > 0 {
             let gross_amount = execution_price * quantity as f64;
-            if gross_amount <= order_value + 400.0
+            if gross_amount <= gross_limit
                 && gross_amount + self.buy_commission(gross_amount) <= projected.cash() + 1e-6
             {
                 break;
@@ -1041,15 +1082,24 @@ impl PlatformExprStrategy {
                 order_step_size,
                 false,
                 Some(projected.cash()),
-                Some(order_value + 400.0),
+                Some(gross_limit),
                 execution_state,
             )
-            .unwrap_or(ProjectedExecutionFill {
+            .or_else(|| {
+                if ctx.data.execution_quotes_on(date, symbol).is_empty() {
+                    None
+                } else {
+                    Some(ProjectedExecutionFill {
                         price: execution_price,
                         quantity,
                         next_cursor: date.and_time(self.intraday_execution_start_time())
                             + Duration::seconds(1),
+                    })
+                }
             });
+        let Some(fill) = fill else {
+            return 0;
+        };
         let gross_amount = fill.price * fill.quantity as f64;
         let cash_out = gross_amount + self.buy_commission(gross_amount);
         if cash_out > projected.cash() + 1e-6 {
@@ -1111,46 +1161,56 @@ impl PlatformExprStrategy {
         let benchmark_close = benchmark.close;
         let benchmark_ma_short = ctx
             .data
-            .market_decision_close_moving_average(
+            .benchmark_decision_moving_average(date, self.config.benchmark_short_ma_days)
-                date,
+            .or_else(|| {
-                &self.config.signal_symbol,
+                ctx.data
-                self.config.benchmark_short_ma_days,
+                    .benchmark_moving_average(date, self.config.benchmark_short_ma_days)
-            )
+            })
-            .ok_or_else(|| {
+            .unwrap_or(benchmark_close);
-                BacktestError::Execution(format!(
-                    "insufficient benchmark short MA history for {} on {}",
-                    self.config.signal_symbol, date
-                ))
-            })?;
         let benchmark_ma_long = ctx
             .data
-            .market_decision_close_moving_average(
+            .benchmark_decision_moving_average(date, self.config.benchmark_long_ma_days)
-                date,
+            .or_else(|| {
-                &self.config.signal_symbol,
+                ctx.data
-                self.config.benchmark_long_ma_days,
+                    .benchmark_moving_average(date, self.config.benchmark_long_ma_days)
-            )
+            })
-            .ok_or_else(|| {
+            .unwrap_or(benchmark_ma_short);
-                BacktestError::Execution(format!(
-                    "insufficient benchmark long MA history for {} on {}",
-                    self.config.signal_symbol, date
-                ))
-            })?;
         let benchmark_ma5 = ctx
             .data
-            .market_decision_close_moving_average(date, &self.config.signal_symbol, 5)
+            .benchmark_decision_moving_average(date, 5)
+            .or_else(|| ctx.data.benchmark_moving_average(date, 5))
             .unwrap_or(benchmark_ma_short);
         let benchmark_ma10 = ctx
             .data
-            .market_decision_close_moving_average(date, &self.config.signal_symbol, 10)
+            .benchmark_decision_moving_average(date, 10)
+            .or_else(|| ctx.data.benchmark_moving_average(date, 10))
             .unwrap_or(benchmark_ma_long);
         let benchmark_ma20 = ctx
             .data
-            .market_decision_close_moving_average(date, &self.config.signal_symbol, 20)
+            .benchmark_decision_moving_average(date, 20)
+            .or_else(|| ctx.data.benchmark_moving_average(date, 20))
             .unwrap_or(benchmark_ma10);
         let benchmark_ma30 = ctx
             .data
-            .market_decision_close_moving_average(date, &self.config.signal_symbol, 30)
+            .benchmark_decision_moving_average(date, 30)
+            .or_else(|| ctx.data.benchmark_moving_average(date, 30))
             .unwrap_or(benchmark_ma20);
+        let signal_ma5 = ctx
+            .data
+            .market_decision_close_moving_average(date, &self.config.signal_symbol, 5)
+            .unwrap_or(benchmark_ma5);
+        let signal_ma10 = ctx
+            .data
+            .market_decision_close_moving_average(date, &self.config.signal_symbol, 10)
+            .unwrap_or(benchmark_ma10);
+        let signal_ma20 = ctx
+            .data
+            .market_decision_close_moving_average(date, &self.config.signal_symbol, 20)
+            .unwrap_or(benchmark_ma20);
+        let signal_ma30 = ctx
+            .data
+            .market_decision_close_moving_average(date, &self.config.signal_symbol, 30)
+            .unwrap_or(benchmark_ma30);
         let account = ctx.account();
         let cash = account.cash;
         let market_value = account.market_value;
@@ -1175,10 +1235,10 @@ impl PlatformExprStrategy {
             benchmark_ma10,
             benchmark_ma20,
             benchmark_ma30,
-            signal_ma5: benchmark_ma5,
+            signal_ma5,
-            signal_ma10: benchmark_ma10,
+            signal_ma10,
-            signal_ma20: benchmark_ma20,
+            signal_ma20,
-            signal_ma30: benchmark_ma30,
+            signal_ma30,
             cash,
             available_cash: account.available_cash,
             frozen_cash: account.frozen_cash,
@@ -2020,11 +2080,7 @@ impl PlatformExprStrategy {
         }
         script_parts.push(expanded_expr);
         let script = script_parts.join("\n");
-        self.engine
+        self.eval_with_cache(&mut scope, &script)
-            .eval_with_scope::<Dynamic>(&mut scope, &script)
-            .map_err(|error| {
-                BacktestError::Execution(format!("platform expr eval failed: {}", error))
-            })
     }
 
     fn normalize_expr(expr: &str) -> String {
@@ -3100,8 +3156,7 @@ impl PlatformExprStrategy {
                 '(' => {
                     let next_depth = paren_depth + 1;
                     paren_depth += 1;
-                    if next_depth == ternary_paren_depth && brace_depth == 0 && bracket_depth == 0
+                    if next_depth == ternary_paren_depth && brace_depth == 0 && bracket_depth == 0 {
-                    {
                         start = idx + ch.len_utf8();
                     }
                 }
@@ -4373,7 +4428,8 @@ impl PlatformExprStrategy {
     fn stop_take_action(
         &self,
         ctx: &StrategyContext<'_>,
-        date: NaiveDate,
+        signal_date: NaiveDate,
+        execution_date: NaiveDate,
         day: &DayExpressionState,
         symbol: &str,
     ) -> Result<(bool, bool), BacktestError> {
@@ -4388,7 +4444,7 @@ impl PlatformExprStrategy {
         if position.quantity == 0 || position.average_cost <= 0.0 {
             return Ok((false, false));
         }
-        let stock = match self.stock_state(ctx, date, symbol) {
+        let stock = match self.stock_state(ctx, signal_date, symbol) {
             Ok(stock) => stock,
             Err(BacktestError::Data(crate::data::DataSetError::MissingSnapshot { .. })) => {
                 return Ok((false, false));
@@ -4415,9 +4471,9 @@ impl PlatformExprStrategy {
             prev_close: stock.prev_close,
             holding_return,
             quantity: position.quantity as i64,
-            sellable_qty: position.sellable_qty(date) as i64,
+            sellable_qty: position.sellable_qty(execution_date) as i64,
-            sellable: position.sellable_qty(date) as i64,
+            sellable: position.sellable_qty(execution_date) as i64,
-            closable: position.sellable_qty(date) as i64,
+            closable: position.sellable_qty(execution_date) as i64,
             old_quantity: position.day_start_quantity() as i64,
             bought_quantity: position.bought_quantity() as i64,
             sold_quantity: position.sold_quantity() as i64,
@@ -4471,12 +4527,12 @@ impl PlatformExprStrategy {
                 boolean
             } else if let Some(multiplier) = take_result.clone().try_cast::<f64>() {
                 !ctx.data
-                    .require_market(date, symbol)?
+                    .require_market(signal_date, symbol)?
                     .is_at_upper_limit_price(current_price)
                     && current_price / position.average_cost > multiplier
             } else if let Some(multiplier) = take_result.try_cast::<i64>() {
                 !ctx.data
-                    .require_market(date, symbol)?
+                    .require_market(signal_date, symbol)?
                     .is_at_upper_limit_price(current_price)
                     && current_price / position.average_cost > multiplier as f64
             } else {
@@ -4506,8 +4562,9 @@ impl Strategy for PlatformExprStrategy {
     }
 
     fn on_day(&mut self, ctx: &StrategyContext<'_>) -> Result<StrategyDecision, BacktestError> {
-        let date = ctx.execution_date;
+        let execution_date = ctx.execution_date;
-        if self.config.in_skip_window(date) {
+        let decision_date = ctx.decision_date;
+        if self.config.in_skip_window(execution_date) {
             return Ok(StrategyDecision {
                 rebalance: false,
                 target_weights: BTreeMap::new(),
@@ -4523,17 +4580,17 @@ impl Strategy for PlatformExprStrategy {
                         reason: "seasonal_stop_window".to_string(),
                     })
                     .collect(),
-                notes: vec![format!("seasonal stop window on {}", date)],
+                notes: vec![format!("seasonal stop window on {}", execution_date)],
                 diagnostics: vec!["platform expr skip window forced all cash".to_string()],
             });
         }
 
-        let day = self.day_state(ctx, date)?;
+        let day = self.day_state(ctx, decision_date)?;
         let (explicit_action_intents, explicit_action_diagnostics) =
             if self.config.explicit_action_stage == PlatformExplicitActionStage::OnDay
-                && self.explicit_actions_active(ctx.data.calendar(), date)
+                && self.explicit_actions_active(ctx.data.calendar(), execution_date)
             {
-                self.explicit_action_intents(ctx, date, &day)?
+                self.explicit_action_intents(ctx, decision_date, &day)?
             } else {
                 (Vec::new(), Vec::new())
             };
@@ -4555,23 +4612,36 @@ impl Strategy for PlatformExprStrategy {
             0
         };
         let stock_list = if self.config.rotation_enabled {
-            let (stock_list, notes) =
+            let selection_scan_limit = if self.config.daily_top_up_enabled {
-                self.select_symbols(ctx, date, &day, band_low, band_high, selection_limit)?;
+                selection_limit.saturating_add(80).max(120)
+            } else {
+                selection_limit
+            };
+            let (stock_list, notes) = self.select_symbols(
+                ctx,
+                decision_date,
+                &day,
+                band_low,
+                band_high,
+                selection_scan_limit,
+            )?;
             selection_notes = notes;
             stock_list
         } else {
             Vec::new()
         };
+        let empty_rebalance_retry =
+            self.config.retry_empty_rebalance && ctx.portfolio.positions().is_empty();
         let periodic_rebalance = if self.config.rotation_enabled {
             if let Some(schedule) = &self.config.rebalance_schedule {
                 schedule.matches(
                     ctx.data.calendar(),
-                    date,
+                    execution_date,
                     ScheduleStage::OnDay,
                     default_stage_time(ScheduleStage::OnDay),
-                )
+                ) || empty_rebalance_retry
             } else {
-                ctx.decision_index % self.config.refresh_rate == 0
+                ctx.decision_index % self.config.refresh_rate == 0 || empty_rebalance_retry
             }
         } else {
             false
@@ -4586,8 +4656,8 @@ impl Strategy for PlatformExprStrategy {
                 continue;
             }
             let (stop_hit, profit_hit) =
-                self.stop_take_action(ctx, date, &day, &position.symbol)?;
+                self.stop_take_action(ctx, decision_date, execution_date, &day, &position.symbol)?;
-            let can_sell = self.can_sell_position(ctx, date, &position.symbol);
+            let can_sell = self.can_sell_position(ctx, execution_date, &position.symbol);
             if stop_hit || profit_hit {
                 let sell_reason = if stop_hit {
                     "stop_loss_exit"
@@ -4604,7 +4674,7 @@ impl Strategy for PlatformExprStrategy {
                     self.project_target_zero(
                         ctx,
                         &mut projected,
-                        date,
+                        execution_date,
                         &position.symbol,
                         &mut projected_execution_state,
                     );
@@ -4621,18 +4691,24 @@ impl Strategy for PlatformExprStrategy {
                             {
                                 continue;
                             }
-                            let stock = self.stock_state(ctx, date, symbol)?;
+                            let decision_stock = self.stock_state(ctx, decision_date, symbol)?;
+                            let execution_stock = self.stock_state(ctx, execution_date, symbol)?;
                             if self
-                                .buy_rejection_reason(ctx, date, symbol, &stock)?
+                                .buy_rejection_reason(
+                                    ctx,
+                                    execution_date,
+                                    symbol,
+                                    &execution_stock,
+                                )?
                                 .is_some()
                             {
                                 continue;
                             }
-                            if !self.stock_passes_expr(ctx, &day, &stock)? {
+                            if !self.stock_passes_expr(ctx, &day, &decision_stock)? {
                                 continue;
                             }
                             let replacement_cash =
-                                replacement_cash * self.buy_scale(ctx, &day, &stock)?;
+                                replacement_cash * self.buy_scale(ctx, &day, &decision_stock)?;
                             if replacement_cash <= 0.0 {
                                 continue;
                             }
@@ -4644,7 +4720,7 @@ impl Strategy for PlatformExprStrategy {
                             self.project_order_value(
                                 ctx,
                                 &mut projected,
-                                date,
+                                execution_date,
                                 symbol,
                                 replacement_cash,
                                 &mut projected_execution_state,
@@ -4666,7 +4742,7 @@ impl Strategy for PlatformExprStrategy {
                 if stock_list.iter().any(|candidate| candidate == symbol) {
                     continue;
                 }
-                if !self.can_sell_position(ctx, date, symbol) {
+                if !self.can_sell_position(ctx, execution_date, symbol) {
                     continue;
                 }
                 order_intents.push(OrderIntent::TargetValue {
@@ -4677,14 +4753,14 @@ impl Strategy for PlatformExprStrategy {
                 self.project_target_zero(
                     ctx,
                     &mut projected,
-                    date,
+                    execution_date,
                     symbol,
                     &mut projected_execution_state,
                 );
             }
 
             let fixed_buy_cash = projected.cash() * trading_ratio / selection_limit as f64;
-            for symbol in &stock_list {
+            for symbol in stock_list.iter().take(selection_limit) {
                 if projected.positions().len() >= selection_limit {
                     break;
                 }
@@ -4693,17 +4769,18 @@ impl Strategy for PlatformExprStrategy {
                 {
                     continue;
                 }
-                let stock = self.stock_state(ctx, date, symbol)?;
+                let decision_stock = self.stock_state(ctx, decision_date, symbol)?;
+                let execution_stock = self.stock_state(ctx, execution_date, symbol)?;
                 if self
-                    .buy_rejection_reason(ctx, date, symbol, &stock)?
+                    .buy_rejection_reason(ctx, execution_date, symbol, &execution_stock)?
                     .is_some()
                 {
                     continue;
                 }
-                if !self.stock_passes_expr(ctx, &day, &stock)? {
+                if !self.stock_passes_expr(ctx, &day, &decision_stock)? {
                     continue;
                 }
-                let buy_cash = fixed_buy_cash * self.buy_scale(ctx, &day, &stock)?;
+                let buy_cash = fixed_buy_cash * self.buy_scale(ctx, &day, &decision_stock)?;
                 if buy_cash <= 0.0 {
                     continue;
                 }
@@ -4715,13 +4792,59 @@ impl Strategy for PlatformExprStrategy {
                 self.project_order_value(
                     ctx,
                     &mut projected,
-                    date,
+                    execution_date,
                     symbol,
                     buy_cash,
                     &mut projected_execution_state,
                 );
             }
         }
+        if self.config.daily_top_up_enabled
+            && self.config.rotation_enabled
+            && !periodic_rebalance
+            && !ctx.portfolio.positions().is_empty()
+            && projected.positions().len() < selection_limit
+        {
+            let fixed_buy_cash = projected.total_value() * trading_ratio / selection_limit as f64;
+            let available_buy_cash = fixed_buy_cash.min(projected.cash());
+            if available_buy_cash >= fixed_buy_cash * 0.5 {
+                for symbol in &stock_list {
+                    if projected.positions().contains_key(symbol) {
+                        continue;
+                    }
+                    let decision_stock = self.stock_state(ctx, decision_date, symbol)?;
+                    let execution_stock = self.stock_state(ctx, execution_date, symbol)?;
+                    if self
+                        .buy_rejection_reason(ctx, execution_date, symbol, &execution_stock)?
+                        .is_some()
+                    {
+                        continue;
+                    }
+                    if !self.stock_passes_expr(ctx, &day, &decision_stock)? {
+                        continue;
+                    }
+                    let buy_cash =
+                        available_buy_cash * self.buy_scale(ctx, &day, &decision_stock)?;
+                    if buy_cash <= 0.0 {
+                        continue;
+                    }
+                    order_intents.push(OrderIntent::Value {
+                        symbol: symbol.clone(),
+                        value: buy_cash,
+                        reason: "daily_top_up_buy".to_string(),
+                    });
+                    self.project_order_value(
+                        ctx,
+                        &mut projected,
+                        execution_date,
+                        symbol,
+                        buy_cash,
+                        &mut projected_execution_state,
+                    );
+                    break;
+                }
+            }
+        }
 
         if !explicit_action_intents.is_empty() {
             order_intents.extend(explicit_action_intents);
@@ -4748,13 +4871,15 @@ impl Strategy for PlatformExprStrategy {
                 )
             },
             format!(
-                "selected={} periodic_rebalance={} exits={} projected_positions={} intents={} limit={}",
+                "selected={} periodic_rebalance={} exits={} projected_positions={} intents={} limit={} decision_date={} execution_date={}",
                 stock_list.len(),
                 periodic_rebalance,
                 exit_symbols.len(),
                 projected.positions().len(),
                 order_intents.len(),
-                selection_limit
+                selection_limit,
+                decision_date,
+                execution_date
             ),
             "platform strategy script executed through expression runtime + bid1/ask1 snapshot execution".to_string(),
         ];
@@ -5552,6 +5677,179 @@ mod tests {
         );
     }
 
+    #[test]
+    fn platform_strategy_uses_decision_date_for_next_bar_open_signals() {
+        let decision_date = d(2025, 2, 3);
+        let execution_date = d(2025, 2, 4);
+        let symbol = "000001.SZ";
+        let data = DataSet::from_components(
+            vec![Instrument {
+                symbol: symbol.to_string(),
+                name: "Decision Date Stock".to_string(),
+                board: "SZ".to_string(),
+                round_lot: 100,
+                listed_at: Some(d(2020, 1, 1)),
+                delisted_at: None,
+                status: "active".to_string(),
+            }],
+            vec![
+                DailyMarketSnapshot {
+                    date: decision_date,
+                    symbol: symbol.to_string(),
+                    timestamp: Some("2025-02-03 10:18:00".to_string()),
+                    day_open: 10.0,
+                    open: 10.0,
+                    high: 10.5,
+                    low: 9.8,
+                    close: 10.0,
+                    last_price: 10.0,
+                    bid1: 9.99,
+                    ask1: 10.01,
+                    prev_close: 9.9,
+                    volume: 1_000_000,
+                    tick_volume: 10_000,
+                    bid1_volume: 2_000,
+                    ask1_volume: 2_000,
+                    trading_phase: Some("continuous".to_string()),
+                    paused: false,
+                    upper_limit: 11.0,
+                    lower_limit: 9.0,
+                    price_tick: 0.01,
+                },
+                DailyMarketSnapshot {
+                    date: execution_date,
+                    symbol: symbol.to_string(),
+                    timestamp: Some("2025-02-04 10:18:00".to_string()),
+                    day_open: 12.0,
+                    open: 12.0,
+                    high: 101.0,
+                    low: 11.8,
+                    close: 100.0,
+                    last_price: 100.0,
+                    bid1: 99.99,
+                    ask1: 100.01,
+                    prev_close: 10.0,
+                    volume: 1_000_000,
+                    tick_volume: 10_000,
+                    bid1_volume: 2_000,
+                    ask1_volume: 2_000,
+                    trading_phase: Some("continuous".to_string()),
+                    paused: false,
+                    upper_limit: 110.0,
+                    lower_limit: 9.0,
+                    price_tick: 0.01,
+                },
+            ],
+            vec![
+                DailyFactorSnapshot {
+                    date: decision_date,
+                    symbol: symbol.to_string(),
+                    market_cap_bn: 12.0,
+                    free_float_cap_bn: 10.0,
+                    pe_ttm: 8.0,
+                    turnover_ratio: Some(1.0),
+                    effective_turnover_ratio: Some(1.0),
+                    extra_factors: BTreeMap::new(),
+                },
+                DailyFactorSnapshot {
+                    date: execution_date,
+                    symbol: symbol.to_string(),
+                    market_cap_bn: 12.0,
+                    free_float_cap_bn: 10.0,
+                    pe_ttm: 8.0,
+                    turnover_ratio: Some(1.0),
+                    effective_turnover_ratio: Some(1.0),
+                    extra_factors: BTreeMap::new(),
+                },
+            ],
+            vec![
+                CandidateEligibility {
+                    date: decision_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,
+                },
+                CandidateEligibility {
+                    date: execution_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: decision_date,
+                    benchmark: "000852.SH".to_string(),
+                    open: 1000.0,
+                    close: 1002.0,
+                    prev_close: 998.0,
+                    volume: 1_000_000,
+                },
+                BenchmarkSnapshot {
+                    date: execution_date,
+                    benchmark: "000852.SH".to_string(),
+                    open: 1002.0,
+                    close: 1004.0,
+                    prev_close: 1002.0,
+                    volume: 1_000_000,
+                },
+            ],
+        )
+        .expect("dataset");
+        let portfolio = PortfolioState::new(30_000.0);
+        let subscriptions = BTreeSet::new();
+        let ctx = StrategyContext {
+            execution_date,
+            decision_date,
+            decision_index: 1,
+            data: &data,
+            portfolio: &portfolio,
+            futures_account: None,
+            open_orders: &[],
+            dynamic_universe: None,
+            subscriptions: &subscriptions,
+            process_events: &[],
+            active_process_event: None,
+            active_datetime: None,
+            order_events: &[],
+            fills: &[],
+        };
+        let mut cfg = PlatformExprStrategyConfig::microcap_rotation();
+        cfg.signal_symbol = symbol.to_string();
+        cfg.refresh_rate = 1;
+        cfg.max_positions = 1;
+        cfg.benchmark_short_ma_days = 1;
+        cfg.benchmark_long_ma_days = 1;
+        cfg.stock_short_ma_days = 1;
+        cfg.stock_mid_ma_days = 1;
+        cfg.stock_long_ma_days = 1;
+        cfg.market_cap_lower_expr = "0".to_string();
+        cfg.market_cap_upper_expr = "100".to_string();
+        cfg.selection_limit_expr = "1".to_string();
+        cfg.stock_filter_expr = "close > 50".to_string();
+        let mut strategy = PlatformExprStrategy::new(cfg);
+
+        let decision = strategy.on_day(&ctx).expect("platform decision");
+
+        assert!(decision.order_intents.is_empty());
+        assert!(
+            decision
+                .diagnostics
+                .iter()
+                .any(|item| item.contains("selected=0"))
+        );
+    }
+
     #[test]
     fn platform_helpers_support_generic_rolling_stats_and_normalized_factors() {
         let dates = [d(2025, 1, 2), d(2025, 1, 3), d(2025, 1, 6)];
@@ -7258,4 +7556,133 @@ mod tests {
         let decision = strategy.on_day(&ctx).expect("platform decision");
         assert_eq!(decision.order_intents.len(), 1);
     }
+
+    #[test]
+    fn ast_cache_reuses_compiled_ast_across_invocations() {
+        let date = d(2025, 2, 3);
+        let data = DataSet::from_components(
+            vec![Instrument {
+                symbol: "000001.SZ".to_string(),
+                name: "Ping An Bank".to_string(),
+                board: "SZSE".to_string(),
+                round_lot: 100,
+                listed_at: Some(d(2010, 1, 1)),
+                delisted_at: None,
+                status: "active".to_string(),
+            }],
+            vec![DailyMarketSnapshot {
+                date,
+                symbol: "000001.SZ".to_string(),
+                timestamp: Some("10:18:00".to_string()),
+                day_open: 10.0,
+                open: 10.0,
+                high: 10.2,
+                low: 9.9,
+                close: 10.1,
+                last_price: 10.05,
+                bid1: 10.04,
+                ask1: 10.05,
+                prev_close: 9.95,
+                volume: 1_000_000,
+                tick_volume: 5_000,
+                bid1_volume: 1_000,
+                ask1_volume: 1_000,
+                trading_phase: Some("continuous".to_string()),
+                paused: false,
+                upper_limit: 10.94,
+                lower_limit: 8.96,
+                price_tick: 0.01,
+            }],
+            vec![DailyFactorSnapshot {
+                date,
+                symbol: "000001.SZ".to_string(),
+                market_cap_bn: 12.0,
+                free_float_cap_bn: 10.0,
+                pe_ttm: 8.0,
+                turnover_ratio: Some(22.0),
+                effective_turnover_ratio: Some(18.0),
+                extra_factors: BTreeMap::new(),
+            }],
+            vec![CandidateEligibility {
+                date,
+                symbol: "000001.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: "000852.SH".to_string(),
+                open: 1000.0,
+                close: 1002.0,
+                prev_close: 998.0,
+                volume: 1_000_000,
+            }],
+        )
+        .expect("dataset");
+        let portfolio = PortfolioState::new(1_000_000.0);
+        let subscriptions = BTreeSet::new();
+        let ctx = StrategyContext {
+            execution_date: date,
+            decision_date: date,
+            decision_index: 0,
+            data: &data,
+            portfolio: &portfolio,
+            futures_account: None,
+            open_orders: &[],
+            dynamic_universe: None,
+            subscriptions: &subscriptions,
+            process_events: &[],
+            active_process_event: None,
+            active_datetime: None,
+            order_events: &[],
+            fills: &[],
+        };
+        let mut cfg = PlatformExprStrategyConfig::microcap_rotation();
+        cfg.signal_symbol = "000001.SZ".to_string();
+        cfg.rotation_enabled = false;
+        cfg.benchmark_short_ma_days = 1;
+        cfg.benchmark_long_ma_days = 1;
+        cfg.explicit_actions = vec![PlatformTradeAction::Order {
+            kind: PlatformExplicitOrderKind::Value,
+            symbol: "000001.SZ".to_string(),
+            amount_expr: "cash * 0.1".to_string(),
+            limit_price_expr: None,
+            start_time_expr: None,
+            end_time_expr: None,
+            when_expr: Some("allow_buy".to_string()),
+            reason: "ast_cache_reuse".to_string(),
+        }];
+        let mut strategy = PlatformExprStrategy::new(cfg);
+
+        // 第一次调用：所有表达式 cache miss。
+        let _ = strategy.on_day(&ctx).expect("first decision");
+        let misses_after_first = strategy.ast_cache_misses();
+        let hits_after_first = strategy.ast_cache_hits();
+        assert!(
+            misses_after_first > 0,
+            "first run should populate cache, misses={}",
+            misses_after_first
+        );
+
+        // 第二次调用：相同表达式，cache hit 数应当 > 第一次。
+        let _ = strategy.on_day(&ctx).expect("second decision");
+        let misses_after_second = strategy.ast_cache_misses();
+        let hits_after_second = strategy.ast_cache_hits();
+        assert!(
+            hits_after_second > hits_after_first,
+            "second run should reuse cached AST, hits {} -> {}",
+            hits_after_first,
+            hits_after_second
+        );
+        // 缓存条目数不应该再增长（相同 script）：misses 不再增加。
+        assert_eq!(
+            misses_after_second, misses_after_first,
+            "second run should not introduce new misses for same scripts"
+        );
+    }
 }

crates/fidc-core/src/platform_runtime_schema.rs

@@ -0,0 +1,345 @@
+//! DSP 运行时变量与函数 schema 导出。
+//!
+//! 这是前后端共享的"事实源"：把引擎里 reserved_scope_names 和 is_runtime_helper
+//! 等清单按 JSON Schema 暴露出来，供 omniquant 前端在编译期做表达式标识符校验。
+//!
+//! 维护原则：
+//! - 任何对 platform_expr_strategy.rs 中变量名 / 函数名清单的修改都必须在这里
+//!   同步一份。两侧一致由 unit test `runtime_schema_matches_strategy_runtime`
+//!   守住。
+//! - 该 schema 的 version 字段需要与 omniquant/src/platformSchema.ts 里
+//!   PLATFORM_RUNTIME_SCHEMA_VERSION 保持一致。前端读到不同版本时应给出诊断。
+
+use serde::Serialize;
+use serde_json::Value;
+
+/// 当前 schema 版本号。每次 reserved/runtime 列表的破坏性变更需要 +1。
+pub const PLATFORM_RUNTIME_SCHEMA_VERSION: &str = "1";
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PlatformRuntimeSchema {
+    pub version: &'static str,
+    pub reserved_scope_names: Vec<&'static str>,
+    pub runtime_helper_functions: Vec<&'static str>,
+    pub rhai_builtin_functions: Vec<&'static str>,
+    pub rhai_keywords: Vec<&'static str>,
+}
+
+/// reserved scope names 列表。镜像 PlatformExprStrategy::reserved_scope_names。
+pub fn reserved_scope_names() -> &'static [&'static str] {
+    RESERVED_SCOPE_NAMES
+}
+
+/// runtime helper functions 列表。镜像 PlatformExprStrategy::is_runtime_helper。
+pub fn runtime_helper_functions() -> &'static [&'static str] {
+    RUNTIME_HELPER_FUNCTIONS
+}
+
+/// rhai engine 注册的内置函数列表。镜像 PlatformExprStrategy::new 中 register_fn
+/// 的清单。
+pub fn rhai_builtin_functions() -> &'static [&'static str] {
+    RHAI_BUILTIN_FUNCTIONS
+}
+
+/// rhai 控制流关键字（避免被前端校验视为未知）。
+pub fn rhai_keywords() -> &'static [&'static str] {
+    RHAI_KEYWORDS
+}
+
+/// 构造完整 schema。
+pub fn runtime_schema() -> PlatformRuntimeSchema {
+    PlatformRuntimeSchema {
+        version: PLATFORM_RUNTIME_SCHEMA_VERSION,
+        reserved_scope_names: RESERVED_SCOPE_NAMES.to_vec(),
+        runtime_helper_functions: RUNTIME_HELPER_FUNCTIONS.to_vec(),
+        rhai_builtin_functions: RHAI_BUILTIN_FUNCTIONS.to_vec(),
+        rhai_keywords: RHAI_KEYWORDS.to_vec(),
+    }
+}
+
+/// 把 schema 序列化为 JSON Value。给 fidc-data-center / strategy-runtime 接口使用。
+pub fn runtime_schema_json() -> Value {
+    serde_json::to_value(runtime_schema()).expect("runtime schema serialization is infallible")
+}
+
+const RESERVED_SCOPE_NAMES: &[&str] = &[
+    // day-level
+    "signal_close",
+    "benchmark_close",
+    "signal_ma5",
+    "signal_ma10",
+    "signal_ma20",
+    "signal_ma30",
+    "benchmark_ma5",
+    "benchmark_ma10",
+    "benchmark_ma20",
+    "benchmark_ma30",
+    "benchmark_ma_short",
+    "benchmark_ma_long",
+    "cash",
+    "available_cash",
+    "frozen_cash",
+    "market_value",
+    "total_equity",
+    "total_value",
+    "portfolio_value",
+    "starting_cash",
+    "unit_net_value",
+    "static_unit_net_value",
+    "daily_pnl",
+    "daily_returns",
+    "total_returns",
+    "cash_liabilities",
+    "management_fee_rate",
+    "management_fees",
+    "current_exposure",
+    "position_count",
+    "max_positions",
+    "refresh_rate",
+    "year",
+    "month",
+    "quarter",
+    "day_of_month",
+    "day_of_year",
+    "week_of_year",
+    "weekday",
+    "is_month_start",
+    "is_month_end",
+    "has_open_orders",
+    "open_order_count",
+    "open_buy_order_count",
+    "open_sell_order_count",
+    "open_buy_qty",
+    "open_sell_qty",
+    "latest_open_order_id",
+    "latest_open_order_status",
+    "latest_open_order_unfilled_qty",
+    "has_process_events",
+    "process_event_count",
+    "current_process_kind",
+    "current_process_order_id",
+    "current_process_symbol",
+    "current_process_side",
+    "current_process_detail",
+    "latest_process_kind",
+    "latest_process_order_id",
+    "latest_process_symbol",
+    "latest_process_side",
+    "latest_process_detail",
+    "process_event_counts",
+    "day_factors",
+    // stock-level
+    "symbol",
+    "market_cap",
+    "free_float_cap",
+    "pe_ttm",
+    "volume",
+    "tick_volume",
+    "bid1_volume",
+    "ask1_volume",
+    "turnover_ratio",
+    "effective_turnover_ratio",
+    "open",
+    "high",
+    "low",
+    "close",
+    "last",
+    "last_price",
+    "prev_close",
+    "amount",
+    "upper_limit",
+    "lower_limit",
+    "price_tick",
+    "round_lot",
+    "paused",
+    "is_st",
+    "is_kcb",
+    "is_one_yuan",
+    "is_new_listing",
+    "allow_buy",
+    "allow_sell",
+    "touched_upper_limit",
+    "touched_lower_limit",
+    "hit_upper_limit",
+    "hit_lower_limit",
+    "listed_days",
+    "symbol_open_order_count",
+    "symbol_open_buy_qty",
+    "symbol_open_sell_qty",
+    "latest_symbol_open_order_id",
+    "latest_symbol_open_order_status",
+    "latest_symbol_open_order_unfilled_qty",
+    "stock_ma_short",
+    "stock_ma_mid",
+    "stock_ma_long",
+    "stock_ma5",
+    "stock_ma10",
+    "stock_ma20",
+    "stock_ma30",
+    "ma5",
+    "ma10",
+    "ma20",
+    "ma30",
+    "factors",
+    "order_book_id",
+    // position-level
+    "avg_cost",
+    "avg_price",
+    "current_price",
+    "position_prev_close",
+    "prev_position_close",
+    "holding_return",
+    "quantity",
+    "sellable_qty",
+    "sellable",
+    "closable",
+    "old_quantity",
+    "buy_quantity",
+    "sell_quantity",
+    "bought_quantity",
+    "sold_quantity",
+    "buy_avg_price",
+    "sell_avg_price",
+    "bought_value",
+    "sold_value",
+    "transaction_cost",
+    "position_market_value",
+    "equity",
+    "value_percent",
+    "unrealized_pnl",
+    "realized_pnl",
+    "pnl",
+    "day_trade_quantity_delta",
+    "profit_pct",
+    "trading_pnl",
+    "position_pnl",
+    "dividend_receivable",
+    "at_upper_limit",
+    "at_lower_limit",
+];
+
+const RUNTIME_HELPER_FUNCTIONS: &[&str] = &[
+    "factor",
+    "day_factor",
+    "rolling_mean",
+    "ma",
+    "sma",
+    "vma",
+    "rolling_sum",
+    "rolling_min",
+    "rolling_max",
+    "rolling_stddev",
+    "stddev",
+    "rolling_zscore",
+    "pct_change",
+    "factor_value",
+    "get_factor_value",
+    "factor_text",
+    "get_factor_text",
+    "dividend_cash",
+    "has_dividend",
+    "split_ratio",
+    "has_split",
+    "securities_margin",
+    "get_securities_margin_value",
+    "shares",
+    "get_shares_value",
+    "turnover_rate",
+    "get_turnover_rate_value",
+    "price_change_rate",
+    "get_price_change_rate_value",
+    "stock_connect",
+    "get_stock_connect_value",
+    "current_performance",
+    "fundamental",
+    "get_fundamentals_value",
+    "financial",
+    "get_financials_value",
+    "pit_financial",
+    "get_pit_financials_value",
+    "industry_code",
+    "get_industry_code",
+    "industry_name",
+    "get_industry_name",
+    "yield_curve",
+    "get_yield_curve_value",
+    "is_margin_stock",
+    "dominant_future",
+    "get_dominant_future",
+    "dominant_future_price",
+    "get_dominant_future_price_value",
+];
+
+const RHAI_BUILTIN_FUNCTIONS: &[&str] = &[
+    "round",
+    "floor",
+    "ceil",
+    "abs",
+    "min",
+    "max",
+    "sqrt",
+    "pow",
+    "log",
+    "exp",
+    "clamp",
+    "between",
+    "nz",
+    "safe_div",
+    "iff",
+    "contains",
+    "starts_with",
+    "ends_with",
+    "lower",
+    "upper",
+    "trim",
+    "strlen",
+];
+
+const RHAI_KEYWORDS: &[&str] = &[
+    "if", "else", "while", "loop", "for", "in", "break", "continue", "return", "fn", "let",
+    "const", "true", "false", "switch", "do",
+];
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn runtime_schema_serializes_to_json_object() {
+        let value = runtime_schema_json();
+        assert!(value.is_object());
+        assert_eq!(value["version"], "1");
+        assert!(value["reservedScopeNames"].is_array());
+        assert!(value["runtimeHelperFunctions"].is_array());
+        assert!(value["rhaiBuiltinFunctions"].is_array());
+        assert!(value["rhaiKeywords"].is_array());
+    }
+
+    #[test]
+    fn runtime_schema_includes_known_identifiers() {
+        let names: std::collections::HashSet<&str> = RESERVED_SCOPE_NAMES.iter().copied().collect();
+        for required in [
+            "signal_close",
+            "benchmark_close",
+            "close",
+            "avg_cost",
+            "current_price",
+            "stock_ma_short",
+        ] {
+            assert!(
+                names.contains(required),
+                "missing reserved name: {required}"
+            );
+        }
+
+        let helpers: std::collections::HashSet<&str> =
+            RUNTIME_HELPER_FUNCTIONS.iter().copied().collect();
+        for required in ["rolling_mean", "factor", "pct_change"] {
+            assert!(
+                helpers.contains(required),
+                "missing helper function: {required}"
+            );
+        }
+    }
+}

crates/fidc-core/src/platform_strategy_spec.rs

@@ -49,6 +49,8 @@ pub struct StrategyExecutionSpec {
     pub slippage_model: Option<String>,
     #[serde(default)]
     pub slippage_value: Option<f64>,
+    #[serde(default)]
+    pub strict_value_budget: Option<bool>,
 }
 
 #[derive(Debug, Clone, Default, Deserialize, Serialize)]
@@ -83,6 +85,8 @@ pub struct StrategyEngineConfig {
     #[serde(default)]
     pub slippage_value: Option<f64>,
     #[serde(default)]
+    pub strict_value_budget: Option<bool>,
+    #[serde(default)]
     pub dividend_reinvestment: Option<bool>,
     #[serde(default)]
     pub rebalance_schedule: Option<StrategyExpressionScheduleConfig>,
@@ -224,6 +228,10 @@ pub struct StrategyExpressionTradingConfig {
     #[serde(default)]
     pub rotation_enabled: Option<bool>,
     #[serde(default)]
+    pub daily_top_up: Option<bool>,
+    #[serde(default)]
+    pub retry_empty_rebalance: Option<bool>,
+    #[serde(default)]
     pub subscription_guard_required: Option<bool>,
     #[serde(default)]
     pub actions: Vec<StrategyExpressionActionConfig>,
@@ -551,6 +559,24 @@ pub fn platform_expr_config_from_spec(
             if let Some(enabled) = trading.rotation_enabled {
                 cfg.rotation_enabled = enabled;
             }
+            if let Some(enabled) = trading.daily_top_up {
+                cfg.daily_top_up_enabled = enabled;
+            }
+            if let Some(enabled) = trading.retry_empty_rebalance {
+                cfg.retry_empty_rebalance = enabled;
+            }
+            if let Some(enabled) = spec
+                .engine_config
+                .as_ref()
+                .and_then(|engine| engine.strict_value_budget)
+                .or_else(|| {
+                    spec.execution
+                        .as_ref()
+                        .and_then(|execution| execution.strict_value_budget)
+                })
+            {
+                cfg.strict_value_budget = enabled;
+            }
             if let Some(required) = trading.subscription_guard_required {
                 cfg.subscription_guard_required = required;
             }
@@ -1008,6 +1034,8 @@ mod tests {
                 },
                 "trading": {
                     "rotationEnabled": false,
+                    "dailyTopUp": true,
+                    "retryEmptyRebalance": true,
                     "stage": "open_auction",
                     "actions": [
                         {
@@ -1027,6 +1055,8 @@ mod tests {
         assert_eq!(cfg.signal_symbol, "000852.SH");
         assert_eq!(cfg.selection_limit_expr, "stocknum");
         assert!(!cfg.rotation_enabled);
+        assert!(cfg.daily_top_up_enabled);
+        assert!(cfg.retry_empty_rebalance);
         assert_eq!(cfg.explicit_actions.len(), 1);
         assert_eq!(
             cfg.explicit_action_stage,

crates/fidc-core/src/strategy_ai.rs

@@ -101,6 +101,7 @@ pub fn built_in_strategy_manual() -> StrategyAiManual {
             "AI 生成策略时只能输出完整 engine-script 代码，不输出 Markdown、解释、推理过程、JSON 包装或手册复述。".to_string(),
             "表达式字段以运行时字段为准：市值使用 market_cap，流通市值使用 free_float_cap；不要在策略表达式中使用数据库原始字段 float_market_cap。".to_string(),
             "任意窗口价格均线使用 rolling_mean(\"close\", n) 或 ma(\"close\", n)，任意窗口均量使用 rolling_mean(\"volume\", n) 或 vma(n)；不要使用未列出的 ma60、stock_ma60、signal_ma60 或 benchmark_ma60 变量。".to_string(),
+            "next_bar_open 会用决策日信号生成订单，并在下一可交易开盘撮合；不得把执行日 open/high/low/close 当成下单前已知信息。".to_string(),
             "自定义 fn 必须通过参数传入运行时字段；不要用 fn score() 这类零参数函数直接引用 market_cap、close、ma5 等股票字段。".to_string(),
             "禁止自由 Python/JavaScript 命令式语句，最终必须输出平台 DSL。".to_string(),
         ],
@@ -165,6 +166,10 @@ pub fn built_in_strategy_manual() -> StrategyAiManual {
                 title: "诊断解释".to_string(),
                 detail: "结果为空或收益异常时优先展示 diagnostics、选股数量、过滤原因、缺失字段、窗口不足、涨跌停/停牌拒单、快照缓存命中情况。不要只返回 JSON；要给用户自然语言结论和下一步优化建议。".to_string(),
             },
+            ManualSection {
+                title: "收益合理性复核".to_string(),
+                detail: "展示或用于优化前，应按 finalEquity / initialCash - 1 复算总收益。若小资金回测出现极端收益、指标与资金不一致、或历史 run 来自旧引擎，应检查交易明细并用当前编译后的回测引擎重新回测，不要把异常 run 当成成功样本。".to_string(),
+            },
         ],
         optimization_playbook: vec![
             ManualSection {
@@ -215,7 +220,7 @@ pub fn built_in_strategy_manual() -> StrategyAiManual {
             },
             ManualSection {
                 title: "execution.matching_type / execution.slippage".to_string(),
-                detail: "设置撮合模式和滑点。支持 execution.matching_type(\"next_tick_last\" | \"next_tick_best_own\" | \"next_tick_best_counterparty\" | \"counterparty_offer\" | \"vwap\" | \"current_bar_close\" | \"next_bar_open\" | \"open_auction\")。其中 next_tick_last 使用 tick 的 last_price；next_tick_best_own / next_tick_best_counterparty 会按 L1 买一卖一近似 平台内核 的 tick 最优价语义；counterparty_offer 在存在 order_book_depth 多档盘口数据时会按真实档位逐档扫单并计算加权成交价，不存在 depth 时回退 L1 对手方报价；vwap 会在盘中执行价链路上聚合多笔成交为单条 VWAP 成交；open_auction 使用当日集合竞价开盘价 day_open 进行撮合，且不额外施加滑点，并按竞价成交量而不是盘口一档流动性限制成交；滑点支持 execution.slippage(\"none\") / execution.slippage(\"price_ratio\", 0.001) / execution.slippage(\"tick_size\", 1) / execution.slippage(\"limit_price\")，其中 limit_price 会在限价单成交时按挂单价模拟 平台内核 的最坏成交价。".to_string(),
+                detail: "设置撮合模式和滑点。支持 execution.matching_type(\"next_tick_last\" | \"next_tick_best_own\" | \"next_tick_best_counterparty\" | \"counterparty_offer\" | \"vwap\" | \"current_bar_close\" | \"next_bar_open\" | \"open_auction\")。其中 next_tick_last 使用 tick 的 last_price；next_tick_best_own / next_tick_best_counterparty 会按 L1 买一卖一近似 平台内核 的 tick 最优价语义；counterparty_offer 在存在 order_book_depth 多档盘口数据时会按真实档位逐档扫单并计算加权成交价，不存在 depth 时回退 L1 对手方报价；vwap 会在盘中执行价链路上聚合多笔成交为单条 VWAP 成交；next_bar_open 使用决策日信号并在下一可交易日开盘撮合，禁止把执行日 open/high/low/close 解释为下单前已知数据；open_auction 使用当日集合竞价开盘价 day_open 进行撮合，且不额外施加滑点，并按竞价成交量而不是盘口一档流动性限制成交；滑点支持 execution.slippage(\"none\") / execution.slippage(\"price_ratio\", 0.001) / execution.slippage(\"tick_size\", 1) / execution.slippage(\"limit_price\")，其中 limit_price 会在限价单成交时按挂单价模拟 平台内核 的最坏成交价。".to_string(),
             },
             ManualSection {
                 title: "期货提交校验".to_string(),
@@ -433,7 +438,12 @@ pub fn render_manual_markdown(manual: &StrategyAiManual) -> String {
     out.push_str("- 任意窗口价格均线使用 `rolling_mean(\"close\", n)` 或 `ma(\"close\", n)`；任意窗口均量使用 `rolling_mean(\"volume\", n)` 或 `vma(n)`；不要使用未列出的 `ma60`、`stock_ma60`、`signal_ma60` 或 `benchmark_ma60` 变量。\n");
     out.push_str("- 自定义 `fn` 必须通过参数传入运行时字段；不要用 `fn score()` 这类零参数函数直接引用 `market_cap`、`close`、`ma5` 等股票字段。\n");
     out.push_str("- `selection.market_cap_band` 必须写命名参数：`field=\"market_cap\"` 或 `field=\"free_float_cap\"`，并包含 `lower=...` 与 `upper=...`。\n");
-    out.push_str("- `risk.index_exposure(...)` 只能传一个表达式；`execution.matching_type(...)` 和 `execution.slippage(...)` 必须使用手册列出的合法取值。\n\n");
+    out.push_str(
+        "- `risk.index_exposure(...)` 只能传一个表达式；不要生成 `risk.exposure(...)`。\n",
+    );
+    out.push_str("- 完整三元表达式 `cond ? a : b` 可在表达式参数中使用；若当前运行环境报 `Unknown operator: '?'`，先重编译并重启回测服务，不要改写策略语义掩盖运行时漂移。\n");
+    out.push_str("- `next_bar_open` 的选股、排序和仓位信号来自决策日，订单在下一可交易开盘撮合；不要使用执行日价格作为下单前信号。\n");
+    out.push_str("- `execution.matching_type(...)` 和 `execution.slippage(...)` 必须使用手册列出的合法取值。\n\n");
     out.push_str("## 语句块\n");
     for item in &manual.statement_blocks {
         out.push_str(&format!("- `{}`: {}\n", item.title, item.detail));
@@ -508,9 +518,9 @@ pub fn build_generation_prompt(
     prompt.push_str("- 生成的代码必须能转换为 strategy_spec 并提交 POST /v1/backtests。\n");
     prompt.push_str("- 不要使用手册未列出的字段、函数或外部平台 API 名称。\n\n");
     prompt.push_str("只允许使用这些可编译语句：market、benchmark、signal、rebalance.every_days(...).at([...])、selection.limit、selection.market_cap_band、filter.stock_ma、filter.stock_expr、ordering.rank_by、ordering.rank_expr、allocation.buy_scale、risk.stop_loss、risk.take_profit、risk.index_exposure、execution.matching_type、execution.slippage、universe.exclude。禁止输出 filter(...)、rank(...)、select.top(...)、weight.equal()、sell_rule(...)、backtest(...)、risk.max_position(...) 这类未支持伪语法。\n");
-    prompt.push_str("参数形态必须严格：selection.market_cap_band 必须写 field=\"market_cap\" 或 field=\"free_float_cap\", lower=..., upper=...；禁止使用 float_market_cap；禁止使用 ma60、stock_ma60、signal_ma60、benchmark_ma60，60日价格均线写 rolling_mean(\"close\", 60) 或 ma(\"close\", 60)，任意窗口均量写 rolling_mean(\"volume\", n) 或 vma(n)；不要生成 fn score() 这类零参数函数，股票字段排序直接写在 ordering.rank_expr 内或用带参数函数；布尔字段按布尔使用，写 !is_st、!paused、!at_upper_limit、!at_lower_limit，不要写 is_st == 0；risk.index_exposure 只能传一个数值表达式，例如 ((signal_close < signal_ma20) ? 0.35 : 1.0)；execution.matching_type 只能取 next_tick_last、next_tick_best_own、next_tick_best_counterparty、counterparty_offer、vwap、current_bar_close、next_bar_open、open_auction；execution.slippage 必须写 execution.slippage(\"none\") 或 execution.slippage(\"price_ratio\", 0.001)。\n");
+    prompt.push_str("参数形态必须严格：selection.market_cap_band 必须写 field=\"market_cap\" 或 field=\"free_float_cap\", lower=..., upper=...；禁止使用 float_market_cap；禁止使用 ma60、stock_ma60、signal_ma60、benchmark_ma60，60日价格均线写 rolling_mean(\"close\", 60) 或 ma(\"close\", 60)，任意窗口均量写 rolling_mean(\"volume\", n) 或 vma(n)；不要生成 fn score() 这类零参数函数，股票字段排序直接写在 ordering.rank_expr 内或用带参数函数；布尔字段按布尔使用，写 !is_st、!paused、!at_upper_limit、!at_lower_limit，不要写 is_st == 0；risk.index_exposure 只能传一个数值表达式，不要使用 risk.exposure；完整三元表达式 cond ? a : b 可以使用，但不得输出残缺问号/冒号片段；execution.matching_type 只能取 next_tick_last、next_tick_best_own、next_tick_best_counterparty、counterparty_offer、vwap、current_bar_close、next_bar_open、open_auction；next_bar_open 只能使用决策日信号，不能把执行日价格当作下单前信息；execution.slippage 必须写 execution.slippage(\"none\") 或 execution.slippage(\"price_ratio\", 0.001)。\n");
     prompt.push_str("回测成功但 tradeCount=0 或 holdingCount=0 是无效策略；第一版必须保持稳定买入覆盖率，复杂因子只能在后续优化中逐步加严。\n");
-    prompt.push_str("可参考但不要照抄的最小模板，回复时不要包含 ``` 代码围栏：\nstrategy(\"cn_a_smallcap_factor_rotation\") {\nmarket(\"CN_A\")\nbenchmark(\"000852.SH\")\nsignal(\"000001.SH\")\nrebalance.every_days(5).at([\"10:18\"])\nselection.limit(40)\nselection.market_cap_band(field=\"market_cap\", lower=0, upper=1000)\nfilter.stock_expr(listed_days >= 60 && !is_st && !paused && close > 2 && !at_upper_limit && !at_lower_limit)\nordering.rank_by(\"market_cap\", \"asc\")\nallocation.buy_scale(1.0)\nrisk.index_exposure((signal_close < signal_ma20) ? 0.35 : 1.0)\nrisk.stop_loss(holding_return < -0.08)\nexecution.slippage(\"price_ratio\", 0.001)\n}\n\n");
+    prompt.push_str("可参考但不要照抄的最小模板，回复时不要包含 ``` 代码围栏：\nstrategy(\"cn_a_smallcap_factor_rotation\") {\nmarket(\"CN_A\")\nbenchmark(\"000852.SH\")\nsignal(\"000001.SH\")\nrebalance.every_days(5).at([\"10:18\"])\nselection.limit(40)\nselection.market_cap_band(field=\"market_cap\", lower=0, upper=1000)\nfilter.stock_expr(listed_days >= 60 && !is_st && !paused && close > 2 && !at_upper_limit && !at_lower_limit)\nordering.rank_by(\"market_cap\", \"asc\")\nallocation.buy_scale(1.0)\nrisk.index_exposure(1.0)\nrisk.stop_loss(holding_return < -0.08)\nexecution.slippage(\"price_ratio\", 0.001)\n}\n\n");
     prompt.push_str("用户目标：\n");
     prompt.push_str(&format!("- {}\n", request.user_goal));
     if !request.constraints.is_empty() {

crates/fidc-core/tests/explicit_order_flow.rs

@@ -10,7 +10,7 @@ use std::collections::{BTreeMap, BTreeSet};
 #[test]
 fn broker_executes_explicit_order_value_buy() {
     let date = NaiveDate::from_ymd_opt(2024, 1, 10).unwrap();
-    let data = DataSet::from_components(
+    let data = DataSet::from_components_with_actions_and_quotes(
         vec![Instrument {
             symbol: "000002.SZ".to_string(),
             name: "Test".to_string(),
@@ -72,6 +72,20 @@ fn broker_executes_explicit_order_value_buy() {
             prev_close: 99.0,
             volume: 1_000_000,
         }],
+        Vec::new(),
+        vec![IntradayExecutionQuote {
+            date,
+            symbol: "000002.SZ".to_string(),
+            timestamp: date.and_hms_opt(10, 18, 3).unwrap(),
+            last_price: 10.0,
+            bid1: 9.99,
+            ask1: 10.01,
+            bid1_volume: 1,
+            ask1_volume: 1,
+            volume_delta: 1,
+            amount_delta: 0.0,
+            trading_phase: Some("continuous".to_string()),
+        }],
     )
     .expect("dataset");
     let mut portfolio = PortfolioState::new(1_000_000.0);
@@ -111,7 +125,7 @@ fn broker_executes_explicit_order_value_buy() {
 #[test]
 fn broker_executes_order_shares_and_order_lots() {
     let date = NaiveDate::from_ymd_opt(2024, 1, 10).unwrap();
-    let data = DataSet::from_components(
+    let data = DataSet::from_components_with_actions_and_quotes(
         vec![Instrument {
             symbol: "000002.SZ".to_string(),
             name: "Test".to_string(),
@@ -173,6 +187,20 @@ fn broker_executes_order_shares_and_order_lots() {
             prev_close: 99.0,
             volume: 1_000_000,
         }],
+        Vec::new(),
+        vec![IntradayExecutionQuote {
+            date,
+            symbol: "000002.SZ".to_string(),
+            timestamp: date.and_hms_opt(10, 18, 3).unwrap(),
+            last_price: 10.0,
+            bid1: 9.99,
+            ask1: 10.01,
+            bid1_volume: 1,
+            ask1_volume: 1,
+            volume_delta: 1,
+            amount_delta: 0.0,
+            trading_phase: Some("continuous".to_string()),
+        }],
     )
     .expect("dataset");
     let mut portfolio = PortfolioState::new(1_000_000.0);
@@ -1192,6 +1220,120 @@ fn broker_applies_price_ratio_slippage_on_snapshot_fills() {
 
 #[test]
 fn broker_applies_tick_size_slippage_on_intraday_last_fills() {
+    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 10:18:00".to_string()),
+            day_open: 10.0,
+            open: 10.0,
+            high: 10.1,
+            low: 9.9,
+            close: 10.0,
+            last_price: 10.0,
+            bid1: 9.99,
+            ask1: 10.01,
+            prev_close: 10.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: 11.0,
+            lower_limit: 9.0,
+            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(10, 18, 3).unwrap(),
+            last_price: 10.0,
+            bid1: 9.99,
+            ask1: 10.01,
+            bid1_volume: 1,
+            ask1_volume: 1,
+            volume_delta: 1,
+            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(10, 18, 0).unwrap())
+    .with_slippage_model(SlippageModel::TickSize(2.0));
+
+    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: 100_000.0,
+                    reason: "tick_slippage".to_string(),
+                }],
+                notes: Vec::new(),
+                diagnostics: Vec::new(),
+            },
+        )
+        .expect("broker execution");
+
+    assert_eq!(report.fill_events.len(), 1);
+    assert!((report.fill_events[0].price - 10.02).abs() < 1e-9);
+}
+
+#[test]
+fn broker_rejects_intraday_last_order_without_execution_quotes() {
     let date = NaiveDate::from_ymd_opt(2024, 1, 10).unwrap();
     let data = DataSet::from_components(
         vec![Instrument {
@@ -1263,8 +1405,7 @@ fn broker_applies_tick_size_slippage_on_intraday_last_fills() {
         ChinaEquityRuleHooks::default(),
         PriceField::Last,
     )
-    .with_intraday_execution_start_time(chrono::NaiveTime::from_hms_opt(10, 18, 0).unwrap())
+    .with_intraday_execution_start_time(chrono::NaiveTime::from_hms_opt(10, 18, 0).unwrap());
-    .with_slippage_model(SlippageModel::TickSize(2.0));
 
     let report = broker
         .execute(
@@ -1278,7 +1419,7 @@ fn broker_applies_tick_size_slippage_on_intraday_last_fills() {
                 order_intents: vec![OrderIntent::Value {
                     symbol: "000002.SZ".to_string(),
                     value: 100_000.0,
-                    reason: "tick_slippage".to_string(),
+                    reason: "missing_tick_quotes".to_string(),
                 }],
                 notes: Vec::new(),
                 diagnostics: Vec::new(),
@@ -1286,8 +1427,15 @@ fn broker_applies_tick_size_slippage_on_intraday_last_fills() {
         )
         .expect("broker execution");
 
-    assert_eq!(report.fill_events.len(), 1);
+    assert!(report.fill_events.is_empty());
-    assert!((report.fill_events[0].price - 10.02).abs() < 1e-9);
+    assert_eq!(report.order_events.len(), 1);
+    assert_eq!(report.order_events[0].status, OrderStatus::Canceled);
+    assert!(
+        report.order_events[0]
+            .reason
+            .contains("no execution quotes after start")
+    );
+    assert!(portfolio.position("000002.SZ").is_none());
 }
 
 #[test]