按实际委托时间选择盘后撮合阶段

This reverts commit d0639558b3.

Cargo.lock

@@ -37,16 +37,6 @@ version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
 
-[[package]]
-name = "bt-demo"
-version = "0.1.0"
-dependencies = [
- "chrono",
- "fidc-core",
- "serde",
- "serde_json",
-]
-
 [[package]]
 name = "bumpalo"
 version = "3.20.2"
@@ -109,12 +99,43 @@ version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
 
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5181e0de7b61eb03a81e347d6dd8797bae9da5146707b51077e2d71a54ec0ceb"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d6914041f254d6e9176c01941b21115dcfb7089e55135a35411081bd106ef3f"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17"
+
 [[package]]
 name = "crunchy"
 version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
 
+[[package]]
+name = "either"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e5e8f6c15a24b9a3ee5efec809ccd006d3b30e8b3bb63c39af737c7f87daa1d"
+
 [[package]]
 name = "equivalent"
 version = "1.0.2"
@@ -125,8 +146,10 @@ checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 name = "fidc-core"
 version = "0.1.0"
 dependencies = [
+ "ahash",
  "chrono",
  "indexmap",
+ "rayon",
  "rhai",
  "serde",
  "serde_json",
@@ -304,6 +327,26 @@ version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
+[[package]]
+name = "rayon"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fb39b166781f92d482534ef4b4b1b2568f42613b53e5b6c160e24cfbfa30926d"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "rhai"
 version = "1.23.6"

Cargo.toml

@@ -1,7 +1,6 @@
 [workspace]
 members = [
     "crates/fidc-core",
-    "crates/bt-demo",
 ]
 resolver = "2"
 
@@ -12,9 +11,11 @@ version = "0.1.0"
 authors = ["OpenAI Codex"]
 
 [workspace.dependencies]
+ahash = "=0.8.12"
 chrono = { version = "=0.4.44", features = ["serde"] }
 indexmap = { version = "=2.11.4", features = ["serde"] }
 reqwest = { version = "=0.12.24", default-features = false, features = ["json", "rustls-tls"] }
+rayon = "=1.12.0"
 rhai = { version = "=1.23.6", features = ["sync"] }
 serde = { version = "=1.0.228", features = ["derive"] }
 serde_json = "=1.0.145"

README.md

@@ -4,7 +4,7 @@
 
 ## 当前能力
 
-- 日频、分钟、tick 级策略生命周期与确定性回放。
+- 日频和分钟执行价策略生命周期与确定性回放。
 - A 股行情、估值、因子、基准、候选资格、涨跌停触达、停牌和 ST 标记。
 - 平台策略 DSL 与 `StrategyContext` 数据 API，不暴露非平台脚本语法。
 - `BacktestConfig` 支持起止日期、初始资金、决策滞后、执行价格字段、基准代码。
@@ -14,6 +14,7 @@
 - Broker 支持目标权重、显式金额、目标股数、限价、VWAP/TWAP、挂单、撤单和订单查询。
 - 期货账户支持多空持仓、开平仓、今昨仓、保证金、手续费、结算和到期处理。
 - 报告输出支持权益曲线、成交、持仓、月度收益、风险指标、基准序列和 JSON 分析包。
+- 账户出入金以独立外部现金流记录保存；权益曲线同时输出 `externalCashFlow` 和现金流中性 `unitNav`，收益指标不把入金/出金计入交易收益。延迟出金在结算前做整批资金校验，不能把账户现金变成负数。
 - 内置 `OmniMicroCapStrategy`，覆盖动态市值带、均线过滤、止损止盈、固定频率再平衡和盘中执行近似。
 
 ## Workspace 布局
@@ -22,7 +23,6 @@
 .
 ├── Cargo.toml
 ├── crates
-│   ├── bt-demo
 │   └── fidc-core
 │       └── src
 │           ├── broker.rs
@@ -37,7 +37,6 @@
 │           ├── scheduler.rs
 │           ├── strategy.rs
 │           └── strategy_ai.rs
-├── data/demo
 └── docs
 ```
 
@@ -51,7 +50,7 @@
 - `futures`: 期货账户、合约参数、保证金、手续费和多空持仓。
 - `rules`: 中国市场交易规则和风控校验。
 - `broker`: 股票撮合、订单簿、滑点、成交量约束、限价和显式订单执行。
-- `scheduler`: 日、周、月、分钟、tick 调度规则。
+- `scheduler`: 日、周、月和分钟调度规则。
 - `platform_expr_strategy`: 平台 DSL 解析后的表达式策略执行模型。
 - `strategy`: 策略 trait、内置策略和运行时视图。
 - `strategy_ai`: 策略 AI 手册、提示词生成和数据库字段目录合并。
@@ -82,6 +81,12 @@
 
 任意数据库指标和自定义因子通过 `factor("field")`、`factor_value("field", lookback)`、`rolling_mean("field", n)`、`sma("close", n)` 等函数读取。未预计算的均线窗口可在回测中按已有历史数据实时计算。
 
+Source Lake 日线成交量保留原始可用性合同：源 `volume=null` 与真实 `volume=0` 含义不同。依赖成交量的 rolling 窗口只要包含源空值就返回缺失，不得把空值补成 0；停牌日明确提供的 0 成交量仍是合法观测。该合同随 runner 快照版本冻结，旧快照不能跨版本复用。
+
+盘后固定价格不是策略类型，也不是 `matchingType`。自 2026-07-06 起，只有实际同日提交时间落在 15:00–15:30 的普通委托才由 broker 进入盘后固定价格执行阶段；15:00–15:04 的委托等待到 15:05，15:05–15:30 按官方收盘价和真实盘后成交量撮合，不叠加滑点，未成交余量不跨日。窗口外委托继续沿用连续竞价、当前收盘或下一交易日开盘合同；`next_bar_open` 策略即使在 15:00 生成信号，也不得被改写为同日盘后委托。缺失盘后行情时必须明确不成交，禁止回退全天成交量或 15:00 前分钟行情。
+
+`holdUntilExit=true` 与 `stopTakeReferencePriceMode=signal_day_post_adjusted_close` 组合表示持久模型组合语义：股票进入模型目标后即记录信号日和后复权参考价，不以买单是否成交为前提。涨停、停牌或其他执行风控导致买单未成交时，模型成员仍占用目标槽位、每天累计模型持有日并继续生成目标仓位；达到止盈、止损或最大模型持有期后才从模型组合移除。实际订单仍由成交日风控独立决定，不得用实际持仓集合覆盖模型目标集合。
+
 ## 内置微盘策略
 
 `OmniMicroCapStrategy` 是平台内置的微盘轮动策略，用于 demo、性能验证和策略迁移基线：
@@ -96,45 +101,9 @@
 
 ## 运行方式
 
-默认运行仓库 demo 数据：
+`fidc-backtest-engine` 不再维护本地 CSV demo、partitioned snapshot 目录或导出融合表作为运行入口。生产和集成回测由 `fidc-backtest-service` runner 创建 `DataSet`，数据来自 Strategy Factory Source Lake 的 Arrow/Parquet、manifest/data_epoch 缓存和运行时逻辑视图。
 
-```bash
-cargo run --bin bt-demo
-```
-
-运行平台内置微盘策略：
-
-```bash
-FIDC_BT_STRATEGY=omni-microcap \
-FIDC_BT_SIGNAL_SYMBOL=000001.SH \
-cargo run --release --bin bt-demo
-```
-
-接入真实分区 snapshot 目录：
-
-```bash
-FIDC_BT_DATA_LAYOUT=partitioned \
-FIDC_BT_DATA_DIR=/path/to/snapshots \
-FIDC_BT_SIGNAL_SYMBOL=000001.SH \
-cargo run --bin bt-demo
-```
-
-约定目录结构：
-
-```text
-snapshots/
-├── instruments.csv
-├── benchmark/YYYY/MM/*.csv
-├── market/YYYY/MM/*.csv
-├── factors/YYYY/MM/*.csv
-└── candidates/YYYY/MM/*.csv
-```
-
-运行后默认生成：
-
-- `output/demo/equity_curve.csv`
-- `output/demo/trades.csv`
-- `output/demo/holdings_summary.csv`
+本仓库只保留核心库构建和测试入口：
 
 ## 测试与构建
 

crates/bt-demo/Cargo.toml

@@ -1,12 +0,0 @@
-[package]
-name = "bt-demo"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-authors.workspace = true
-
-[dependencies]
-chrono = { workspace = true }
-fidc-core = { path = "../fidc-core" }
-serde = { workspace = true }
-serde_json = "1"

crates/bt-demo/src/main.rs

@@ -1,516 +0,0 @@
-use std::collections::BTreeSet;
-use std::error::Error;
-use std::fs;
-use std::io::Write;
-use std::path::{Path, PathBuf};
-
-use chrono::{NaiveDate, NaiveTime};
-use fidc_core::{
-    BacktestConfig, BacktestEngine, BenchmarkSnapshot, BrokerSimulator, ChinaAShareCostModel,
-    ChinaEquityRuleHooks, CnSmallCapRotationConfig, CnSmallCapRotationStrategy, DailyEquityPoint,
-    DataSet, FillEvent, HoldingSummary, OmniMicroCapConfig, OmniMicroCapStrategy, PortfolioState,
-    PriceField, Strategy, StrategyContext,
-};
-use serde_json::json;
-
-fn main() -> Result<(), Box<dyn Error>> {
-    let root = workspace_root();
-    let data_dir = std::env::var("FIDC_BT_DATA_DIR")
-        .map(PathBuf::from)
-        .unwrap_or_else(|_| root.join("data/demo"));
-    let data_layout = std::env::var("FIDC_BT_DATA_LAYOUT").unwrap_or_else(|_| "flat".to_string());
-    let output_dir = std::env::var("FIDC_BT_OUTPUT_DIR")
-        .map(PathBuf::from)
-        .unwrap_or_else(|_| root.join("output/demo"));
-    let json_output = std::env::var("FIDC_BT_JSON")
-        .map(|value| value == "1" || value.eq_ignore_ascii_case("true"))
-        .unwrap_or(false);
-
-    fs::create_dir_all(&output_dir)?;
-
-    let data = if data_layout == "partitioned" {
-        DataSet::from_partitioned_dir(&data_dir)?
-    } else {
-        DataSet::from_csv_dir(&data_dir)?
-    };
-    let strategy_name =
-        std::env::var("FIDC_BT_STRATEGY").unwrap_or_else(|_| "cn-smallcap-rotation".to_string());
-    let debug_date = std::env::var("FIDC_BT_DEBUG_DATE")
-        .ok()
-        .filter(|value| !value.trim().is_empty())
-        .map(|value| NaiveDate::parse_from_str(value.trim(), "%Y-%m-%d"))
-        .transpose()?;
-    let decision_lag = std::env::var("FIDC_BT_DECISION_LAG")
-        .ok()
-        .and_then(|value| value.parse::<usize>().ok());
-    let execution_price =
-        std::env::var("FIDC_BT_EXECUTION_PRICE")
-            .ok()
-            .map(|value| match value.as_str() {
-                "close" => PriceField::Close,
-                "last" => PriceField::Last,
-                _ => PriceField::Open,
-            });
-    let initial_cash = std::env::var("FIDC_BT_INITIAL_CASH")
-        .ok()
-        .and_then(|value| value.parse::<f64>().ok());
-    let start_date = std::env::var("FIDC_BT_START_DATE")
-        .ok()
-        .filter(|value| !value.trim().is_empty())
-        .map(|value| NaiveDate::parse_from_str(value.trim(), "%Y-%m-%d"))
-        .transpose()?;
-    let end_date = std::env::var("FIDC_BT_END_DATE")
-        .ok()
-        .filter(|value| !value.trim().is_empty())
-        .map(|value| NaiveDate::parse_from_str(value.trim(), "%Y-%m-%d"))
-        .transpose()?;
-    let mut config = BacktestConfig {
-        initial_cash: initial_cash.unwrap_or(1_000_000.0),
-        benchmark_code: data.benchmark_code().to_string(),
-        start_date,
-        end_date,
-        decision_lag_trading_days: 1,
-        execution_price_field: PriceField::Open,
-    };
-    let result = match strategy_name.as_str() {
-        "cn-smallcap-rotation" | "cn-dyn-smallcap-band" => {
-            let mut strategy_cfg = if strategy_name == "cn-dyn-smallcap-band" {
-                CnSmallCapRotationConfig::cn_dyn_smallcap_band()
-            } else {
-                CnSmallCapRotationConfig::demo()
-            };
-            if strategy_cfg.strategy_name == "cn-smallcap-rotation" {
-                strategy_cfg.base_index_level = 3000.0;
-                strategy_cfg.base_cap_floor = 38.0;
-                strategy_cfg.cap_span = 25.0;
-            }
-            if let Ok(signal_symbol) = std::env::var("FIDC_BT_SIGNAL_SYMBOL") {
-                if !signal_symbol.trim().is_empty() {
-                    strategy_cfg.signal_symbol = Some(signal_symbol);
-                }
-            }
-            config.decision_lag_trading_days = decision_lag.unwrap_or(1);
-            config.execution_price_field = execution_price.unwrap_or(PriceField::Open);
-            let strategy = CnSmallCapRotationStrategy::new(strategy_cfg);
-            let broker = BrokerSimulator::new_with_execution_price(
-                ChinaAShareCostModel::default(),
-                ChinaEquityRuleHooks::default(),
-                config.execution_price_field,
-            );
-            let mut engine = BacktestEngine::new(data, strategy, broker, config);
-            engine.run()?
-        }
-        _ => {
-            let mut strategy_cfg = OmniMicroCapConfig::omni_microcap();
-            if let Ok(signal_symbol) = std::env::var("FIDC_BT_SIGNAL_SYMBOL") {
-                if !signal_symbol.trim().is_empty() {
-                    strategy_cfg.benchmark_signal_symbol = signal_symbol;
-                }
-            }
-            if let Some(date) = debug_date {
-                let eligible = data.eligible_universe_on(date);
-                eprintln!(
-                    "DEBUG eligible_universe_on {} count={}",
-                    date,
-                    eligible.len()
-                );
-                for row in eligible.iter().take(20) {
-                    eprintln!("  {} {:.6}", row.symbol, row.market_cap_bn);
-                }
-                let mut debug_strategy = OmniMicroCapStrategy::new(strategy_cfg.clone());
-                let debug_subscriptions = BTreeSet::new();
-                let decision = debug_strategy.on_day(&StrategyContext {
-                    execution_date: date,
-                    decision_date: date,
-                    decision_index: 1,
-                    data: &data,
-                    portfolio: &PortfolioState::new(10_000_000.0),
-                    futures_account: None,
-                    open_orders: &[],
-                    dynamic_universe: None,
-                    subscriptions: &debug_subscriptions,
-                    process_events: &[],
-                    active_process_event: None,
-                    active_datetime: None,
-                    order_events: &[],
-                    fills: &[],
-                })?;
-                eprintln!("DEBUG notes={:?}", decision.notes);
-                eprintln!("DEBUG diagnostics={:?}", decision.diagnostics);
-                return Ok(());
-            }
-            config.decision_lag_trading_days = decision_lag.unwrap_or(0);
-            config.execution_price_field = execution_price.unwrap_or(PriceField::Last);
-            config.initial_cash = initial_cash.unwrap_or(10_000_000.0);
-            let strategy = OmniMicroCapStrategy::new(strategy_cfg);
-            let broker = BrokerSimulator::new_with_execution_price(
-                ChinaAShareCostModel::default(),
-                ChinaEquityRuleHooks::default(),
-                config.execution_price_field,
-            )
-            .with_intraday_execution_start_time(
-                NaiveTime::parse_from_str("10:18:00", "%H:%M:%S").expect("valid 10:18:00"),
-            )
-            .with_volume_limit(false)
-            .with_inactive_limit(false)
-            .with_liquidity_limit(false);
-            let mut engine = BacktestEngine::new(data, strategy, broker, config);
-            engine.run()?
-        }
-    };
-
-    write_equity_curve_csv(&output_dir.join("equity_curve.csv"), &result.equity_curve)?;
-    write_trades_csv(&output_dir.join("trades.csv"), &result.fills)?;
-    write_holdings_csv(
-        &output_dir.join("holdings_summary.csv"),
-        &result.holdings_summary,
-    )?;
-
-    let summary = build_summary(
-        &result.strategy_name,
-        &result.equity_curve,
-        &result.fills,
-        &result.holdings_summary,
-        result.benchmark_series.last(),
-        &output_dir,
-    );
-
-    print_summary(&summary, &result.equity_curve, &result.holdings_summary);
-    println!("Artifacts written under {}", output_dir.display());
-    if json_output {
-        println!("{}", serde_json::to_string(&summary)?);
-    }
-    Ok(())
-}
-
-fn workspace_root() -> PathBuf {
-    Path::new(env!("CARGO_MANIFEST_DIR"))
-        .join("../..")
-        .canonicalize()
-        .expect("workspace root")
-}
-
-fn write_equity_curve_csv(path: &Path, rows: &[DailyEquityPoint]) -> Result<(), Box<dyn Error>> {
-    let mut file = fs::File::create(path)?;
-    writeln!(
-        file,
-        "date,cash,market_value,total_equity,benchmark_close,benchmark_prev_close,notes,diagnostics"
-    )?;
-    for row in rows {
-        writeln!(
-            file,
-            "{},{:.2},{:.2},{:.2},{:.2},{:.2},{},{}",
-            row.date,
-            row.cash,
-            row.market_value,
-            row.total_equity,
-            row.benchmark_close,
-            row.benchmark_prev_close,
-            sanitize_csv_field(&row.notes),
-            sanitize_csv_field(&row.diagnostics),
-        )?;
-    }
-    Ok(())
-}
-
-fn write_trades_csv(path: &Path, rows: &[FillEvent]) -> Result<(), Box<dyn Error>> {
-    let mut file = fs::File::create(path)?;
-    writeln!(
-        file,
-        "date,symbol,side,quantity,price,gross_amount,commission,stamp_tax,net_cash_flow,reason"
-    )?;
-    for row in rows {
-        writeln!(
-            file,
-            "{},{},{:?},{},{:.2},{:.2},{:.2},{:.2},{:.2},{}",
-            row.date,
-            row.symbol,
-            row.side,
-            row.quantity,
-            row.price,
-            row.gross_amount,
-            row.commission,
-            row.stamp_tax,
-            row.net_cash_flow,
-            sanitize_csv_field(&row.reason),
-        )?;
-    }
-    Ok(())
-}
-
-fn write_holdings_csv(path: &Path, rows: &[HoldingSummary]) -> Result<(), Box<dyn Error>> {
-    let mut file = fs::File::create(path)?;
-    writeln!(
-        file,
-        "date,symbol,quantity,average_cost,last_price,market_value,unrealized_pnl,realized_pnl"
-    )?;
-    for row in rows {
-        writeln!(
-            file,
-            "{},{},{},{:.2},{:.2},{:.2},{:.2},{:.2}",
-            row.date,
-            row.symbol,
-            row.quantity,
-            row.average_cost,
-            row.last_price,
-            row.market_value,
-            row.unrealized_pnl,
-            row.realized_pnl,
-        )?;
-    }
-    Ok(())
-}
-
-fn sanitize_csv_field(text: &str) -> String {
-    text.replace(',', ";")
-}
-
-#[derive(Debug, serde::Serialize)]
-struct RunSummary {
-    strategy: String,
-    start_date: String,
-    end_date: String,
-    start_equity: f64,
-    final_equity: f64,
-    total_return: f64,
-    trade_count: usize,
-    holding_count: usize,
-    benchmark_code: Option<String>,
-    benchmark_last_close: Option<f64>,
-    output_dir: String,
-    diagnostics: serde_json::Value,
-    warnings: Vec<String>,
-    equity_preview: Vec<serde_json::Value>,
-    trades_preview: Vec<serde_json::Value>,
-}
-
-fn build_summary(
-    strategy_name: &str,
-    equity_curve: &[DailyEquityPoint],
-    fills: &[FillEvent],
-    holdings: &[HoldingSummary],
-    benchmark_last: Option<&BenchmarkSnapshot>,
-    output_dir: &Path,
-) -> RunSummary {
-    let first = equity_curve.first();
-    let last = equity_curve.last();
-    let start_equity = first.map(|row| row.total_equity).unwrap_or_default();
-    let final_equity = last.map(|row| row.total_equity).unwrap_or_default();
-    let total_return = if start_equity.abs() < f64::EPSILON {
-        0.0
-    } else {
-        (final_equity / start_equity) - 1.0
-    };
-
-    let diagnostics = extract_diagnostics(equity_curve);
-    let warnings = build_warnings(fills, holdings, &diagnostics);
-    let equity_preview = equity_curve
-        .iter()
-        .rev()
-        .take(5)
-        .collect::<Vec<_>>()
-        .into_iter()
-        .rev()
-        .map(|row| {
-            json!({
-                "date": row.date.to_string(),
-                "cash": row.cash,
-                "marketValue": row.market_value,
-                "totalEquity": row.total_equity,
-                "benchmarkClose": row.benchmark_close,
-                "benchmarkPrevClose": row.benchmark_prev_close,
-                "notes": row.notes,
-                "diagnostics": row.diagnostics,
-            })
-        })
-        .collect::<Vec<_>>();
-    let trades_preview = fills
-        .iter()
-        .rev()
-        .take(10)
-        .collect::<Vec<_>>()
-        .into_iter()
-        .rev()
-        .map(|row| {
-            json!({
-                "date": row.date.to_string(),
-                "symbol": row.symbol,
-                "side": format!("{:?}", row.side),
-                "quantity": row.quantity,
-                "price": row.price,
-                "grossAmount": row.gross_amount,
-                "netCashFlow": row.net_cash_flow,
-                "reason": row.reason,
-            })
-        })
-        .collect::<Vec<_>>();
-
-    RunSummary {
-        strategy: strategy_name.to_string(),
-        start_date: first.map(|row| row.date.to_string()).unwrap_or_default(),
-        end_date: last.map(|row| row.date.to_string()).unwrap_or_default(),
-        start_equity,
-        final_equity,
-        total_return,
-        trade_count: fills.len(),
-        holding_count: holdings.len(),
-        benchmark_code: benchmark_last.map(|row| row.benchmark.clone()),
-        benchmark_last_close: benchmark_last.map(|row| row.close),
-        output_dir: output_dir.display().to_string(),
-        diagnostics,
-        warnings,
-        equity_preview,
-        trades_preview,
-    }
-}
-
-fn extract_diagnostics(equity_curve: &[DailyEquityPoint]) -> serde_json::Value {
-    let last = equity_curve.last();
-    let text = last.map(|row| row.diagnostics.as_str()).unwrap_or("");
-    let notes = last.map(|row| row.notes.as_str()).unwrap_or("");
-    let mut map = serde_json::Map::new();
-    map.insert("latestText".to_string(), json!(text));
-    map.insert("latestNotes".to_string(), json!(notes));
-    map.insert("equityPointCount".to_string(), json!(equity_curve.len()));
-
-    for part in text.split(" | ") {
-        let part = part.trim();
-        if let Some(rest) = part.strip_prefix("selection_diag ") {
-            for token in rest.split_whitespace() {
-                if let Some((k, v)) = token.split_once('=') {
-                    map.insert(k.to_string(), parse_diag_value(v));
-                }
-            }
-        } else if let Some(rest) = part.strip_prefix("selection_band ") {
-            for token in rest.split_whitespace() {
-                if let Some((k, v)) = token.split_once('=') {
-                    map.insert(k.to_string(), parse_diag_value(v));
-                }
-            }
-        } else if let Some(rest) =
-            part.strip_prefix("market_cap_missing likely blocks selection; sample=")
-        {
-            map.insert(
-                "marketCapMissingSample".to_string(),
-                json!(
-                    rest.split('|')
-                        .filter(|s| !s.is_empty())
-                        .collect::<Vec<_>>()
-                ),
-            );
-        } else if let Some(rest) = part.strip_prefix("selection_rejections sample=") {
-            map.insert(
-                "selectionRejectionsSample".to_string(),
-                json!(
-                    rest.split(" | ")
-                        .filter(|s| !s.is_empty())
-                        .collect::<Vec<_>>()
-                ),
-            );
-        } else if let Some(rest) = part.strip_prefix("ma_filter_rejections sample=") {
-            map.insert(
-                "maFilterRejectionsSample".to_string(),
-                json!(
-                    rest.split('|')
-                        .filter(|s| !s.is_empty())
-                        .collect::<Vec<_>>()
-                ),
-            );
-        } else if let Some(rest) = part.strip_prefix("selected=") {
-            map.insert("selectedLine".to_string(), json!(rest));
-        }
-    }
-
-    serde_json::Value::Object(map)
-}
-
-fn parse_diag_value(value: &str) -> serde_json::Value {
-    if let Ok(v) = value.parse::<i64>() {
-        return json!(v);
-    }
-    if let Ok(v) = value.parse::<f64>() {
-        return json!(v);
-    }
-    json!(value)
-}
-
-fn build_warnings(
-    fills: &[FillEvent],
-    holdings: &[HoldingSummary],
-    diagnostics: &serde_json::Value,
-) -> Vec<String> {
-    let mut warnings = Vec::new();
-    if fills.is_empty() {
-        warnings.push("本次回测没有产生任何成交。".to_string());
-    }
-    if holdings.is_empty() {
-        warnings.push("期末没有持仓。".to_string());
-    }
-    let selected_after_ma_is_empty = diagnostics
-        .get("selected_after_ma")
-        .and_then(|v| v.as_i64())
-        .unwrap_or(0)
-        == 0;
-    if selected_after_ma_is_empty && fills.is_empty() && holdings.is_empty() {
-        warnings
-            .push("最终没有股票通过完整选股链路，结果为空时请优先查看 diagnostics。".to_string());
-    }
-    if diagnostics
-        .get("market_cap_missing_count")
-        .and_then(|v| v.as_i64())
-        .unwrap_or(0)
-        > 0
-    {
-        warnings.push("存在 market_cap 缺失或非正值，当前会直接阻断该股票进入候选池。".to_string());
-    }
-    warnings
-}
-
-fn print_summary(
-    summary: &RunSummary,
-    equity_curve: &[DailyEquityPoint],
-    holdings: &[HoldingSummary],
-) {
-    if equity_curve.is_empty() {
-        println!("No equity curve points generated.");
-        return;
-    }
-
-    println!("Strategy: {}", summary.strategy);
-    println!("Start equity: {:.2}", summary.start_equity);
-    println!("Final equity: {:.2}", summary.final_equity);
-    println!("Total return: {:.2}%", summary.total_return * 100.0);
-    println!("Trades: {}", summary.trade_count);
-    println!("Final holdings: {}", summary.holding_count);
-
-    if let (Some(code), Some(close)) = (&summary.benchmark_code, summary.benchmark_last_close) {
-        println!("Benchmark last close: {} {:.2}", code, close);
-    }
-
-    println!("Recent equity points:");
-    for point in equity_curve
-        .iter()
-        .rev()
-        .take(3)
-        .collect::<Vec<_>>()
-        .into_iter()
-        .rev()
-    {
-        println!(
-            "  {} equity {:.2} cash {:.2} mv {:.2}",
-            point.date, point.total_equity, point.cash, point.market_value
-        );
-    }
-
-    if holdings.is_empty() {
-        println!("No holdings at the end of the demo run.");
-    } else {
-        println!("Ending holdings:");
-        for holding in holdings {
-            println!(
-                "  {} qty {} mv {:.2} pnl {:.2}",
-                holding.symbol, holding.quantity, holding.market_value, holding.unrealized_pnl
-            );
-        }
-    }
-}

crates/fidc-core/Cargo.toml

@@ -6,8 +6,10 @@ license.workspace = true
 authors.workspace = true
 
 [dependencies]
+ahash.workspace = true
 chrono.workspace = true
 indexmap.workspace = true
+rayon.workspace = true
 rhai.workspace = true
 serde.workspace = true
 serde_json.workspace = true

crates/fidc-core/src/cost.rs

@@ -3,18 +3,32 @@ use std::collections::BTreeMap;
 use chrono::NaiveDate;
 
 use crate::events::OrderSide;
-
-pub const STOCK_PIT_TAX_CHANGE_DATE: (i32, u32, u32) = (2023, 8, 28);
+use crate::fixed_point::{FixedChinaAShareCostModel, FixedMoney, FixedTradingCost};
+use crate::risk_control::TradingConstraintConfig;
 
 #[derive(Debug, Clone, Copy)]
 pub struct TradingCost {
     pub commission: f64,
     pub stamp_tax: f64,
+    pub transfer_fee: f64,
 }
 
 impl TradingCost {
     pub fn total(self) -> f64 {
-        self.commission + self.stamp_tax
+        self.fixed_total().to_f64()
+    }
+
+    pub fn fixed_total(self) -> FixedMoney {
+        FixedMoney::checked_sum_f64([self.commission, self.stamp_tax, self.transfer_fee])
+            .expect("trading costs must be finite fixed-point money")
+    }
+
+    fn from_fixed(value: FixedTradingCost) -> Self {
+        Self {
+            commission: value.commission.to_f64(),
+            stamp_tax: value.stamp_tax.to_f64(),
+            transfer_fee: value.transfer_fee.to_f64(),
+        }
     }
 }
 
@@ -35,50 +49,133 @@ pub trait CostModel {
 
 #[derive(Debug, Clone, Copy)]
 pub struct ChinaAShareCostModel {
-    pub commission_rate: f64,
-    pub stamp_tax_rate_before_change: f64,
-    pub stamp_tax_rate_after_change: f64,
-    pub minimum_commission: f64,
+    fixed: FixedChinaAShareCostModel,
 }
 
 impl Default for ChinaAShareCostModel {
     fn default() -> Self {
-        Self {
-            commission_rate: 0.0003,
-            stamp_tax_rate_before_change: 0.001,
-            stamp_tax_rate_after_change: 0.0005,
-            minimum_commission: 5.0,
-        }
+        Self::from_trading_constraints(TradingConstraintConfig::default())
     }
 }
 
 impl ChinaAShareCostModel {
+    pub fn from_trading_constraints(config: TradingConstraintConfig) -> Self {
+        Self {
+            fixed: FixedChinaAShareCostModel {
+                commission_rate: Self::fixed_money(config.commission_rate, "commission rate"),
+                stamp_tax_rate_before_change: Self::fixed_money(
+                    config.stamp_tax_rate_before_change,
+                    "stamp tax rate before change",
+                ),
+                stamp_tax_rate_after_change: Self::fixed_money(
+                    config.stamp_tax_rate_after_change,
+                    "stamp tax rate after change",
+                ),
+                stamp_tax_change_date: config.stamp_tax_change_date,
+                minimum_commission: Self::fixed_money(
+                    config.minimum_commission,
+                    "minimum commission",
+                ),
+                transfer_fee_rate: Self::fixed_money(config.transfer_fee_rate, "transfer fee rate"),
+            },
+        }
+    }
+
+    pub fn set_commission_rate(&mut self, value: f64) {
+        self.fixed.commission_rate = Self::fixed_money(value, "commission rate");
+    }
+
+    pub fn set_minimum_commission(&mut self, value: f64) {
+        self.fixed.minimum_commission = Self::fixed_money(value, "minimum commission");
+    }
+
+    pub fn set_transfer_fee_rate(&mut self, value: f64) {
+        self.fixed.transfer_fee_rate = Self::fixed_money(value, "transfer fee rate");
+    }
+
+    pub fn set_stamp_tax_rate_before_change(&mut self, value: f64) {
+        self.fixed.stamp_tax_rate_before_change =
+            Self::fixed_money(value, "stamp tax rate before change");
+    }
+
+    pub fn set_stamp_tax_rate_after_change(&mut self, value: f64) {
+        self.fixed.stamp_tax_rate_after_change =
+            Self::fixed_money(value, "stamp tax rate after change");
+    }
+
+    pub fn set_stamp_tax_change_date(&mut self, value: NaiveDate) {
+        self.fixed.stamp_tax_change_date = value;
+    }
+
+    pub fn commission_rate(&self) -> f64 {
+        self.fixed.commission_rate.to_f64()
+    }
+
+    pub fn minimum_commission(&self) -> f64 {
+        self.fixed.minimum_commission.to_f64()
+    }
+
+    pub fn transfer_fee_rate(&self) -> f64 {
+        self.fixed.transfer_fee_rate.to_f64()
+    }
+
+    pub fn stamp_tax_rate_before_change(&self) -> f64 {
+        self.fixed.stamp_tax_rate_before_change.to_f64()
+    }
+
+    pub fn stamp_tax_rate_after_change(&self) -> f64 {
+        self.fixed.stamp_tax_rate_after_change.to_f64()
+    }
+
+    pub fn stamp_tax_change_date(&self) -> NaiveDate {
+        self.fixed.stamp_tax_change_date
+    }
+
+    pub fn with_commission_rate(mut self, value: f64) -> Self {
+        self.set_commission_rate(value);
+        self
+    }
+
+    pub fn with_minimum_commission(mut self, value: f64) -> Self {
+        self.set_minimum_commission(value);
+        self
+    }
+
+    pub fn with_stamp_tax_rates(mut self, before: f64, after: f64) -> Self {
+        self.set_stamp_tax_rate_before_change(before);
+        self.set_stamp_tax_rate_after_change(after);
+        self
+    }
+
     pub fn commission_for(&self, gross_amount: f64) -> f64 {
         if gross_amount <= 0.0 {
             return 0.0;
         }
-        (gross_amount * self.commission_rate).max(self.minimum_commission)
+        self.fixed_model()
+            .commission_for(Self::fixed_money(gross_amount, "gross amount"))
+            .to_f64()
     }
 
     pub fn stamp_tax_rate_for(&self, date: NaiveDate) -> f64 {
-        let change_date = NaiveDate::from_ymd_opt(
-            STOCK_PIT_TAX_CHANGE_DATE.0,
-            STOCK_PIT_TAX_CHANGE_DATE.1,
-            STOCK_PIT_TAX_CHANGE_DATE.2,
-        )
-        .expect("valid pit tax change date");
-        if date < change_date {
-            self.stamp_tax_rate_before_change
-        } else {
-            self.stamp_tax_rate_after_change
-        }
+        self.fixed.stamp_tax_rate_for(date).to_f64()
     }
 
     pub fn stamp_tax_for(&self, date: NaiveDate, side: OrderSide, gross_amount: f64) -> f64 {
         if gross_amount <= 0.0 || side == OrderSide::Buy {
             return 0.0;
         }
-        gross_amount * self.stamp_tax_rate_for(date)
+        self.fixed_model()
+            .stamp_tax_for(date, side, Self::fixed_money(gross_amount, "gross amount"))
+            .to_f64()
+    }
+
+    pub fn transfer_fee_for(&self, gross_amount: f64) -> f64 {
+        if gross_amount <= 0.0 {
+            return 0.0;
+        }
+        self.fixed_model()
+            .transfer_fee_for(Self::fixed_money(gross_amount, "gross amount"))
+            .to_f64()
     }
 
     pub fn commission_for_order_fill(
@@ -91,31 +188,29 @@ impl ChinaAShareCostModel {
             return 0.0;
         }
 
-        let raw_commission = gross_amount * self.commission_rate;
         let Some(order_id) = order_id else {
-            return raw_commission.max(self.minimum_commission);
+            return self.commission_for(gross_amount);
         };
 
         let remaining_minimum = commission_state
             .entry(order_id)
-            .or_insert(self.minimum_commission);
-        if raw_commission > *remaining_minimum {
-            let charged = if (*remaining_minimum - self.minimum_commission).abs() < 1e-12 {
-                raw_commission
-            } else {
-                raw_commission - *remaining_minimum
-            };
-            *remaining_minimum = 0.0;
-            charged
-        } else {
-            let charged = if (*remaining_minimum - self.minimum_commission).abs() < 1e-12 {
-                self.minimum_commission
-            } else {
-                0.0
-            };
-            *remaining_minimum -= raw_commission;
-            charged
-        }
+            .or_insert(self.fixed.minimum_commission.to_f64());
+        let mut fixed_remaining = Self::fixed_money(*remaining_minimum, "remaining commission");
+        let charged = self.fixed_model().commission_for_order_fill_remaining(
+            Self::fixed_money(gross_amount, "gross amount"),
+            &mut fixed_remaining,
+        );
+        *remaining_minimum = fixed_remaining.to_f64();
+        charged.to_f64()
+    }
+
+    fn fixed_money(value: f64, label: &str) -> FixedMoney {
+        FixedMoney::from_f64(value)
+            .unwrap_or_else(|| panic!("{label} is not representable as fixed-point money: {value}"))
+    }
+
+    fn fixed_model(&self) -> FixedChinaAShareCostModel {
+        self.fixed
     }
 }
 
@@ -125,16 +220,15 @@ impl CostModel for ChinaAShareCostModel {
             return TradingCost {
                 commission: 0.0,
                 stamp_tax: 0.0,
+                transfer_fee: 0.0,
             };
         }
 
-        let commission = self.commission_for(gross_amount);
-        let stamp_tax = self.stamp_tax_for(date, side, gross_amount);
-
-        TradingCost {
-            commission,
-            stamp_tax,
-        }
+        TradingCost::from_fixed(self.fixed_model().calculate(
+            date,
+            side,
+            Self::fixed_money(gross_amount, "gross amount"),
+        ))
     }
 
     fn calculate_with_order_state(
@@ -149,15 +243,79 @@ impl CostModel for ChinaAShareCostModel {
             return TradingCost {
                 commission: 0.0,
                 stamp_tax: 0.0,
+                transfer_fee: 0.0,
             };
         }
 
-        let commission = self.commission_for_order_fill(gross_amount, order_id, commission_state);
-        let stamp_tax = self.stamp_tax_for(date, side, gross_amount);
-
-        TradingCost {
+        let fixed_model = self.fixed_model();
+        let fixed_gross = Self::fixed_money(gross_amount, "gross amount");
+        let commission = if let Some(order_id) = order_id {
+            let remaining = commission_state
+                .entry(order_id)
+                .or_insert(self.fixed.minimum_commission.to_f64());
+            let mut fixed_remaining = Self::fixed_money(*remaining, "remaining commission");
+            let commission =
+                fixed_model.commission_for_order_fill_remaining(fixed_gross, &mut fixed_remaining);
+            *remaining = fixed_remaining.to_f64();
+            commission
+        } else {
+            fixed_model.commission_for(fixed_gross)
+        };
+        TradingCost::from_fixed(FixedTradingCost {
             commission,
-            stamp_tax,
-        }
+            stamp_tax: fixed_model.stamp_tax_for(date, side, fixed_gross),
+            transfer_fee: fixed_model.transfer_fee_for(fixed_gross),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn default_quantizes_fees_to_micro_yuan() {
+        let model = ChinaAShareCostModel::default();
+        let date = NaiveDate::from_ymd_opt(2025, 11, 11).expect("valid date");
+
+        assert!((model.commission_for(248_059.812) - 74.417944).abs() < 1e-12);
+        assert!(
+            (model.stamp_tax_for(date, OrderSide::Sell, 245_747.007) - 122.873504).abs() < 1e-12
+        );
+    }
+
+    #[test]
+    fn cost_model_can_use_configurable_stamp_tax_change_date() {
+        let config = TradingConstraintConfig {
+            commission_rate: 0.0003,
+            minimum_commission: 5.0,
+            transfer_fee_rate: 0.00001,
+            stamp_tax_rate_before_change: 0.002,
+            stamp_tax_rate_after_change: 0.001,
+            stamp_tax_change_date: NaiveDate::from_ymd_opt(2025, 1, 10).expect("valid date"),
+            ..TradingConstraintConfig::default()
+        };
+        let model = ChinaAShareCostModel::from_trading_constraints(config);
+
+        assert!((model.transfer_fee_for(10_000.0) - 0.1).abs() < 1e-12);
+
+        assert!(
+            (model.stamp_tax_for(
+                NaiveDate::from_ymd_opt(2025, 1, 9).expect("valid date"),
+                OrderSide::Sell,
+                10_000.0
+            ) - 20.0)
+                .abs()
+                < 1e-9
+        );
+        assert!(
+            (model.stamp_tax_for(
+                NaiveDate::from_ymd_opt(2025, 1, 10).expect("valid date"),
+                OrderSide::Sell,
+                10_000.0
+            ) - 10.0)
+                .abs()
+                < 1e-9
+        );
     }
 }

crates/fidc-core/src/event_bus.rs

@@ -125,6 +125,15 @@ impl ProcessEventBus {
         loader.install_enabled(self, enabled_names)
     }
 
+    pub fn has_listeners_for(&self, kinds: &[ProcessEventKind]) -> bool {
+        !self.any_listeners.is_empty()
+            || kinds.iter().any(|kind| {
+                self.listeners
+                    .get(kind)
+                    .is_some_and(|listeners| !listeners.is_empty())
+            })
+    }
+
     pub fn publish(&mut self, event: &ProcessEvent) {
         if let Some(listeners) = self.listeners.get_mut(&event.kind) {
             for listener in listeners {

crates/fidc-core/src/events.rs

@@ -1,4 +1,4 @@
-use chrono::NaiveDate;
+use chrono::{NaiveDate, NaiveDateTime};
 use serde::{Deserialize, Serialize};
 
 mod date_format {
@@ -23,6 +23,62 @@ mod date_format {
     }
 }
 
+mod optional_date_format {
+    use chrono::NaiveDate;
+    use serde::{self, Deserialize, Deserializer, Serializer};
+
+    const FORMAT: &str = "%Y-%m-%d";
+
+    pub fn serialize<S>(date: &Option<NaiveDate>, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match date {
+            Some(date) => serializer.serialize_some(&date.format(FORMAT).to_string()),
+            None => serializer.serialize_none(),
+        }
+    }
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<NaiveDate>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let value = Option::<String>::deserialize(deserializer)?;
+        value
+            .map(|text| NaiveDate::parse_from_str(&text, FORMAT).map_err(serde::de::Error::custom))
+            .transpose()
+    }
+}
+
+mod optional_datetime_format {
+    use chrono::NaiveDateTime;
+    use serde::{self, Deserialize, Deserializer, Serializer};
+
+    const FORMAT: &str = "%Y-%m-%d %H:%M:%S%.f";
+
+    pub fn serialize<S>(datetime: &Option<NaiveDateTime>, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match datetime {
+            Some(datetime) => serializer.serialize_some(&datetime.format(FORMAT).to_string()),
+            None => serializer.serialize_none(),
+        }
+    }
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<NaiveDateTime>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let value = Option::<String>::deserialize(deserializer)?;
+        value
+            .map(|text| {
+                NaiveDateTime::parse_from_str(&text, FORMAT).map_err(serde::de::Error::custom)
+            })
+            .transpose()
+    }
+}
+
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
 pub enum OrderSide {
     Buy,
@@ -45,6 +101,7 @@ pub enum OrderStatus {
     PartiallyFilled,
     Canceled,
     Rejected,
+    Expired,
 }
 
 impl OrderStatus {
@@ -55,6 +112,7 @@ impl OrderStatus {
             Self::PartiallyFilled => "partially_filled",
             Self::Canceled => "canceled",
             Self::Rejected => "rejected",
+            Self::Expired => "expired",
         }
     }
 }
@@ -63,6 +121,12 @@ impl OrderStatus {
 pub struct OrderEvent {
     #[serde(with = "date_format")]
     pub date: NaiveDate,
+    #[serde(default, with = "optional_date_format")]
+    pub decision_date: Option<NaiveDate>,
+    #[serde(default, with = "optional_date_format")]
+    pub order_created_date: Option<NaiveDate>,
+    #[serde(default, with = "optional_date_format")]
+    pub execution_date: Option<NaiveDate>,
     #[serde(default)]
     pub order_id: Option<u64>,
     pub symbol: String,
@@ -73,10 +137,72 @@ pub struct OrderEvent {
     pub reason: String,
 }
 
+impl OrderEvent {
+    pub fn validate(&self) -> Result<(), String> {
+        if self.symbol.trim().is_empty() || self.requested_quantity == 0 {
+            return Err(format!(
+                "invalid order identity/quantity order_id={:?} symbol={} requested={}",
+                self.order_id, self.symbol, self.requested_quantity
+            ));
+        }
+        if self.filled_quantity > self.requested_quantity {
+            return Err(format!(
+                "order overfill order_id={:?} requested={} filled={}",
+                self.order_id, self.requested_quantity, self.filled_quantity
+            ));
+        }
+        let quantity_valid = match self.status {
+            OrderStatus::Pending => self.filled_quantity < self.requested_quantity,
+            OrderStatus::Filled => self.filled_quantity == self.requested_quantity,
+            OrderStatus::PartiallyFilled => {
+                self.filled_quantity > 0 && self.filled_quantity < self.requested_quantity
+            }
+            OrderStatus::Canceled => self.filled_quantity < self.requested_quantity,
+            OrderStatus::Rejected => self.filled_quantity == 0,
+            OrderStatus::Expired => self.filled_quantity < self.requested_quantity,
+        };
+        if !quantity_valid {
+            return Err(format!(
+                "order status/quantity mismatch order_id={:?} status={} requested={} filled={}",
+                self.order_id,
+                self.status.as_str(),
+                self.requested_quantity,
+                self.filled_quantity
+            ));
+        }
+        if self.reason.trim().is_empty() {
+            return Err(format!(
+                "order reason is empty order_id={:?} status={}",
+                self.order_id,
+                self.status.as_str()
+            ));
+        }
+        Ok(())
+    }
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct FillEvent {
     #[serde(with = "date_format")]
     pub date: NaiveDate,
+    #[serde(default, with = "optional_date_format")]
+    pub decision_date: Option<NaiveDate>,
+    #[serde(default, with = "optional_date_format")]
+    pub order_created_date: Option<NaiveDate>,
+    #[serde(default, with = "optional_date_format")]
+    pub execution_date: Option<NaiveDate>,
+    #[serde(
+        default,
+        with = "optional_datetime_format",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub execution_start_timestamp: Option<NaiveDateTime>,
+    #[serde(
+        default,
+        with = "optional_datetime_format",
+        skip_serializing_if = "Option::is_none"
+    )]
+    pub execution_timestamp: Option<NaiveDateTime>,
     #[serde(default)]
     pub order_id: Option<u64>,
     pub symbol: String,
@@ -86,10 +212,47 @@ pub struct FillEvent {
     pub gross_amount: f64,
     pub commission: f64,
     pub stamp_tax: f64,
+    pub transfer_fee: f64,
     pub net_cash_flow: f64,
     pub reason: String,
 }
 
+impl FillEvent {
+    pub fn validate(&self) -> Result<(), String> {
+        if self.symbol.trim().is_empty()
+            || self.quantity == 0
+            || !self.price.is_finite()
+            || self.price <= 0.0
+        {
+            return Err(format!(
+                "invalid fill identity/quantity/price order_id={:?} symbol={} quantity={} price={}",
+                self.order_id, self.symbol, self.quantity, self.price
+            ));
+        }
+        if let (Some(start), Some(end)) = (self.execution_start_timestamp, self.execution_timestamp)
+        {
+            if start > end {
+                return Err(format!(
+                    "fill execution timestamp order is invalid order_id={:?} start={} end={}",
+                    self.order_id, start, end
+                ));
+            }
+            if start.date() != self.date || end.date() != self.date {
+                return Err(format!(
+                    "fill execution timestamp date mismatch order_id={:?} fill_date={} start={} end={}",
+                    self.order_id, self.date, start, end
+                ));
+            }
+        } else if self.execution_start_timestamp.is_some() || self.execution_timestamp.is_some() {
+            return Err(format!(
+                "fill execution timestamp range is incomplete order_id={:?}",
+                self.order_id
+            ));
+        }
+        Ok(())
+    }
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct PositionEvent {
     #[serde(with = "date_format")]
@@ -123,9 +286,9 @@ pub enum ProcessEventKind {
     PreBar,
     Bar,
     PostBar,
-    PreTick,
-    Tick,
-    PostTick,
+    PreMinute,
+    Minute,
+    PostMinute,
     PreScheduled,
     PostScheduled,
     PreOnDay,
@@ -143,6 +306,9 @@ pub enum ProcessEventKind {
     OrderPendingCancel,
     OrderCancellationPass,
     OrderCancellationReject,
+    OrderPendingUpdate,
+    OrderUpdatePass,
+    OrderUpdateReject,
     OrderUnsolicitedUpdate,
     Trade,
     UniverseUpdated,
@@ -165,9 +331,9 @@ impl ProcessEventKind {
             Self::PreBar => "pre_bar",
             Self::Bar => "bar",
             Self::PostBar => "post_bar",
-            Self::PreTick => "pre_tick",
-            Self::Tick => "tick",
-            Self::PostTick => "post_tick",
+            Self::PreMinute => "pre_minute",
+            Self::Minute => "minute",
+            Self::PostMinute => "post_minute",
             Self::PreScheduled => "pre_scheduled",
             Self::PostScheduled => "post_scheduled",
             Self::PreOnDay => "pre_on_day",
@@ -185,6 +351,9 @@ impl ProcessEventKind {
             Self::OrderPendingCancel => "order_pending_cancel",
             Self::OrderCancellationPass => "order_cancellation_pass",
             Self::OrderCancellationReject => "order_cancellation_reject",
+            Self::OrderPendingUpdate => "order_pending_update",
+            Self::OrderUpdatePass => "order_update_pass",
+            Self::OrderUpdateReject => "order_update_reject",
             Self::OrderUnsolicitedUpdate => "order_unsolicited_update",
             Self::Trade => "trade",
             Self::UniverseUpdated => "universe_updated",
@@ -195,6 +364,38 @@ impl ProcessEventKind {
             Self::AccountManagementFee => "account_management_fee",
         }
     }
+
+    /// Returns whether the event is part of the durable business lifecycle
+    /// audit. Phase boundary events are useful during interactive debugging,
+    /// but retaining every minute phase marker for a long run is unnecessary.
+    pub fn is_business_lifecycle(&self) -> bool {
+        matches!(
+            *self,
+            Self::PreScheduled
+                | Self::PostScheduled
+                | Self::PreOnDay
+                | Self::OnDay
+                | Self::PostOnDay
+                | Self::OrderPendingNew
+                | Self::OrderCreationPass
+                | Self::OrderCreationReject
+                | Self::OrderPendingCancel
+                | Self::OrderCancellationPass
+                | Self::OrderCancellationReject
+                | Self::OrderPendingUpdate
+                | Self::OrderUpdatePass
+                | Self::OrderUpdateReject
+                | Self::OrderUnsolicitedUpdate
+                | Self::Trade
+                | Self::UniverseUpdated
+                | Self::UniverseSubscribed
+                | Self::UniverseUnsubscribed
+                | Self::AccountDepositWithdraw
+                | Self::AccountFinanceRepay
+                | Self::AccountManagementFee
+                | Self::Settlement
+        )
+    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -210,3 +411,116 @@ pub struct ProcessEvent {
     pub side: Option<OrderSide>,
     pub detail: String,
 }
+
+#[cfg(test)]
+mod tests {
+    use chrono::{NaiveDate, NaiveDateTime};
+
+    use super::{FillEvent, OrderEvent, OrderSide, OrderStatus, ProcessEventKind};
+
+    fn order_event(status: OrderStatus, filled_quantity: u32) -> OrderEvent {
+        OrderEvent {
+            date: NaiveDate::from_ymd_opt(2025, 1, 2).unwrap(),
+            decision_date: None,
+            order_created_date: None,
+            execution_date: None,
+            order_id: Some(1),
+            symbol: "600000.SH".to_string(),
+            side: OrderSide::Buy,
+            requested_quantity: 100,
+            filled_quantity,
+            status,
+            reason: "test".to_string(),
+        }
+    }
+
+    #[test]
+    fn order_event_status_quantity_contract_is_explicit() {
+        assert!(order_event(OrderStatus::Pending, 0).validate().is_ok());
+        assert!(
+            order_event(OrderStatus::PartiallyFilled, 40)
+                .validate()
+                .is_ok()
+        );
+        assert!(order_event(OrderStatus::Filled, 100).validate().is_ok());
+        assert!(order_event(OrderStatus::Canceled, 40).validate().is_ok());
+        assert!(order_event(OrderStatus::Rejected, 0).validate().is_ok());
+        assert!(order_event(OrderStatus::Expired, 40).validate().is_ok());
+
+        assert!(
+            order_event(OrderStatus::PartiallyFilled, 0)
+                .validate()
+                .is_err()
+        );
+        assert!(order_event(OrderStatus::Filled, 99).validate().is_err());
+        assert!(order_event(OrderStatus::Canceled, 100).validate().is_err());
+        assert!(order_event(OrderStatus::Rejected, 1).validate().is_err());
+        assert!(order_event(OrderStatus::Expired, 100).validate().is_err());
+    }
+
+    fn fill_event(start: Option<NaiveDateTime>, end: Option<NaiveDateTime>) -> FillEvent {
+        FillEvent {
+            date: NaiveDate::from_ymd_opt(2025, 1, 2).unwrap(),
+            decision_date: None,
+            order_created_date: None,
+            execution_date: None,
+            execution_start_timestamp: start,
+            execution_timestamp: end,
+            order_id: Some(1),
+            symbol: "600000.SH".to_string(),
+            side: OrderSide::Buy,
+            quantity: 100,
+            price: 10.0,
+            gross_amount: 1_000.0,
+            commission: 5.0,
+            stamp_tax: 0.0,
+            transfer_fee: 0.0,
+            net_cash_flow: -1_005.0,
+            reason: "test".to_string(),
+        }
+    }
+
+    #[test]
+    fn fill_execution_timestamp_range_is_explicit_and_backward_compatible() {
+        let start = NaiveDate::from_ymd_opt(2025, 1, 2)
+            .unwrap()
+            .and_hms_opt(10, 18, 0)
+            .unwrap();
+        let end = start + chrono::Duration::seconds(3);
+        assert!(fill_event(Some(start), Some(end)).validate().is_ok());
+        assert!(fill_event(Some(end), Some(start)).validate().is_err());
+        assert!(fill_event(Some(start), None).validate().is_err());
+
+        let next_day = start + chrono::Duration::days(1);
+        assert!(
+            fill_event(Some(next_day), Some(next_day))
+                .validate()
+                .is_err()
+        );
+
+        let legacy = fill_event(None, None);
+        let legacy_json = serde_json::to_value(&legacy).unwrap();
+        assert!(legacy_json.get("execution_start_timestamp").is_none());
+        assert!(legacy_json.get("execution_timestamp").is_none());
+        let decoded: FillEvent = serde_json::from_value(legacy_json).unwrap();
+        assert_eq!(decoded.execution_start_timestamp, None);
+        assert_eq!(decoded.execution_timestamp, None);
+
+        let timestamped_json = serde_json::to_value(fill_event(Some(start), Some(end))).unwrap();
+        assert_eq!(
+            timestamped_json["execution_start_timestamp"],
+            "2025-01-02 10:18:00"
+        );
+        assert_eq!(
+            timestamped_json["execution_timestamp"],
+            "2025-01-02 10:18:03"
+        );
+    }
+    #[test]
+    fn process_event_business_lifecycle_filter_keeps_audit_events_only() {
+        assert!(ProcessEventKind::OrderUpdateReject.is_business_lifecycle());
+        assert!(ProcessEventKind::Settlement.is_business_lifecycle());
+        assert!(!ProcessEventKind::PreMinute.is_business_lifecycle());
+        assert!(!ProcessEventKind::PostBar.is_business_lifecycle());
+    }
+}

crates/fidc-core/src/fixed_point.rs

@@ -0,0 +1,566 @@
+//! Fixed-point execution primitives for money and fee arithmetic.
+//!
+//! Market data and analytics remain floating point at their API boundaries.
+//! The execution kernel quantizes monetary values to micro-yuan before fee,
+//! budget and cash-ledger arithmetic so repeated fills and external cash flows
+//! do not accumulate binary floating-point drift.
+
+use std::collections::{BTreeMap, VecDeque};
+
+use chrono::NaiveDate;
+
+use crate::events::OrderSide;
+
+pub const MONEY_SCALE: i128 = 1_000_000;
+const MONEY_SCALE_F64: f64 = MONEY_SCALE as f64;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
+pub struct FixedMoney(i128);
+
+impl FixedMoney {
+    pub const ZERO: Self = Self(0);
+
+    pub const fn from_raw(raw: i128) -> Self {
+        Self(raw)
+    }
+
+    pub const fn raw(self) -> i128 {
+        self.0
+    }
+
+    pub fn from_decimal_str(value: &str) -> Result<Self, String> {
+        let value = value.trim();
+        if value.is_empty() {
+            return Err("fixed money value is empty".to_string());
+        }
+        let (negative, unsigned) = match value.as_bytes()[0] {
+            b'-' => (true, &value[1..]),
+            b'+' => (false, &value[1..]),
+            _ => (false, value),
+        };
+        let mut parts = unsigned.split('.');
+        let whole = parts.next().unwrap_or_default();
+        let fractional = parts.next().unwrap_or_default();
+        if parts.next().is_some()
+            || whole.is_empty()
+            || !whole.bytes().all(|byte| byte.is_ascii_digit())
+            || !fractional.bytes().all(|byte| byte.is_ascii_digit())
+        {
+            return Err(format!("invalid fixed money decimal: {value}"));
+        }
+        let whole = whole
+            .parse::<i128>()
+            .map_err(|_| format!("fixed money whole part is out of range: {value}"))?;
+        let mut fractional_digits = fractional.as_bytes().to_vec();
+        let round_up = fractional_digits.len() > 6 && fractional_digits[6] >= b'5';
+        fractional_digits.truncate(6);
+        while fractional_digits.len() < 6 {
+            fractional_digits.push(b'0');
+        }
+        let fractional = if fractional_digits.is_empty() {
+            0
+        } else {
+            std::str::from_utf8(&fractional_digits)
+                .expect("fractional digits are ASCII")
+                .parse::<i128>()
+                .map_err(|_| format!("fixed money fractional part is invalid: {value}"))?
+        };
+        let mut raw = whole
+            .checked_mul(MONEY_SCALE)
+            .and_then(|raw| raw.checked_add(fractional))
+            .ok_or_else(|| format!("fixed money value is out of range: {value}"))?;
+        if round_up {
+            raw = raw
+                .checked_add(1)
+                .ok_or_else(|| format!("fixed money value is out of range: {value}"))?;
+        }
+        Ok(Self(if negative { -raw } else { raw }))
+    }
+
+    pub fn from_f64(value: f64) -> Option<Self> {
+        if !value.is_finite() {
+            return None;
+        }
+        let raw = (value * MONEY_SCALE_F64).round();
+        if !raw.is_finite() || raw < i128::MIN as f64 || raw > i128::MAX as f64 {
+            return None;
+        }
+        Some(Self(raw as i128))
+    }
+
+    pub fn to_f64(self) -> f64 {
+        self.0 as f64 / MONEY_SCALE_F64
+    }
+
+    pub fn checked_add(self, other: Self) -> Option<Self> {
+        self.0.checked_add(other.0).map(Self)
+    }
+
+    pub fn checked_sub(self, other: Self) -> Option<Self> {
+        self.0.checked_sub(other.0).map(Self)
+    }
+
+    pub fn checked_mul_quantity(self, quantity: u64) -> Option<Self> {
+        self.0.checked_mul(i128::from(quantity)).map(Self)
+    }
+
+    pub fn checked_neg(self) -> Option<Self> {
+        self.0.checked_neg().map(Self)
+    }
+
+    pub fn checked_mul_rate(self, rate: Self) -> Option<Self> {
+        let product = self.0.checked_mul(rate.0)?;
+        let half = MONEY_SCALE / 2;
+        let rounded = if product >= 0 {
+            product.checked_add(half)? / MONEY_SCALE
+        } else {
+            product.checked_sub(half)? / MONEY_SCALE
+        };
+        Some(Self(rounded))
+    }
+
+    pub fn checked_sum_f64(values: impl IntoIterator<Item = f64>) -> Option<Self> {
+        values.into_iter().try_fold(Self::ZERO, |total, value| {
+            total.checked_add(Self::from_f64(value)?)
+        })
+    }
+
+    pub fn f64_fits_within(value: f64, limit: f64) -> Option<bool> {
+        let value = Self::from_f64(value)?;
+        if limit == f64::INFINITY {
+            return Some(true);
+        }
+        Some(value <= Self::from_f64(limit)?)
+    }
+
+    pub fn abs(self) -> Self {
+        Self(self.0.abs())
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub struct FixedTradingCost {
+    pub commission: FixedMoney,
+    pub stamp_tax: FixedMoney,
+    pub transfer_fee: FixedMoney,
+}
+
+impl FixedTradingCost {
+    pub fn total(self) -> FixedMoney {
+        FixedMoney::from_raw(self.commission.raw() + self.stamp_tax.raw() + self.transfer_fee.raw())
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct FixedChinaAShareCostModel {
+    pub commission_rate: FixedMoney,
+    pub stamp_tax_rate_before_change: FixedMoney,
+    pub stamp_tax_rate_after_change: FixedMoney,
+    pub stamp_tax_change_date: NaiveDate,
+    pub minimum_commission: FixedMoney,
+    pub transfer_fee_rate: FixedMoney,
+}
+
+impl FixedChinaAShareCostModel {
+    pub fn commission_for(self, gross_amount: FixedMoney) -> FixedMoney {
+        if gross_amount.raw() <= 0 {
+            return FixedMoney::ZERO;
+        }
+        let raw = gross_amount
+            .checked_mul_rate(self.commission_rate)
+            .expect("fixed commission multiplication overflow");
+        raw.max(self.minimum_commission)
+    }
+
+    pub fn stamp_tax_rate_for(self, date: NaiveDate) -> FixedMoney {
+        if date < self.stamp_tax_change_date {
+            self.stamp_tax_rate_before_change
+        } else {
+            self.stamp_tax_rate_after_change
+        }
+    }
+
+    pub fn stamp_tax_for(
+        self,
+        date: NaiveDate,
+        side: OrderSide,
+        gross_amount: FixedMoney,
+    ) -> FixedMoney {
+        if gross_amount.raw() <= 0 || side == OrderSide::Buy {
+            return FixedMoney::ZERO;
+        }
+        gross_amount
+            .checked_mul_rate(self.stamp_tax_rate_for(date))
+            .expect("fixed stamp tax multiplication overflow")
+    }
+
+    pub fn transfer_fee_for(self, gross_amount: FixedMoney) -> FixedMoney {
+        if gross_amount.raw() <= 0 {
+            return FixedMoney::ZERO;
+        }
+        gross_amount
+            .checked_mul_rate(self.transfer_fee_rate)
+            .expect("fixed transfer fee multiplication overflow")
+    }
+
+    pub fn calculate(
+        self,
+        date: NaiveDate,
+        side: OrderSide,
+        gross_amount: FixedMoney,
+    ) -> FixedTradingCost {
+        FixedTradingCost {
+            commission: self.commission_for(gross_amount),
+            stamp_tax: self.stamp_tax_for(date, side, gross_amount),
+            transfer_fee: self.transfer_fee_for(gross_amount),
+        }
+    }
+
+    pub fn commission_for_order_fill(
+        self,
+        gross_amount: FixedMoney,
+        order_id: Option<u64>,
+        commission_state: &mut BTreeMap<u64, FixedMoney>,
+    ) -> FixedMoney {
+        if gross_amount.raw() <= 0 {
+            return FixedMoney::ZERO;
+        }
+        let raw = gross_amount
+            .checked_mul_rate(self.commission_rate)
+            .expect("fixed commission multiplication overflow");
+        let Some(order_id) = order_id else {
+            return raw.max(self.minimum_commission);
+        };
+        let remaining = commission_state
+            .entry(order_id)
+            .or_insert(self.minimum_commission);
+        self.commission_for_order_fill_remaining(gross_amount, remaining)
+    }
+
+    pub fn commission_for_order_fill_remaining(
+        self,
+        gross_amount: FixedMoney,
+        remaining: &mut FixedMoney,
+    ) -> FixedMoney {
+        if gross_amount.raw() <= 0 {
+            return FixedMoney::ZERO;
+        }
+        let raw = gross_amount
+            .checked_mul_rate(self.commission_rate)
+            .expect("fixed commission multiplication overflow");
+        if raw > *remaining {
+            let charged = if *remaining == self.minimum_commission {
+                raw
+            } else {
+                raw.checked_sub(*remaining)
+                    .expect("fixed remaining commission underflow")
+            };
+            *remaining = FixedMoney::ZERO;
+            charged
+        } else {
+            let charged = if *remaining == self.minimum_commission {
+                self.minimum_commission
+            } else {
+                FixedMoney::ZERO
+            };
+            *remaining = remaining
+                .checked_sub(raw)
+                .expect("fixed remaining commission underflow");
+            charged
+        }
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct FixedLot {
+    pub acquired_date: NaiveDate,
+    pub quantity: u64,
+    pub entry_price: FixedMoney,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct FixedLotBook {
+    lots: VecDeque<FixedLot>,
+    pub realized_pnl: FixedMoney,
+    pub quantity: u64,
+}
+
+impl FixedLotBook {
+    pub fn buy(&mut self, date: NaiveDate, quantity: u64, price: FixedMoney) {
+        if quantity == 0 {
+            return;
+        }
+        self.lots.push_back(FixedLot {
+            acquired_date: date,
+            quantity,
+            entry_price: price,
+        });
+        self.quantity = self.quantity.saturating_add(quantity);
+    }
+
+    pub fn sell(&mut self, quantity: u64, price: FixedMoney) -> Result<FixedMoney, String> {
+        if quantity > self.quantity {
+            return Err(format!(
+                "fixed sell quantity {} exceeds current quantity {}",
+                quantity, self.quantity
+            ));
+        }
+        let mut remaining = quantity;
+        let mut realized = FixedMoney::ZERO;
+        while remaining > 0 {
+            let Some(mut lot) = self.lots.pop_front() else {
+                return Err("fixed lot book is empty while selling".to_string());
+            };
+            let sold = remaining.min(lot.quantity);
+            let price_delta = price
+                .checked_sub(lot.entry_price)
+                .and_then(|delta| delta.checked_mul_quantity(sold))
+                .ok_or_else(|| "fixed realized PnL overflow".to_string())?;
+            realized = realized
+                .checked_add(price_delta)
+                .ok_or_else(|| "fixed realized PnL overflow".to_string())?;
+            lot.quantity -= sold;
+            remaining -= sold;
+            if lot.quantity > 0 {
+                self.lots.push_front(lot);
+            }
+        }
+        self.quantity -= quantity;
+        self.realized_pnl = self
+            .realized_pnl
+            .checked_add(realized)
+            .ok_or_else(|| "fixed realized PnL overflow".to_string())?;
+        Ok(realized)
+    }
+
+    pub fn market_value(&self, mark_price: FixedMoney) -> FixedMoney {
+        mark_price
+            .checked_mul_quantity(self.quantity)
+            .expect("fixed market value overflow")
+    }
+
+    pub fn unrealized_pnl(&self, mark_price: FixedMoney) -> FixedMoney {
+        self.lots.iter().fold(FixedMoney::ZERO, |total, lot| {
+            let delta = mark_price
+                .checked_sub(lot.entry_price)
+                .and_then(|value| value.checked_mul_quantity(lot.quantity))
+                .expect("fixed unrealized PnL overflow");
+            total
+                .checked_add(delta)
+                .expect("fixed unrealized PnL overflow")
+        })
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct FixedAccount {
+    pub cash: FixedMoney,
+    pub units: FixedMoney,
+    pub external_cash_flow_total: FixedMoney,
+}
+
+impl FixedAccount {
+    pub fn new(initial_cash: FixedMoney) -> Self {
+        Self {
+            cash: initial_cash,
+            units: initial_cash,
+            external_cash_flow_total: FixedMoney::ZERO,
+        }
+    }
+
+    pub fn apply_external_cash_flow(
+        &mut self,
+        amount: FixedMoney,
+        unit_nav: FixedMoney,
+    ) -> Result<(), String> {
+        if unit_nav.raw() <= 0 {
+            return Err("fixed unit NAV must be positive".to_string());
+        }
+        let exact_units_raw = amount
+            .raw()
+            .checked_mul(MONEY_SCALE)
+            .and_then(|value| value.checked_div(unit_nav.raw()))
+            .ok_or_else(|| "fixed external flow unit conversion overflow".to_string())?;
+        self.cash = self
+            .cash
+            .checked_add(amount)
+            .ok_or_else(|| "fixed cash overflow".to_string())?;
+        self.units = self
+            .units
+            .checked_add(FixedMoney::from_raw(exact_units_raw))
+            .ok_or_else(|| "fixed units overflow".to_string())?;
+        self.external_cash_flow_total = self
+            .external_cash_flow_total
+            .checked_add(amount)
+            .ok_or_else(|| "fixed external flow overflow".to_string())?;
+        Ok(())
+    }
+
+    pub fn unit_nav(&self, total_equity: FixedMoney) -> Result<FixedMoney, String> {
+        if self.units.raw() <= 0 {
+            return Err("fixed account has no units".to_string());
+        }
+        let raw = total_equity
+            .raw()
+            .checked_mul(MONEY_SCALE)
+            .and_then(|value| value.checked_div(self.units.raw()))
+            .ok_or_else(|| "fixed unit NAV overflow".to_string())?;
+        Ok(FixedMoney::from_raw(raw))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::cost::{ChinaAShareCostModel, CostModel};
+    use crate::risk_control::TradingConstraintConfig;
+
+    fn fixed_model() -> FixedChinaAShareCostModel {
+        let config = TradingConstraintConfig::default();
+        FixedChinaAShareCostModel {
+            commission_rate: FixedMoney::from_f64(config.commission_rate).unwrap(),
+            stamp_tax_rate_before_change: FixedMoney::from_f64(config.stamp_tax_rate_before_change)
+                .unwrap(),
+            stamp_tax_rate_after_change: FixedMoney::from_f64(config.stamp_tax_rate_after_change)
+                .unwrap(),
+            stamp_tax_change_date: config.stamp_tax_change_date,
+            minimum_commission: FixedMoney::from_f64(config.minimum_commission).unwrap(),
+            transfer_fee_rate: FixedMoney::from_f64(config.transfer_fee_rate).unwrap(),
+        }
+    }
+
+    #[test]
+    fn decimal_parser_rounds_only_beyond_money_scale() {
+        assert_eq!(
+            FixedMoney::from_decimal_str("1.234567").unwrap().raw(),
+            1_234_567
+        );
+        assert_eq!(
+            FixedMoney::from_decimal_str("1.2345675").unwrap().raw(),
+            1_234_568
+        );
+        assert_eq!(
+            FixedMoney::from_decimal_str("-0.0000014").unwrap().raw(),
+            -1
+        );
+    }
+
+    #[test]
+    fn runtime_cost_model_matches_fixed_execution_primitive() {
+        let fixed = fixed_model();
+        let float = ChinaAShareCostModel::default();
+        let dates = [
+            NaiveDate::from_ymd_opt(2024, 12, 31).unwrap(),
+            NaiveDate::from_ymd_opt(2025, 1, 2).unwrap(),
+        ];
+        for gross in [0.01, 10.0, 16_666.67, 248_059.812, 1_000_000.01] {
+            let fixed_gross = FixedMoney::from_f64(gross).unwrap();
+            for date in dates {
+                for side in [OrderSide::Buy, OrderSide::Sell] {
+                    let expected = float.calculate(date, side, gross);
+                    let actual = fixed.calculate(date, side, fixed_gross);
+                    for (actual, expected) in [
+                        (actual.commission, expected.commission),
+                        (actual.stamp_tax, expected.stamp_tax),
+                        (actual.transfer_fee, expected.transfer_fee),
+                    ] {
+                        assert_eq!(actual.to_f64(), expected);
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn runtime_split_commission_matches_fixed_execution_primitive() {
+        let fixed = fixed_model();
+        let float = ChinaAShareCostModel::default();
+        let mut fixed_state = BTreeMap::new();
+        let mut float_state = BTreeMap::new();
+        let mut fixed_total = FixedMoney::ZERO;
+        let mut float_total = 0.0;
+        for gross in [1000.0, 2000.0, 4000.0, 40_000.0] {
+            let fixed_fee = fixed.commission_for_order_fill(
+                FixedMoney::from_f64(gross).unwrap(),
+                Some(42),
+                &mut fixed_state,
+            );
+            let float_fee = float.commission_for_order_fill(gross, Some(42), &mut float_state);
+            fixed_total = fixed_total.checked_add(fixed_fee).unwrap();
+            float_total += float_fee;
+        }
+        assert_eq!(fixed_total.to_f64(), float_total);
+    }
+
+    #[test]
+    fn fixed_budget_never_exceeds_cash_after_cost() {
+        let model = fixed_model();
+        let date = NaiveDate::from_ymd_opt(2025, 2, 3).unwrap();
+        let cash = FixedMoney::from_decimal_str("99880.00").unwrap();
+        let price = FixedMoney::from_decimal_str("19.9731").unwrap();
+        let mut quantity = 5_000u64;
+        while quantity > 0 {
+            let gross = price.checked_mul_quantity(quantity).unwrap();
+            if gross
+                .checked_add(model.calculate(date, OrderSide::Buy, gross).total())
+                .unwrap()
+                <= cash
+            {
+                break;
+            }
+            quantity -= 100;
+        }
+        let gross = price.checked_mul_quantity(quantity).unwrap();
+        let total = gross
+            .checked_add(model.calculate(date, OrderSide::Buy, gross).total())
+            .unwrap();
+        assert!(total <= cash);
+        assert!(quantity < 5_000);
+    }
+
+    #[test]
+    fn fixed_budget_comparison_rejects_one_micro_yuan_overrun() {
+        assert_eq!(FixedMoney::f64_fits_within(100.0, 100.0), Some(true));
+        assert_eq!(FixedMoney::f64_fits_within(100.000001, 100.0), Some(false));
+        assert_eq!(
+            FixedMoney::f64_fits_within(100.000001, f64::INFINITY),
+            Some(true)
+        );
+    }
+
+    #[test]
+    fn fixed_fifo_pnl_and_external_flow_are_deterministic() {
+        let day_one = NaiveDate::from_ymd_opt(2025, 1, 2).unwrap();
+        let day_two = NaiveDate::from_ymd_opt(2025, 1, 3).unwrap();
+        let mut book = FixedLotBook::default();
+        book.buy(day_one, 100, FixedMoney::from_decimal_str("10.01").unwrap());
+        book.buy(day_two, 100, FixedMoney::from_decimal_str("10.03").unwrap());
+        let realized = book
+            .sell(150, FixedMoney::from_decimal_str("10.11").unwrap())
+            .unwrap();
+        assert_eq!(realized.raw(), 14_000_000);
+        assert_eq!(book.quantity, 50);
+        assert_eq!(
+            book.unrealized_pnl(FixedMoney::from_decimal_str("10.20").unwrap())
+                .raw(),
+            8_500_000
+        );
+
+        let mut account = FixedAccount::new(FixedMoney::from_decimal_str("100.00").unwrap());
+        account
+            .apply_external_cash_flow(
+                FixedMoney::from_decimal_str("50.00").unwrap(),
+                FixedMoney::from_decimal_str("1.00").unwrap(),
+            )
+            .unwrap();
+        assert_eq!(account.units.raw(), 150 * MONEY_SCALE);
+        assert_eq!(
+            account
+                .unit_nav(FixedMoney::from_decimal_str("150.00").unwrap())
+                .unwrap()
+                .raw(),
+            MONEY_SCALE
+        );
+        assert_eq!(account.external_cash_flow_total.raw(), 50 * MONEY_SCALE);
+    }
+}

crates/fidc-core/src/futures.rs

@@ -7,6 +7,24 @@ use crate::events::{
     AccountEvent, FillEvent, OrderEvent, OrderSide, OrderStatus, PositionEvent, ProcessEvent,
     ProcessEventKind,
 };
+use crate::fixed_point::FixedMoney;
+
+fn futures_money(value: f64, label: &str) -> Result<FixedMoney, String> {
+    FixedMoney::from_f64(value)
+        .ok_or_else(|| format!("{label} is not representable as fixed-point money: {value}"))
+}
+
+fn futures_money_or_panic(value: f64, label: &str) -> FixedMoney {
+    futures_money(value, label).unwrap_or_else(|error| panic!("{error}"))
+}
+
+fn sum_futures_money(values: impl IntoIterator<Item = FixedMoney>, label: &str) -> FixedMoney {
+    values.into_iter().fold(FixedMoney::ZERO, |total, value| {
+        total
+            .checked_add(value)
+            .unwrap_or_else(|| panic!("fixed-point {label} overflow"))
+    })
+}
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 pub enum FuturesDirection {
@@ -345,6 +363,14 @@ pub struct FuturesExecutionReport {
 }
 
 impl FuturesContractSpec {
+    pub fn unresolved() -> Self {
+        Self {
+            contract_multiplier: f64::NAN,
+            long_margin_rate: f64::NAN,
+            short_margin_rate: f64::NAN,
+        }
+    }
+
     pub fn new(contract_multiplier: f64, long_margin_rate: f64, short_margin_rate: f64) -> Self {
         Self {
             contract_multiplier: contract_multiplier.max(1.0),
@@ -359,6 +385,15 @@ impl FuturesContractSpec {
             FuturesDirection::Short => self.short_margin_rate,
         }
     }
+
+    pub fn is_resolved(&self) -> bool {
+        self.contract_multiplier.is_finite()
+            && self.contract_multiplier > 0.0
+            && self.long_margin_rate.is_finite()
+            && self.long_margin_rate >= 0.0
+            && self.short_margin_rate.is_finite()
+            && self.short_margin_rate >= 0.0
+    }
 }
 
 #[derive(Debug, Clone)]
@@ -366,15 +401,16 @@ pub struct FuturesPosition {
     pub symbol: String,
     pub direction: FuturesDirection,
     pub old_quantity: u32,
+    day_start_quantity: u32,
     pub quantity: u32,
     pub avg_price: f64,
     pub last_price: f64,
     pub prev_close: f64,
     pub contract_multiplier: f64,
     pub margin_rate: f64,
-    pub transaction_cost: f64,
+    transaction_cost: FixedMoney,
     trade_quantity_delta: i32,
-    trade_cost: f64,
+    trade_value: FixedMoney,
 }
 
 impl FuturesPosition {
@@ -390,15 +426,16 @@ impl FuturesPosition {
             symbol: symbol.into(),
             direction,
             old_quantity: init_quantity,
+            day_start_quantity: init_quantity,
             quantity: init_quantity,
             avg_price: init_price.max(0.0),
             last_price: init_price.max(0.0),
             prev_close: init_price.max(0.0),
             contract_multiplier: spec.contract_multiplier,
             margin_rate,
-            transaction_cost: 0.0,
+            transaction_cost: FixedMoney::ZERO,
             trade_quantity_delta: 0,
-            trade_cost: 0.0,
+            trade_value: FixedMoney::ZERO,
         }
     }
 
@@ -407,18 +444,39 @@ impl FuturesPosition {
     }
 
     pub fn market_value(&self) -> f64 {
-        self.quantity as f64 * self.last_price * self.contract_multiplier
+        self.market_value_money().to_f64()
+    }
+
+    fn market_value_money(&self) -> FixedMoney {
+        futures_money_or_panic(
+            self.quantity as f64 * self.last_price * self.contract_multiplier,
+            "futures position market value",
+        )
     }
 
     pub fn margin(&self) -> f64 {
-        self.market_value() * self.margin_rate
+        self.margin_money().to_f64()
+    }
+
+    fn margin_money(&self) -> FixedMoney {
+        futures_money_or_panic(
+            self.market_value_money().to_f64() * self.margin_rate,
+            "futures position margin",
+        )
     }
 
     pub fn equity(&self) -> f64 {
-        (self.last_price - self.avg_price)
-            * self.quantity as f64
-            * self.contract_multiplier
-            * self.direction.factor()
+        self.equity_money().to_f64()
+    }
+
+    fn equity_money(&self) -> FixedMoney {
+        futures_money_or_panic(
+            (self.last_price - self.avg_price)
+                * self.quantity as f64
+                * self.contract_multiplier
+                * self.direction.factor(),
+            "futures position equity",
+        )
     }
 
     pub fn pnl(&self) -> f64 {
@@ -426,22 +484,47 @@ impl FuturesPosition {
     }
 
     pub fn trading_pnl(&self) -> f64 {
-        (self.trade_quantity_delta as f64 * self.last_price - self.trade_cost)
-            * self.contract_multiplier
-            * self.direction.factor()
+        self.trading_pnl_money().to_f64()
+    }
+
+    fn trading_pnl_money(&self) -> FixedMoney {
+        let marked_trade_value = futures_money_or_panic(
+            self.trade_quantity_delta as f64 * self.last_price * self.contract_multiplier,
+            "futures marked trade value",
+        );
+        let pnl = marked_trade_value
+            .checked_sub(self.trade_value)
+            .expect("fixed-point futures trading PnL overflow");
+        if self.direction == FuturesDirection::Short {
+            pnl.checked_neg()
+                .expect("fixed-point futures short trading PnL overflow")
+        } else {
+            pnl
+        }
     }
 
     pub fn position_pnl(&self) -> f64 {
-        if self.old_quantity == 0 {
-            0.0
+        self.position_pnl_money().to_f64()
+    }
+
+    fn position_pnl_money(&self) -> FixedMoney {
+        if self.day_start_quantity == 0 {
+            FixedMoney::ZERO
         } else {
-            self.old_quantity as f64
-                * (self.last_price - self.prev_close)
-                * self.contract_multiplier
-                * self.direction.factor()
+            futures_money_or_panic(
+                self.day_start_quantity as f64
+                    * (self.last_price - self.prev_close)
+                    * self.contract_multiplier
+                    * self.direction.factor(),
+                "futures position daily PnL",
+            )
         }
     }
 
+    pub fn transaction_cost(&self) -> f64 {
+        self.transaction_cost.to_f64()
+    }
+
     pub fn open(&mut self, quantity: u32, price: f64, transaction_cost: f64) {
         if quantity == 0 {
             return;
@@ -450,9 +533,20 @@ impl FuturesPosition {
         self.quantity += quantity;
         self.avg_price = (old_value + price * quantity as f64) / self.quantity as f64;
         self.last_price = price;
-        self.transaction_cost += transaction_cost.max(0.0);
+        let transaction_cost =
+            futures_money_or_panic(transaction_cost.max(0.0), "futures open transaction cost");
+        self.transaction_cost = self
+            .transaction_cost
+            .checked_add(transaction_cost)
+            .expect("fixed-point futures transaction cost overflow");
         self.trade_quantity_delta += quantity as i32;
-        self.trade_cost += price * quantity as f64;
+        self.trade_value = self
+            .trade_value
+            .checked_add(futures_money_or_panic(
+                price * quantity as f64 * self.contract_multiplier,
+                "futures open trade value",
+            ))
+            .expect("fixed-point futures trade value overflow");
     }
 
     pub fn close(
@@ -476,6 +570,17 @@ impl FuturesPosition {
         transaction_cost: f64,
         effect: FuturesPositionEffect,
     ) -> Result<f64, String> {
+        self.close_with_effect_money(quantity, price, transaction_cost, effect)
+            .map(FixedMoney::to_f64)
+    }
+
+    fn close_with_effect_money(
+        &mut self,
+        quantity: u32,
+        price: f64,
+        transaction_cost: f64,
+        effect: FuturesPositionEffect,
+    ) -> Result<FixedMoney, String> {
         if effect == FuturesPositionEffect::Open {
             return Err("close_with_effect does not accept open effect".to_string());
         }
@@ -489,7 +594,7 @@ impl FuturesPosition {
             ));
         }
         if quantity == 0 {
-            return Ok(0.0);
+            return Ok(FixedMoney::ZERO);
         }
         match effect {
             FuturesPositionEffect::Open => unreachable!(),
@@ -523,19 +628,34 @@ impl FuturesPosition {
             }
         }
 
-        let realized = (price - self.avg_price)
-            * quantity as f64
-            * self.contract_multiplier
-            * self.direction.factor()
-            - transaction_cost.max(0.0);
+        let transaction_cost =
+            futures_money(transaction_cost.max(0.0), "futures close transaction cost")?;
+        let realized = futures_money(
+            (price - self.avg_price)
+                * quantity as f64
+                * self.contract_multiplier
+                * self.direction.factor(),
+            "futures realized PnL",
+        )?
+        .checked_sub(transaction_cost)
+        .ok_or_else(|| "fixed-point futures realized PnL overflow".to_string())?;
         self.quantity -= quantity;
         if self.quantity == 0 {
             self.avg_price = 0.0;
         }
         self.last_price = price;
-        self.transaction_cost += transaction_cost.max(0.0);
+        self.transaction_cost = self
+            .transaction_cost
+            .checked_add(transaction_cost)
+            .ok_or_else(|| "fixed-point futures transaction cost overflow".to_string())?;
         self.trade_quantity_delta -= quantity as i32;
-        self.trade_cost -= price * quantity as f64;
+        self.trade_value = self
+            .trade_value
+            .checked_sub(futures_money(
+                price * quantity as f64 * self.contract_multiplier,
+                "futures close trade value",
+            )?)
+            .ok_or_else(|| "fixed-point futures trade value overflow".to_string())?;
         Ok(realized)
     }
 
@@ -547,98 +667,163 @@ impl FuturesPosition {
 
     pub fn begin_trading_day(&mut self) {
         self.old_quantity = self.quantity;
+        self.day_start_quantity = self.quantity;
         self.prev_close = self.last_price;
-        self.transaction_cost = 0.0;
+        self.transaction_cost = FixedMoney::ZERO;
         self.trade_quantity_delta = 0;
-        self.trade_cost = 0.0;
+        self.trade_value = FixedMoney::ZERO;
     }
 
     pub fn settlement(&mut self, settlement_price: f64) -> f64 {
+        self.settlement_money(settlement_price).to_f64()
+    }
+
+    fn settlement_money(&mut self, settlement_price: f64) -> FixedMoney {
         self.mark_price(settlement_price);
-        let cash_delta = self.equity();
+        let cash_delta = self.equity_money();
         self.avg_price = self.last_price;
-        self.prev_close = self.last_price;
-        self.old_quantity = self.quantity;
         cash_delta
     }
 }
 
 #[derive(Debug, Clone)]
 pub struct FuturesAccountState {
-    starting_cash: f64,
-    total_cash: f64,
-    frozen_cash: f64,
+    starting_cash: FixedMoney,
+    total_cash: FixedMoney,
+    frozen_cash: FixedMoney,
+    closed_day_trading_pnl: FixedMoney,
+    closed_day_position_pnl: FixedMoney,
+    closed_day_transaction_cost: FixedMoney,
     positions: BTreeMap<(String, FuturesDirection), FuturesPosition>,
 }
 
 impl FuturesAccountState {
     pub fn new(total_cash: f64) -> Self {
+        let total_cash = futures_money_or_panic(total_cash, "futures starting cash");
         Self {
             starting_cash: total_cash,
             total_cash,
-            frozen_cash: 0.0,
+            frozen_cash: FixedMoney::ZERO,
+            closed_day_trading_pnl: FixedMoney::ZERO,
+            closed_day_position_pnl: FixedMoney::ZERO,
+            closed_day_transaction_cost: FixedMoney::ZERO,
             positions: BTreeMap::new(),
         }
     }
 
     pub fn starting_cash(&self) -> f64 {
-        self.starting_cash
+        self.starting_cash.to_f64()
     }
 
     pub fn total_cash(&self) -> f64 {
-        self.total_cash
+        self.total_cash.to_f64()
     }
 
     pub fn frozen_cash(&self) -> f64 {
-        self.frozen_cash
+        self.frozen_cash.to_f64()
     }
 
     pub fn cash(&self) -> f64 {
-        self.total_cash - self.margin() - self.frozen_cash
+        self.cash_money().to_f64()
+    }
+
+    fn cash_money(&self) -> FixedMoney {
+        self.total_cash
+            .checked_sub(self.margin_money())
+            .and_then(|cash| cash.checked_sub(self.frozen_cash))
+            .expect("fixed-point futures available cash overflow")
     }
 
     pub fn margin(&self) -> f64 {
-        self.positions.values().map(FuturesPosition::margin).sum()
+        self.margin_money().to_f64()
+    }
+
+    fn margin_money(&self) -> FixedMoney {
+        sum_futures_money(
+            self.positions.values().map(FuturesPosition::margin_money),
+            "futures account margin",
+        )
     }
 
     pub fn market_value(&self) -> f64 {
-        self.positions
-            .values()
-            .map(FuturesPosition::market_value)
-            .sum()
+        sum_futures_money(
+            self.positions
+                .values()
+                .map(FuturesPosition::market_value_money),
+            "futures account market value",
+        )
+        .to_f64()
     }
 
     pub fn position_equity(&self) -> f64 {
-        self.positions.values().map(FuturesPosition::equity).sum()
+        self.position_equity_money().to_f64()
+    }
+
+    fn position_equity_money(&self) -> FixedMoney {
+        sum_futures_money(
+            self.positions.values().map(FuturesPosition::equity_money),
+            "futures account position equity",
+        )
     }
 
     pub fn total_value(&self) -> f64 {
-        self.total_cash + self.position_equity()
+        self.total_cash
+            .checked_add(self.position_equity_money())
+            .expect("fixed-point futures total value overflow")
+            .to_f64()
     }
 
     pub fn daily_pnl(&self) -> f64 {
-        self.trading_pnl() + self.position_pnl() - self.transaction_cost()
+        self.trading_pnl_money()
+            .checked_add(self.position_pnl_money())
+            .and_then(|pnl| pnl.checked_sub(self.transaction_cost_money()))
+            .expect("fixed-point futures daily PnL overflow")
+            .to_f64()
     }
 
     pub fn trading_pnl(&self) -> f64 {
-        self.positions
-            .values()
-            .map(FuturesPosition::trading_pnl)
-            .sum()
+        self.trading_pnl_money().to_f64()
+    }
+
+    fn trading_pnl_money(&self) -> FixedMoney {
+        sum_futures_money(
+            std::iter::once(self.closed_day_trading_pnl).chain(
+                self.positions
+                    .values()
+                    .map(FuturesPosition::trading_pnl_money),
+            ),
+            "futures account trading PnL",
+        )
     }
 
     pub fn position_pnl(&self) -> f64 {
-        self.positions
-            .values()
-            .map(FuturesPosition::position_pnl)
-            .sum()
+        self.position_pnl_money().to_f64()
+    }
+
+    fn position_pnl_money(&self) -> FixedMoney {
+        sum_futures_money(
+            std::iter::once(self.closed_day_position_pnl).chain(
+                self.positions
+                    .values()
+                    .map(FuturesPosition::position_pnl_money),
+            ),
+            "futures account position PnL",
+        )
     }
 
     pub fn transaction_cost(&self) -> f64 {
-        self.positions
-            .values()
-            .map(|position| position.transaction_cost)
-            .sum()
+        self.transaction_cost_money().to_f64()
+    }
+
+    fn transaction_cost_money(&self) -> FixedMoney {
+        sum_futures_money(
+            std::iter::once(self.closed_day_transaction_cost).chain(
+                self.positions
+                    .values()
+                    .map(|position| position.transaction_cost),
+            ),
+            "futures account transaction cost",
+        )
     }
 
     pub fn positions(&self) -> &BTreeMap<(String, FuturesDirection), FuturesPosition> {
@@ -667,7 +852,13 @@ impl FuturesAccountState {
             .entry((symbol.clone(), direction))
             .or_insert_with(|| FuturesPosition::new(symbol, direction, spec, 0, price));
         position.open(quantity, price, transaction_cost);
-        self.total_cash -= transaction_cost.max(0.0);
+        self.total_cash = self
+            .total_cash
+            .checked_sub(futures_money_or_panic(
+                transaction_cost.max(0.0),
+                "futures open transaction cost",
+            ))
+            .expect("fixed-point futures cash overflow");
     }
 
     pub fn close(
@@ -702,12 +893,30 @@ impl FuturesAccountState {
             .positions
             .get_mut(&key)
             .ok_or_else(|| format!("missing futures position {symbol} {}", direction.as_str()))?;
-        let cash_delta = position.close_with_effect(quantity, price, transaction_cost, effect)?;
-        self.total_cash += cash_delta;
+        let cash_delta =
+            position.close_with_effect_money(quantity, price, transaction_cost, effect)?;
+        self.total_cash = self
+            .total_cash
+            .checked_add(cash_delta)
+            .ok_or_else(|| "fixed-point futures cash overflow".to_string())?;
         if position.quantity == 0 {
+            self.closed_day_trading_pnl = self
+                .closed_day_trading_pnl
+                .checked_add(position.trading_pnl_money())
+                .ok_or_else(|| "fixed-point closed futures trading PnL overflow".to_string())?;
+            self.closed_day_position_pnl = self
+                .closed_day_position_pnl
+                .checked_add(position.position_pnl_money())
+                .ok_or_else(|| "fixed-point closed futures position PnL overflow".to_string())?;
+            self.closed_day_transaction_cost = self
+                .closed_day_transaction_cost
+                .checked_add(position.transaction_cost)
+                .ok_or_else(|| {
+                    "fixed-point closed futures transaction cost overflow".to_string()
+                })?;
             self.positions.remove(&key);
         }
-        Ok(cash_delta)
+        Ok(cash_delta.to_f64())
     }
 
     pub fn execute_order(
@@ -746,6 +955,9 @@ impl FuturesAccountState {
             );
             report.order_events.push(OrderEvent {
                 date,
+                decision_date: None,
+                order_created_date: None,
+                execution_date: None,
                 order_id,
                 symbol: intent.symbol,
                 side,
@@ -779,7 +991,7 @@ impl FuturesAccountState {
                     intent.price,
                     intent.transaction_cost,
                 );
-                if projected.cash() < -1e-8 {
+                if projected.cash_money().raw() < 0 {
                     Err(format!(
                         "insufficient futures margin available_cash={:.2} required_margin_after={:.2}",
                         self.cash(),
@@ -794,7 +1006,13 @@ impl FuturesAccountState {
                         intent.price,
                         intent.transaction_cost,
                     );
-                    Ok(-intent.transaction_cost.max(0.0))
+                    Ok(futures_money_or_panic(
+                        intent.transaction_cost.max(0.0),
+                        "futures open transaction cost",
+                    )
+                    .checked_neg()
+                    .expect("fixed-point futures open cash delta overflow")
+                    .to_f64())
                 }
             }
             FuturesPositionEffect::Close
@@ -819,18 +1037,32 @@ impl FuturesAccountState {
                     .position(&intent.symbol, intent.direction)
                     .map(|position| position.avg_price)
                     .unwrap_or(0.0);
-                let notional =
-                    intent.price * intent.quantity as f64 * intent.spec.contract_multiplier;
+                let notional = futures_money_or_panic(
+                    intent.price * intent.quantity as f64 * intent.spec.contract_multiplier,
+                    "futures fill notional",
+                )
+                .to_f64();
+                let transaction_cost = futures_money_or_panic(
+                    intent.transaction_cost.max(0.0),
+                    "futures fill transaction cost",
+                )
+                .to_f64();
                 report.fill_events.push(FillEvent {
                     date,
+                    decision_date: None,
+                    order_created_date: None,
+                    execution_date: None,
+                    execution_start_timestamp: None,
+                    execution_timestamp: None,
                     order_id,
                     symbol: intent.symbol.clone(),
                     side,
                     quantity: intent.quantity,
                     price: intent.price,
                     gross_amount: notional,
-                    commission: intent.transaction_cost.max(0.0),
+                    commission: transaction_cost,
                     stamp_tax: 0.0,
+                    transfer_fee: 0.0,
                     net_cash_flow: cash_delta,
                     reason: format!(
                         "{} direction={} effect={}",
@@ -889,6 +1121,9 @@ impl FuturesAccountState {
                 });
                 report.order_events.push(OrderEvent {
                     date,
+                    decision_date: None,
+                    order_created_date: None,
+                    execution_date: None,
                     order_id,
                     symbol: intent.symbol,
                     side,
@@ -915,6 +1150,9 @@ impl FuturesAccountState {
                 );
                 report.order_events.push(OrderEvent {
                     date,
+                    decision_date: None,
+                    order_created_date: None,
+                    execution_date: None,
                     order_id,
                     symbol: intent.symbol,
                     side,
@@ -997,22 +1235,30 @@ impl FuturesAccountState {
     }
 
     pub fn begin_trading_day(&mut self) {
+        self.closed_day_trading_pnl = FixedMoney::ZERO;
+        self.closed_day_position_pnl = FixedMoney::ZERO;
+        self.closed_day_transaction_cost = FixedMoney::ZERO;
         for position in self.positions.values_mut() {
             position.begin_trading_day();
         }
     }
 
     pub fn settle(&mut self, settlement_prices: &BTreeMap<String, f64>) -> f64 {
-        let mut cash_delta = 0.0;
+        let mut cash_delta = FixedMoney::ZERO;
         for position in self.positions.values_mut() {
             let price = settlement_prices
                 .get(&position.symbol)
                 .copied()
                 .unwrap_or(position.last_price);
-            cash_delta += position.settlement(price);
+            cash_delta = cash_delta
+                .checked_add(position.settlement_money(price))
+                .expect("fixed-point futures settlement overflow");
         }
-        self.total_cash += cash_delta;
-        cash_delta
+        self.total_cash = self
+            .total_cash
+            .checked_add(cash_delta)
+            .expect("fixed-point futures cash settlement overflow");
+        cash_delta.to_f64()
     }
 }
 

crates/fidc-core/src/instrument.rs

@@ -40,10 +40,15 @@ impl Instrument {
             .is_some_and(|delisted_at| delisted_at < date)
     }
 
+    pub fn is_delisted_on_or_before(&self, date: NaiveDate) -> bool {
+        self.delisted_at
+            .is_some_and(|delisted_at| delisted_at <= date)
+    }
+
     pub fn is_active_on(&self, date: NaiveDate) -> bool {
         self.listed_at.is_none_or(|listed_at| listed_at <= date)
             && !self.is_delisted_before(date)
-            && !self.status.eq_ignore_ascii_case("inactive")
+            && !(self.status.eq_ignore_ascii_case("inactive") && self.delisted_at.is_none())
     }
 }
 

crates/fidc-core/src/lib.rs

@@ -5,39 +5,51 @@ pub mod data;
 pub mod engine;
 pub mod event_bus;
 pub mod events;
+pub mod fixed_point;
 pub mod futures;
 pub mod instrument;
 pub mod metrics;
+mod numeric_expr_vm;
 pub mod platform_expr_strategy;
 pub mod platform_runtime_schema;
 pub mod platform_strategy_spec;
 pub mod portfolio;
+pub mod risk_control;
 pub mod rules;
 pub mod scheduler;
 pub mod strategy;
 pub mod strategy_ai;
 pub mod universe;
 
-pub use broker::{BrokerExecutionReport, BrokerSimulator, MatchingType, SlippageModel};
+pub use broker::{
+    BrokerExecutionReport, BrokerSimulator, DynamicSlippageConfig, MatchingType, RebalanceCashMode,
+    SlippageModel,
+};
 pub use calendar::TradingCalendar;
 pub use cost::{ChinaAShareCostModel, CostModel, TradingCost};
 pub use data::{
     BenchmarkSnapshot, CandidateEligibility, CorporateAction, DailyFactorSnapshot,
     DailyMarketSnapshot, DailySnapshotBundle, DataSet, DataSetError, DividendRecord,
     EligibleUniverseSnapshot, FactorTextValue, FactorValue, IntradayExecutionQuote,
-    IntradayOrderBookDepthLevel, PriceBar, PriceField, SecuritiesMarginRecord, SplitRecord,
-    YieldCurvePoint,
+    IntradayOrderBookDepthLevel, NumericFactorMap, PriceBar, PriceField, SecuritiesMarginRecord,
+    SplitRecord, YieldCurvePoint,
 };
 pub use engine::{
     AnalyzerMonthlyReturnRow, AnalyzerPositionRow, AnalyzerReport, AnalyzerRiskSummary,
     AnalyzerTradeRow, BacktestConfig, BacktestDayProgress, BacktestEngine, BacktestError,
-    BacktestResult, DailyEquityPoint, FuturesValidationConfig,
+    BacktestResult, BacktestTerminalAssetClass, BacktestTerminalAudit, BacktestTerminalOpenOrder,
+    BacktestTerminalStatus, DailyEquityPoint, ExecutionQuoteRequest, FuturesValidationConfig,
+    ProcessEventRetention,
 };
 pub use event_bus::{BacktestProcessMod, BacktestProcessModLoader, ProcessEventBus};
 pub use events::{
     AccountEvent, FillEvent, OrderEvent, OrderSide, OrderStatus, PositionEvent, ProcessEvent,
     ProcessEventKind,
 };
+pub use fixed_point::{
+    FixedAccount, FixedChinaAShareCostModel, FixedLotBook, FixedMoney, FixedTradingCost,
+    MONEY_SCALE,
+};
 pub use futures::{
     FuturesAccountState, FuturesCommissionType, FuturesContractSpec, FuturesDirection,
     FuturesExecutionReport, FuturesOrderIntent, FuturesPosition, FuturesPositionEffect,
@@ -48,7 +60,8 @@ pub use metrics::{BacktestMetrics, compute_backtest_metrics};
 pub use platform_expr_strategy::{
     PlatformAccountActionKind, PlatformExplicitActionStage, PlatformExplicitCancelKind,
     PlatformExplicitOrderKind, PlatformExprStrategy, PlatformExprStrategyConfig,
-    PlatformRebalanceSchedule, PlatformScheduleFrequency, PlatformTradeAction,
+    PlatformPortfolioDrawdownControlConfig, PlatformRebalanceSchedule, PlatformScheduleFrequency,
+    PlatformSelectionQuotePlan, PlatformStopTakeReferencePriceMode, PlatformTradeAction,
     PlatformUniverseActionKind,
 };
 pub use platform_runtime_schema::{
@@ -62,24 +75,31 @@ pub use platform_strategy_spec::{
     StrategyExpressionActionConfig, StrategyExpressionAllocationConfig,
     StrategyExpressionOrderingConfig, StrategyExpressionRiskConfig,
     StrategyExpressionScheduleConfig, StrategyExpressionSelectionConfig,
-    StrategyExpressionTradingConfig, StrategyRuntimeEnvironment, StrategyRuntimeExpressions,
-    StrategyRuntimeSpec, platform_expr_config_from_spec, platform_expr_config_from_value,
+    StrategyExpressionTradingConfig, StrategyPortfolioDrawdownControlConfig,
+    StrategyRebalanceSpec, StrategyRiskPolicySpec, StrategyRuntimeEnvironment,
+    StrategyRuntimeExpressions, StrategyRuntimeSpec, StrategyUniverseSpec,
+    platform_expr_config_from_spec, platform_expr_config_from_value,
 };
 pub use portfolio::{CashReceivable, HoldingSummary, PendingCashFlow, PortfolioState, Position};
+pub use risk_control::{
+    ChinaAShareRiskControl, FidcRiskControlConfig, FidcRiskDecisionAudit, RiskCheckScope,
+    StaticRiskRuleConfig, TradingConstraintConfig,
+};
 pub use rules::{ChinaEquityRuleHooks, EquityRuleHooks, RuleCheck};
 pub use scheduler::{
     ScheduleFrequency, ScheduleRule, ScheduleStage, ScheduleTimeRule, Scheduler, default_stage_time,
 };
 pub use strategy::{
     AlgoOrderStyle, CnSmallCapRotationConfig, CnSmallCapRotationStrategy, OmniMicroCapConfig,
-    OmniMicroCapStrategy, OpenOrderView, OrderIntent, OrderRuntimeView, PortfolioRuntimeView,
-    Strategy, StrategyContext, StrategyDecision, TargetPortfolioOrderPricing,
+    OmniMicroCapStrategy, OpenOrderView, OrderIntent, OrderRuntimeView, OrderTimeInForce,
+    PortfolioRuntimeView, Strategy, StrategyContext, StrategyDecision, TargetPortfolioOrderPricing,
 };
 pub use strategy_ai::{
     ManualExample, ManualFactorSource, ManualField, ManualFieldGroup, ManualFunction,
-    ManualSection, StrategyAiCatalog, StrategyAiGenerateRequest, StrategyAiManual,
-    StrategyAiOptimizeRequest, build_generation_prompt, build_optimization_prompt,
-    built_in_strategy_manual, merge_catalog_into_manual, render_manual_markdown,
+    ManualSection, StrategyAiCatalog, StrategyAiGenerateRequest, StrategyAiHoldingCountContract,
+    StrategyAiManual, StrategyAiOptimizeRequest, build_generation_prompt,
+    build_optimization_prompt, built_in_strategy_manual, merge_catalog_into_manual,
+    render_manual_markdown,
 };
 pub use universe::{
     BandRegime, DynamicMarketCapBandSelector, SelectionContext, SelectionDiagnostics,

crates/fidc-core/src/metrics.rs

@@ -4,7 +4,7 @@ use chrono::{Datelike, NaiveDate};
 use serde::{Deserialize, Serialize};
 
 use crate::engine::DailyEquityPoint;
-use crate::events::FillEvent;
+use crate::events::{AccountEvent, FillEvent};
 use crate::portfolio::HoldingSummary;
 
 const TRADING_DAYS_PER_YEAR: f64 = 252.0;
@@ -47,6 +47,11 @@ pub struct BacktestMetrics {
     pub cash_balance: f64,
     pub unit_nav: f64,
     pub initial_cash: f64,
+    /// Sum of external deposits (positive) and withdrawals (negative).  This
+    /// is reported separately so callers cannot mistake a cash transfer for
+    /// trading performance.
+    #[serde(default)]
+    pub external_cash_flow_total: f64,
     pub excess_win_rate: f64,
     pub monthly_sharpe: f64,
     pub monthly_volatility: f64,
@@ -56,6 +61,7 @@ pub fn compute_backtest_metrics(
     equity_curve: &[DailyEquityPoint],
     fills: &[FillEvent],
     daily_holdings: &[HoldingSummary],
+    account_events: &[AccountEvent],
     initial_cash: f64,
 ) -> BacktestMetrics {
     let Some(first_point) = equity_curve.first() else {
@@ -81,12 +87,28 @@ pub fn compute_backtest_metrics(
     } else {
         first_point.benchmark_close
     };
-    let mut returns = Vec::with_capacity(equity_curve.len());
-    returns.push(pct_change(initial_cash, first_point.total_equity));
-    returns.extend(
+    let explicit_unit_nav = equity_curve.iter().any(|point| {
+        point.external_cash_flow.abs() > f64::EPSILON
+            || (point.unit_nav.is_finite()
+                && point.unit_nav > 0.0
+                && (point.unit_nav - safe_div(point.total_equity, initial_cash, 1.0)).abs() > 1e-12)
+    });
+    let portfolio_nav = if explicit_unit_nav {
         equity_curve
+            .iter()
+            .map(|point| point_nav(point, initial_cash))
+            .collect::<Vec<_>>()
+    } else {
+        flow_neutral_nav_series(equity_curve, account_events, initial_cash)
+    };
+    let mut returns = Vec::with_capacity(portfolio_nav.len());
+    if let Some(first_nav) = portfolio_nav.first().copied() {
+        returns.push(pct_change(1.0, first_nav));
+    }
+    returns.extend(
+        portfolio_nav
             .windows(2)
-            .map(|window| pct_change(window[0].total_equity, window[1].total_equity)),
+            .map(|window| pct_change(window[0], window[1])),
     );
     let mut benchmark_returns = Vec::with_capacity(equity_curve.len());
     benchmark_returns.push(pct_change(benchmark_start, first_point.benchmark_close));
@@ -107,15 +129,12 @@ pub fn compute_backtest_metrics(
         last_point.benchmark_close / benchmark_start
     };
     let benchmark_cumulative_return = benchmark_net_value - 1.0;
-    let total_return = if initial_cash.abs() < f64::EPSILON {
-        0.0
-    } else {
-        (last_point.total_equity / initial_cash) - 1.0
-    };
+    let final_nav = portfolio_nav.last().copied().unwrap_or(1.0);
+    let total_return = final_nav - 1.0;
     let excess_cumulative_return = if benchmark_net_value.abs() < f64::EPSILON {
         total_return
     } else {
-        (last_point.total_equity / initial_cash) / benchmark_net_value - 1.0
+        portfolio_nav.last().copied().unwrap_or(0.0) / benchmark_net_value - 1.0
     };
     let excess_return = total_return - benchmark_cumulative_return;
     let annual_return = annualize_return(total_return, trade_days);
@@ -132,10 +151,7 @@ pub fn compute_backtest_metrics(
     let excess_sharpe = annualized_sharpe(&excess_returns, 0.0, TRADING_DAYS_PER_YEAR);
     let (alpha, beta) = alpha_beta(&returns, &benchmark_returns, daily_rf);
 
-    let equity_nav = equity_curve
-        .iter()
-        .map(|point| safe_div(point.total_equity, initial_cash, 1.0))
-        .collect::<Vec<_>>();
+    let equity_nav = portfolio_nav;
     let benchmark_nav_series = equity_curve
         .iter()
         .map(|point| safe_div(point.benchmark_close, benchmark_start, 1.0))
@@ -154,8 +170,7 @@ pub fn compute_backtest_metrics(
     let win_rate = ratio(winning_days, returns.len());
     let excess_win_rate = ratio(excess_winning_days, excess_returns.len());
 
-    let monthly_portfolio_returns =
-        group_monthly_returns(equity_curve, initial_cash, |point| point.total_equity);
+    let monthly_portfolio_returns = group_monthly_returns_from_values(equity_curve, &equity_nav);
     let monthly_benchmark_returns =
         group_monthly_returns(equity_curve, benchmark_start, |point| point.benchmark_close);
     let monthly_excess_returns = monthly_portfolio_returns
@@ -257,14 +272,30 @@ pub fn compute_backtest_metrics(
         average_daily_turnover,
         total_assets: last_point.total_equity,
         cash_balance: last_point.cash,
-        unit_nav: safe_div(last_point.total_equity, initial_cash, 0.0),
+        unit_nav: final_nav,
         initial_cash,
+        external_cash_flow_total: if explicit_unit_nav {
+            equity_curve
+                .iter()
+                .map(|point| point.external_cash_flow)
+                .sum()
+        } else {
+            external_flow_total_from_events(account_events)
+        },
         excess_win_rate,
         monthly_sharpe,
         monthly_volatility,
     }
 }
 
+fn point_nav(point: &DailyEquityPoint, initial_cash: f64) -> f64 {
+    if point.unit_nav.is_finite() && point.unit_nav > 0.0 {
+        point.unit_nav
+    } else {
+        safe_div(point.total_equity, initial_cash, 1.0)
+    }
+}
+
 fn pct_change(previous: f64, current: f64) -> f64 {
     if previous.abs() < f64::EPSILON {
         0.0
@@ -384,6 +415,80 @@ fn drawdown_stats(nav: &[f64]) -> (f64, usize) {
     (max_drawdown, max_duration)
 }
 
+fn flow_neutral_nav_series(
+    equity_curve: &[DailyEquityPoint],
+    account_events: &[AccountEvent],
+    initial_cash: f64,
+) -> Vec<f64> {
+    let mut external_flow_by_date = BTreeMap::<NaiveDate, f64>::new();
+    for event in account_events {
+        if !(event.note.starts_with("deposit_withdraw amount=")
+            || event.note.starts_with("deposit_withdraw_settled amount="))
+        {
+            continue;
+        }
+        *external_flow_by_date.entry(event.date).or_default() +=
+            event.cash_after - event.cash_before;
+    }
+
+    let mut units = initial_cash;
+    let mut previous_equity = initial_cash;
+    let mut navs = Vec::with_capacity(equity_curve.len());
+    for point in equity_curve {
+        let unit_nav_before_flow = safe_div(previous_equity, units, 1.0);
+        let external_flow = external_flow_by_date
+            .get(&point.date)
+            .copied()
+            .unwrap_or_default();
+        if external_flow.abs() > f64::EPSILON && unit_nav_before_flow.is_finite() {
+            units += external_flow / unit_nav_before_flow;
+        }
+        let unit_nav = safe_div(point.total_equity, units, 0.0);
+        navs.push(unit_nav);
+        previous_equity = point.total_equity;
+    }
+    navs
+}
+
+fn external_flow_total_from_events(account_events: &[AccountEvent]) -> f64 {
+    account_events
+        .iter()
+        .filter(|event| {
+            event.note.starts_with("deposit_withdraw amount=")
+                || event.note.starts_with("deposit_withdraw_settled amount=")
+        })
+        .map(|event| event.cash_after - event.cash_before)
+        .sum()
+}
+
+fn group_monthly_returns_from_values(
+    equity_curve: &[DailyEquityPoint],
+    values: &[f64],
+) -> Vec<f64> {
+    let mut month_last = BTreeMap::<(i32, u32), f64>::new();
+    let mut month_first = BTreeMap::<(i32, u32), f64>::new();
+    let mut previous_value = 1.0;
+    for (point, value) in equity_curve.iter().zip(values.iter().copied()) {
+        let key = (point.date.year(), point.date.month());
+        month_first.entry(key).or_insert(previous_value);
+        month_last.insert(key, value);
+        previous_value = value;
+    }
+    let mut keys = month_last.keys().copied().collect::<Vec<_>>();
+    keys.sort_unstable();
+    keys.into_iter()
+        .filter_map(|key| {
+            let first = month_first.get(&key).copied().unwrap_or_default();
+            let last = month_last.get(&key).copied().unwrap_or_default();
+            if first.abs() < f64::EPSILON {
+                None
+            } else {
+                Some((last / first) - 1.0)
+            }
+        })
+        .collect()
+}
+
 fn group_monthly_returns<F>(
     equity_curve: &[DailyEquityPoint],
     initial_value: f64,
@@ -486,6 +591,8 @@ mod tests {
             cash: total_equity,
             market_value: 0.0,
             total_equity,
+            external_cash_flow: 0.0,
+            unit_nav: total_equity / 100.0,
             benchmark_close,
             benchmark_prev_close,
             notes: String::new(),
@@ -499,8 +606,38 @@ mod tests {
             equity_point("2025-01-02", 100.0, 5797.089, 5957.717),
             equity_point("2025-12-31", 120.0, 7595.285, 7597.299),
         ];
-        let metrics = compute_backtest_metrics(&curve, &[], &[], 100.0);
+        let metrics = compute_backtest_metrics(&curve, &[], &[], &[], 100.0);
         let expected = 7595.285 / 5957.717 - 1.0;
         assert!((metrics.benchmark_cumulative_return - expected).abs() < 1e-12);
     }
+
+    #[test]
+    fn external_cash_flow_is_excluded_from_return_and_reported_separately() {
+        let curve = vec![
+            equity_point("2025-01-02", 100.0, 100.0, 100.0),
+            DailyEquityPoint {
+                date: NaiveDate::from_ymd_opt(2025, 1, 3).unwrap(),
+                cash: 220.0,
+                market_value: 0.0,
+                total_equity: 220.0,
+                external_cash_flow: 100.0,
+                unit_nav: 1.1,
+                benchmark_close: 100.0,
+                benchmark_prev_close: 100.0,
+                notes: String::new(),
+                diagnostics: String::new(),
+            },
+        ];
+        let events = vec![AccountEvent {
+            date: NaiveDate::from_ymd_opt(2025, 1, 3).unwrap(),
+            cash_before: 100.0,
+            cash_after: 200.0,
+            total_equity: 200.0,
+            note: "deposit_withdraw amount=100.00 reason=test".to_string(),
+        }];
+        let metrics = compute_backtest_metrics(&curve, &[], &[], &events, 100.0);
+        assert!((metrics.total_return - 0.1).abs() < 1e-12);
+        assert!((metrics.unit_nav - 1.1).abs() < 1e-12);
+        assert!((metrics.external_cash_flow_total - 100.0).abs() < 1e-12);
+    }
 }

crates/fidc-core/src/platform_runtime_schema.rs

@@ -67,6 +67,7 @@ const RESERVED_SCOPE_NAMES: &[&str] = &[
     // day-level
     "signal_close",
     "benchmark_close",
+    "benchmark_signal_close",
     "signal_ma5",
     "signal_ma10",
     "signal_ma20",
@@ -135,11 +136,12 @@ const RESERVED_SCOPE_NAMES: &[&str] = &[
     "free_float_cap",
     "pe_ttm",
     "volume",
-    "tick_volume",
+    "minute_volume",
     "bid1_volume",
     "ask1_volume",
     "turnover_ratio",
     "effective_turnover_ratio",
+    "up_days_stock",
     "open",
     "high",
     "low",
@@ -154,7 +156,9 @@ const RESERVED_SCOPE_NAMES: &[&str] = &[
     "round_lot",
     "paused",
     "is_st",
+    "is_star_st",
     "is_kcb",
+    "is_bjse",
     "is_one_yuan",
     "is_new_listing",
     "allow_buy",
@@ -223,6 +227,9 @@ const RUNTIME_HELPER_FUNCTIONS: &[&str] = &[
     "factor",
     "day_factor",
     "rolling_mean",
+    "rolling_mean_current",
+    "rolling_max_current",
+    "rolling_return_stddev_current",
     "ma",
     "sma",
     "vma",
@@ -318,17 +325,21 @@ mod tests {
 
     #[test]
     fn runtime_schema_includes_known_identifiers() {
-        let names: std::collections::HashSet<&str> =
-            RESERVED_SCOPE_NAMES.iter().copied().collect();
+        let names: std::collections::HashSet<&str> = RESERVED_SCOPE_NAMES.iter().copied().collect();
         for required in [
             "signal_close",
             "benchmark_close",
+            "benchmark_signal_close",
             "close",
             "avg_cost",
             "current_price",
             "stock_ma_short",
+            "up_days_stock",
         ] {
-            assert!(names.contains(required), "missing reserved name: {required}");
+            assert!(
+                names.contains(required),
+                "missing reserved name: {required}"
+            );
         }
 
         let helpers: std::collections::HashSet<&str> =

crates/fidc-core/src/rules.rs

@@ -2,6 +2,7 @@ use chrono::NaiveDate;
 
 use crate::data::{CandidateEligibility, DailyMarketSnapshot, PriceField};
 use crate::portfolio::Position;
+use crate::risk_control::ChinaAShareRiskControl;
 
 #[derive(Debug, Clone)]
 pub struct RuleCheck {
@@ -26,6 +27,10 @@ impl RuleCheck {
 }
 
 pub trait EquityRuleHooks {
+    fn duplicates_standard_china_risk(&self) -> bool {
+        false
+    }
+
     fn can_buy(
         &self,
         execution_date: NaiveDate,
@@ -47,21 +52,11 @@ pub trait EquityRuleHooks {
 #[derive(Debug, Clone, Default)]
 pub struct ChinaEquityRuleHooks;
 
-impl ChinaEquityRuleHooks {
-    fn at_upper_limit(snapshot: &DailyMarketSnapshot, price_field: PriceField) -> bool {
-        snapshot.is_at_upper_limit_price(snapshot.buy_price(price_field))
-    }
-
-    fn at_lower_limit(snapshot: &DailyMarketSnapshot, price_field: PriceField) -> bool {
-        let check_price = match price_field {
-            PriceField::Last => snapshot.price(PriceField::Last),
-            _ => snapshot.sell_price(price_field),
-        };
-        snapshot.is_at_lower_limit_price(check_price)
-    }
-}
-
 impl EquityRuleHooks for ChinaEquityRuleHooks {
+    fn duplicates_standard_china_risk(&self) -> bool {
+        true
+    }
+
     fn can_buy(
         &self,
         _execution_date: NaiveDate,
@@ -69,14 +64,14 @@ impl EquityRuleHooks for ChinaEquityRuleHooks {
         candidate: &CandidateEligibility,
         price_field: PriceField,
     ) -> RuleCheck {
-        if snapshot.paused || candidate.is_paused {
-            return RuleCheck::reject("paused");
-        }
-        if !candidate.allow_buy {
-            return RuleCheck::reject("buy disabled by eligibility flags");
-        }
-        if Self::at_upper_limit(snapshot, price_field) {
-            return RuleCheck::reject("open at or above upper limit");
+        if let Some(reason) = ChinaAShareRiskControl::buy_rejection_reason(
+            _execution_date,
+            candidate,
+            snapshot,
+            None,
+            ChinaAShareRiskControl::buy_check_price(snapshot, price_field),
+        ) {
+            return RuleCheck::reject(reason);
         }
 
         RuleCheck::allow()
@@ -90,17 +85,15 @@ impl EquityRuleHooks for ChinaEquityRuleHooks {
         position: &Position,
         price_field: PriceField,
     ) -> RuleCheck {
-        if snapshot.paused || candidate.is_paused {
-            return RuleCheck::reject("paused");
-        }
-        if !candidate.allow_sell {
-            return RuleCheck::reject("sell disabled by eligibility flags");
-        }
-        if Self::at_lower_limit(snapshot, price_field) {
-            return RuleCheck::reject("open at or below lower limit");
-        }
-        if position.sellable_qty(execution_date) == 0 {
-            return RuleCheck::reject("t+1 sellable quantity is zero");
+        if let Some(reason) = ChinaAShareRiskControl::sell_rejection_reason(
+            execution_date,
+            candidate,
+            snapshot,
+            None,
+            Some(position),
+            ChinaAShareRiskControl::sell_check_price(snapshot, price_field),
+        ) {
+            return RuleCheck::reject(reason);
         }
 
         RuleCheck::allow()

crates/fidc-core/src/scheduler.rs

@@ -7,7 +7,7 @@ pub enum ScheduleStage {
     BeforeTrading,
     OpenAuction,
     Bar,
-    Tick,
+    Minute,
     OnDay,
     AfterTrading,
     Settlement,
@@ -164,6 +164,16 @@ impl<'a> Scheduler<'a> {
             .collect()
     }
 
+    /// Evaluate only the trading-calendar frequency of a rule.
+    ///
+    /// Strategy callbacks and order execution clocks are separate contracts:
+    /// a 15:00 schedule is still due on the same daily/weekly/monthly trading
+    /// date even when the engine's coarse `on_day` callback runs at another
+    /// default time. Exact clock matching remains in `triggered_rules_at`.
+    pub fn is_due_on(&self, date: NaiveDate, rule: &ScheduleRule) -> bool {
+        self.matches(date, rule)
+    }
+
     fn matches(&self, date: NaiveDate, rule: &ScheduleRule) -> bool {
         match &rule.frequency {
             ScheduleFrequency::Daily => true,
@@ -225,7 +235,7 @@ pub fn default_stage_time(stage: ScheduleStage) -> Option<NaiveTime> {
         ScheduleStage::BeforeTrading => Some(NaiveTime::from_hms_opt(9, 0, 0).expect("valid time")),
         ScheduleStage::OpenAuction => Some(NaiveTime::from_hms_opt(9, 31, 0).expect("valid time")),
         ScheduleStage::Bar => Some(NaiveTime::from_hms_opt(10, 18, 0).expect("valid time")),
-        ScheduleStage::Tick => None,
+        ScheduleStage::Minute => None,
         ScheduleStage::OnDay => Some(NaiveTime::from_hms_opt(10, 18, 0).expect("valid time")),
         ScheduleStage::AfterTrading => Some(NaiveTime::from_hms_opt(15, 0, 0).expect("valid time")),
         ScheduleStage::Settlement => Some(NaiveTime::from_hms_opt(15, 1, 0).expect("valid time")),
@@ -265,6 +275,29 @@ mod tests {
         ])
     }
 
+    #[test]
+    fn date_due_is_independent_from_the_order_execution_clock() {
+        let calendar = sample_calendar();
+        let scheduler = Scheduler::new(&calendar);
+        let daily = ScheduleRule::daily("close_signal", ScheduleStage::OnDay)
+            .with_time_rule(ScheduleTimeRule::physical_time(15, 0));
+
+        assert!(scheduler.is_due_on(d(2025, 1, 30), &daily));
+        assert!(scheduler.is_due_on(d(2025, 1, 31), &daily));
+        assert!(scheduler.triggered_rules_at(
+            d(2025, 1, 30),
+            ScheduleStage::OnDay,
+            Some(NaiveTime::from_hms_opt(15, 0, 0).unwrap()),
+            std::slice::from_ref(&daily),
+        ).len() == 1);
+        assert!(scheduler.triggered_rules_at(
+            d(2025, 1, 30),
+            ScheduleStage::OnDay,
+            Some(NaiveTime::from_hms_opt(10, 18, 0).unwrap()),
+            std::slice::from_ref(&daily),
+        ).is_empty());
+    }
+
     #[test]
     fn scheduler_matches_daily_weekly_and_monthly_rules() {
         let calendar = sample_calendar();

crates/fidc-core/src/strategy_ai.rs

@@ -69,7 +69,30 @@ pub struct StrategyAiCatalog {
     pub indicator_factors: Vec<String>,
     #[serde(default)]
     #[serde(skip_serializing_if = "Vec::is_empty")]
-    pub clickhouse_table_fields: Vec<ManualFactorSource>,
+    pub data_lake_fields: Vec<ManualFactorSource>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct StrategyAiHoldingCountContract {
+    #[serde(
+        default,
+        alias = "holdingCount",
+        alias = "holding_count",
+        alias = "targetHoldingCount",
+        alias = "target_holding_count"
+    )]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub count: Option<i64>,
+    #[serde(
+        default,
+        alias = "kind",
+        alias = "holdingCountMode",
+        alias = "holding_count_mode",
+        alias = "targetHoldingCountMode",
+        alias = "target_holding_count_mode"
+    )]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mode: Option<String>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -79,6 +102,9 @@ pub struct StrategyAiGenerateRequest {
     pub market: String,
     pub benchmark_symbol: String,
     pub signal_symbol: String,
+    #[serde(default, alias = "holdingCountContract")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub holding_count_contract: Option<StrategyAiHoldingCountContract>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -87,8 +113,15 @@ pub struct StrategyAiOptimizeRequest {
     pub objective: String,
     pub result_summary: serde_json::Value,
     pub diagnostics: Vec<String>,
+    #[serde(default, alias = "holdingCountContract")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub holding_count_contract: Option<StrategyAiHoldingCountContract>,
 }
 
+const PERFORMANCE_ACCEPTANCE_CONTRACT_PROMPT: &str = "收益验收合同：收益、回撤、年度收益、样本外区间及比较运算符只能来自用户目标、请求约束或不可变 candidate/promotion contract；不得注入 120% 或其他默认数值，也不得提高、降低或替换已经明确的门槛。没有明确数值合同时只做策略有效性、数据时序和风险审计，禁止声称收益已经达标；存在冻结合同时必须逐项按原运算符验证，不能只看总收益。";
+const DEFAULT_RISK_POLICY_DSL_PROMPT: &str = "reject_st_selection=false、reject_st_buy=true、reject_star_st_selection=false、reject_star_st_buy=true、reject_paused_selection=false、reject_paused_buy=true、reject_paused_sell=true、reject_inactive_selection=false、reject_inactive_buy=true、reject_inactive_sell=true、reject_new_listing_selection=false、reject_new_listing_buy=true、reject_kcb_selection=false、reject_kcb_buy=true、reject_bjse_selection=false、reject_bjse_buy=true、reject_one_yuan_selection=false、reject_one_yuan_buy=true、respect_allow_buy_sell=true、reject_upper_limit_selection=false、reject_lower_limit_selection=false、reject_upper_limit_buy=true、reject_lower_limit_sell=true、forbid_same_day_rebuy_after_sell=true、blacklist_enabled=true、allow_market_orders=true、live_trading_enabled=false、volume_limit_enabled=true、liquidity_limit_enabled=true、volume_percent=0.25、commission_rate=0.0003、minimum_commission=5、stamp_tax_rate_before_change=0.001、stamp_tax_rate_after_change=0.0005、stamp_tax_change_date=\"2023-08-28\"";
+const DEFAULT_RISK_POLICY_DSL_CODE: &str = "reject_st_selection=false, reject_st_buy=true, reject_star_st_selection=false, reject_star_st_buy=true, reject_paused_selection=false, reject_paused_buy=true, reject_paused_sell=true, reject_inactive_selection=false, reject_inactive_buy=true, reject_inactive_sell=true, reject_new_listing_selection=false, reject_new_listing_buy=true, reject_kcb_selection=false, reject_kcb_buy=true, reject_bjse_selection=false, reject_bjse_buy=true, reject_one_yuan_selection=false, reject_one_yuan_buy=true, respect_allow_buy_sell=true, reject_upper_limit_selection=false, reject_lower_limit_selection=false, reject_upper_limit_buy=true, reject_lower_limit_sell=true, forbid_same_day_rebuy_after_sell=true, blacklist_enabled=true, allow_market_orders=true, live_trading_enabled=false, volume_limit_enabled=true, liquidity_limit_enabled=true, volume_percent=0.25, commission_rate=0.0003, minimum_commission=5, stamp_tax_rate_before_change=0.001, stamp_tax_rate_after_change=0.0005, stamp_tax_change_date=\"2023-08-28\"";
+
 pub fn built_in_strategy_manual() -> StrategyAiManual {
     StrategyAiManual {
         title: "OmniQuant 平台策略脚本手册".to_string(),
@@ -97,11 +130,12 @@ pub fn built_in_strategy_manual() -> StrategyAiManual {
             "平台策略脚本采用声明式 DSL + 表达式执行模型。".to_string(),
             "支持 let 变量、fn 自定义函数、when/unless/else 条件块、可用指标/因子字段映射。".to_string(),
             "支持数值型和字符串型因子，字符串字段可用于行业、概念、标签、板块等分类过滤。".to_string(),
-            "当前默认回测数据已支持 OHLCV、市值、流通市值、换手率、有效换手率、上市天数、停牌/ST/板块、涨跌停价格、tick 触达涨跌停、常用价格/成交量均线，以及 stock_indicator_factors_v1 中已入库的通用指标因子。".to_string(),
+            "用户明确指定目标持仓数量或最低持仓数量时，selection.limit 必须严格表达该数量；不要因为优化收益、减少交易或转换框架而擅自改小持仓数。".to_string(),
+            "当前默认回测数据已支持 OHLCV、市值、流通市值、换手率、有效换手率、上市天数、停牌/ST/板块、涨跌停价格、分钟线触达涨跌停、常用价格/成交量均线，以及 stock_indicator_factors_v1 中已入库的通用指标因子。".to_string(),
             "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(),
+            "next_bar_open 会在 T 日收盘冻结目标金额或目标权益，并在下一可交易日按实际 open、滑点、手续费和证券数量步长重算股数；不得把执行日 open/high/low/close 当成下单前已知信息，也不得用 T+1 prev_close 或 T 日估算股数直接成交；涨停买入和跌停卖出风控必须用实际 next-open 成交价比较，不能用执行日 close/last 或 next-close。".to_string(),
             "自定义 fn 必须通过参数传入运行时字段；不要用 fn score() 这类零参数函数直接引用 market_cap、close、ma5 等股票字段。".to_string(),
             "禁止自由 Python/JavaScript 命令式语句，最终必须输出平台 DSL。".to_string(),
         ],
@@ -203,8 +237,8 @@ pub fn built_in_strategy_manual() -> StrategyAiManual {
                 detail: "支持按交易周或交易月调仓，例如 rebalance.weekly(weekday=5).at([\"10:18\"])、rebalance.weekly(tradingday=-1).at([\"10:18\"])、rebalance.monthly(tradingday=1).at([\"10:18\"])。`.at([...])` 的最后一个时刻会编进分钟级 schedule/time_rule；当前平台把 on_day 近似到 10:18，把 open_auction 近似到 09:31。".to_string(),
             },
             ManualSection {
-                title: "bar / tick 生命周期".to_string(),
-                detail: "回测内核支持 平台内核 风格的 bar/tick 生命周期：日内会发布 pre_bar/bar/post_bar 过程事件；存在 tick 订阅或 tick 调度规则时，会按 execution_quotes 的时间顺序发布 pre_tick/tick/post_tick，并把 tick 阶段下单限制在当前 tick 时间窗内撮合。平台 DSL 中可通过 subscribe([...])、trading.subscription_guard(true) 和 process_event 字段配合显式订单模拟 tick 订阅策略。".to_string(),
+                title: "bar / minute execution 生命周期".to_string(),
+                detail: "回测内核支持 平台内核 风格的 bar/分钟执行价生命周期：日内会发布 pre_bar/bar/post_bar 过程事件；存在分钟执行价订阅或分钟调度规则时，会按 execution_quotes 的时间顺序发布 pre_minute/minute/post_minute 过程事件，并把日内阶段下单限制在当前分钟执行价时间窗内撮合。平台 DSL 中可通过 subscribe([...])、trading.subscription_guard(true) 和 process_event 字段配合显式订单模拟日内订阅策略。".to_string(),
             },
             ManualSection {
                 title: "selection.market_cap_band / selection.limit / ordering.rank_by / ordering.rank_expr".to_string(),
@@ -214,21 +248,33 @@ pub fn built_in_strategy_manual() -> StrategyAiManual {
                 title: "filter.stock_expr / risk.stop_loss / risk.take_profit / allocation.buy_scale".to_string(),
                 detail: "表达式型规则，支持多条组合。stop_loss/take_profit 多条按 OR 组合，filter.stock_expr 多条按 AND 组合。".to_string(),
             },
+            ManualSection {
+                title: "risk.policy / risk.blacklist".to_string(),
+                detail: "统一配置 FIDC 基础风控。risk.policy(...) 支持 reject_st_selection、reject_st_buy、reject_star_st_selection、reject_star_st_buy、reject_paused_selection、reject_paused_buy、reject_paused_sell、reject_inactive_selection、reject_inactive_buy、reject_inactive_sell、reject_new_listing_selection、reject_new_listing_buy、reject_kcb_selection、reject_kcb_buy、reject_bjse_selection、reject_bjse_buy、reject_one_yuan_selection、reject_one_yuan_buy、respect_allow_buy_sell、reject_upper_limit_selection、reject_lower_limit_selection、reject_upper_limit_buy、reject_lower_limit_sell、forbid_same_day_rebuy_after_sell、blacklist_enabled、allow_market_orders、live_trading_enabled、blacklisted_symbols、volume_limit_enabled、liquidity_limit_enabled、volume_percent、commission_rate、minimum_commission、stamp_tax_rate_before_change、stamp_tax_rate_after_change、stamp_tax_change_date 等命名参数；risk.blacklist([\"600000.SH\"]) 写策略级黑名单。框架默认的 ST、*ST、停牌、退市、科创、北交所、一元、涨跌停、同日卖出禁买、黑名单、成交量和费用等基础风控必须走 risk.policy 或运行态 RiskLimits，不能被转换器隐式写进 universe.exclude 或 filter.stock_expr；但源策略明确写出的业务选股排除属于策略本身，必须原样保留在 filter.stock_expr，并且不能反向修改冻结的 reject_*_selection 开关。PG/Source Lake 是真相源，Redis 只可做当日锁、热配置缓存和配置变更通知。".to_string(),
+            },
             ManualSection {
                 title: "corporate_actions.dividend_reinvestment".to_string(),
                 detail: "支持 corporate_actions.dividend_reinvestment(true)。开启后，现金分红到账会优先按 round lot 回补成同一只股票，零头保留为现金。".to_string(),
             },
             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 成交；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(),
+                detail: "设置回测全局撮合模式和滑点。日线回测只允许 execution.matching_type(\"current_bar_close\") 或 execution.matching_type(\"next_bar_open\")；current_bar_close 使用决策日当日 close，next_bar_open 在 T 日收盘冻结目标金额或目标权益，并在下一可交易日按实际 open、滑点、手续费和证券数量步长重算股数，保证执行金额加手续费不超过分配金额；禁止把执行日 open/high/low/close 解释为下单前已知数据，也禁止用 T+1 prev_close 或 T 日估算股数直接成交；next_bar_open 的涨停买入和跌停卖出判断必须比较实际 open 成交价与涨跌停价，不能用执行日 close/last 或 next-close。金额预算始终严格，execution.strict_value_budget(false) 会被拒绝。分钟线回测使用当前分钟价格成交，只能写 execution.matching_type(\"minute_last\")；不要把 vwap、twap、open_auction、minute_best_own、minute_best_counterparty 写成全局 matching_type，这些只属于显式订单或内部撮合能力。日线调仓现金口径由 execution.rebalance_cash_mode(\"sell_then_buy\" | \"same_point_net\" | \"pre_open_cash\") 或页面/API 参数控制，默认 sell_then_buy；sell_then_buy_delay_slippage_rate 只来自页面/API 执行参数，默认 0，不要写进策略表达式。滑点支持 execution.slippage(\"none\") / execution.slippage(\"price_ratio\", 请求滑点率，例如 0.002) / execution.slippage(\"tick_size\", 1) / execution.slippage(\"limit_price\")，其中 limit_price 会在限价单成交时按挂单价模拟 平台内核 的最坏成交价。".to_string(),
             },
             ManualSection {
-                title: "期货提交校验".to_string(),
-                detail: "期货订单进入撮合前会先执行账户与交易规则校验：合约必须在上市/退市日期范围内，日行情不能停牌，trading_phase 需处于 continuous/trading/open_auction/auction/call_auction/opening_auction 等可交易阶段，限价必须为正且按 futures_trading_parameters.price_tick 或日行情 price_tick 对齐，并且不能越过 upper_limit/lower_limit；随后继续检查反向挂单自成交风险、保证金和可平数量。服务层可通过 FuturesValidationConfig 分别关闭 active instrument、trading phase、limit price tick、price limit 校验，用于兼容特殊数据，但默认全部开启。".to_string(),
+                title: "期货 runtime action 与提交校验".to_string(),
+                detail: "runtimeExpressions.trading.actions 支持 futures_order、futures_open、futures_close、futures_close_today、futures_close_yesterday；字段包括 symbol、direction=long|short、quantityExpr/amountExpr、可选 limitPriceExpr、transactionCostExpr、whenExpr 和 reason。期货-only 策略把请求初始资金分配给期货账户且股票账户为0；股票+期货混合策略必须显式声明 futuresInitialCash，可选 stockInitialCash。合约必须先由 Source Lake 发布 futures_contract_daily、futures_contract_spec_history、futures_cost_margin_history 三张真实数据集；缺任一张时生成/回测必须失败，禁止手写默认乘数、保证金、费用或价格。订单进入撮合前继续检查上市/退市日期、停牌、trading_phase、限价 tick、涨跌停、反向挂单自成交、保证金和可平今昨仓。".to_string(),
             },
             ManualSection {
-                title: "trading.rotation / order.* / cancel.* / update_universe / subscribe".to_string(),
-                detail: "支持显式下单、撤单、AlgoOrder、动态 universe 和账户资金动作。可以用 trading.rotation(false) 关闭默认轮动链路，再用 trading.stage(\"open_auction\" | \"on_day\") 指定执行阶段；需要模拟 平台内核 的 tick 订阅保护时，可写 trading.subscription_guard(true)，未订阅 symbol 的显式订单会被拦截，TargetPortfolioSmart + AlgoOrder 会过滤未订阅标的。用 trading.schedule.daily().at([\"10:18\"]) / trading.schedule.weekly(weekday=5).at([\"10:18\"]) / trading.schedule.weekly(tradingday=-1).at([\"10:18\"]) / trading.schedule.monthly(tradingday=1).at([\"10:18\"]) 指定触发频率和分钟级 time_rule，然后写 order.shares(\"600000.SH\", 1000)、order.target_shares(\"600000.SH\", 2000)、order.value(\"600000.SH\", cash * 0.25)、order.target_percent(\"600000.SH\", 0.05)、order.limit_value(\"600000.SH\", cash * 0.25, open * 0.99)、order.vwap_value(\"600000.SH\", cash * 0.25, \"09:31\", \"09:40\")、order.twap_percent(\"600000.SH\", 0.05, \"10:00\", \"10:30\")、order.target_portfolio_smart(weights={\"600000.SH\": 0.3, \"000001.SZ\": 0.2}, order_prices=VWAPOrder(930, 940), valuation_prices={\"600000.SH\": prev_close})、order.target_portfolio_smart(weights={\"600000.SH\": 0.3, \"000001.SZ\": 0.2}, order_prices={\"600000.SH\": open * 0.99}, valuation_prices={\"600000.SH\": prev_close})、cancel.order(12345)、cancel.symbol(\"600000.SH\")、cancel.all()、update_universe([\"600000.SH\", \"000001.SZ\"])、subscribe([\"000001.SZ\"])、unsubscribe([\"000001.SZ\"])、account.deposit_withdraw(100000, receiving_days=0)、account.finance_repay(50000)、account.set_management_fee_rate(0.001)。其中 order.target_shares(...) 对应 平台内核 的 order_to，order.target_portfolio_smart(...) 对应 平台内核 的 order_target_portfolio_smart 批量目标权重语义；account.deposit_withdraw(...) 和 account.finance_repay(...) 对应 平台内核 账户出入金与融资/还款语义；order_prices 既可以是逐标的限价映射，也可以是 VWAPOrder/TWAPOrder 这类全局 AlgoOrder；order.vwap_* / order.twap_* 对应 平台内核 的 AlgoOrder 时间窗订单风格，而 update_universe/subscribe/unsubscribe 对应 平台内核 的动态 universe 与订阅接口。symbol 使用标准证券代码；数量、金额、仓位、时间窗、限价、order_id 和 symbol 列表都支持表达式；这些语句也支持放进 when/unless 条件块。".to_string(),
+                title: "trading.rotation / order.* / order.modify / cancel.* / update_universe / subscribe".to_string(),
+                detail: "支持股票显式下单、期货 runtime action、撤单、AlgoOrder、动态 universe 和账户资金动作。可以用 trading.rotation(false) 关闭默认轮动链路，再用 trading.stage(\"open_auction\" | \"on_day\") 指定执行阶段；需要模拟 平台内核 的日内订阅保护时，可写 trading.subscription_guard(true)，未订阅 symbol 的显式订单会被拦截，TargetPortfolioSmart + AlgoOrder 会过滤未订阅标的。用 trading.schedule.daily().at([\"10:18\"]) / trading.schedule.weekly(weekday=5).at([\"10:18\"]) / trading.schedule.weekly(tradingday=-1).at([\"10:18\"]) / trading.schedule.monthly(tradingday=1).at([\"10:18\"]) 指定触发频率和分钟级 time_rule，然后写 order.shares(\"600000.SH\", 1000)、order.target_shares(\"600000.SH\", 2000)、order.value(\"600000.SH\", cash * 0.25)、order.target_percent(\"600000.SH\", 0.05)、order.limit_value(\"600000.SH\", cash * 0.25, open * 0.99, time_in_force=\"gtc\")、order.vwap_value(\"600000.SH\", cash * 0.25, \"09:31\", \"09:40\")、order.twap_percent(\"600000.SH\", 0.05, \"10:00\", \"10:30\")、order.target_portfolio_smart(weights={\"600000.SH\": 0.3, \"000001.SZ\": 0.2}, order_prices=VWAPOrder(930, 940), valuation_prices={\"600000.SH\": prev_close})、cancel.order(12345)、cancel.symbol(\"600000.SH\")、cancel.all()、update_universe([\"600000.SH\", \"000001.SZ\"])、subscribe([\"000001.SZ\"])、unsubscribe([\"000001.SZ\"])、account.deposit_withdraw(100000, receiving_days=0)、account.finance_repay(50000)、account.set_management_fee_rate(0.001)。股票订单和 target_portfolio_smart 支持可选关键字 time_in_force=\"day|ioc|fok|gtc\"，编译后写入 runtimeExpressions.trading.actions[].timeInForce：DAY 日内保留并在收盘 Expired，IOC 立即撤销未成交余量，FOK 必须全量可成交否则零成交，GTC 仅支持限价单并跨交易日保留；VWAP/TWAP 不接受 FOK/GTC。期货 action 必须由编译器写入结构化 runtimeExpressions，不得让策略源码直接构造 FuturesOrderIntent 或硬编码合约参数。symbol 使用标准证券/合约代码；数量、金额、仓位、时间窗、限价、order_id 和 symbol 列表都支持表达式；这些语句也支持放进 when/unless 条件块。".to_string(),
+            },
+            ManualSection {
+                title: "order.time_in_force target runtime scope".to_string(),
+                detail: "回测支持 DAY/IOC/FOK/GTC；paper/live 当前只支持 DAY/IOC/FOK。GTC 需要持久化跨交易日 parent/child 重挂账本和券商适配器能力，在该合同实现前只允许回测，paper/live 必须明确拒绝并禁止降级为 DAY。生成策略前必须按目标运行模式选择能力。".to_string(),
+            },
+            ManualSection {
+                title: "order.modify".to_string(),
+                detail: "回测中可用 order.modify(order_id, total_quantity=?, limit_price=?) 原位修改仍未完成的限价单。total_quantity 是新的总委托量而不是增量，不能低于已成交量；改价或增量会重置盘口队列优先级，减少总量且不改价保留优先级，同时保留 order_id、有效期、累计成交和费用状态。paper/live 在适配器提供持久且确认的 cancel-replace 合同前必须拒绝该动作，不得静默转换为撤单加新订单。".to_string(),
             },
             ManualSection {
                 title: "when / unless / else".to_string(),
@@ -242,6 +288,7 @@ pub fn built_in_strategy_manual() -> StrategyAiManual {
                 fields: vec![
                     ManualField { name: "signal_open/signal_close".to_string(), field_type: "float".to_string(), detail: "信号指数当日开盘价与前一日收盘价。".to_string() },
                     ManualField { name: "benchmark_open/benchmark_close".to_string(), field_type: "float".to_string(), detail: "基准当日开盘价与前一日收盘价。".to_string() },
+                    ManualField { name: "benchmark_signal_close".to_string(), field_type: "float".to_string(), detail: "信号日收盘后可见的基准当日收盘价；用于 T 日生成信号、T+1 开盘成交的条件，不能在盘中或 T 日开盘决策中使用。".to_string() },
                     ManualField { name: "signal_ma5/signal_ma10/signal_ma20/signal_ma30".to_string(), field_type: "float".to_string(), detail: "信号指数滚动均线。".to_string() },
                     ManualField { name: "benchmark_ma5/benchmark_ma10/benchmark_ma20/benchmark_ma30".to_string(), field_type: "float".to_string(), detail: "基准指数滚动均线。".to_string() },
                     ManualField { name: "cash/available_cash/frozen_cash/market_value/total_equity".to_string(), field_type: "float".to_string(), detail: "账户可用资金、挂单冻结资金、市值与总权益；available_cash 会扣减当前买入挂单冻结估算。".to_string() },
@@ -267,17 +314,17 @@ pub fn built_in_strategy_manual() -> StrategyAiManual {
                 fields: vec![
                     ManualField { name: "symbol".to_string(), field_type: "string".to_string(), detail: "证券代码。".to_string() },
                     ManualField { name: "market_cap/free_float_cap".to_string(), field_type: "float".to_string(), detail: "总市值、流通市值。".to_string() },
-                    ManualField { name: "turnover/turnover_ratio/effective_turnover_ratio".to_string(), field_type: "float".to_string(), detail: "换手率、换手率标准字段、有效换手率；turnover 是 turnover_ratio 的兼容别名。".to_string() },
+                    ManualField { name: "turnover_ratio/effective_turnover_ratio".to_string(), field_type: "float".to_string(), detail: "换手率标准字段和有效换手率。".to_string() },
                     ManualField { name: "open/high/low/close/last/last_price/prev_close/amount".to_string(), field_type: "float".to_string(), detail: "开盘、最高、最低、收盘、盘中价、昨收和成交额。".to_string() },
                     ManualField { name: "upper_limit/lower_limit/price_tick/round_lot/minimum_order_quantity/order_step_size".to_string(), field_type: "float/int".to_string(), detail: "涨跌停、最小价位、整手、最小下单量和数量步长。KSH/BJSE 等板块可与 round_lot 不同。".to_string() },
-                    ManualField { name: "paused/is_st/is_kcb/is_one_yuan/is_new_listing".to_string(), field_type: "bool".to_string(), detail: "可交易性与板块标志。".to_string() },
+                    ManualField { name: "paused/is_st/is_star_st/is_kcb/is_one_yuan/is_new_listing".to_string(), field_type: "bool".to_string(), detail: "可交易性与板块标志，ST 与 *ST 是独立字段。".to_string() },
                     ManualField { name: "allow_buy/allow_sell/at_upper_limit/at_lower_limit".to_string(), field_type: "bool".to_string(), detail: "盘中买卖与涨跌停状态。".to_string() },
-                    ManualField { name: "touched_upper_limit/touched_lower_limit/hit_upper_limit/hit_lower_limit".to_string(), field_type: "bool".to_string(), detail: "当日 tick 曾经触达涨跌停。".to_string() },
+                    ManualField { name: "touched_upper_limit/touched_lower_limit/hit_upper_limit/hit_lower_limit".to_string(), field_type: "bool".to_string(), detail: "当日分钟执行价曾经触达涨跌停。".to_string() },
                     ManualField { name: "symbol_open_order_count/symbol_open_buy_qty/symbol_open_sell_qty/latest_symbol_open_order_id".to_string(), field_type: "int".to_string(), detail: "当前证券在挂单簿中的未成交挂单摘要和最近挂单 id。".to_string() },
                     ManualField { name: "latest_symbol_open_order_status/latest_symbol_open_order_unfilled_qty".to_string(), field_type: "string/int".to_string(), detail: "当前证券最近一笔挂单的状态和未成交数量。".to_string() },
                     ManualField { name: "in_dynamic_universe/is_subscribed".to_string(), field_type: "bool".to_string(), detail: "当前证券是否在动态 universe 内，以及是否仍在订阅集合中。".to_string() },
                     ManualField { name: "stock_ma5/stock_ma10/stock_ma20/stock_ma30".to_string(), field_type: "float".to_string(), detail: "个股价格均线内建别名，按当前交易日前 N 个已完成交易日的收盘价计算；历史窗口不足时为 NaN，比较条件会自然不通过；15 日、45 日等任意窗口请改用 sma(\"close\", n)。".to_string() },
-                    ManualField { name: "stock_volume_ma5/stock_volume_ma10/stock_volume_ma20/stock_volume_ma60".to_string(), field_type: "float".to_string(), detail: "个股成交量均线内建别名，按当前交易日前 N 个已完成交易日的成交量计算，不包含回测当天未来成交量；历史窗口不足时为 NaN，比较条件会自然不通过；任意窗口请改用 rolling_mean(\"volume\", n)。".to_string() },
+                    ManualField { name: "stock_volume_ma5/stock_volume_ma10/stock_volume_ma20/stock_volume_ma60/stock_volume_ma100".to_string(), field_type: "float".to_string(), detail: "个股成交量均线内建别名，按当前交易日前 N 个已完成交易日的成交量计算，不包含回测当天未来成交量；历史窗口不足时为 NaN，比较条件会自然不通过；任意窗口请改用 rolling_mean(\"volume\", n)。".to_string() },
                     ManualField { name: "factors[\"field\"] / factor(\"field\")".to_string(), field_type: "float/string".to_string(), detail: "当前证券当日可用因子。默认可用字段以手册的“可用指标、参数和字段”清单为准；自定义因子需要预先写入策略数据或 extra_factors。数值字段返回数字，字符串字段返回字符串。".to_string() },
                     ManualField { name: "listed_days".to_string(), field_type: "int".to_string(), detail: "上市天数。".to_string() },
                 ],
@@ -304,13 +351,13 @@ pub fn built_in_strategy_manual() -> StrategyAiManual {
         functions: vec![
             ManualFunction { name: "factor".to_string(), signature: "factor(\"column_name\")".to_string(), detail: "读取当前股票当日可用因子列。数值因子返回 float，字符串因子返回 string；缺失字段默认返回 0 或空字符串，建议重要条件配合 diagnostics 查看候选过滤数量。".to_string() },
             ManualFunction { name: "day_factor".to_string(), signature: "day_factor(\"field_name\")".to_string(), detail: "读取日级/指数级字段映射。".to_string() },
-            ManualFunction { name: "history_bars".to_string(), signature: "ctx.history_bars(symbol, count, \"1d\" | \"1m\" | \"tick\", \"close\", include_now)".to_string(), detail: "回测内核策略上下文数据 API，返回指定证券最近 N 条数值序列。日线字段支持 open/high/low/close/last/prev_close/volume/upper_limit/lower_limit；分钟或 tick 字段支持 last/bid1/ask1/volume_delta/amount_delta。日线 include_now=false 排除当前交易日；分钟/tick 会按当前 on_bar、on_tick 或调度时刻截断，include_now=false 排除当前 bar/tick，避免未来函数。".to_string() },
-            ManualFunction { name: "current_snapshot".to_string(), signature: "ctx.current_snapshot(symbol)".to_string(), detail: "读取当前交易日指定证券的日级快照，可用于获得当日 open/close/last/upper_limit/lower_limit 等字段。".to_string() },
+            ManualFunction { name: "history_bars".to_string(), signature: "ctx.history_bars(symbol, count, \"1d\" | \"1m\", \"close\", include_now)".to_string(), detail: "回测内核策略上下文数据 API，返回指定证券最近 N 条数值序列。日线字段支持 open/high/low/close/last/prev_close/volume/upper_limit/lower_limit；分钟字段支持 last/bid1/ask1/volume_delta/amount_delta。日线 include_now=false 排除当前信号日；分钟线会按当前 on_bar、日内事件或调度时刻截断，include_now=false 排除当前分钟执行价。next_bar_open 下该 API 只能看到信号日数据，不能读取实际成交日数据。".to_string() },
+            ManualFunction { name: "current_snapshot".to_string(), signature: "ctx.current_snapshot(symbol)".to_string(), detail: "读取当前信号日指定证券的日级快照，可用于获得信号日 open/close/last/upper_limit/lower_limit 等字段；next_bar_open 的实际成交日涨跌停、停牌、ST、退市、一元、黑名单、成交量和盘口流动性由撮合层按执行日判断。".to_string() },
             ManualFunction { name: "instrument/instruments/all_instruments".to_string(), signature: "ctx.instrument(symbol)".to_string(), detail: "读取证券元数据，包括名称、板块、上市日期、退市日期、最小下单量、整手、最小价位等；all_instruments 按证券代码稳定排序返回全量证券。".to_string() },
-            ManualFunction { name: "active_instruments/instruments_history".to_string(), signature: "ctx.active_instruments(&[symbol])".to_string(), detail: "active_instruments 返回当前交易日已上市且未退市的证券；instruments_history 返回给定代码的历史证券记录，包含当前已退市标的，对齐 平台内核 的 active_instruments/instruments_history 能力。".to_string() },
+            ManualFunction { name: "active_instruments/instruments_history".to_string(), signature: "ctx.active_instruments(&[symbol])".to_string(), detail: "active_instruments 返回当前信号日已上市且未退市的证券；instruments_history 返回给定代码的历史证券记录，包含当前已退市标的，对齐 平台内核 的 active_instruments/instruments_history 能力。".to_string() },
             ManualFunction { name: "get_trading_dates/get_previous_trading_date/get_next_trading_date".to_string(), signature: "ctx.get_previous_trading_date(date, n)".to_string(), detail: "交易日历 API。get_trading_dates 返回闭区间交易日；previous/next 返回相对某日向前或向后的第 n 个交易日，当前日自身不计入。".to_string() },
-            ManualFunction { name: "is_suspended/is_st_stock".to_string(), signature: "ctx.is_suspended(symbol, count)".to_string(), detail: "读取指定证券截至当前交易日最近 count 个交易日的停牌或 ST 标记，返回 bool 序列，顺序从旧到新；对应平台内核的 is_suspended/is_st_stock 数据能力。".to_string() },
-            ManualFunction { name: "get_price".to_string(), signature: "ctx.get_price(symbol, start_date, end_date, \"1d\" | \"1m\" | \"tick\")".to_string(), detail: "按日期区间读取统一 PriceBar 序列。日线返回 open/high/low/close/last/volume/盘口字段；分钟或 tick 返回按 timestamp 排序的 last/bid1/ask1/volume_delta/amount_delta 映射，便于服务层转成表格或前端明细。".to_string() },
+            ManualFunction { name: "is_suspended/is_st_stock".to_string(), signature: "ctx.is_suspended(symbol, count)".to_string(), detail: "读取指定证券截至当前信号日最近 count 个交易日的停牌或 ST 标记，返回 bool 序列，顺序从旧到新；对应平台内核的 is_suspended/is_st_stock 数据能力。执行日停牌或 ST 只能由撮合风控判断，不能在 next_bar_open 的 T 日提前固化。".to_string() },
+            ManualFunction { name: "get_price".to_string(), signature: "ctx.get_price(symbol, start_date, end_date, \"1d\" | \"1m\")".to_string(), detail: "按日期区间读取统一 PriceBar 序列。日线返回 open/high/low/close/last/volume/盘口字段；分钟线返回按 timestamp 排序的 last/bid1/ask1/volume_delta/amount_delta 映射，便于服务层转成表格或前端明细。".to_string() },
             ManualFunction { name: "get_dividend / dividend_cash / has_dividend".to_string(), signature: "dividend_cash(lookback) / has_dividend(lookback)".to_string(), detail: "高级数据 风格分红 API。Rust Context 可用 ctx.get_dividend(symbol, start_date) 读取明细；平台表达式可用 dividend_cash(lookback) 汇总当前股票最近 N 个交易日现金分红，用 has_dividend(lookback) 判断是否发生分红，也支持 dividend_cash(\"600000.SH\", lookback)。".to_string() },
             ManualFunction { name: "get_split / split_ratio / has_split".to_string(), signature: "split_ratio(lookback) / has_split(lookback)".to_string(), detail: "高级数据 风格拆分/送转 API。Rust Context 可用 ctx.get_split(symbol, start_date) 读取明细；平台表达式可用 split_ratio(lookback) 计算当前股票最近 N 个交易日累计拆分比例，has_split(lookback) 判断是否发生送转。".to_string() },
             ManualFunction { name: "get_factor / factor_value".to_string(), signature: "factor_value(\"field\", lookback=1)".to_string(), detail: "数值因子 API。factor(\"field\") 读取当前股票当日因子；factor_value(\"field\", lookback) 会在最近 N 个交易日内取该字段最新数值，适合读取任意可用指标或自定义数值因子。Rust Context 可用 ctx.get_factor(symbol, start, end, field) 读取完整数值序列。".to_string() },
@@ -327,14 +374,14 @@ pub fn built_in_strategy_manual() -> StrategyAiManual {
             ManualFunction { name: "get_dominant_future / dominant_future / dominant_future_price".to_string(), signature: "dominant_future(\"IF\") / dominant_future_price(\"IF\", \"close\", lookback=1)".to_string(), detail: "主力合约 API。dominant_future 返回当前日期匹配前缀的主力期货合约代码；dominant_future_price 读取该主力合约最近 N 个交易日指定字段的最新价格。Rust Context 可用 ctx.get_dominant_future(...) 和 ctx.get_dominant_future_price(...)。".to_string() },
             ManualFunction { name: "order/order_status/order_avg_price/order_transaction_cost".to_string(), signature: "ctx.order(order_id)".to_string(), detail: "按订单 id 查询运行时订单对象，支持已结束订单和当前挂单。返回字段包括 status、filled_quantity、unfilled_quantity、avg_price、transaction_cost、symbol、side、reason；可用便捷函数读取状态、成交均价和费用，对齐 平台内核 Order 的核心属性。".to_string() },
             ManualFunction { name: "account/portfolio_view/accounts".to_string(), signature: "ctx.account()".to_string(), detail: "返回当前股票账户/组合运行时视图，字段包括 account_type、cash、available_cash、frozen_cash、market_value、total_value、unit_net_value、daily_pnl、daily_returns、total_returns、transaction_cost、trading_pnl、position_pnl 等；DSL 中同名字段可直接使用。也可用 ctx.stock_account()、ctx.account_by_type(\"STOCK\")、ctx.accounts() 按账户类型读取；当前股票回测路径不会把 FUTURE 虚假映射成 STOCK。".to_string() },
-            ManualFunction { name: "deposit_withdraw/finance_repay/management_fee".to_string(), signature: "account.deposit_withdraw(amount, receiving_days=0)".to_string(), detail: "策略账户资金动作。deposit_withdraw 正数入金、负数出金；receiving_days 大于 0 时按交易日延迟到账，并保持净值口径不把外部资金流当成收益。finance_repay 正数融资、负数还款，会同步维护 cash_liabilities。set_management_fee_rate 设置结算管理费率；普通策略可覆盖 management_fee(ctx, rate) 自定义计算器，对齐 平台内核 管理费回调能力。".to_string() },
-            ManualFunction { name: "rolling_mean / sma / ma".to_string(), signature: "rolling_mean(\"field\", lookback) / ma(\"close\", 20)".to_string(), detail: "任意字段滚动均值，支持 close、volume、amount、turnover_ratio、effective_turnover_ratio、signal_open/signal_close、benchmark_open/benchmark_close 和所有数值型 extra_factors。个股 close 使用当前交易日前已完成收盘序列，volume 使用当前交易日前已完成成交量序列；历史窗口不足时在选股过滤和买入仓位表达式中按不通过/0 仓处理。".to_string() },
+            ManualFunction { name: "deposit_withdraw/finance_repay/management_fee".to_string(), signature: "account.deposit_withdraw(amount, receiving_days=0)".to_string(), detail: "策略账户资金动作。回测中 deposit_withdraw 正数入金、负数出金，receiving_days 大于 0 时按交易日延迟到账，并保持现金流中性净值不把外部资金流当成收益；回测 finance_repay 与 management_fee 按账户合同结算。模拟盘只接受由 runtime 明确返回的即时 deposit_withdraw，并通过幂等现金流账本落库；延迟流、融资/管理费动作必须显式失败。实盘禁止策略侧改变现金，必须以券商资产和已核验资金流水为真相，策略返回上述动作会在下单前 fail-closed。".to_string() },
+            ManualFunction { name: "rolling_mean / sma / ma".to_string(), signature: "rolling_mean(\"field\", lookback) / ma(\"close\", 20)".to_string(), detail: "任意字段滚动均值，支持 close、volume、amount、turnover_ratio、effective_turnover_ratio、signal_open/signal_close、benchmark_open/benchmark_close 和所有数值型 extra_factors。第一个参数必须是字段名或字符串字段名，不能传嵌套表达式或另一个 helper 调用。个股 close 使用当前交易日前已完成收盘序列，volume 使用当前交易日前已完成成交量序列；历史窗口不足时在选股过滤和买入仓位表达式中按不通过/0 仓处理。".to_string() },
             ManualFunction { name: "vma".to_string(), signature: "vma(60)".to_string(), detail: "rolling_mean(\"volume\", lookback) 的便捷别名，用于任意窗口成交量均线，例如 vma(5) < vma(60)。".to_string() },
-            ManualFunction { name: "rolling_sum / rolling_min / rolling_max".to_string(), signature: "rolling_sum(\"volume\", 20)".to_string(), detail: "任意数值字段滚动求和、最小值、最大值。可用于量能收缩、区间高低点、资金活跃度等过滤或排序。".to_string() },
-            ManualFunction { name: "rolling_stddev / stddev / rolling_zscore / pct_change".to_string(), signature: "stddev(\"close\", 20) / pct_change(\"close\", 10)".to_string(), detail: "滚动标准差、最新值 Z 分数和区间涨跌幅。pct_change(field, n) 会读取 n+1 个窗口点并计算 latest / first - 1。".to_string() },
-            ManualFunction { name: "数据库指标因子".to_string(), signature: "factor_value(\"ths_valid_turnover_stock\", 1)".to_string(), detail: "stock_indicator_factors_v1 中的指标会进入 extra_factors，可用 factor(\"字段\")、factors[\"字段\"]、factor_value(\"字段\", lookback) 或 rolling_mean(\"字段\", n) 读取。市值类指标统一提供亿元口径别名 ths_market_value_stock、ths_market_value_stock_bn、ths_current_mv_stock、ths_current_mv_stock_bn，同时保留 raw 后缀原始值。".to_string() },
+            ManualFunction { name: "rolling_sum / rolling_min / rolling_max".to_string(), signature: "rolling_sum(\"volume\", 20)".to_string(), detail: "任意数值字段滚动求和、最小值、最大值。第一个参数必须是字段名或字符串字段名，不能传嵌套表达式或另一个 helper 调用。可用于量能收缩、区间高低点、资金活跃度等过滤或排序。".to_string() },
+            ManualFunction { name: "rolling_stddev / stddev / rolling_zscore / pct_change".to_string(), signature: "stddev(\"close\", 20) / pct_change(\"close\", 10)".to_string(), detail: "滚动标准差、最新值 Z 分数和区间涨跌幅。第一个参数必须是字段名或字符串字段名，不能传嵌套表达式或另一个 helper 调用；需要收益率波动时先使用已注册收益率字段或发布因子，不要写 rolling_stddev(pct_change(\"close\", 1), 20)。pct_change(field, n) 会读取 n+1 个窗口点并计算 latest / first - 1。".to_string() },
+            ManualFunction { name: "Source Lake 指标因子".to_string(), signature: "factor_value(\"ths_valid_turnover_stock\", 1)".to_string(), detail: "Strategy Factory Source Lake 中已完成 PIT/as-of 审计的 source rows 字段、已发布指标或因子 artifact 会进入 extra_factors，可用 factor(\"字段\")、factors[\"字段\"]、factor_value(\"字段\", lookback) 或 rolling_mean(\"字段\", n) 读取。市值类指标统一提供亿元口径别名 ths_market_value_stock、ths_market_value_stock_bn、ths_current_mv_stock、ths_current_mv_stock_bn，同时保留 raw 后缀原始值。".to_string() },
             ManualFunction { name: "round/floor/ceil/abs/min/max/clamp".to_string(), signature: "round(x)".to_string(), detail: "常用数值函数。".to_string() },
-            ManualFunction { name: "safe_div".to_string(), signature: "safe_div(lhs, rhs, fallback)".to_string(), detail: "安全除法。".to_string() },
+            ManualFunction { name: "safe_div".to_string(), signature: "safe_div(lhs, rhs) / safe_div(lhs, rhs, fallback)".to_string(), detail: "安全除法，两参数形式默认 fallback=0。".to_string() },
             ManualFunction { name: "contains/starts_with/ends_with/lower/upper/trim/strlen".to_string(), signature: "starts_with(symbol, \"60\")".to_string(), detail: "字符串辅助函数。".to_string() },
         ],
         factor_sources: vec![
@@ -360,12 +407,12 @@ pub fn built_in_strategy_manual() -> StrategyAiManual {
             },
             ManualFactorSource {
                 table: "盘口深度参数".to_string(),
-                detail: "可选字段包括 date、symbol、timestamp、level、bid_price、bid_volume、ask_price、ask_volume。存在盘口深度时，期货 counterparty_offer / next_tick_best_counterparty 可按真实多档盘口逐档扫单；不存在时不会伪造 depth。".to_string(),
+                detail: "可选字段包括 date、symbol、timestamp、level、bid_price、bid_volume、ask_price、ask_volume。存在盘口深度时，期货 minute_best_counterparty 可按真实多档盘口逐档扫单；不存在时不会伪造 depth。".to_string(),
                 fields: vec![],
             },
             ManualFactorSource {
                 table: "期货交易参数".to_string(),
-                detail: "字段包括 symbol、effective_date、contract_multiplier、long_margin_rate、short_margin_rate、commission_type、open_commission_ratio、close_commission_ratio、close_today_commission_ratio、price_tick。回测会按交易日自动选择不晚于当前日期的最新参数，用于保证金、手续费和限价 tick 校验。".to_string(),
+                detail: "来自 futures_contract_spec_history 与 futures_cost_margin_history；字段包括 symbol、effective_date、contract_multiplier、long_margin_rate、short_margin_rate、commission_type、open_commission_ratio、close_commission_ratio、close_today_commission_ratio、price_tick。回测按交易日选择不晚于当前日期的最新参数。schema catalog 未同时发布 futures_contract_daily、futures_contract_spec_history、futures_cost_margin_history 时，该能力视为不可用。".to_string(),
                 fields: vec![],
             },
         ],
@@ -383,8 +430,8 @@ pub fn built_in_strategy_manual() -> StrategyAiManual {
                 code: "filter.stock_expr(industry_name(\"citics\", 1) == \"电子\" && factor_text(\"concept\") == \"ai_chip\")".to_string(),
             },
             ManualExample {
-                title: "next tick 撮合 + tick 滑点".to_string(),
-                code: "execution.matching_type(\"next_tick_last\")\nexecution.slippage(\"tick_size\", 1)".to_string(),
+                title: "分钟执行价撮合 + 最小价位滑点".to_string(),
+                code: "execution.matching_type(\"minute_last\")\nexecution.slippage(\"tick_size\", 1)".to_string(),
             },
             ManualExample {
                 title: "动态 universe 和订阅".to_string(),
@@ -432,17 +479,22 @@ pub fn render_manual_markdown(manual: &StrategyAiManual) -> String {
     out.push_str("## AI 代码生成硬约束\n");
     out.push_str("- 只输出完整 `engine-script` 代码；第一行必须是 `strategy(\"...\")`、`let`、`fn`、`const` 或 `//`。\n");
     out.push_str("- 禁止输出 Markdown、解释、推理过程、JSON 包装、手册复述或结果报告。\n");
-    out.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`。\n");
+    out.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`、`risk.policy`、`risk.blacklist`、`execution.matching_type`、`execution.rebalance_cash_mode`、`execution.slippage`、`universe.exclude`。\n");
+    out.push_str("- `universe.exclude` 只用于用户明确要求的业务排除项；框架默认的 ST、停牌、退市、新股、科创、一元、涨跌停、同日卖出禁买、成交量、手续费和印花税等基础风控必须写 `risk.policy(...)` 或由运行态 RiskLimits 注入。源策略明确写出的业务选股排除必须保留为策略表达式，不能改写冻结的 selection 风控开关。\n");
     out.push_str("- 禁止伪 DSL：`filter(...)`、`rank(...)`、`select.top(...)`、`weight.equal(...)`、`sell_rule(...)`、`backtest(...)`、`risk.max_position(...)`。\n");
     out.push_str("- 市值表达式字段只能用 `market_cap` 或 `free_float_cap`；不要使用数据库原始字段 `float_market_cap`。\n");
     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("- `rolling_mean`、`rolling_sum/min/max/stddev/zscore`、`pct_change`、`factor_value` 等 helper 的第一个参数必须是字段名或字符串字段名；不要输出 `rolling_stddev(pct_change(\"close\", 1), 20)` 这类嵌套表达式。\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(...)` 只能传一个表达式；不要生成 `risk.exposure(...)`。\n",
     );
+    out.push_str("- `filter.stock_expr(...)` 只写 alpha 或策略明确声明的业务过滤条件；转换器不得自行把框架默认基础风控注入过滤表达式。源策略明确写出的 `!is_st`、`!is_star_st`、`!is_kcb`、`!is_bjse` 等业务选股排除必须原样保留，同时冻结的 `reject_*_selection` 值不得改变。\n");
     out.push_str("- 完整三元表达式 `cond ? a : b` 可在表达式参数中使用；若当前运行环境报 `Unknown operator: '?'`，先重编译并重启回测服务，不要改写策略语义掩盖运行时漂移。\n");
     out.push_str("- `next_bar_open` 的选股、排序和仓位信号来自决策日，订单在下一可交易开盘撮合；不要使用执行日价格作为下单前信号。\n");
+    out.push_str("- `next_bar_open` 必须区分信号日、订单创建日和实际成交日：T 日只生成订单意图，涨跌停、停牌、ST、退市、一元股、黑名单、成交量和盘口流动性等执行约束必须由撮合/风控层按实际成交日判断；涨停买入和跌停卖出必须比较实际 next-open 成交价与涨跌停价，不能用执行日 close/last 或 next-close；禁止用 T 日执行状态拦截 T+1 可交易订单。\n");
+    out.push_str("- 日线目标金额、目标比例和目标权重在 `next_bar_open` 下冻结 T 日收盘目标，T+1 按实际 open、滑点、卖后买延迟滑点、手续费和证券数量步长重算股数；禁止用 T+1 prev_close、T 日估算股数或 T+1 开盘后权益替代。金额预算始终严格，不能生成 `execution.strict_value_budget(false)`。\n");
     out.push_str("- `execution.matching_type(...)` 和 `execution.slippage(...)` 必须使用手册列出的合法取值。\n\n");
     out.push_str("## 语句块\n");
     for item in &manual.statement_blocks {
@@ -514,13 +566,19 @@ pub fn build_generation_prompt(
     prompt.push_str("- 不要输出解释文本。\n");
     prompt.push_str("- 必须使用 strategy(\"...\") { ... } 语法。\n");
     prompt.push_str("- 如需自定义参数，使用 let 和 fn。\n");
-    prompt.push_str("- 优先使用数据库已存在字段和 factors[...]。\n\n");
+    prompt.push_str("- 优先使用 Strategy Factory Source Lake 已注册 source rows 字段、已发布指标/因子 artifact 和运行时已存在字段、factors[...]；不要回退 ficlaw-data、QuantAPI、旧数据中心 HTTP、ClickHouse 或临时文件。\n\n");
     prompt.push_str("- 生成的代码必须能转换为 strategy_spec 并提交 POST /v1/backtests。\n");
+    prompt.push_str("- 用户指定“持仓N只、目标持仓N、stocknum=N、selection.limit(N)”时，必须把最终持仓槽位写成 N；用户指定“至少/不少于N只”时，最终持仓槽位必须 >= N。\n");
+    prompt.push_str("- ");
+    prompt.push_str(PERFORMANCE_ACCEPTANCE_CONTRACT_PROMPT);
+    prompt.push('\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 只能传一个数值表达式，不要使用 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("只允许使用这些可编译语句：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、risk.policy、risk.blacklist、execution.matching_type、execution.rebalance_cash_mode、execution.slippage、universe.exclude。universe.exclude 只用于用户明确要求的业务排除项，不能表达 FIDC 基础风控。禁止输出 filter(...)、rank(...)、select.top(...)、weight.equal()、sell_rule(...)、backtest(...)、risk.max_position(...) 这类未支持伪语法。\n");
+    prompt.push_str(&format!("参数形态必须严格：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)；rolling_mean、rolling_sum/min/max/stddev/zscore、pct_change、factor_value 等 helper 的第一个参数必须是字段名或字符串字段名，不能传嵌套表达式或另一个 helper 调用；不要生成 fn score() 这类零参数函数，股票字段排序直接写在 ordering.rank_expr 内或用带参数函数；布尔字段按布尔使用，不要写 is_st == 0；filter.stock_expr 只写 alpha 或业务过滤条件，不要把 !is_st、!paused、!at_upper_limit、!at_lower_limit 这类基础风控散落在表达式里；risk.index_exposure 只能传一个数值表达式，不要使用 risk.exposure；risk.policy 只写 FIDC 基础风控、成交量和交易成本命名参数，必须覆盖完整默认配置面，例如 {DEFAULT_RISK_POLICY_DSL_PROMPT}，不要用它表达策略择时或收益规则；完整三元表达式 cond ? a : b 可以使用，但不得输出残缺问号/冒号片段；日线回测 execution.matching_type 只能取 current_bar_close 或 next_bar_open，分钟线回测只能取 minute_last；日线 execution.rebalance_cash_mode 只允许 same_point_net、sell_then_buy、pre_open_cash，分钟线固定使用 sell_then_buy；不要把 vwap、twap、open_auction、minute_best_own、minute_best_counterparty 写成全局 matching_type；next_bar_open 只能使用决策日信号，不能把执行日价格当作下单前信息；next_bar_open 下 T 日只生成订单意图并在收盘冻结目标金额或目标权益，T+1 按实际 open、滑点、手续费和证券数量步长重算股数，不能用 T+1 prev_close 或 T 日估算股数直接成交；涨跌停、停牌、ST、退市、一元股、黑名单、成交量和盘口流动性等执行约束必须由撮合/风控层按实际成交日判断；涨停买入和跌停卖出必须用实际 next-open 成交价比较，不能用执行日 close/last 或 next-close；禁止用 T 日执行状态拦截 T+1 可交易订单；金额预算始终严格，禁止 execution.strict_value_budget(false)；execution.slippage 必须写 execution.slippage(\"none\") 或 execution.slippage(\"price_ratio\", 请求滑点率，例如 0.002)，并且请求里指定固定滑点时必须使用请求值。\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(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 && close > 2)\nordering.rank_by(\"market_cap\", \"asc\")\nallocation.buy_scale(1.0)\nrisk.policy(");
+    prompt.push_str(DEFAULT_RISK_POLICY_DSL_CODE);
+    prompt.push_str(")\nrisk.index_exposure(1.0)\nrisk.stop_loss(holding_return < -0.08)\nexecution.slippage(\"price_ratio\", 0.002)\n}\n\n");
     prompt.push_str("用户目标：\n");
     prompt.push_str(&format!("- {}\n", request.user_goal));
     if !request.constraints.is_empty() {
@@ -546,8 +604,11 @@ 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("优化可以调整调仓周期、持仓数、市值带、filter.stock_expr、ordering.rank_expr、allocation.buy_scale、止盈止损；如上一轮无交易或质量分过低，必须先放宽过滤条件并优先使用已入库指标因子、rolling_mean/ma/vma/rolling_stddev/pct_change 等支持函数。\n");
+    prompt.push_str("优化不限制在原策略已有参数或少量扰动。只要 OmniQuant/FIDC 已支持，可以自由增加、修改、删除策略代码、参数、候选池、过滤函数、排序、仓位、止盈止损、调仓周期、指标因子和辅助函数；不得引入手册未列出的字段或外部平台 API 名称。\n");
+    prompt.push_str("持仓数量属于策略合同，不是优化自由参数。原策略或用户目标明确 stocknum、selection.limit、目标持仓N只或不少于N只时，优化后必须保留该目标槽位或满足最低槽位，不能为了收益或交易次数擅自改小。\n");
+    prompt.push_str(PERFORMANCE_ACCEPTANCE_CONTRACT_PROMPT);
+    prompt.push('\n');
+    prompt.push_str("可以使用 Strategy Factory Source Lake 已注册并完成 PIT/as-of 审计的日频 source rows 字段、已发布指标/因子 artifact 和表达式函数，例如 rolling_mean/ma/vma/rolling_sum/rolling_stddev/pct_change/factor/factor_value/factors；这些滚动/因子 helper 的字段参数只能是字段名或字符串字段名，不要嵌套表达式；不要回退 ficlaw-data、QuantAPI、旧数据中心 HTTP、ClickHouse 或临时文件。如上一轮无交易或质量分过低，必须先扩大候选覆盖并修正不可交易过滤，再优化收益。\n");
     prompt.push_str("优化目标：\n");
     prompt.push_str(&format!("- {}\n\n", request.objective));
     prompt.push_str("当前策略代码如下，仅作为输入参考；回复时不要包含 Markdown 代码围栏：\n");
@@ -569,3 +630,81 @@ pub fn build_optimization_prompt(
     prompt.push_str(manual_markdown);
     prompt
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn generation_prompt_uses_explicit_performance_acceptance_contract() {
+        let prompt = build_generation_prompt(
+            "manual",
+            &StrategyAiGenerateRequest {
+                user_goal: "生成策略".to_string(),
+                constraints: Vec::new(),
+                market: "CN_A".to_string(),
+                benchmark_symbol: "000852.SH".to_string(),
+                signal_symbol: "000001.SH".to_string(),
+                holding_count_contract: None,
+            },
+        );
+
+        assert!(prompt.contains("只能来自用户目标、请求约束或不可变 candidate/promotion contract"));
+        assert!(prompt.contains("不得注入 120% 或其他默认数值"));
+        assert!(!prompt.contains("总收益严格 > 120%"));
+        assert!(prompt.contains("Strategy Factory Source Lake 已注册 source rows 字段"));
+        assert!(prompt.contains("不要回退 ficlaw-data"));
+        assert!(prompt.contains("ClickHouse"));
+        assert!(prompt.contains("T 日只生成订单意图"));
+        assert!(prompt.contains("按实际成交日判断"));
+        assert!(prompt.contains("禁止用 T 日执行状态拦截 T+1 可交易订单"));
+        assert!(prompt.contains("execution.rebalance_cash_mode"));
+        assert!(prompt.contains("same_point_net、sell_then_buy、pre_open_cash"));
+        assert!(prompt.contains("分钟线固定使用 sell_then_buy"));
+        assert!(prompt.contains("必须覆盖完整默认配置面"));
+        assert!(prompt.contains("reject_inactive_buy=true"));
+        assert!(prompt.contains("reject_inactive_sell=true"));
+        assert!(prompt.contains("reject_new_listing_buy=true"));
+        assert!(prompt.contains("reject_kcb_buy=true"));
+        assert!(prompt.contains("reject_bjse_buy=true"));
+        assert!(prompt.contains("reject_one_yuan_buy=true"));
+        assert!(prompt.contains("respect_allow_buy_sell=true"));
+        assert!(prompt.contains("stamp_tax_rate_before_change=0.001"));
+        assert!(prompt.contains("stamp_tax_change_date=\"2023-08-28\""));
+    }
+
+    #[test]
+    fn manual_separates_explicit_business_selection_from_framework_risk_policy() {
+        let markdown = render_manual_markdown(&built_in_strategy_manual());
+        assert!(markdown.contains("源策略明确写出的业务选股排除属于策略本身"));
+        assert!(markdown.contains("不能反向修改冻结的 reject_*_selection 开关"));
+        assert!(markdown.contains("冻结的 `reject_*_selection` 值不得改变"));
+        assert!(markdown.contains("time_in_force=\"day|ioc|fok|gtc\""));
+        assert!(markdown.contains("FOK 必须全量可成交否则零成交"));
+        assert!(markdown.contains("GTC 仅支持限价单并跨交易日保留"));
+        assert!(markdown.contains("paper/live 当前只支持 DAY/IOC/FOK"));
+        assert!(markdown.contains("paper/live 必须明确拒绝并禁止降级为 DAY"));
+    }
+
+    #[test]
+    fn optimization_prompt_uses_explicit_performance_acceptance_contract() {
+        let prompt = build_optimization_prompt(
+            "manual",
+            &StrategyAiOptimizeRequest {
+                current_code: "strategy(\"demo\") {}".to_string(),
+                objective: "优化收益".to_string(),
+                result_summary: json!({ "total_return": 1.49 }),
+                diagnostics: Vec::new(),
+                holding_count_contract: None,
+            },
+        );
+
+        assert!(prompt.contains("只能来自用户目标、请求约束或不可变 candidate/promotion contract"));
+        assert!(prompt.contains("不得注入 120% 或其他默认数值"));
+        assert!(!prompt.contains("总收益严格 > 120%"));
+        assert!(prompt.contains("Strategy Factory Source Lake 已注册并完成 PIT/as-of 审计"));
+        assert!(prompt.contains("不要回退 ficlaw-data"));
+        assert!(prompt.contains("ClickHouse"));
+    }
+}

crates/fidc-core/src/universe.rs

@@ -4,6 +4,7 @@ use chrono::NaiveDate;
 use serde::Serialize;
 
 use crate::data::{BenchmarkSnapshot, DataSet, EligibleUniverseSnapshot};
+use crate::risk_control::{ChinaAShareRiskControl, FidcRiskControlConfig, FidcRiskDecisionAudit};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum BandRegime {
@@ -39,6 +40,7 @@ pub struct SelectionDiagnostics {
     pub missing_market_cap_symbols: Vec<String>,
     pub selected_symbols: Vec<String>,
     pub rejection_examples: Vec<String>,
+    pub risk_decisions: Vec<FidcRiskDecisionAudit>,
 }
 
 pub struct SelectionContext<'a> {
@@ -47,20 +49,62 @@ pub struct SelectionContext<'a> {
     pub reference_level: f64,
     pub data: &'a DataSet,
     pub dynamic_universe: Option<&'a BTreeSet<String>>,
+    pub risk_config: Option<&'a FidcRiskControlConfig>,
+    pub defer_selection_risk: bool,
 }
 
 impl SelectionContext<'_> {
     fn eligible_universe(&self) -> Vec<EligibleUniverseSnapshot> {
-        let eligible = self.data.eligible_universe_on(self.decision_date);
+        let eligible = match (self.risk_config, self.defer_selection_risk) {
+            (Some(risk_config), false) => self
+                .data
+                .eligible_universe_on_with_risk_config(self.decision_date, risk_config),
+            _ => self.data.eligible_universe_on(self.decision_date).to_vec(),
+        };
         match self.dynamic_universe {
             Some(symbols) if !symbols.is_empty() => eligible
-                .iter()
+                .into_iter()
                 .filter(|row| symbols.contains(&row.symbol))
-                .cloned()
                 .collect(),
-            _ => eligible.to_vec(),
+            _ => eligible,
         }
     }
+
+    fn selection_risk_decisions(&self) -> Vec<FidcRiskDecisionAudit> {
+        let default_risk_config;
+        let risk_config = match self.risk_config {
+            Some(value) => value,
+            None => {
+                default_risk_config = FidcRiskControlConfig::default();
+                &default_risk_config
+            }
+        };
+        let mut decisions = Vec::new();
+        for factor in self.data.factor_snapshot_rows_on(self.decision_date) {
+            if self
+                .dynamic_universe
+                .is_some_and(|symbols| !symbols.is_empty() && !symbols.contains(&factor.symbol))
+            {
+                continue;
+            }
+            let Some(candidate) = self.data.candidate(self.decision_date, &factor.symbol) else {
+                continue;
+            };
+            let Some(market) = self.data.market(self.decision_date, &factor.symbol) else {
+                continue;
+            };
+            if let Some(decision) = ChinaAShareRiskControl::selection_rejection_decision_with_config(
+                self.decision_date,
+                candidate,
+                market,
+                self.data.instrument(&factor.symbol),
+                risk_config,
+            ) {
+                decisions.push(decision);
+            }
+        }
+        decisions
+    }
 }
 
 pub trait UniverseSelector {
@@ -78,6 +122,9 @@ pub struct DynamicMarketCapBandSelector {
     pub cap_span: f64,
     pub xs: f64,
     pub top_n: usize,
+    pub padding_ratio: f64,
+    pub min_padding: f64,
+    pub max_padding: f64,
 }
 
 impl DynamicMarketCapBandSelector {
@@ -87,6 +134,9 @@ impl DynamicMarketCapBandSelector {
         cap_span: f64,
         xs: f64,
         top_n: usize,
+        padding_ratio: f64,
+        min_padding: f64,
+        max_padding: f64,
     ) -> Self {
         Self {
             base_index_level,
@@ -94,11 +144,14 @@ impl DynamicMarketCapBandSelector {
             cap_span,
             xs,
             top_n,
+            padding_ratio,
+            min_padding,
+            max_padding,
         }
     }
 
     pub fn demo(top_n: usize) -> Self {
-        Self::new(2000.0, 7.0, 10.0, 4.0 / 500.0, top_n)
+        Self::new(2000.0, 7.0, 10.0, 4.0 / 500.0, top_n, 0.5, 8.0, 20.0)
     }
 
     pub fn regime(&self, benchmark_level: f64) -> BandRegime {
@@ -114,7 +167,18 @@ impl DynamicMarketCapBandSelector {
     pub fn band_for_level(&self, benchmark_level: f64) -> (f64, f64) {
         let start = ((benchmark_level - self.base_index_level) * self.xs) + self.base_cap_floor;
         let low = start.round();
-        (low, low + self.cap_span)
+        let high = low + self.cap_span;
+
+        // Apply padding to expand the range
+        let span = high - low;
+        let padding = (span * self.padding_ratio)
+            .max(self.min_padding)
+            .min(self.max_padding);
+
+        let lower_bound = (low - padding).max(0.0);
+        let upper_bound = high + padding;
+
+        (lower_bound, upper_bound)
     }
 }
 
@@ -146,9 +210,23 @@ impl UniverseSelector for DynamicMarketCapBandSelector {
             missing_market_cap_symbols: Vec::new(),
             selected_symbols: Vec::new(),
             rejection_examples: Vec::new(),
+            risk_decisions: Vec::new(),
         };
 
-        diagnostics.factor_total = ctx.data.factor_snapshots_on(ctx.decision_date).len();
+        diagnostics.factor_total = ctx.data.factor_snapshot_rows_on(ctx.decision_date).len();
+        diagnostics.risk_decisions = ctx.selection_risk_decisions();
+        diagnostics.not_eligible_count = diagnostics.risk_decisions.len();
+        diagnostics.paused_count = diagnostics
+            .risk_decisions
+            .iter()
+            .filter(|decision| decision.rule_code == "paused")
+            .count();
+        diagnostics.rejection_examples = diagnostics
+            .risk_decisions
+            .iter()
+            .take(8)
+            .map(|decision| format!("{} rejected by {}", decision.symbol, decision.rule_code))
+            .collect();
         let eligible = ctx.eligible_universe();
         diagnostics.market_cap_missing_count =
             diagnostics.factor_total.saturating_sub(eligible.len());
@@ -201,3 +279,266 @@ fn to_universe_candidate(
         band_high,
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::data::{
+        BenchmarkSnapshot, CandidateEligibility, DailyFactorSnapshot, DailyMarketSnapshot, DataSet,
+    };
+    use crate::instrument::Instrument;
+
+    fn d() -> NaiveDate {
+        NaiveDate::from_ymd_opt(2025, 1, 2).unwrap()
+    }
+
+    fn instrument(symbol: &str) -> Instrument {
+        Instrument {
+            symbol: symbol.to_string(),
+            name: symbol.to_string(),
+            board: symbol.rsplit('.').next().unwrap_or("").to_string(),
+            round_lot: 100,
+            listed_at: Some(NaiveDate::from_ymd_opt(2020, 1, 1).unwrap()),
+            delisted_at: None,
+            status: "active".to_string(),
+        }
+    }
+
+    fn market(symbol: &str, price: f64) -> DailyMarketSnapshot {
+        DailyMarketSnapshot {
+            date: d(),
+            symbol: symbol.to_string(),
+            timestamp: Some("2025-01-02 10:00:00".to_string()),
+            day_open: price,
+            open: price,
+            high: price,
+            low: price,
+            close: price,
+            last_price: price,
+            bid1: price,
+            ask1: price,
+            prev_close: price,
+            volume: 1_000_000,
+            minute_volume: 10_000,
+            bid1_volume: 10_000,
+            ask1_volume: 10_000,
+            trading_phase: Some("continuous".to_string()),
+            paused: false,
+            upper_limit: price * 1.1,
+            lower_limit: price * 0.9,
+            price_tick: 0.01,
+        }
+    }
+
+    fn factor(symbol: &str, market_cap_bn: f64) -> DailyFactorSnapshot {
+        DailyFactorSnapshot {
+            date: d(),
+            symbol: symbol.to_string(),
+            market_cap_bn,
+            free_float_cap_bn: market_cap_bn,
+            pe_ttm: 10.0,
+            turnover_ratio: Some(0.01),
+            effective_turnover_ratio: Some(0.01),
+            extra_factors: Default::default(),
+        }
+    }
+
+    fn candidate(symbol: &str, is_st: bool, is_kcb: bool) -> CandidateEligibility {
+        CandidateEligibility {
+            date: d(),
+            symbol: symbol.to_string(),
+            is_st,
+            is_star_st: false,
+            is_new_listing: false,
+            is_paused: false,
+            allow_buy: true,
+            allow_sell: true,
+            is_kcb,
+            is_one_yuan: false,
+            risk_level_code: None,
+        }
+    }
+
+    fn benchmark() -> BenchmarkSnapshot {
+        BenchmarkSnapshot {
+            date: d(),
+            benchmark: "000852.SH".to_string(),
+            open: 2000.0,
+            close: 2000.0,
+            prev_close: 1990.0,
+            volume: 1_000_000,
+        }
+    }
+
+    #[test]
+    fn selector_records_structured_selection_risk_decisions() {
+        let data = DataSet::from_components(
+            vec![
+                instrument("000001.SZ"),
+                instrument("688001.SH"),
+                instrument("000002.SZ"),
+            ],
+            vec![
+                market("000001.SZ", 10.0),
+                market("688001.SH", 10.0),
+                market("000002.SZ", 10.0),
+            ],
+            vec![
+                factor("000001.SZ", 8.0),
+                factor("688001.SH", 9.0),
+                factor("000002.SZ", 10.0),
+            ],
+            vec![
+                candidate("000001.SZ", true, false),
+                candidate("688001.SH", false, true),
+                candidate("000002.SZ", false, false),
+            ],
+            vec![benchmark()],
+        )
+        .unwrap();
+        let selector = DynamicMarketCapBandSelector::new(2000.0, 7.0, 10.0, 0.0, 10, 0.0, 0.0, 0.0);
+        let mut risk_config = FidcRiskControlConfig::default();
+        risk_config.static_rules.reject_st_selection = true;
+        risk_config.static_rules.reject_kcb_selection = true;
+        let (_selected, diagnostics) = selector.select_with_diagnostics(&SelectionContext {
+            decision_date: d(),
+            benchmark: &benchmark(),
+            reference_level: 2000.0,
+            data: &data,
+            dynamic_universe: None,
+            risk_config: Some(&risk_config),
+            defer_selection_risk: false,
+        });
+
+        let rules = diagnostics
+            .risk_decisions
+            .iter()
+            .map(|decision| decision.rule_code.as_str())
+            .collect::<BTreeSet<_>>();
+        assert!(rules.contains("st"), "{:?}", diagnostics.risk_decisions);
+        assert!(rules.contains("kcb"), "{:?}", diagnostics.risk_decisions);
+        assert_eq!(
+            diagnostics.not_eligible_count,
+            diagnostics.risk_decisions.len()
+        );
+        assert!(
+            diagnostics.risk_decisions[0]
+                .diagnostic_line()
+                .starts_with("risk_decision=")
+        );
+    }
+
+    #[test]
+    fn selector_applies_configured_selection_risk_on_decision_date() {
+        let data = DataSet::from_components(
+            vec![
+                instrument("000001.SZ"),
+                instrument("688001.SH"),
+                instrument("000002.SZ"),
+            ],
+            vec![
+                market("000001.SZ", 10.0),
+                market("688001.SH", 10.0),
+                market("000002.SZ", 10.0),
+            ],
+            vec![
+                factor("000001.SZ", 8.0),
+                factor("688001.SH", 9.0),
+                factor("000002.SZ", 10.0),
+            ],
+            vec![
+                candidate("000001.SZ", true, false),
+                candidate("688001.SH", false, true),
+                candidate("000002.SZ", false, false),
+            ],
+            vec![benchmark()],
+        )
+        .unwrap();
+        let selector = DynamicMarketCapBandSelector::new(2000.0, 7.0, 10.0, 0.0, 10, 0.0, 0.0, 0.0);
+        let mut risk_config = FidcRiskControlConfig::default();
+        risk_config.static_rules.reject_st_selection = true;
+        risk_config.static_rules.reject_kcb_selection = true;
+        let (selected, diagnostics) = selector.select_with_diagnostics(&SelectionContext {
+            decision_date: d(),
+            benchmark: &benchmark(),
+            reference_level: 2000.0,
+            data: &data,
+            dynamic_universe: None,
+            risk_config: Some(&risk_config),
+            defer_selection_risk: false,
+        });
+
+        let selected_symbols = selected
+            .iter()
+            .map(|candidate| candidate.symbol.as_str())
+            .collect::<BTreeSet<_>>();
+        assert!(!selected_symbols.contains("000001.SZ"));
+        assert!(!selected_symbols.contains("688001.SH"));
+        assert!(selected_symbols.contains("000002.SZ"));
+        assert_eq!(diagnostics.not_eligible_count, 2);
+        let rules = diagnostics
+            .risk_decisions
+            .iter()
+            .map(|decision| decision.rule_code.as_str())
+            .collect::<BTreeSet<_>>();
+        assert!(rules.contains("st"), "{:?}", diagnostics.risk_decisions);
+        assert!(rules.contains("kcb"), "{:?}", diagnostics.risk_decisions);
+    }
+
+    #[test]
+    fn selector_can_defer_configured_selection_risk_without_losing_diagnostics() {
+        let data = DataSet::from_components(
+            vec![
+                instrument("000001.SZ"),
+                instrument("688001.SH"),
+                instrument("000002.SZ"),
+            ],
+            vec![
+                market("000001.SZ", 10.0),
+                market("688001.SH", 10.0),
+                market("000002.SZ", 10.0),
+            ],
+            vec![
+                factor("000001.SZ", 8.0),
+                factor("688001.SH", 9.0),
+                factor("000002.SZ", 10.0),
+            ],
+            vec![
+                candidate("000001.SZ", true, false),
+                candidate("688001.SH", false, true),
+                candidate("000002.SZ", false, false),
+            ],
+            vec![benchmark()],
+        )
+        .unwrap();
+        let selector = DynamicMarketCapBandSelector::new(2000.0, 7.0, 10.0, 0.0, 10, 0.0, 0.0, 0.0);
+        let mut risk_config = FidcRiskControlConfig::default();
+        risk_config.static_rules.reject_st_selection = true;
+        risk_config.static_rules.reject_kcb_selection = true;
+
+        let (selected, diagnostics) = selector.select_with_diagnostics(&SelectionContext {
+            decision_date: d(),
+            benchmark: &benchmark(),
+            reference_level: 2000.0,
+            data: &data,
+            dynamic_universe: None,
+            risk_config: Some(&risk_config),
+            defer_selection_risk: true,
+        });
+
+        let selected_symbols = selected
+            .iter()
+            .map(|candidate| candidate.symbol.as_str())
+            .collect::<BTreeSet<_>>();
+        assert!(selected_symbols.contains("000001.SZ"));
+        assert!(selected_symbols.contains("688001.SH"));
+        assert!(selected_symbols.contains("000002.SZ"));
+        let rules = diagnostics
+            .risk_decisions
+            .iter()
+            .map(|decision| decision.rule_code.as_str())
+            .collect::<BTreeSet<_>>();
+        assert!(rules.contains("st"), "{:?}", diagnostics.risk_decisions);
+        assert!(rules.contains("kcb"), "{:?}", diagnostics.risk_decisions);
+    }
+}

crates/fidc-core/tests/core_rules.rs

@@ -17,12 +17,14 @@ fn candidate() -> CandidateEligibility {
         date: d(2024, 1, 3),
         symbol: "000001.SZ".to_string(),
         is_st: false,
+        is_star_st: false,
         is_new_listing: false,
         is_paused: false,
         allow_buy: true,
         allow_sell: true,
         is_kcb: false,
         is_one_yuan: false,
+        risk_level_code: None,
     }
 }
 
@@ -41,7 +43,7 @@ fn snapshot(open: f64, upper_limit: f64, lower_limit: f64) -> DailyMarketSnapsho
         ask1: open,
         prev_close: 10.0,
         volume: 1_000_000,
-        tick_volume: 100_000,
+        minute_volume: 100_000,
         bid1_volume: 50_000,
         ask1_volume: 50_000,
         trading_phase: Some("continuous".to_string()),
@@ -65,6 +67,29 @@ fn china_cost_model_applies_minimum_commission_and_stamp_tax() {
     assert!((sell.stamp_tax - 100.0).abs() < 1e-9);
 }
 
+#[test]
+fn configured_cost_model_matches_declared_run_options() {
+    let model =
+        ChinaAShareCostModel::from_trading_constraints(fidc_core::TradingConstraintConfig {
+            commission_rate: 0.0003,
+            minimum_commission: 5.0,
+            stamp_tax_rate_before_change: 0.0005,
+            stamp_tax_rate_after_change: 0.0005,
+            ..fidc_core::TradingConstraintConfig::default()
+        });
+
+    let buy = model.calculate(d(2026, 5, 19), OrderSide::Buy, 49_978.84);
+    assert!((buy.commission - 14.993652).abs() < 1e-9);
+    assert_eq!(buy.stamp_tax, 0.0);
+
+    let sell = model.calculate(d(2026, 5, 19), OrderSide::Sell, 100_724.72);
+    assert!((sell.commission - 30.217416).abs() < 1e-9);
+    assert!((sell.stamp_tax - 50.36236).abs() < 1e-9);
+
+    let small_buy = model.calculate(d(2026, 5, 19), OrderSide::Buy, 1_000.0);
+    assert!((small_buy.commission - 5.0).abs() < 1e-9);
+}
+
 #[test]
 fn china_cost_model_switches_stamp_tax_rate_after_2023_08_28() {
     let model = ChinaAShareCostModel::default();
@@ -175,7 +200,7 @@ fn china_rule_hooks_block_buy_at_limit_up_and_sell_at_limit_down() {
 }
 
 #[test]
-fn china_rule_hooks_use_tick_size_tolerance_for_price_limits() {
+fn china_rule_hooks_use_strict_price_limits() {
     let hooks = ChinaEquityRuleHooks;
     let candidate = candidate();
 
@@ -184,6 +209,13 @@ fn china_rule_hooks_use_tick_size_tolerance_for_price_limits() {
         ..snapshot(10.9995, 11.0, 9.0)
     };
     let buy_check = hooks.can_buy(d(2024, 1, 3), &near_upper, &candidate, PriceField::Open);
+    assert!(buy_check.allowed);
+
+    let exact_upper = DailyMarketSnapshot {
+        price_tick: 0.001,
+        ..snapshot(11.0, 11.0, 9.0)
+    };
+    let buy_check = hooks.can_buy(d(2024, 1, 3), &exact_upper, &candidate, PriceField::Open);
     assert!(!buy_check.allowed);
 
     let near_lower = DailyMarketSnapshot {
@@ -199,6 +231,19 @@ fn china_rule_hooks_use_tick_size_tolerance_for_price_limits() {
         &position,
         PriceField::Open,
     );
+    assert!(sell_check.allowed);
+
+    let exact_lower = DailyMarketSnapshot {
+        price_tick: 0.001,
+        ..snapshot(9.0, 11.0, 9.0)
+    };
+    let sell_check = hooks.can_sell(
+        d(2024, 1, 3),
+        &exact_lower,
+        &candidate,
+        &position,
+        PriceField::Open,
+    );
     assert!(!sell_check.allowed);
 }
 
@@ -223,7 +268,7 @@ fn china_rule_hooks_allow_sell_when_last_price_is_above_lower_limit() {
         ask1: 2.53,
         prev_close: 2.80,
         volume: 1_000_000,
-        tick_volume: 100_000,
+        minute_volume: 100_000,
         bid1_volume: 50_000,
         ask1_volume: 50_000,
         trading_phase: Some("continuous".to_string()),

crates/fidc-core/tests/corporate_actions.rs

@@ -49,14 +49,30 @@ fn portfolio_settles_cash_receivable_on_payable_date() {
         amount: 500.0,
         reason: "cash_dividend 0.5".to_string(),
     });
+    portfolio.add_cash_receivable(CashReceivable {
+        symbol: "000002.SZ".to_string(),
+        ex_date: d(2025, 1, 2),
+        payable_date: d(2025, 1, 5),
+        amount: 250.0,
+        reason: "cash_dividend 0.25".to_string(),
+    });
 
-    let settled_early = portfolio.settle_cash_receivables(d(2025, 1, 4));
-    assert!(settled_early.is_empty());
+    let due_early = portfolio.take_due_cash_receivables(d(2025, 1, 4));
+    assert!(due_early.is_empty());
     assert!((portfolio.cash() - 1_000_000.0).abs() < 1e-9);
 
-    let settled = portfolio.settle_cash_receivables(d(2025, 1, 5));
-    assert_eq!(settled.len(), 1);
-    assert!((portfolio.cash() - 1_000_500.0).abs() < 1e-9);
+    let due = portfolio.take_due_cash_receivables(d(2025, 1, 5));
+    assert_eq!(due.len(), 2);
+    let mut cash_chain = Vec::new();
+    for receivable in &due {
+        let cash_before = portfolio.cash();
+        portfolio.settle_cash_receivable(receivable).unwrap();
+        cash_chain.push((cash_before, portfolio.cash()));
+    }
+    assert_eq!(
+        cash_chain,
+        vec![(1_000_000.0, 1_000_500.0), (1_000_500.0, 1_000_750.0)]
+    );
     assert!(portfolio.cash_receivables().is_empty());
 }
 
@@ -88,10 +104,77 @@ impl Strategy for BuyAndHoldStrategy {
             },
             notes: Vec::new(),
             diagnostics: Vec::new(),
+            risk_decisions: Vec::new(),
         })
     }
 }
 
+fn stock_market_snapshot(date: NaiveDate) -> DailyMarketSnapshot {
+    DailyMarketSnapshot {
+        date,
+        symbol: "000001.SZ".to_string(),
+        timestamp: Some(format!("{date} 10:18:00")),
+        day_open: 10.0,
+        open: 10.0,
+        high: 10.1,
+        low: 9.9,
+        close: 10.0,
+        last_price: 10.0,
+        bid1: 10.0,
+        ask1: 10.0,
+        prev_close: 10.0,
+        volume: 100_000,
+        minute_volume: 100_000,
+        bid1_volume: 100_000,
+        ask1_volume: 100_000,
+        trading_phase: Some("continuous".to_string()),
+        paused: false,
+        upper_limit: 11.0,
+        lower_limit: 9.0,
+        price_tick: 0.01,
+    }
+}
+
+fn stock_factor_snapshot(date: NaiveDate) -> DailyFactorSnapshot {
+    DailyFactorSnapshot {
+        date,
+        symbol: "000001.SZ".to_string(),
+        market_cap_bn: 20.0,
+        free_float_cap_bn: 18.0,
+        pe_ttm: 10.0,
+        turnover_ratio: Some(1.0),
+        effective_turnover_ratio: Some(1.0),
+        extra_factors: BTreeMap::new(),
+    }
+}
+
+fn stock_candidate(date: NaiveDate) -> CandidateEligibility {
+    CandidateEligibility {
+        date,
+        symbol: "000001.SZ".to_string(),
+        is_st: false,
+        is_star_st: false,
+        is_new_listing: false,
+        is_paused: false,
+        allow_buy: true,
+        allow_sell: true,
+        is_kcb: false,
+        is_one_yuan: false,
+        risk_level_code: None,
+    }
+}
+
+fn benchmark_snapshot(date: NaiveDate) -> BenchmarkSnapshot {
+    BenchmarkSnapshot {
+        date,
+        benchmark: "000300.SH".to_string(),
+        open: 100.0,
+        close: 100.0,
+        prev_close: 99.0,
+        volume: 1_000_000,
+    }
+}
+
 #[test]
 fn engine_reinvests_dividend_receivable_in_round_lots() {
     let buy_date = d(2025, 1, 1);
@@ -122,7 +205,7 @@ fn engine_reinvests_dividend_receivable_in_round_lots() {
                 ask1: 10.0,
                 prev_close: 10.0,
                 volume: 100_000,
-                tick_volume: 100_000,
+                minute_volume: 100_000,
                 bid1_volume: 100_000,
                 ask1_volume: 100_000,
                 trading_phase: Some("continuous".to_string()),
@@ -145,7 +228,7 @@ fn engine_reinvests_dividend_receivable_in_round_lots() {
                 ask1: 10.0,
                 prev_close: 10.0,
                 volume: 100_000,
-                tick_volume: 100_000,
+                minute_volume: 100_000,
                 bid1_volume: 100_000,
                 ask1_volume: 100_000,
                 trading_phase: Some("continuous".to_string()),
@@ -168,7 +251,7 @@ fn engine_reinvests_dividend_receivable_in_round_lots() {
                 ask1: 10.0,
                 prev_close: 10.0,
                 volume: 100_000,
-                tick_volume: 100_000,
+                minute_volume: 100_000,
                 bid1_volume: 100_000,
                 ask1_volume: 100_000,
                 trading_phase: Some("continuous".to_string()),
@@ -215,34 +298,40 @@ fn engine_reinvests_dividend_receivable_in_round_lots() {
                 date: buy_date,
                 symbol: "000001.SZ".to_string(),
                 is_st: false,
+                is_star_st: false,
                 is_new_listing: false,
                 is_paused: false,
                 allow_buy: true,
                 allow_sell: true,
                 is_kcb: false,
                 is_one_yuan: false,
+                risk_level_code: None,
             },
             CandidateEligibility {
                 date: ex_date,
                 symbol: "000001.SZ".to_string(),
                 is_st: false,
+                is_star_st: false,
                 is_new_listing: false,
                 is_paused: false,
                 allow_buy: true,
                 allow_sell: true,
                 is_kcb: false,
                 is_one_yuan: false,
+                risk_level_code: None,
             },
             CandidateEligibility {
                 date: payable_date,
                 symbol: "000001.SZ".to_string(),
                 is_st: false,
+                is_star_st: false,
                 is_new_listing: false,
                 is_paused: false,
                 allow_buy: true,
                 allow_sell: true,
                 is_kcb: false,
                 is_one_yuan: false,
+                risk_level_code: None,
             },
         ],
         vec![
@@ -295,12 +384,14 @@ fn engine_reinvests_dividend_receivable_in_round_lots() {
             first_date: buy_date,
         },
         BrokerSimulator::new_with_execution_price(
-            ChinaAShareCostModel::default(),
+            ChinaAShareCostModel::default()
+                .with_commission_rate(0.0008)
+                .with_minimum_commission(0.0),
             ChinaEquityRuleHooks::default(),
             PriceField::Open,
         ),
         BacktestConfig {
-            initial_cash: 11_005.0,
+            initial_cash: 11_008.0,
             benchmark_code: "000300.SH".to_string(),
             start_date: Some(buy_date),
             end_date: Some(payable_date),
@@ -327,3 +418,96 @@ fn engine_reinvests_dividend_receivable_in_round_lots() {
     assert_eq!(reinvest_fill.commission, 0.0);
     assert_eq!(reinvest_fill.stamp_tax, 0.0);
 }
+
+#[test]
+fn engine_settles_same_day_dividend_after_split_for_aiquant_semantics() {
+    let buy_date = d(2025, 1, 1);
+    let ex_date = d(2025, 1, 2);
+    let data = DataSet::from_components_with_actions(
+        vec![Instrument {
+            symbol: "000001.SZ".to_string(),
+            name: "Anchor".to_string(),
+            board: "SZ".to_string(),
+            round_lot: 100,
+            listed_at: Some(d(2020, 1, 1)),
+            delisted_at: None,
+            status: "active".to_string(),
+        }],
+        vec![
+            stock_market_snapshot(buy_date),
+            stock_market_snapshot(ex_date),
+        ],
+        vec![
+            stock_factor_snapshot(buy_date),
+            stock_factor_snapshot(ex_date),
+        ],
+        vec![stock_candidate(buy_date), stock_candidate(ex_date)],
+        vec![benchmark_snapshot(buy_date), benchmark_snapshot(ex_date)],
+        vec![CorporateAction {
+            date: ex_date,
+            symbol: "000001.SZ".to_string(),
+            payable_date: Some(ex_date),
+            share_cash: 1.05,
+            share_bonus: 0.2,
+            share_gift: 0.0,
+            issue_quantity: 0.0,
+            issue_price: 0.0,
+            reform: false,
+            adjust_factor: None,
+            successor_symbol: None,
+            successor_ratio: None,
+            successor_cash: None,
+        }],
+    )
+    .expect("dataset");
+
+    let mut engine = BacktestEngine::new(
+        data,
+        BuyAndHoldStrategy {
+            first_date: buy_date,
+        },
+        BrokerSimulator::new_with_execution_price(
+            ChinaAShareCostModel::default(),
+            ChinaEquityRuleHooks::default(),
+            PriceField::Open,
+        ),
+        BacktestConfig {
+            initial_cash: 11_008.0,
+            benchmark_code: "000300.SH".to_string(),
+            start_date: Some(buy_date),
+            end_date: Some(ex_date),
+            decision_lag_trading_days: 0,
+            execution_price_field: PriceField::Open,
+        },
+    )
+    .with_dividend_reinvestment(true);
+
+    let result = engine.run().expect("backtest run");
+    let final_holding = result
+        .holdings_summary
+        .iter()
+        .find(|row| row.symbol == "000001.SZ")
+        .expect("holding");
+    assert_eq!(final_holding.quantity, 1_300);
+
+    let reinvest_fill = result
+        .fills
+        .iter()
+        .find(|fill| fill.reason == "dividend_reinvestment")
+        .expect("reinvestment fill");
+    assert_eq!(reinvest_fill.quantity, 100);
+    assert!((reinvest_fill.price - ((10.0 - 1.05) / 1.2)).abs() < 1e-9);
+
+    assert!(
+        result
+            .position_events
+            .iter()
+            .any(|event| event.reason == "stock_split 1.200000" && event.quantity_after == 1_200)
+    );
+    assert!(
+        result
+            .account_events
+            .iter()
+            .any(|event| event.note.contains("cash_receivable_reinvested"))
+    );
+}

crates/fidc-core/tests/decision_quote_preload.rs

@@ -0,0 +1,652 @@
+use chrono::{Duration, NaiveDate, NaiveTime};
+use fidc_core::{
+    BacktestConfig, BacktestEngine, BenchmarkSnapshot, BrokerSimulator, CandidateEligibility,
+    ChinaAShareCostModel, ChinaEquityRuleHooks, DailyFactorSnapshot, DailyMarketSnapshot, DataSet,
+    IntradayExecutionQuote, MatchingType, OrderIntent, PriceField, Strategy, StrategyContext,
+    StrategyDecision,
+};
+use std::sync::{Arc, Mutex};
+
+fn d(year: i32, month: u32, day: u32) -> NaiveDate {
+    NaiveDate::from_ymd_opt(year, month, day).expect("valid date")
+}
+
+fn t(hour: u32, minute: u32, second: u32) -> NaiveTime {
+    NaiveTime::from_hms_opt(hour, minute, second).expect("valid time")
+}
+
+#[derive(Default)]
+struct DecisionQuoteReader {
+    day_count: usize,
+}
+
+impl Strategy for DecisionQuoteReader {
+    fn name(&self) -> &str {
+        "decision_quote_reader"
+    }
+
+    fn decision_quote_times(&self) -> Vec<NaiveTime> {
+        vec![t(10, 40, 0)]
+    }
+
+    fn on_day(
+        &mut self,
+        ctx: &StrategyContext<'_>,
+    ) -> Result<StrategyDecision, fidc_core::BacktestError> {
+        self.day_count += 1;
+        if self.day_count == 1 {
+            return Ok(StrategyDecision {
+                order_intents: vec![OrderIntent::Value {
+                    symbol: "000001.SZ".to_string(),
+                    value: 5_000.0,
+                    reason: "seed_position".to_string(),
+                }],
+                ..StrategyDecision::default()
+            });
+        }
+
+        assert!(
+            ctx.portfolio.position("000001.SZ").is_some(),
+            "second day should carry the first day position"
+        );
+        let quote_loaded_before_decision = ctx
+            .data
+            .execution_quotes_on(ctx.execution_date, "000001.SZ")
+            .iter()
+            .any(|quote| quote.timestamp.time() == t(10, 39, 59) && quote.last_price == 11.0);
+        assert!(
+            quote_loaded_before_decision,
+            "engine must load declared decision quote before strategy.on_day"
+        );
+        Ok(StrategyDecision::default())
+    }
+}
+
+#[test]
+fn engine_preloads_declared_decision_quotes_for_current_positions() {
+    let first = d(2026, 1, 5);
+    let second = d(2026, 1, 6);
+    let data = DataSet::from_components(
+        Vec::new(),
+        vec![
+            DailyMarketSnapshot {
+                date: first,
+                symbol: "000001.SZ".to_string(),
+                timestamp: Some("2026-01-05 15:00:00".to_string()),
+                day_open: 10.0,
+                open: 10.0,
+                high: 10.2,
+                low: 9.9,
+                close: 10.0,
+                last_price: 10.0,
+                bid1: 10.0,
+                ask1: 10.0,
+                prev_close: 9.8,
+                volume: 10_000,
+                minute_volume: 1_000,
+                bid1_volume: 10_000,
+                ask1_volume: 10_000,
+                trading_phase: Some("continuous".to_string()),
+                paused: false,
+                upper_limit: 10.78,
+                lower_limit: 8.82,
+                price_tick: 0.01,
+            },
+            DailyMarketSnapshot {
+                date: second,
+                symbol: "000001.SZ".to_string(),
+                timestamp: Some("2026-01-06 15:00:00".to_string()),
+                day_open: 10.5,
+                open: 10.5,
+                high: 11.2,
+                low: 10.4,
+                close: 10.6,
+                last_price: 10.6,
+                bid1: 10.6,
+                ask1: 10.6,
+                prev_close: 10.0,
+                volume: 10_000,
+                minute_volume: 1_000,
+                bid1_volume: 10_000,
+                ask1_volume: 10_000,
+                trading_phase: Some("continuous".to_string()),
+                paused: false,
+                upper_limit: 11.0,
+                lower_limit: 9.0,
+                price_tick: 0.01,
+            },
+        ],
+        vec![
+            DailyFactorSnapshot {
+                date: first,
+                symbol: "000001.SZ".to_string(),
+                market_cap_bn: 10.0,
+                free_float_cap_bn: 10.0,
+                pe_ttm: 10.0,
+                turnover_ratio: None,
+                effective_turnover_ratio: None,
+                extra_factors: Default::default(),
+            },
+            DailyFactorSnapshot {
+                date: second,
+                symbol: "000001.SZ".to_string(),
+                market_cap_bn: 10.0,
+                free_float_cap_bn: 10.0,
+                pe_ttm: 10.0,
+                turnover_ratio: None,
+                effective_turnover_ratio: None,
+                extra_factors: Default::default(),
+            },
+        ],
+        vec![
+            CandidateEligibility {
+                date: first,
+                symbol: "000001.SZ".to_string(),
+                is_st: false,
+                is_star_st: false,
+                is_new_listing: false,
+                is_paused: false,
+                allow_buy: true,
+                allow_sell: true,
+                is_kcb: false,
+                is_one_yuan: false,
+                risk_level_code: None,
+            },
+            CandidateEligibility {
+                date: second,
+                symbol: "000001.SZ".to_string(),
+                is_st: false,
+                is_star_st: false,
+                is_new_listing: false,
+                is_paused: false,
+                allow_buy: true,
+                allow_sell: true,
+                is_kcb: false,
+                is_one_yuan: false,
+                risk_level_code: None,
+            },
+        ],
+        vec![
+            BenchmarkSnapshot {
+                date: first,
+                benchmark: "000852.SH".to_string(),
+                open: 1000.0,
+                close: 1000.0,
+                prev_close: 990.0,
+                volume: 1_000_000,
+            },
+            BenchmarkSnapshot {
+                date: second,
+                benchmark: "000852.SH".to_string(),
+                open: 1000.0,
+                close: 1001.0,
+                prev_close: 1000.0,
+                volume: 1_000_000,
+            },
+        ],
+    )
+    .expect("dataset");
+
+    let broker = BrokerSimulator::new_with_execution_price(
+        ChinaAShareCostModel::default(),
+        ChinaEquityRuleHooks,
+        PriceField::Last,
+    )
+    .with_matching_type(MatchingType::MinuteLast)
+    .with_intraday_execution_start_time(t(10, 40, 0));
+    let config = BacktestConfig {
+        initial_cash: 10_000.0,
+        benchmark_code: "000852.SH".to_string(),
+        start_date: Some(first),
+        end_date: Some(second),
+        decision_lag_trading_days: 0,
+        execution_price_field: PriceField::Last,
+    };
+    let mut engine = BacktestEngine::new(data, DecisionQuoteReader::default(), broker, config)
+        .with_execution_quote_loader(move |request| {
+            assert_eq!(
+                request.end_time, None,
+                "decision quote preload must request latest quote at or before start_time"
+            );
+            Ok(request
+                .symbols
+                .into_iter()
+                .map(|symbol| IntradayExecutionQuote {
+                    date: request.date,
+                    symbol,
+                    timestamp: request.date.and_time(t(10, 39, 59)),
+                    last_price: if request.date == second { 11.0 } else { 10.0 },
+                    bid1: if request.date == second { 11.0 } else { 10.0 },
+                    ask1: if request.date == second { 11.0 } else { 10.0 },
+                    bid1_volume: 10_000,
+                    ask1_volume: 10_000,
+                    volume_delta: 10_000,
+                    amount_delta: 100_000.0,
+                    trading_phase: Some("continuous".to_string()),
+                })
+                .collect())
+        });
+
+    engine.run().expect("backtest should run");
+}
+
+#[test]
+fn engine_reuses_preloaded_decision_quotes_without_loader_call() {
+    let first = d(2026, 1, 5);
+    let second = d(2026, 1, 6);
+    let data = DataSet::from_components_with_actions_and_quotes(
+        Vec::new(),
+        vec![
+            DailyMarketSnapshot {
+                date: first,
+                symbol: "000001.SZ".to_string(),
+                timestamp: Some("2026-01-05 15:00:00".to_string()),
+                day_open: 10.0,
+                open: 10.0,
+                high: 10.2,
+                low: 9.9,
+                close: 10.0,
+                last_price: 10.0,
+                bid1: 10.0,
+                ask1: 10.0,
+                prev_close: 9.8,
+                volume: 10_000,
+                minute_volume: 1_000,
+                bid1_volume: 10_000,
+                ask1_volume: 10_000,
+                trading_phase: Some("continuous".to_string()),
+                paused: false,
+                upper_limit: 10.78,
+                lower_limit: 8.82,
+                price_tick: 0.01,
+            },
+            DailyMarketSnapshot {
+                date: second,
+                symbol: "000001.SZ".to_string(),
+                timestamp: Some("2026-01-06 15:00:00".to_string()),
+                day_open: 10.5,
+                open: 10.5,
+                high: 11.2,
+                low: 10.4,
+                close: 10.6,
+                last_price: 10.6,
+                bid1: 10.6,
+                ask1: 10.6,
+                prev_close: 10.0,
+                volume: 10_000,
+                minute_volume: 1_000,
+                bid1_volume: 10_000,
+                ask1_volume: 10_000,
+                trading_phase: Some("continuous".to_string()),
+                paused: false,
+                upper_limit: 11.0,
+                lower_limit: 9.0,
+                price_tick: 0.01,
+            },
+        ],
+        vec![
+            DailyFactorSnapshot {
+                date: first,
+                symbol: "000001.SZ".to_string(),
+                market_cap_bn: 10.0,
+                free_float_cap_bn: 10.0,
+                pe_ttm: 10.0,
+                turnover_ratio: None,
+                effective_turnover_ratio: None,
+                extra_factors: Default::default(),
+            },
+            DailyFactorSnapshot {
+                date: second,
+                symbol: "000001.SZ".to_string(),
+                market_cap_bn: 10.0,
+                free_float_cap_bn: 10.0,
+                pe_ttm: 10.0,
+                turnover_ratio: None,
+                effective_turnover_ratio: None,
+                extra_factors: Default::default(),
+            },
+        ],
+        vec![
+            CandidateEligibility {
+                date: first,
+                symbol: "000001.SZ".to_string(),
+                is_st: false,
+                is_star_st: false,
+                is_new_listing: false,
+                is_paused: false,
+                allow_buy: true,
+                allow_sell: true,
+                is_kcb: false,
+                is_one_yuan: false,
+                risk_level_code: None,
+            },
+            CandidateEligibility {
+                date: second,
+                symbol: "000001.SZ".to_string(),
+                is_st: false,
+                is_star_st: false,
+                is_new_listing: false,
+                is_paused: false,
+                allow_buy: true,
+                allow_sell: true,
+                is_kcb: false,
+                is_one_yuan: false,
+                risk_level_code: None,
+            },
+        ],
+        vec![
+            BenchmarkSnapshot {
+                date: first,
+                benchmark: "000852.SH".to_string(),
+                open: 1000.0,
+                close: 1000.0,
+                prev_close: 990.0,
+                volume: 1_000_000,
+            },
+            BenchmarkSnapshot {
+                date: second,
+                benchmark: "000852.SH".to_string(),
+                open: 1000.0,
+                close: 1001.0,
+                prev_close: 1000.0,
+                volume: 1_000_000,
+            },
+        ],
+        Vec::new(),
+        vec![
+            IntradayExecutionQuote {
+                date: first,
+                symbol: "000001.SZ".to_string(),
+                timestamp: first.and_time(t(10, 39, 59)),
+                last_price: 10.0,
+                bid1: 10.0,
+                ask1: 10.0,
+                bid1_volume: 10_000,
+                ask1_volume: 10_000,
+                volume_delta: 10_000,
+                amount_delta: 100_000.0,
+                trading_phase: Some("continuous".to_string()),
+            },
+            IntradayExecutionQuote {
+                date: second,
+                symbol: "000001.SZ".to_string(),
+                timestamp: second.and_time(t(10, 39, 59)),
+                last_price: 11.0,
+                bid1: 11.0,
+                ask1: 11.0,
+                bid1_volume: 10_000,
+                ask1_volume: 10_000,
+                volume_delta: 10_000,
+                amount_delta: 100_000.0,
+                trading_phase: Some("continuous".to_string()),
+            },
+        ],
+    )
+    .expect("dataset");
+
+    let broker = BrokerSimulator::new_with_execution_price(
+        ChinaAShareCostModel::default(),
+        ChinaEquityRuleHooks,
+        PriceField::Last,
+    )
+    .with_matching_type(MatchingType::MinuteLast)
+    .with_intraday_execution_start_time(t(10, 40, 0));
+    let config = BacktestConfig {
+        initial_cash: 10_000.0,
+        benchmark_code: "000852.SH".to_string(),
+        start_date: Some(first),
+        end_date: Some(second),
+        decision_lag_trading_days: 0,
+        execution_price_field: PriceField::Last,
+    };
+    let loader_calls = Arc::new(Mutex::new(0usize));
+    let captured_loader_calls = Arc::clone(&loader_calls);
+    let mut engine = BacktestEngine::new(data, DecisionQuoteReader::default(), broker, config)
+        .with_execution_quote_loader(move |_| {
+            *captured_loader_calls.lock().expect("loader mutex") += 1;
+            Ok(Vec::new())
+        });
+
+    engine.run().expect("backtest should run");
+    assert_eq!(
+        *loader_calls.lock().expect("loader mutex"),
+        0,
+        "preloaded execution quotes should satisfy decision-time quote requests"
+    );
+}
+
+#[derive(Default)]
+struct MultiTimeDecisionQuoteReader {
+    day_count: usize,
+}
+
+impl Strategy for MultiTimeDecisionQuoteReader {
+    fn name(&self) -> &str {
+        "multi_time_decision_quote_reader"
+    }
+
+    fn decision_quote_times(&self) -> Vec<NaiveTime> {
+        vec![t(10, 31, 0), t(10, 40, 0)]
+    }
+
+    fn on_day(
+        &mut self,
+        ctx: &StrategyContext<'_>,
+    ) -> Result<StrategyDecision, fidc_core::BacktestError> {
+        self.day_count += 1;
+        if self.day_count == 1 {
+            return Ok(StrategyDecision {
+                order_intents: vec![OrderIntent::Value {
+                    symbol: "000001.SZ".to_string(),
+                    value: 5_000.0,
+                    reason: "seed_position".to_string(),
+                }],
+                ..StrategyDecision::default()
+            });
+        }
+
+        let quote_times = ctx
+            .data
+            .execution_quotes_on(ctx.execution_date, "000001.SZ")
+            .iter()
+            .map(|quote| quote.timestamp.time())
+            .collect::<Vec<_>>();
+        assert!(
+            quote_times.contains(&t(10, 30, 59)),
+            "10:31 decision quote must be loaded"
+        );
+        assert!(
+            quote_times.contains(&t(10, 39, 59)),
+            "10:40 decision quote must not be skipped because 10:31 was loaded"
+        );
+        Ok(StrategyDecision::default())
+    }
+}
+
+#[test]
+fn engine_loads_distinct_decision_quote_times_on_same_day() {
+    let first = d(2026, 1, 5);
+    let second = d(2026, 1, 6);
+    let data = DataSet::from_components(
+        Vec::new(),
+        vec![
+            DailyMarketSnapshot {
+                date: first,
+                symbol: "000001.SZ".to_string(),
+                timestamp: Some("2026-01-05 15:00:00".to_string()),
+                day_open: 10.0,
+                open: 10.0,
+                high: 10.2,
+                low: 9.9,
+                close: 10.0,
+                last_price: 10.0,
+                bid1: 10.0,
+                ask1: 10.0,
+                prev_close: 9.8,
+                volume: 10_000,
+                minute_volume: 1_000,
+                bid1_volume: 10_000,
+                ask1_volume: 10_000,
+                trading_phase: Some("continuous".to_string()),
+                paused: false,
+                upper_limit: 10.78,
+                lower_limit: 8.82,
+                price_tick: 0.01,
+            },
+            DailyMarketSnapshot {
+                date: second,
+                symbol: "000001.SZ".to_string(),
+                timestamp: Some("2026-01-06 15:00:00".to_string()),
+                day_open: 10.5,
+                open: 10.5,
+                high: 11.2,
+                low: 10.4,
+                close: 10.6,
+                last_price: 10.6,
+                bid1: 10.6,
+                ask1: 10.6,
+                prev_close: 10.0,
+                volume: 10_000,
+                minute_volume: 1_000,
+                bid1_volume: 10_000,
+                ask1_volume: 10_000,
+                trading_phase: Some("continuous".to_string()),
+                paused: false,
+                upper_limit: 11.0,
+                lower_limit: 9.0,
+                price_tick: 0.01,
+            },
+        ],
+        vec![
+            DailyFactorSnapshot {
+                date: first,
+                symbol: "000001.SZ".to_string(),
+                market_cap_bn: 10.0,
+                free_float_cap_bn: 10.0,
+                pe_ttm: 10.0,
+                turnover_ratio: None,
+                effective_turnover_ratio: None,
+                extra_factors: Default::default(),
+            },
+            DailyFactorSnapshot {
+                date: second,
+                symbol: "000001.SZ".to_string(),
+                market_cap_bn: 10.0,
+                free_float_cap_bn: 10.0,
+                pe_ttm: 10.0,
+                turnover_ratio: None,
+                effective_turnover_ratio: None,
+                extra_factors: Default::default(),
+            },
+        ],
+        vec![
+            CandidateEligibility {
+                date: first,
+                symbol: "000001.SZ".to_string(),
+                is_st: false,
+                is_star_st: false,
+                is_new_listing: false,
+                is_paused: false,
+                allow_buy: true,
+                allow_sell: true,
+                is_kcb: false,
+                is_one_yuan: false,
+                risk_level_code: None,
+            },
+            CandidateEligibility {
+                date: second,
+                symbol: "000001.SZ".to_string(),
+                is_st: false,
+                is_star_st: false,
+                is_new_listing: false,
+                is_paused: false,
+                allow_buy: true,
+                allow_sell: true,
+                is_kcb: false,
+                is_one_yuan: false,
+                risk_level_code: None,
+            },
+        ],
+        vec![
+            BenchmarkSnapshot {
+                date: first,
+                benchmark: "000852.SH".to_string(),
+                open: 1000.0,
+                close: 1000.0,
+                prev_close: 990.0,
+                volume: 1_000_000,
+            },
+            BenchmarkSnapshot {
+                date: second,
+                benchmark: "000852.SH".to_string(),
+                open: 1000.0,
+                close: 1001.0,
+                prev_close: 1000.0,
+                volume: 1_000_000,
+            },
+        ],
+    )
+    .expect("dataset");
+
+    let broker = BrokerSimulator::new_with_execution_price(
+        ChinaAShareCostModel::default(),
+        ChinaEquityRuleHooks,
+        PriceField::Last,
+    )
+    .with_matching_type(MatchingType::MinuteLast)
+    .with_intraday_execution_start_time(t(10, 40, 0));
+    let config = BacktestConfig {
+        initial_cash: 10_000.0,
+        benchmark_code: "000852.SH".to_string(),
+        start_date: Some(first),
+        end_date: Some(second),
+        decision_lag_trading_days: 0,
+        execution_price_field: PriceField::Last,
+    };
+    let requests = Arc::new(Mutex::new(Vec::<(NaiveDate, NaiveTime)>::new()));
+    let captured_requests = Arc::clone(&requests);
+    let mut engine = BacktestEngine::new(
+        data,
+        MultiTimeDecisionQuoteReader::default(),
+        broker,
+        config,
+    )
+    .with_execution_quote_loader(move |request| {
+        let start_time = request
+            .start_time
+            .expect("decision quote loader request must include start_time");
+        captured_requests
+            .lock()
+            .expect("request mutex")
+            .push((request.date, start_time));
+        Ok(request
+            .symbols
+            .into_iter()
+            .map(|symbol| IntradayExecutionQuote {
+                date: request.date,
+                symbol,
+                timestamp: request.date.and_time(start_time) - Duration::seconds(1),
+                last_price: 10.0,
+                bid1: 10.0,
+                ask1: 10.0,
+                bid1_volume: 10_000,
+                ask1_volume: 10_000,
+                volume_delta: 10_000,
+                amount_delta: 100_000.0,
+                trading_phase: Some("continuous".to_string()),
+            })
+            .collect())
+    });
+
+    engine.run().expect("backtest should run");
+
+    let requests = requests.lock().expect("request mutex").clone();
+    assert!(
+        requests.contains(&(second, t(10, 31, 0))),
+        "second-day 10:31 quote request is required"
+    );
+    assert!(
+        requests.contains(&(second, t(10, 40, 0))),
+        "second-day 10:40 quote request must not be skipped by earlier quote"
+    );
+}

crates/fidc-core/tests/delisting.rs

@@ -34,6 +34,7 @@ impl Strategy for BuyThenHoldStrategy {
                 }],
                 notes: Vec::new(),
                 diagnostics: Vec::new(),
+                risk_decisions: Vec::new(),
             });
         }
         Ok(StrategyDecision::default())
@@ -41,9 +42,10 @@ impl Strategy for BuyThenHoldStrategy {
 }
 
 #[test]
-fn engine_settles_delisted_position_before_missing_market_snapshot_breaks_run() {
+fn engine_keeps_unresolved_delisted_position_without_fabricating_a_fill() {
     let date1 = d(2025, 1, 2);
-    let date2 = d(2025, 1, 3);
+    let delist_date = d(2025, 1, 3);
+    let date2 = d(2025, 1, 6);
     let data = DataSet::from_components(
         vec![
             Instrument {
@@ -52,8 +54,8 @@ fn engine_settles_delisted_position_before_missing_market_snapshot_breaks_run()
                 board: "SZ".to_string(),
                 round_lot: 100,
                 listed_at: Some(d(2020, 1, 1)),
-                delisted_at: Some(date1),
-                status: "delisted".to_string(),
+                delisted_at: Some(delist_date),
+                status: "active".to_string(),
             },
             Instrument {
                 symbol: "000002.SZ".to_string(),
@@ -80,7 +82,7 @@ fn engine_settles_delisted_position_before_missing_market_snapshot_breaks_run()
                 ask1: 10.0,
                 prev_close: 10.0,
                 volume: 100_000,
-                tick_volume: 100_000,
+                minute_volume: 100_000,
                 bid1_volume: 100_000,
                 ask1_volume: 100_000,
                 trading_phase: Some("continuous".to_string()),
@@ -103,7 +105,7 @@ fn engine_settles_delisted_position_before_missing_market_snapshot_breaks_run()
                 ask1: 5.01,
                 prev_close: 5.0,
                 volume: 100_000,
-                tick_volume: 100_000,
+                minute_volume: 100_000,
                 bid1_volume: 100_000,
                 ask1_volume: 100_000,
                 trading_phase: Some("continuous".to_string()),
@@ -113,9 +115,32 @@ fn engine_settles_delisted_position_before_missing_market_snapshot_breaks_run()
                 price_tick: 0.01,
             },
             DailyMarketSnapshot {
-                date: date2,
+                date: delist_date,
                 symbol: "000002.SZ".to_string(),
                 timestamp: Some("2025-01-03 10:18:00".to_string()),
+                day_open: 5.05,
+                open: 5.05,
+                high: 5.15,
+                low: 5.0,
+                close: 5.05,
+                last_price: 5.05,
+                bid1: 5.04,
+                ask1: 5.06,
+                prev_close: 5.0,
+                volume: 110_000,
+                minute_volume: 110_000,
+                bid1_volume: 110_000,
+                ask1_volume: 110_000,
+                trading_phase: Some("continuous".to_string()),
+                paused: false,
+                upper_limit: 5.5,
+                lower_limit: 4.5,
+                price_tick: 0.01,
+            },
+            DailyMarketSnapshot {
+                date: date2,
+                symbol: "000002.SZ".to_string(),
+                timestamp: Some("2025-01-06 10:18:00".to_string()),
                 day_open: 5.1,
                 open: 5.1,
                 high: 5.2,
@@ -126,7 +151,7 @@ fn engine_settles_delisted_position_before_missing_market_snapshot_breaks_run()
                 ask1: 5.11,
                 prev_close: 5.0,
                 volume: 120_000,
-                tick_volume: 120_000,
+                minute_volume: 120_000,
                 bid1_volume: 120_000,
                 ask1_volume: 120_000,
                 trading_phase: Some("continuous".to_string()),
@@ -157,6 +182,16 @@ fn engine_settles_delisted_position_before_missing_market_snapshot_breaks_run()
                 effective_turnover_ratio: Some(1.0),
                 extra_factors: BTreeMap::new(),
             },
+            DailyFactorSnapshot {
+                date: delist_date,
+                symbol: "000002.SZ".to_string(),
+                market_cap_bn: 30.5,
+                free_float_cap_bn: 28.5,
+                pe_ttm: 10.0,
+                turnover_ratio: Some(1.0),
+                effective_turnover_ratio: Some(1.0),
+                extra_factors: BTreeMap::new(),
+            },
             DailyFactorSnapshot {
                 date: date2,
                 symbol: "000002.SZ".to_string(),
@@ -173,34 +208,53 @@ fn engine_settles_delisted_position_before_missing_market_snapshot_breaks_run()
                 date: date1,
                 symbol: "000001.SZ".to_string(),
                 is_st: false,
+                is_star_st: false,
                 is_new_listing: false,
                 is_paused: false,
                 allow_buy: true,
                 allow_sell: true,
                 is_kcb: false,
                 is_one_yuan: false,
+                risk_level_code: None,
             },
             CandidateEligibility {
                 date: date1,
                 symbol: "000002.SZ".to_string(),
                 is_st: false,
+                is_star_st: false,
                 is_new_listing: false,
                 is_paused: false,
                 allow_buy: true,
                 allow_sell: true,
                 is_kcb: false,
                 is_one_yuan: false,
+                risk_level_code: None,
+            },
+            CandidateEligibility {
+                date: delist_date,
+                symbol: "000002.SZ".to_string(),
+                is_st: false,
+                is_star_st: false,
+                is_new_listing: false,
+                is_paused: false,
+                allow_buy: true,
+                allow_sell: true,
+                is_kcb: false,
+                is_one_yuan: false,
+                risk_level_code: None,
             },
             CandidateEligibility {
                 date: date2,
                 symbol: "000002.SZ".to_string(),
                 is_st: false,
+                is_star_st: false,
                 is_new_listing: false,
                 is_paused: false,
                 allow_buy: true,
                 allow_sell: true,
                 is_kcb: false,
                 is_one_yuan: false,
+                risk_level_code: None,
             },
         ],
         vec![
@@ -212,6 +266,14 @@ fn engine_settles_delisted_position_before_missing_market_snapshot_breaks_run()
                 prev_close: 99.0,
                 volume: 1_000_000,
             },
+            BenchmarkSnapshot {
+                date: delist_date,
+                benchmark: "000300.SH".to_string(),
+                open: 100.5,
+                close: 100.5,
+                prev_close: 100.0,
+                volume: 1_050_000,
+            },
             BenchmarkSnapshot {
                 date: date2,
                 benchmark: "000300.SH".to_string(),
@@ -244,24 +306,33 @@ fn engine_settles_delisted_position_before_missing_market_snapshot_breaks_run()
     );
 
     let result = engine.run().expect("backtest succeeds");
-    assert_eq!(result.fills.len(), 2);
+    assert_eq!(result.fills.len(), 1);
     assert!(
         result
             .fills
             .iter()
-            .any(|fill| fill.reason.contains("delisted_cash_settlement")
-                && fill.symbol == "000001.SZ")
-    );
-    assert!(
-        result
-            .holdings_summary
-            .iter()
-            .all(|holding| holding.symbol != "000001.SZ")
+            .all(|fill| !fill.reason.contains("delisted_cash_settlement"))
     );
+    let unresolved = result
+        .holdings_summary
+        .iter()
+        .find(|holding| holding.symbol == "000001.SZ")
+        .expect("unresolved delisted holding remains auditable");
+    assert_eq!(unresolved.quantity, 900);
+    assert_eq!(unresolved.last_price, 0.0);
+    assert_eq!(unresolved.market_value, 0.0);
+    assert!(result.equity_curve.iter().any(|point| {
+        point
+            .notes
+            .contains("unresolved_delisted_position symbol=000001.SZ")
+            && point.notes.contains("settlement_action=missing")
+            && point.notes.contains("valuation_policy=zero")
+            && point.notes.contains("no_order=true")
+    }));
 }
 
 #[test]
-fn engine_applies_successor_conversion_before_delisted_cash_settlement() {
+fn engine_applies_successor_conversion_before_unresolved_delisting_audit() {
     let date1 = d(2025, 1, 2);
     let date2 = d(2025, 1, 3);
     let data = DataSet::from_components_with_actions(
@@ -273,7 +344,7 @@ fn engine_applies_successor_conversion_before_delisted_cash_settlement() {
                 round_lot: 100,
                 listed_at: Some(d(2020, 1, 1)),
                 delisted_at: Some(date2),
-                status: "delisted".to_string(),
+                status: "active".to_string(),
             },
             Instrument {
                 symbol: "000002.SZ".to_string(),
@@ -300,7 +371,7 @@ fn engine_applies_successor_conversion_before_delisted_cash_settlement() {
                 ask1: 10.0,
                 prev_close: 10.0,
                 volume: 100_000,
-                tick_volume: 100_000,
+                minute_volume: 100_000,
                 bid1_volume: 100_000,
                 ask1_volume: 100_000,
                 trading_phase: Some("continuous".to_string()),
@@ -323,7 +394,7 @@ fn engine_applies_successor_conversion_before_delisted_cash_settlement() {
                 ask1: 20.0,
                 prev_close: 20.0,
                 volume: 100_000,
-                tick_volume: 100_000,
+                minute_volume: 100_000,
                 bid1_volume: 100_000,
                 ask1_volume: 100_000,
                 trading_phase: Some("continuous".to_string()),
@@ -346,7 +417,7 @@ fn engine_applies_successor_conversion_before_delisted_cash_settlement() {
                 ask1: 21.0,
                 prev_close: 20.0,
                 volume: 120_000,
-                tick_volume: 120_000,
+                minute_volume: 120_000,
                 bid1_volume: 120_000,
                 ask1_volume: 120_000,
                 trading_phase: Some("continuous".to_string()),
@@ -393,34 +464,40 @@ fn engine_applies_successor_conversion_before_delisted_cash_settlement() {
                 date: date1,
                 symbol: "000001.SZ".to_string(),
                 is_st: false,
+                is_star_st: false,
                 is_new_listing: false,
                 is_paused: false,
                 allow_buy: true,
                 allow_sell: true,
                 is_kcb: false,
                 is_one_yuan: false,
+                risk_level_code: None,
             },
             CandidateEligibility {
                 date: date1,
                 symbol: "000002.SZ".to_string(),
                 is_st: false,
+                is_star_st: false,
                 is_new_listing: false,
                 is_paused: false,
                 allow_buy: true,
                 allow_sell: true,
                 is_kcb: false,
                 is_one_yuan: false,
+                risk_level_code: None,
             },
             CandidateEligibility {
                 date: date2,
                 symbol: "000002.SZ".to_string(),
                 is_st: false,
+                is_star_st: false,
                 is_new_listing: false,
                 is_paused: false,
                 allow_buy: true,
                 allow_sell: true,
                 is_kcb: false,
                 is_one_yuan: false,
+                risk_level_code: None,
             },
         ],
         vec![
@@ -492,7 +569,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 +580,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/futures_account.rs

@@ -208,3 +208,134 @@ fn futures_expiration_settlement_closes_all_contract_directions() {
     );
     assert!((account.total_cash() - 1_003_000.0).abs() < 1e-6);
 }
+
+#[test]
+fn futures_full_close_preserves_closed_position_daily_metrics() {
+    let spec = FuturesContractSpec::new(10.0, 0.1, 0.1);
+    let mut account = FuturesAccountState::new(100_000.0);
+    account.open("IF2506.CCFX", FuturesDirection::Long, spec, 1, 100.0, 1.0);
+    account.begin_trading_day();
+
+    let realized = account
+        .close("IF2506.CCFX", FuturesDirection::Long, 1, 110.0, 2.0)
+        .expect("close overnight position");
+
+    assert!(account.positions().is_empty());
+    assert!((realized - 98.0).abs() < 1e-12);
+    assert!((account.position_pnl() - 100.0).abs() < 1e-12);
+    assert!(account.trading_pnl().abs() < 1e-12);
+    assert!((account.transaction_cost() - 2.0).abs() < 1e-12);
+    assert!((account.daily_pnl() - 98.0).abs() < 1e-12);
+    assert!((account.total_cash() - 100_097.0).abs() < 1e-12);
+
+    account.begin_trading_day();
+    assert!(account.daily_pnl().abs() < 1e-12);
+    assert!(account.transaction_cost().abs() < 1e-12);
+}
+
+#[test]
+fn futures_intraday_roundtrip_preserves_closed_trading_pnl() {
+    let spec = FuturesContractSpec::new(10.0, 0.1, 0.1);
+    let mut account = FuturesAccountState::new(100_000.0);
+    account.begin_trading_day();
+    account.open("IF2506.CCFX", FuturesDirection::Long, spec, 1, 100.0, 1.0);
+    account
+        .close("IF2506.CCFX", FuturesDirection::Long, 1, 110.0, 2.0)
+        .expect("close intraday position");
+
+    assert!(account.positions().is_empty());
+    assert!((account.trading_pnl() - 100.0).abs() < 1e-12);
+    assert!(account.position_pnl().abs() < 1e-12);
+    assert!((account.transaction_cost() - 3.0).abs() < 1e-12);
+    assert!((account.daily_pnl() - 97.0).abs() < 1e-12);
+    assert!((account.total_cash() - 100_097.0).abs() < 1e-12);
+}
+
+#[test]
+fn futures_partial_close_offsets_later_mark_with_trading_pnl() {
+    let spec = FuturesContractSpec::new(10.0, 0.1, 0.1);
+    let mut account = FuturesAccountState::new(100_000.0);
+    account.open("IF2506.CCFX", FuturesDirection::Long, spec, 2, 100.0, 0.0);
+    account.begin_trading_day();
+    account
+        .close("IF2506.CCFX", FuturesDirection::Long, 1, 110.0, 0.0)
+        .expect("partially close overnight position");
+    account.mark_price("IF2506.CCFX", FuturesDirection::Long, 120.0);
+
+    assert!((account.position_pnl() - 400.0).abs() < 1e-12);
+    assert!((account.trading_pnl() + 100.0).abs() < 1e-12);
+    assert!((account.daily_pnl() - 300.0).abs() < 1e-12);
+    assert!((account.total_value() - 100_300.0).abs() < 1e-12);
+}
+
+#[test]
+fn futures_settlement_keeps_same_day_pnl_visible_until_next_day() {
+    let spec = FuturesContractSpec::new(10.0, 0.1, 0.1);
+    let mut account = FuturesAccountState::new(100_000.0);
+    account.open("IF2506.CCFX", FuturesDirection::Long, spec, 1, 100.0, 0.0);
+    account.begin_trading_day();
+    account.mark_price("IF2506.CCFX", FuturesDirection::Long, 110.0);
+
+    let settled = account.settle(&BTreeMap::from([("IF2506.CCFX".to_string(), 110.0)]));
+
+    assert!((settled - 100.0).abs() < 1e-12);
+    assert!((account.daily_pnl() - 100.0).abs() < 1e-12);
+    assert!((account.total_cash() - 100_100.0).abs() < 1e-12);
+    assert!((account.total_value() - 100_100.0).abs() < 1e-12);
+
+    account.begin_trading_day();
+    assert!(account.daily_pnl().abs() < 1e-12);
+}
+
+#[test]
+fn futures_cash_and_closed_cost_accumulate_micro_yuan_exactly() {
+    let spec = FuturesContractSpec::new(1.0, 0.0, 0.0);
+    let mut account = FuturesAccountState::new(1_000_000.0);
+    account.begin_trading_day();
+    for _ in 0..10_000 {
+        account.open(
+            "IF2506.CCFX",
+            FuturesDirection::Long,
+            spec,
+            1,
+            100.0,
+            0.000001,
+        );
+        account
+            .close("IF2506.CCFX", FuturesDirection::Long, 1, 100.0, 0.000001)
+            .expect("close micro-cost position");
+    }
+
+    assert!((account.total_cash() - 999_999.98).abs() < 1e-12);
+    assert!((account.transaction_cost() - 0.02).abs() < 1e-12);
+    assert!((account.daily_pnl() + 0.02).abs() < 1e-12);
+}
+
+#[test]
+fn futures_margin_gate_and_fill_cash_use_exact_micro_yuan() {
+    let date = d(2025, 1, 2);
+    let spec = FuturesContractSpec::new(1.0, 1.0, 1.0);
+    let intent = FuturesOrderIntent::open(
+        "IF2506.CCFX",
+        FuturesDirection::Long,
+        spec,
+        1,
+        100.0,
+        0.000001,
+        "micro margin boundary",
+    );
+
+    let mut insufficient = FuturesAccountState::new(100.0);
+    let rejected = insufficient.execute_order(date, Some(1), intent.clone());
+    assert_eq!(rejected.order_events[0].status, OrderStatus::Rejected);
+    assert!((insufficient.total_cash() - 100.0).abs() < 1e-12);
+
+    let mut exact = FuturesAccountState::new(100.000001);
+    let filled = exact.execute_order(date, Some(2), intent);
+    assert_eq!(filled.order_events[0].status, OrderStatus::Filled);
+    assert_eq!(filled.fill_events.len(), 1);
+    assert!((filled.fill_events[0].gross_amount - 100.0).abs() < 1e-12);
+    assert!((filled.fill_events[0].commission - 0.000001).abs() < 1e-12);
+    assert!((filled.fill_events[0].net_cash_flow + 0.000001).abs() < 1e-12);
+    assert!(exact.cash().abs() < 1e-12);
+}

crates/fidc-core/tests/intraday_history_performance.rs

@@ -0,0 +1,222 @@
+use std::hint::black_box;
+use std::time::Instant;
+
+use chrono::{Duration, NaiveDate, NaiveDateTime, NaiveTime};
+use fidc_core::{
+    BenchmarkSnapshot, DailyMarketSnapshot, DataSet, Instrument, IntradayExecutionQuote,
+};
+
+const SYMBOL: &str = "000001.SZ";
+
+fn dataset(day_count: usize, bars_per_day: usize) -> (DataSet, Vec<NaiveDate>) {
+    let start = NaiveDate::from_ymd_opt(2025, 1, 1).expect("valid start date");
+    let dates = (0..day_count)
+        .map(|offset| start + Duration::days(offset as i64))
+        .collect::<Vec<_>>();
+    let markets = dates
+        .iter()
+        .map(|date| DailyMarketSnapshot {
+            date: *date,
+            symbol: SYMBOL.to_string(),
+            timestamp: None,
+            day_open: 10.0,
+            open: 10.0,
+            high: 10.5,
+            low: 9.5,
+            close: 10.0,
+            last_price: 10.0,
+            bid1: 9.99,
+            ask1: 10.01,
+            prev_close: 10.0,
+            volume: 1_000_000,
+            minute_volume: 1_000,
+            bid1_volume: 10_000,
+            ask1_volume: 10_000,
+            trading_phase: Some("continuous".to_string()),
+            paused: false,
+            upper_limit: 11.0,
+            lower_limit: 9.0,
+            price_tick: 0.01,
+        })
+        .collect::<Vec<_>>();
+    let benchmarks = dates
+        .iter()
+        .map(|date| BenchmarkSnapshot {
+            date: *date,
+            benchmark: "000852.SH".to_string(),
+            open: 1_000.0,
+            close: 1_000.0,
+            prev_close: 1_000.0,
+            volume: 10_000_000,
+        })
+        .collect::<Vec<_>>();
+    let mut quotes = Vec::with_capacity(day_count * bars_per_day);
+    for date in &dates {
+        let session_start = date
+            .and_hms_opt(9, 30, 0)
+            .expect("valid session start");
+        for offset in 0..bars_per_day {
+            let timestamp = session_start + Duration::minutes(offset as i64);
+            quotes.push(IntradayExecutionQuote {
+                date: *date,
+                symbol: SYMBOL.to_string(),
+                timestamp,
+                last_price: 10.0 + offset as f64 / 10_000.0,
+                bid1: 9.99,
+                ask1: 10.01,
+                bid1_volume: 10_000,
+                ask1_volume: 10_000,
+                volume_delta: 1_000,
+                amount_delta: 10_000.0,
+                trading_phase: Some("continuous".to_string()),
+            });
+        }
+    }
+    let data = DataSet::from_components_with_actions_and_quotes(
+        vec![Instrument {
+            symbol: SYMBOL.to_string(),
+            name: "平安银行".to_string(),
+            board: "SZ".to_string(),
+            round_lot: 100,
+            listed_at: Some(start - Duration::days(1_000)),
+            delisted_at: None,
+            status: "active".to_string(),
+        }],
+        markets,
+        Vec::new(),
+        Vec::new(),
+        benchmarks,
+        Vec::new(),
+        quotes,
+    )
+    .expect("build intraday history dataset");
+    (data, dates)
+}
+
+fn timestamp(date: NaiveDate, time: &str) -> NaiveDateTime {
+    let time = NaiveTime::parse_from_str(time, "%H:%M:%S").expect("valid time");
+    date.and_time(time)
+}
+
+#[test]
+fn intraday_history_is_bounded_by_visibility_and_preserves_order() {
+    let (data, dates) = dataset(3, 4);
+    let rows = data.history_intraday_quotes_at(
+        dates[1],
+        Some(timestamp(dates[1], "09:32:00")),
+        SYMBOL,
+        3,
+        false,
+    );
+    assert_eq!(
+        rows.iter().map(|row| row.timestamp).collect::<Vec<_>>(),
+        vec![
+            timestamp(dates[0], "09:33:00"),
+            timestamp(dates[1], "09:30:00"),
+            timestamp(dates[1], "09:31:00"),
+        ]
+    );
+
+    let including_now = data.history_intraday_quotes_at(
+        dates[1],
+        Some(timestamp(dates[1], "09:32:00")),
+        SYMBOL,
+        3,
+        true,
+    );
+    assert_eq!(
+        including_now
+            .iter()
+            .map(|row| row.timestamp)
+            .collect::<Vec<_>>(),
+        vec![
+            timestamp(dates[1], "09:30:00"),
+            timestamp(dates[1], "09:31:00"),
+            timestamp(dates[1], "09:32:00"),
+        ]
+    );
+}
+
+#[test]
+#[ignore = "manual release-mode intraday history benchmark"]
+fn benchmark_bounded_intraday_history() {
+    let (data, dates) = dataset(250, 240);
+    let active_datetime = timestamp(*dates.last().expect("last date"), "13:29:00");
+
+    for _ in 0..5 {
+        black_box(data.history_intraday_quotes_at(
+            active_datetime.date(),
+            Some(active_datetime),
+            SYMBOL,
+            30,
+            true,
+        ));
+    }
+
+    let started = Instant::now();
+    let mut checksum = 0_i64;
+    for _ in 0..200 {
+        let rows = data.history_intraday_quotes_at(
+            active_datetime.date(),
+            Some(active_datetime),
+            SYMBOL,
+            30,
+            true,
+        );
+        checksum += rows
+            .last()
+            .expect("history row")
+            .timestamp
+            .and_utc()
+            .timestamp();
+        black_box(&rows);
+    }
+    let elapsed = started.elapsed();
+    eprintln!(
+        "intraday_history_benchmark iterations=200 rows_per_dataset=60000 elapsed_seconds={:.6} checksum={checksum}",
+        elapsed.as_secs_f64(),
+    );
+}
+
+#[test]
+#[ignore = "manual release-mode quote-stream benchmark"]
+fn benchmark_borrowed_execution_quote_stream() {
+    let (data, dates) = dataset(250, 240);
+    let date = *dates.last().expect("last date");
+    let symbols = std::collections::BTreeSet::from([SYMBOL.to_string()]);
+
+    for _ in 0..5 {
+        black_box(data.execution_quotes_on_date_for_symbols(date, Some(&symbols)));
+        black_box(
+            data.execution_quotes_iter_on_date_for_symbols(date, Some(&symbols))
+                .count(),
+        );
+    }
+
+    let materialized_started = Instant::now();
+    let mut materialized_checksum = 0_i64;
+    for _ in 0..5_000 {
+        let rows = data.execution_quotes_on_date_for_symbols(date, Some(&symbols));
+        materialized_checksum += rows
+            .iter()
+            .map(|quote| quote.timestamp.and_utc().timestamp())
+            .sum::<i64>();
+        black_box(rows);
+    }
+    let materialized_seconds = materialized_started.elapsed().as_secs_f64();
+
+    let streamed_started = Instant::now();
+    let mut streamed_checksum = 0_i64;
+    for _ in 0..5_000 {
+        let count = data
+            .execution_quotes_iter_on_date_for_symbols(date, Some(&symbols))
+            .map(|quote| quote.timestamp.and_utc().timestamp())
+            .sum::<i64>();
+        streamed_checksum += count;
+        black_box(count);
+    }
+    let streamed_seconds = streamed_started.elapsed().as_secs_f64();
+    eprintln!(
+        "quote_stream_benchmark iterations=5000 rows_per_day=240 materialized_seconds={materialized_seconds:.6} streamed_seconds={streamed_seconds:.6} materialized_checksum={materialized_checksum} streamed_checksum={streamed_checksum}"
+    );
+}

crates/fidc-core/tests/partitioned_loader.rs

@@ -1,93 +0,0 @@
-use fidc_core::DataSet;
-use std::fs;
-use std::path::PathBuf;
-use std::time::{SystemTime, UNIX_EPOCH};
-
-fn temp_dir() -> PathBuf {
-    let uniq = SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .expect("clock")
-        .as_nanos();
-    let dir = std::env::temp_dir().join(format!("fidc-bt-partitioned-{uniq}"));
-    fs::create_dir_all(&dir).expect("mkdir temp");
-    dir
-}
-
-#[test]
-fn can_load_partitioned_snapshot_dir() {
-    let dir = temp_dir();
-    fs::create_dir_all(dir.join("benchmark/2024/01")).unwrap();
-    fs::create_dir_all(dir.join("market/2024/01")).unwrap();
-    fs::create_dir_all(dir.join("factors/2024/01")).unwrap();
-    fs::create_dir_all(dir.join("candidates/2024/01")).unwrap();
-    fs::create_dir_all(dir.join("corporate_actions/2024/01")).unwrap();
-
-    fs::write(
-        dir.join("instruments.csv"),
-        "symbol,name,board,round_lot,listed_at,delisted_at,status\n000001.SZ,PingAn,SZ,100,2020-01-01,,active\n",
-    )
-    .unwrap();
-    fs::write(
-        dir.join("benchmark/2024/01/2024-01-02.csv"),
-        "date,benchmark,open,close,prev_close,volume\n2024-01-02,CSI300.DEMO,2990,3000,2980,100000000\n",
-    )
-    .unwrap();
-    fs::write(
-        dir.join("market/2024/01/2024-01-02.csv"),
-        "date,symbol,open,high,low,close,prev_close,volume,paused,upper_limit,lower_limit,day_open,last_price,bid1,ask1,price_tick\n2024-01-02,000001.SZ,10,10.5,9.9,10.2,10,100000,false,11,9,10.1,10.15,10.14,10.16,0.01\n",
-    )
-    .unwrap();
-    fs::write(
-        dir.join("factors/2024/01/2024-01-02.csv"),
-        "date,symbol,market_cap_bn,free_float_cap_bn,pe_ttm,turnover_ratio,effective_turnover_ratio\n2024-01-02,000001.SZ,40,35,12,3.2,2.1\n",
-    )
-    .unwrap();
-    fs::write(
-        dir.join("candidates/2024/01/2024-01-02.csv"),
-        "date,symbol,is_st,is_new_listing,is_paused,allow_buy,allow_sell,is_kcb,is_one_yuan\n2024-01-02,000001.SZ,false,false,false,true,true,false,false\n",
-    )
-    .unwrap();
-    fs::write(
-        dir.join("corporate_actions/2024/01/2024-01-02.csv"),
-        "date,symbol,payable_date,share_cash,share_bonus,share_gift,issue_quantity,issue_price,reform,adjust_factor\n2024-01-02,000001.SZ,2024-01-05,0.5,0.1,0.0,0,0,false,1.05\n",
-    )
-    .unwrap();
-
-    let data = DataSet::from_partitioned_dir(&dir).expect("partitioned dataset");
-    assert_eq!(data.benchmark_code(), "CSI300.DEMO");
-    assert!(
-        data.market_snapshots_on(chrono::NaiveDate::from_ymd_opt(2024, 1, 2).unwrap())
-            .len()
-            == 1
-    );
-    let market_rows =
-        data.market_snapshots_on(chrono::NaiveDate::from_ymd_opt(2024, 1, 2).unwrap());
-    let snapshot = market_rows.first().expect("market snapshot");
-    assert_eq!(snapshot.day_open, 10.1);
-    assert_eq!(snapshot.last_price, 10.15);
-    assert_eq!(snapshot.price_tick, 0.01);
-    assert_eq!(
-        data.instruments()
-            .get("000001.SZ")
-            .expect("instrument")
-            .round_lot,
-        100
-    );
-    assert_eq!(
-        data.instruments()
-            .get("000001.SZ")
-            .expect("instrument")
-            .listed_at,
-        Some(chrono::NaiveDate::from_ymd_opt(2020, 1, 1).unwrap())
-    );
-    let actions = data.corporate_actions_on(chrono::NaiveDate::from_ymd_opt(2024, 1, 2).unwrap());
-    assert_eq!(actions.len(), 1);
-    assert_eq!(
-        actions[0].payable_date,
-        Some(chrono::NaiveDate::from_ymd_opt(2024, 1, 5).unwrap())
-    );
-    assert!((actions[0].share_cash - 0.5).abs() < 1e-9);
-    assert!((actions[0].split_ratio() - 1.1).abs() < 1e-9);
-
-    let _ = fs::remove_dir_all(&dir);
-}

crates/fidc-core/tests/strategy_selection.rs

@@ -1,15 +1,582 @@
 use chrono::NaiveDate;
 use fidc_core::{
-    CnSmallCapRotationConfig, CnSmallCapRotationStrategy, DataSet, OmniMicroCapConfig,
+    BenchmarkSnapshot, CandidateEligibility, CnSmallCapRotationConfig, CnSmallCapRotationStrategy,
+    DailyFactorSnapshot, DailyMarketSnapshot, DataSet, Instrument, OmniMicroCapConfig,
     OmniMicroCapStrategy, PortfolioState, Strategy, StrategyContext,
 };
 use std::collections::BTreeSet;
-use std::path::PathBuf;
+
+fn d(value: &str) -> NaiveDate {
+    NaiveDate::parse_from_str(value, "%Y-%m-%d").unwrap()
+}
+
+fn instrument(symbol: &str, name: &str) -> Instrument {
+    Instrument {
+        symbol: symbol.to_string(),
+        name: name.to_string(),
+        board: "Main".to_string(),
+        round_lot: 100,
+        listed_at: None,
+        delisted_at: None,
+        status: "active".to_string(),
+    }
+}
+
+fn market(
+    date: &str,
+    symbol: &str,
+    open: f64,
+    high: f64,
+    low: f64,
+    close: f64,
+    prev_close: f64,
+    volume: u64,
+    paused: bool,
+) -> DailyMarketSnapshot {
+    DailyMarketSnapshot {
+        date: d(date),
+        symbol: symbol.to_string(),
+        timestamp: None,
+        day_open: open,
+        open,
+        high,
+        low,
+        close,
+        last_price: close,
+        bid1: close,
+        ask1: close,
+        prev_close,
+        volume,
+        minute_volume: 0,
+        bid1_volume: 0,
+        ask1_volume: 0,
+        trading_phase: None,
+        paused,
+        upper_limit: (prev_close * 1.10 * 100.0).round() / 100.0,
+        lower_limit: (prev_close * 0.90 * 100.0).round() / 100.0,
+        price_tick: 0.01,
+    }
+}
+
+fn factor(
+    date: &str,
+    symbol: &str,
+    market_cap_bn: f64,
+    free_float_cap_bn: f64,
+) -> DailyFactorSnapshot {
+    DailyFactorSnapshot {
+        date: d(date),
+        symbol: symbol.to_string(),
+        market_cap_bn,
+        free_float_cap_bn,
+        pe_ttm: 18.0,
+        turnover_ratio: None,
+        effective_turnover_ratio: None,
+        extra_factors: Default::default(),
+    }
+}
+
+fn candidate(
+    date: &str,
+    symbol: &str,
+    is_new_listing: bool,
+    is_paused: bool,
+    allow_buy: bool,
+    allow_sell: bool,
+) -> CandidateEligibility {
+    CandidateEligibility {
+        date: d(date),
+        symbol: symbol.to_string(),
+        is_st: false,
+        is_star_st: false,
+        is_new_listing,
+        is_paused,
+        allow_buy,
+        allow_sell,
+        is_kcb: false,
+        is_one_yuan: false,
+        risk_level_code: None,
+    }
+}
+
+fn benchmark(date: &str, open: f64, close: f64, prev_close: f64, volume: u64) -> BenchmarkSnapshot {
+    BenchmarkSnapshot {
+        date: d(date),
+        benchmark: "CSI300.DEMO".to_string(),
+        open,
+        close,
+        prev_close,
+        volume,
+    }
+}
+
+fn strategy_test_dataset() -> DataSet {
+    let dates = [
+        "2024-01-02",
+        "2024-01-03",
+        "2024-01-04",
+        "2024-01-05",
+        "2024-01-08",
+        "2024-01-09",
+        "2024-01-10",
+        "2024-01-11",
+        "2024-01-12",
+    ];
+    let instruments = vec![
+        instrument("000001.SZ", "Alpha Components"),
+        instrument("000002.SZ", "Beta Precision"),
+        instrument("000003.SZ", "Charlie Materials"),
+        instrument("600001.SH", "Delta Industrials"),
+    ];
+    let market = vec![
+        market(
+            "2024-01-02",
+            "000001.SZ",
+            10.0,
+            10.2,
+            9.9,
+            10.1,
+            9.8,
+            1_200_000,
+            false,
+        ),
+        market(
+            "2024-01-02",
+            "000002.SZ",
+            11.0,
+            11.3,
+            10.9,
+            11.2,
+            10.8,
+            1_100_000,
+            false,
+        ),
+        market(
+            "2024-01-02",
+            "000003.SZ",
+            8.0,
+            8.1,
+            7.8,
+            7.9,
+            8.0,
+            900_000,
+            false,
+        ),
+        market(
+            "2024-01-02",
+            "600001.SH",
+            15.0,
+            15.2,
+            14.9,
+            15.1,
+            15.0,
+            800_000,
+            false,
+        ),
+        market(
+            "2024-01-03",
+            "000001.SZ",
+            10.2,
+            10.5,
+            10.1,
+            10.4,
+            10.1,
+            1_250_000,
+            false,
+        ),
+        market(
+            "2024-01-03",
+            "000002.SZ",
+            11.2,
+            11.6,
+            11.1,
+            11.5,
+            11.2,
+            1_120_000,
+            false,
+        ),
+        market(
+            "2024-01-03",
+            "000003.SZ",
+            7.8,
+            7.9,
+            7.3,
+            7.4,
+            7.9,
+            930_000,
+            false,
+        ),
+        market(
+            "2024-01-03",
+            "600001.SH",
+            15.1,
+            15.3,
+            15.0,
+            15.2,
+            15.1,
+            820_000,
+            false,
+        ),
+        market(
+            "2024-01-04",
+            "000001.SZ",
+            10.5,
+            10.8,
+            10.4,
+            10.7,
+            10.4,
+            1_280_000,
+            false,
+        ),
+        market(
+            "2024-01-04",
+            "000002.SZ",
+            11.4,
+            11.9,
+            11.3,
+            11.8,
+            11.5,
+            1_150_000,
+            false,
+        ),
+        market(
+            "2024-01-04",
+            "000003.SZ",
+            7.3,
+            7.4,
+            7.0,
+            7.1,
+            7.4,
+            940_000,
+            false,
+        ),
+        market(
+            "2024-01-04",
+            "600001.SH",
+            15.2,
+            15.5,
+            15.1,
+            15.4,
+            15.2,
+            830_000,
+            false,
+        ),
+        market(
+            "2024-01-05",
+            "000001.SZ",
+            10.8,
+            11.1,
+            10.7,
+            11.0,
+            10.7,
+            1_300_000,
+            false,
+        ),
+        market(
+            "2024-01-05",
+            "000002.SZ",
+            11.9,
+            12.1,
+            11.8,
+            12.0,
+            11.8,
+            1_180_000,
+            false,
+        ),
+        market(
+            "2024-01-05",
+            "000003.SZ",
+            7.0,
+            7.1,
+            6.8,
+            6.9,
+            7.1,
+            950_000,
+            false,
+        ),
+        market(
+            "2024-01-05",
+            "600001.SH",
+            15.4,
+            15.6,
+            15.3,
+            15.5,
+            15.4,
+            840_000,
+            false,
+        ),
+        market(
+            "2024-01-08",
+            "000001.SZ",
+            11.1,
+            11.6,
+            11.0,
+            11.5,
+            11.0,
+            1_400_000,
+            false,
+        ),
+        market(
+            "2024-01-08",
+            "000002.SZ",
+            12.1,
+            12.5,
+            12.0,
+            12.4,
+            12.0,
+            1_200_000,
+            false,
+        ),
+        market(
+            "2024-01-08",
+            "000003.SZ",
+            7.0,
+            7.3,
+            6.9,
+            7.2,
+            6.9,
+            980_000,
+            false,
+        ),
+        market(
+            "2024-01-08",
+            "600001.SH",
+            15.5,
+            15.7,
+            15.4,
+            15.6,
+            15.5,
+            850_000,
+            false,
+        ),
+        market(
+            "2024-01-09",
+            "000001.SZ",
+            11.6,
+            12.4,
+            11.5,
+            12.3,
+            11.5,
+            1_500_000,
+            false,
+        ),
+        market(
+            "2024-01-09",
+            "000002.SZ",
+            12.5,
+            12.9,
+            12.4,
+            12.8,
+            12.4,
+            1_250_000,
+            false,
+        ),
+        market(
+            "2024-01-09",
+            "000003.SZ",
+            7.2,
+            7.5,
+            7.1,
+            7.4,
+            7.2,
+            990_000,
+            false,
+        ),
+        market(
+            "2024-01-09",
+            "600001.SH",
+            15.6,
+            15.7,
+            15.4,
+            15.5,
+            15.6,
+            860_000,
+            false,
+        ),
+        market(
+            "2024-01-10",
+            "000001.SZ",
+            12.2,
+            12.3,
+            11.9,
+            12.0,
+            12.3,
+            1_450_000,
+            false,
+        ),
+        market(
+            "2024-01-10",
+            "000002.SZ",
+            12.7,
+            12.8,
+            12.5,
+            12.6,
+            12.8,
+            1_220_000,
+            false,
+        ),
+        market(
+            "2024-01-10",
+            "000003.SZ",
+            7.5,
+            7.6,
+            7.4,
+            7.5,
+            7.4,
+            1_000_000,
+            false,
+        ),
+        market(
+            "2024-01-10",
+            "600001.SH",
+            15.4,
+            15.5,
+            15.1,
+            15.2,
+            15.5,
+            870_000,
+            false,
+        ),
+        market(
+            "2024-01-11",
+            "000001.SZ",
+            12.0,
+            12.1,
+            11.5,
+            11.6,
+            12.0,
+            1_420_000,
+            false,
+        ),
+        market(
+            "2024-01-11",
+            "000002.SZ",
+            12.5,
+            12.6,
+            12.1,
+            12.2,
+            12.6,
+            1_210_000,
+            false,
+        ),
+        market(
+            "2024-01-11",
+            "000003.SZ",
+            7.4,
+            7.5,
+            7.2,
+            7.3,
+            7.5,
+            980_000,
+            false,
+        ),
+        market(
+            "2024-01-11",
+            "600001.SH",
+            15.2,
+            15.2,
+            15.2,
+            15.2,
+            15.2,
+            0,
+            true,
+        ),
+        market(
+            "2024-01-12",
+            "000001.SZ",
+            11.5,
+            11.6,
+            11.1,
+            11.2,
+            11.6,
+            1_380_000,
+            false,
+        ),
+        market(
+            "2024-01-12",
+            "000002.SZ",
+            12.1,
+            12.2,
+            11.8,
+            11.9,
+            12.2,
+            1_190_000,
+            false,
+        ),
+        market(
+            "2024-01-12",
+            "000003.SZ",
+            7.2,
+            7.2,
+            6.9,
+            7.0,
+            7.3,
+            960_000,
+            false,
+        ),
+        market(
+            "2024-01-12",
+            "600001.SH",
+            14.8,
+            15.0,
+            14.7,
+            14.9,
+            15.2,
+            850_000,
+            false,
+        ),
+    ];
+    let factors = dates
+        .iter()
+        .enumerate()
+        .flat_map(|(idx, date)| {
+            let i = idx as f64;
+            [
+                factor(date, "000001.SZ", 38.0 + i, 24.0 + i * 0.5),
+                factor(date, "000002.SZ", 45.0 + i, 30.0 + i * 0.5),
+                factor(date, "000003.SZ", 65.0 - i, 40.0 - i * 0.5),
+                factor(date, "600001.SH", 85.0 + i, 55.0 + i * 0.5),
+            ]
+        })
+        .collect::<Vec<_>>();
+    let candidates = dates
+        .iter()
+        .flat_map(|date| {
+            let first_two = *date == "2024-01-02" || *date == "2024-01-03";
+            let paused_600001 = *date == "2024-01-11";
+            [
+                candidate(date, "000001.SZ", first_two, false, !first_two, true),
+                candidate(date, "000002.SZ", false, false, true, true),
+                candidate(date, "000003.SZ", false, false, true, true),
+                candidate(
+                    date,
+                    "600001.SH",
+                    false,
+                    paused_600001,
+                    !paused_600001,
+                    !paused_600001,
+                ),
+            ]
+        })
+        .collect::<Vec<_>>();
+    let benchmarks = vec![
+        benchmark("2024-01-02", 2990.0, 3000.0, 2980.0, 100_000_000),
+        benchmark("2024-01-03", 3005.0, 3020.0, 3000.0, 102_000_000),
+        benchmark("2024-01-04", 3025.0, 3050.0, 3020.0, 105_000_000),
+        benchmark("2024-01-05", 3055.0, 3080.0, 3050.0, 108_000_000),
+        benchmark("2024-01-08", 3085.0, 3110.0, 3080.0, 109_000_000),
+        benchmark("2024-01-09", 3100.0, 3090.0, 3110.0, 107_000_000),
+        benchmark("2024-01-10", 3080.0, 3040.0, 3090.0, 111_000_000),
+        benchmark("2024-01-11", 3030.0, 2990.0, 3040.0, 115_000_000),
+        benchmark("2024-01-12", 2980.0, 2950.0, 2990.0, 118_000_000),
+    ];
+    DataSet::from_components(instruments, market, factors, candidates, benchmarks)
+        .expect("strategy test dataset")
+}
 
 #[test]
 fn strategy_emits_target_weights_and_diagnostics() {
-    let data_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../data/demo");
-    let data = DataSet::from_csv_dir(&data_dir).expect("demo data");
+    let data = strategy_test_dataset();
     let decision_date = NaiveDate::from_ymd_opt(2024, 1, 10).unwrap();
     let execution_date = NaiveDate::from_ymd_opt(2024, 1, 11).unwrap();
     let portfolio = PortfolioState::new(1_000_000.0);
@@ -53,8 +620,7 @@ fn strategy_emits_target_weights_and_diagnostics() {
 
 #[test]
 fn omni_strategy_emits_same_day_decision() {
-    let data_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../data/demo");
-    let data = DataSet::from_csv_dir(&data_dir).expect("demo data");
+    let data = strategy_test_dataset();
     let execution_date = NaiveDate::from_ymd_opt(2024, 1, 10).unwrap();
     let portfolio = PortfolioState::new(1_000_000.0);
     let mut cfg = OmniMicroCapConfig::omni_microcap();

data/demo/000852量价微盘平台策略.engine-script.txt

@@ -1,63 +0,0 @@
-let refresh_rate = 15;
-let stocknum = 40;
-let close_rate = 1.07;
-let loss_rate = 0.93;
-let rsi_rate = 1.0001;
-let trade_rate = 0.5;
-let xs = 4 / 500;
-let base_index_level = 2000;
-let base_cap_floor = 3;
-let base_cap_ceiling = 28;
-
-fn band_start(current_price, base_index_level, xs, base_cap_floor) {
-  if current_price == base_index_level {
-    base_cap_floor
-  } else if current_price > 0 {
-    round((current_price - base_index_level) * xs + base_cap_floor)
-  } else {
-    base_cap_floor
-  }
-}
-
-fn band_end(current_price, base_index_level, xs, base_cap_ceiling) {
-  if current_price == base_index_level {
-    base_cap_ceiling
-  } else if current_price > 0 {
-    round((current_price - base_index_level) * xs + base_cap_ceiling)
-  } else {
-    base_cap_ceiling
-  }
-}
-
-strategy("microcap_volume_trend_000852") {
-  market("CN_A")
-  benchmark("000852.SH")
-  signal("000852.SH")
-
-  rebalance.every_days(refresh_rate).at("10:18")
-
-  universe.exclude("paused", "st", "kcb", "one_yuan", "new_listing")
-
-  selection.limit(stocknum)
-  selection.market_cap_band(
-    field="market_cap",
-    lower=band_start(signal_close, base_index_level, xs, base_cap_floor),
-    upper=band_end(signal_close, base_index_level, xs, base_cap_ceiling)
-  )
-
-  risk.index_exposure(
-    signal_ma5 > signal_ma10 * rsi_rate ? 1.0 : trade_rate
-  )
-
-  filter.stock_expr(
-    stock_ma5 > stock_ma10 * rsi_rate &&
-    stock_ma10 > stock_ma30 * rsi_rate &&
-    rolling_mean("volume", 5) < rolling_mean("volume", 60)
-  )
-
-  risk.take_profit(close_rate)
-  risk.stop_loss(loss_rate)
-  allocation.buy_scale(touched_upper_limit ? 1.0 : trade_rate)
-
-  ordering.rank_by("market_cap", "asc")
-}

data/demo/000852量价微盘平台策略.strategy_spec.json

@@ -1,41 +0,0 @@
-{
-  "strategyId": "microcap_volume_trend_000852",
-  "version": "2",
-  "parser": "omniquant-engine-script-v2",
-  "market": "CN_A",
-  "signalSymbol": "000852.SH",
-  "benchmark": {
-    "instrumentId": "000852.SH",
-    "fallbackInstrumentId": "000852.SH"
-  },
-  "engineConfig": {
-    "market": "CN_A",
-    "signalSymbol": "000852.SH",
-    "benchmarkSymbol": "000852.SH",
-    "refreshRate": 15,
-    "rankLimit": 40
-  },
-  "runtimeExpressions": {
-    "prelude": "let refresh_rate = 15;\nlet stocknum = 40;\nlet close_rate = 1.07;\nlet loss_rate = 0.93;\nlet rsi_rate = 1.0001;\nlet trade_rate = 0.5;\nlet xs = 4 / 500;\nlet base_index_level = 2000;\nlet base_cap_floor = 3;\nlet base_cap_ceiling = 28;\nfn band_start(current_price, base_index_level, xs, base_cap_floor) {\n  if current_price == base_index_level {\n    base_cap_floor\n  } else if current_price > 0 {\n    round((current_price - base_index_level) * xs + base_cap_floor)\n  } else {\n    base_cap_floor\n  }\n}\nfn band_end(current_price, base_index_level, xs, base_cap_ceiling) {\n  if current_price == base_index_level {\n    base_cap_ceiling\n  } else if current_price > 0 {\n    round((current_price - base_index_level) * xs + base_cap_ceiling)\n  } else {\n    base_cap_ceiling\n  }\n}",
-    "selection": {
-      "limitExpr": "stocknum",
-      "marketCapField": "market_cap",
-      "marketCapLowerExpr": "band_start(signal_close, base_index_level, xs, base_cap_floor)",
-      "marketCapUpperExpr": "band_end(signal_close, base_index_level, xs, base_cap_ceiling)",
-      "stockFilterExpr": "stock_ma5 > stock_ma10 * rsi_rate && stock_ma10 > stock_ma30 * rsi_rate && rolling_mean(\"volume\", 5) < rolling_mean(\"volume\", 60)"
-    },
-    "risk": {
-      "exposureExpr": "signal_ma5 > signal_ma10 * rsi_rate ? 1.0 : trade_rate",
-      "stopLossExpr": "loss_rate",
-      "takeProfitExpr": "close_rate"
-    },
-    "allocation": {
-      "buyScaleExpr": "touched_upper_limit ? 1.0 : trade_rate"
-    },
-    "ordering": {
-      "rankBy": "market_cap",
-      "rankExpr": "",
-      "rankOrder": "asc"
-    }
-  }
-}

data/demo/ai_generated_000001_open_cap_band.engine-script.txt

@@ -1,42 +0,0 @@
-let refresh_rate = 15;
-let stocknum = 40;
-let xs = 0.008;
-let base_index_level = 2000;
-let lower_offset = 3;
-let upper_offset = 28;
-
-fn cap_floor(current_price, base_index_level, xs, lower_offset) {
-round((current_price - base_index_level) * xs + lower_offset)
-}
-
-fn cap_ceiling(current_price, base_index_level, xs, upper_offset) {
-round((current_price - base_index_level) * xs + upper_offset)
-}
-
-strategy("ai_generated_000001_open_cap_band") {
-market("CN_A")
-benchmark("000852.SH")
-signal("000001.SH")
-
-rebalance.every_days(refresh_rate).at("10:18")
-
-universe.exclude("paused", "st", "kcb", "one_yuan", "new_listing")
-
-selection.limit(stocknum)
-selection.market_cap_band(
-field="market_cap",
-lower=cap_floor(signal_open, base_index_level, xs, lower_offset),
-upper=cap_ceiling(signal_open, base_index_level, xs, upper_offset)
-)
-
-filter.stock_expr(
-stock_ma5 > stock_ma10 &&
-stock_ma10 > stock_ma30 &&
-rolling_mean("volume", 5) < rolling_mean("volume", 60) &&
-!ends_with(symbol, ".BJ") &&
-!at_upper_limit &&
-!at_lower_limit
-)
-
-  ordering.rank_by("market_cap", "asc")
-}

data/demo/ai_generated_000001_open_cap_band.strategy_spec.json

@@ -1,33 +0,0 @@
-{
-  "strategyId": "ai_generated_000001_open_cap_band",
-  "version": "2",
-  "parser": "omniquant-engine-script-v2",
-  "market": "CN_A",
-  "signalSymbol": "000001.SH",
-  "benchmark": {
-    "instrumentId": "000852.SH",
-    "fallbackInstrumentId": "000852.SH"
-  },
-  "engineConfig": {
-    "market": "CN_A",
-    "signalSymbol": "000001.SH",
-    "benchmarkSymbol": "000852.SH",
-    "refreshRate": 15,
-    "rankLimit": 40
-  },
-  "runtimeExpressions": {
-    "prelude": "let refresh_rate = 15;\nlet stocknum = 40;\nlet xs = 0.008;\nlet base_index_level = 2000;\nlet lower_offset = 3;\nlet upper_offset = 28;\n\nfn cap_floor(current_price, base_index_level, xs, lower_offset) {\nround((current_price - base_index_level) * xs + lower_offset)\n}\n\nfn cap_ceiling(current_price, base_index_level, xs, upper_offset) {\nround((current_price - base_index_level) * xs + upper_offset)\n}",
-    "selection": {
-      "limitExpr": "stocknum",
-      "marketCapField": "market_cap",
-      "marketCapLowerExpr": "cap_floor(signal_open, base_index_level, xs, lower_offset)",
-      "marketCapUpperExpr": "cap_ceiling(signal_open, base_index_level, xs, upper_offset)",
-      "stockFilterExpr": "stock_ma5 > stock_ma10 && stock_ma10 > stock_ma30 && rolling_mean(\"volume\", 5) < rolling_mean(\"volume\", 60) && !ends_with(symbol, \".BJ\") && !at_upper_limit && !at_lower_limit"
-    },
-    "ordering": {
-      "rankBy": "market_cap",
-      "rankExpr": "",
-      "rankOrder": "asc"
-    }
-  }
-}

data/demo/benchmark.csv

@@ -1,10 +0,0 @@
-date,benchmark,open,close,prev_close,volume
-2024-01-02,CSI300.DEMO,2990,3000,2980,100000000
-2024-01-03,CSI300.DEMO,3005,3020,3000,102000000
-2024-01-04,CSI300.DEMO,3025,3050,3020,105000000
-2024-01-05,CSI300.DEMO,3055,3080,3050,108000000
-2024-01-08,CSI300.DEMO,3085,3110,3080,109000000
-2024-01-09,CSI300.DEMO,3100,3090,3110,107000000
-2024-01-10,CSI300.DEMO,3080,3040,3090,111000000
-2024-01-11,CSI300.DEMO,3030,2990,3040,115000000
-2024-01-12,CSI300.DEMO,2980,2950,2990,118000000

data/demo/candidate_flags.csv

@@ -1,37 +0,0 @@
-date,symbol,is_st,is_new_listing,is_paused,allow_buy,allow_sell,is_kcb,is_one_yuan
-2024-01-02,000001.SZ,false,true,false,false,true,false,false
-2024-01-02,000002.SZ,false,false,false,true,true,false,false
-2024-01-02,000003.SZ,false,false,false,true,true,false,false
-2024-01-02,600001.SH,false,false,false,true,true,false,false
-2024-01-03,000001.SZ,false,true,false,false,true,false,false
-2024-01-03,000002.SZ,false,false,false,true,true,false,false
-2024-01-03,000003.SZ,false,false,false,true,true,false,false
-2024-01-03,600001.SH,false,false,false,true,true,false,false
-2024-01-04,000001.SZ,false,false,false,true,true,false,false
-2024-01-04,000002.SZ,false,false,false,true,true,false,false
-2024-01-04,000003.SZ,false,false,false,true,true,false,false
-2024-01-04,600001.SH,false,false,false,true,true,false,false
-2024-01-05,000001.SZ,false,false,false,true,true,false,false
-2024-01-05,000002.SZ,false,false,false,true,true,false,false
-2024-01-05,000003.SZ,false,false,false,true,true,false,false
-2024-01-05,600001.SH,false,false,false,true,true,false,false
-2024-01-08,000001.SZ,false,false,false,true,true,false,false
-2024-01-08,000002.SZ,false,false,false,true,true,false,false
-2024-01-08,000003.SZ,false,false,false,true,true,false,false
-2024-01-08,600001.SH,false,false,false,true,true,false,false
-2024-01-09,000001.SZ,false,false,false,true,true,false,false
-2024-01-09,000002.SZ,false,false,false,true,true,false,false
-2024-01-09,000003.SZ,false,false,false,true,true,false,false
-2024-01-09,600001.SH,false,false,false,true,true,false,false
-2024-01-10,000001.SZ,false,false,false,true,true,false,false
-2024-01-10,000002.SZ,false,false,false,true,true,false,false
-2024-01-10,000003.SZ,false,false,false,true,true,false,false
-2024-01-10,600001.SH,false,false,false,true,true,false,false
-2024-01-11,000001.SZ,false,false,false,true,true,false,false
-2024-01-11,000002.SZ,false,false,false,true,true,false,false
-2024-01-11,000003.SZ,false,false,false,true,true,false,false
-2024-01-11,600001.SH,false,false,true,false,false,false,false
-2024-01-12,000001.SZ,false,false,false,true,true,false,false
-2024-01-12,000002.SZ,false,false,false,true,true,false,false
-2024-01-12,000003.SZ,false,false,false,true,true,false,false
-2024-01-12,600001.SH,false,false,false,true,true,false,false

data/demo/factors.csv

@@ -1,37 +0,0 @@
-date,symbol,market_cap_bn,free_float_cap_bn,pe_ttm
-2024-01-02,000001.SZ,38,24,18
-2024-01-02,000002.SZ,45,30,20
-2024-01-02,000003.SZ,65,40,15
-2024-01-02,600001.SH,85,55,13
-2024-01-03,000001.SZ,39,24.5,18
-2024-01-03,000002.SZ,46,30.5,20
-2024-01-03,000003.SZ,64,39.5,15
-2024-01-03,600001.SH,85,55,13
-2024-01-04,000001.SZ,40,25,18
-2024-01-04,000002.SZ,47,31,20
-2024-01-04,000003.SZ,63,39,15
-2024-01-04,600001.SH,86,55.5,13
-2024-01-05,000001.SZ,41,25.5,18
-2024-01-05,000002.SZ,48,32,20
-2024-01-05,000003.SZ,62,38.5,15
-2024-01-05,600001.SH,86,56,13
-2024-01-08,000001.SZ,42,26,18
-2024-01-08,000002.SZ,50,33,21
-2024-01-08,000003.SZ,61,38,15
-2024-01-08,600001.SH,87,56.5,13
-2024-01-09,000001.SZ,44,27,19
-2024-01-09,000002.SZ,52,34,21
-2024-01-09,000003.SZ,60,37.5,15
-2024-01-09,600001.SH,88,57,13
-2024-01-10,000001.SZ,43,26.5,19
-2024-01-10,000002.SZ,53,34.5,21
-2024-01-10,000003.SZ,59,37,15
-2024-01-10,600001.SH,89,57.5,13
-2024-01-11,000001.SZ,42,26,18
-2024-01-11,000002.SZ,52,34,21
-2024-01-11,000003.SZ,58,36.5,15
-2024-01-11,600001.SH,90,58,13
-2024-01-12,000001.SZ,40,25,18
-2024-01-12,000002.SZ,50,33,20
-2024-01-12,000003.SZ,57,36,15
-2024-01-12,600001.SH,92,59,13

data/demo/instruments.csv

@@ -1,5 +0,0 @@
-symbol,name,board
-000001.SZ,Alpha Components,Main
-000002.SZ,Beta Precision,Main
-000003.SZ,Charlie Materials,Main
-600001.SH,Delta Industrials,Main

data/demo/market.csv

@@ -1,37 +0,0 @@
-date,symbol,open,high,low,close,prev_close,volume,paused
-2024-01-02,000001.SZ,10.0,10.2,9.9,10.1,9.8,1200000,false
-2024-01-02,000002.SZ,11.0,11.3,10.9,11.2,10.8,1100000,false
-2024-01-02,000003.SZ,8.0,8.1,7.8,7.9,8.0,900000,false
-2024-01-02,600001.SH,15.0,15.2,14.9,15.1,15.0,800000,false
-2024-01-03,000001.SZ,10.2,10.5,10.1,10.4,10.1,1250000,false
-2024-01-03,000002.SZ,11.2,11.6,11.1,11.5,11.2,1120000,false
-2024-01-03,000003.SZ,7.8,7.9,7.3,7.4,7.9,930000,false
-2024-01-03,600001.SH,15.1,15.3,15.0,15.2,15.1,820000,false
-2024-01-04,000001.SZ,10.5,10.8,10.4,10.7,10.4,1280000,false
-2024-01-04,000002.SZ,11.4,11.9,11.3,11.8,11.5,1150000,false
-2024-01-04,000003.SZ,7.3,7.4,7.0,7.1,7.4,940000,false
-2024-01-04,600001.SH,15.2,15.5,15.1,15.4,15.2,830000,false
-2024-01-05,000001.SZ,10.8,11.1,10.7,11.0,10.7,1300000,false
-2024-01-05,000002.SZ,11.9,12.1,11.8,12.0,11.8,1180000,false
-2024-01-05,000003.SZ,7.0,7.1,6.8,6.9,7.1,950000,false
-2024-01-05,600001.SH,15.4,15.6,15.3,15.5,15.4,840000,false
-2024-01-08,000001.SZ,11.1,11.6,11.0,11.5,11.0,1400000,false
-2024-01-08,000002.SZ,12.1,12.5,12.0,12.4,12.0,1200000,false
-2024-01-08,000003.SZ,7.0,7.3,6.9,7.2,6.9,980000,false
-2024-01-08,600001.SH,15.5,15.7,15.4,15.6,15.5,850000,false
-2024-01-09,000001.SZ,11.6,12.4,11.5,12.3,11.5,1500000,false
-2024-01-09,000002.SZ,12.5,12.9,12.4,12.8,12.4,1250000,false
-2024-01-09,000003.SZ,7.2,7.5,7.1,7.4,7.2,990000,false
-2024-01-09,600001.SH,15.6,15.7,15.4,15.5,15.6,860000,false
-2024-01-10,000001.SZ,12.2,12.3,11.9,12.0,12.3,1450000,false
-2024-01-10,000002.SZ,12.7,12.8,12.5,12.6,12.8,1220000,false
-2024-01-10,000003.SZ,7.5,7.6,7.4,7.5,7.4,1000000,false
-2024-01-10,600001.SH,15.4,15.5,15.1,15.2,15.5,870000,false
-2024-01-11,000001.SZ,12.0,12.1,11.5,11.6,12.0,1420000,false
-2024-01-11,000002.SZ,12.5,12.6,12.1,12.2,12.6,1210000,false
-2024-01-11,000003.SZ,7.4,7.5,7.2,7.3,7.5,980000,false
-2024-01-11,600001.SH,15.2,15.2,15.2,15.2,15.2,0,true
-2024-01-12,000001.SZ,11.5,11.6,11.1,11.2,11.6,1380000,false
-2024-01-12,000002.SZ,12.1,12.2,11.8,11.9,12.2,1190000,false
-2024-01-12,000003.SZ,7.2,7.2,6.9,7.0,7.3,960000,false
-2024-01-12,600001.SH,14.8,15.0,14.7,14.9,15.2,850000,false

docs/engine-capability-roadmap.md

@@ -20,7 +20,9 @@ futures path. Confirmed aligned areas:
   pending limit orders, cancellation, open order views, and final order lookup.
 - Stock account and portfolio runtime fields including cash, frozen cash, total
   value, transaction cost, trading/position PnL, management fees, financing
-  liability, deposit/withdraw, and position aliases.
+  liability, deposit/withdraw, and position aliases. External deposits and
+  withdrawals are unitized separately from trading PnL; delayed withdrawals
+  are preflighted atomically at settlement.
 - Scheduler, dynamic universe, subscription guard, `history_bars`,
   `current_snapshot`, `get_price`, instruments, trading-date APIs, suspension
   and ST helpers.
@@ -37,6 +39,7 @@ futures path. Confirmed aligned areas:
 | P0 | Futures intraday matching | Closed for daily/open/close, tick-price futures fills, and true multi-level order-book sweeping when optional `order_book_depth` data exists. L1-only data still uses the existing L1 matcher and is not inflated into fake depth. | Extend depth fields only if production vendors expose more levels or exchange-specific fields. |
 | P0 | Futures open-order lifecycle | Closed for futures pending limit orders, cross-day rematching, cancellation by id/symbol/all, and merged open-order runtime views. | Add more order status transitions only if UI requires extra intermediate event names. |
 | P0 | Combined multi-account NAV | Closed. `DailyEquityPoint`, progress events, and metrics use aggregate stock + futures initial cash and total equity. | None. |
+| P0 | Fixed-point execution money | Stock execution now freezes fee rates once and uses signed micro-yuan `i128` for gross amount, commission, stamp tax, transfer fee, strict budget checks, cash, liabilities, management fees, external flows and account units. Market indicators and return statistics remain `f64` outside the execution boundary. | Migrate position cost/PnL and the standalone futures cash ledger only after independent artifact and performance A/B gates. |
 | P1 | Futures trading parameter data source | Closed for engine-side trading-parameter ingestion/resolution via `futures_trading_parameters.csv` or component data. | Add more exchange metadata columns only when source data exposes them. |
 | P1 | Futures transaction cost decider | Closed. `FuturesTransactionCostModel` calculates by-money/by-volume open/close/close-today costs from trading parameters. | None. |
 | P1 | Futures settlement price mode | Closed. Engine supports configurable settlement price mode and resolves settlement/prev-settlement from factor fields with close/prev_close fallback. | Add dedicated settlement columns if the storage layer later separates them from factors. |
@@ -52,22 +55,24 @@ futures path. Confirmed aligned areas:
 - [x] Rich explicit order styles exposed to platform scripts.
 - [x] Minute-level `time_rule` semantics including market-open, market-close,
       and physical-time style schedules.
-- [x] Fine-grained daily, minute, and tick strategy execution entrypoints.
+- [x] Fine-grained daily and minute execution quote strategy entrypoints.
+- [x] Stock broker fee, budget and cash-ledger arithmetic uses a micro-yuan
+      fixed-point execution primitive; one-micro over-budget orders fail.
 - [x] Scheduled actions evaluated against explicit intraday times.
 - [x] `update_universe`, `subscribe`, and `unsubscribe`.
-- [x] Tick-frequency subscription guards at strategy API level.
+- [x] Intraday subscription guards at strategy API level; intraday execution uses minute quote semantics.
 - [x] VWAP and TWAP explicit action styles.
 - [x] `order_target_portfolio_smart(..., order_prices=AlgoOrder, valuation_prices=...)`.
 - [x] Trading PnL, position PnL, dividend receivable, and richer position
       lifecycle fields.
 - [x] Stock position aliases including `order_book_id`, `avg_price`,
       `sellable`, `closable`, `equity`, and `position_prev_close`.
-- [x] `history_bars` numeric helper for daily, intraday, and tick fields.
+- [x] `history_bars` numeric helper for daily and minute execution quote fields.
 - [x] `current_snapshot`, instrument metadata, all-instrument queries, and
       active/historical instrument helpers.
 - [x] Trading-date range, previous-date, and next-date helpers.
-- [x] Phase-aware minute/tick history cursor semantics matching the active bar
-      or tick callback.
+- [x] Phase-aware minute history cursor semantics matching the active bar or
+      intraday execution quote callback.
 - [x] Suspension, ST, date-range price, active instrument, and instrument
       history helpers.
 - [x] Open-order status, unfilled quantity, final order lookup, average fill

scripts/verify-no-legacy-data-source.sh

@@ -0,0 +1,164 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$ROOT_DIR"
+
+fail() {
+  local message="$1"
+  local details="${2:-}"
+  printf '[FAIL] %s\n' "$message" >&2
+  if [[ -n "$details" ]]; then
+    printf '%s\n' "$details" >&2
+  fi
+  exit 1
+}
+
+runtime_hits="$(
+  rg -n \
+    --glob '!**/.git/**' \
+    --glob '!**/target/**' \
+    --glob '!**/docs/**' \
+    --glob '!**/*.md' \
+    --glob '!**/tests/**' \
+    --glob '!**/*.test.rs' \
+    --glob '!**/*_test.rs' \
+    --glob '!crates/fidc-core/src/strategy_ai.rs' \
+    --glob '!scripts/verify-no-legacy-data-source.sh' \
+    'fidatacenter|FIDATACENTER|/v1/backtest/data|/v1/xuntou|ClickHouse|clickhouse|CLICKHOUSE|FIDC_BT_INSTRUMENT_METADATA_CSV|FIDC_BT_WRITE_SNAPSHOTS|FIDC_BT_WRITE_CSV_SNAPSHOTS|FIDC_BT_WRITE_COMBINED_SOURCE_ROW_CACHE|write_csv_snapshot_files|write_csv\(|FIDC_RISK_RUNTIME_FILE|FIDC_RISK_RUNTIME_URL|FIDC_FIRISK_RUNTIME_FILE|FiRisk runtime snapshot' \
+    crates Cargo.toml \
+    2>/dev/null || true
+)"
+
+if [[ -n "$runtime_hits" ]]; then
+  fail "legacy fidatacenter/ClickHouse/CSV snapshot/FiRisk runtime data source references are not allowed in fidc-backtest-engine" "$runtime_hits"
+fi
+
+manifest_hits="$(
+  rg -n --glob '!scripts/verify-no-legacy-data-source.sh' '\b(mysql|mariadb|clickhouse|clickhouse-rs|mysql_async|sqlx-mysql)\b' Cargo.toml crates 2>/dev/null || true
+)"
+
+if [[ -n "$manifest_hits" ]]; then
+  fail "legacy database dependencies are not allowed in fidc-backtest-engine manifests" "$manifest_hits"
+fi
+
+local_only_hits="$(
+  rg -n \
+    --glob '!**/.git/**' \
+    --glob '!**/target/**' \
+    --glob '!**/docs/**' \
+    --glob '!**/*.md' \
+    --glob '!**/tests/**' \
+    --glob '!**/*.test.rs' \
+    --glob '!**/*_test.rs' \
+    --glob '!crates/fidc-core/src/strategy_ai.rs' \
+    --glob '!scripts/verify-no-legacy-data-source.sh' \
+    'FICLAW_DATA_AGENT_URL|ficlaw_data\.source_rows_v1|strategy-factory-source-lake://local|FIDC_BT_WRITE_COMBINED_SOURCE_ROW_CACHE' \
+    crates Cargo.toml \
+    2>/dev/null || true
+)"
+
+if [[ -n "$local_only_hits" ]]; then
+  fail "legacy or local-only data source references are not allowed in fidc-backtest-engine runtime" "$local_only_hits"
+fi
+
+json_query_hits="$(
+  rg -n \
+    --glob '!**/.git/**' \
+    --glob '!**/target/**' \
+    --glob '!**/docs/**' \
+    --glob '!**/*.md' \
+    --glob '!**/tests/**' \
+    --glob '!**/*.test.rs' \
+    --glob '!**/*_test.rs' \
+    --glob '!crates/fidc-core/src/strategy_ai.rs' \
+    --glob '!scripts/verify-no-legacy-data-source.sh' \
+    '/v1/query/(source-rows|daily-execution-prices|minute-execution-prices|instruments|corporate-actions)\.json' \
+    crates Cargo.toml \
+    2>/dev/null || true
+)"
+
+if [[ -n "$json_query_hits" ]]; then
+  fail "JSON Source Lake high-throughput endpoints are not allowed in fidc-backtest-engine runtime; use Arrow endpoints" "$json_query_hits"
+fi
+
+fused_hits="$(
+  rg -n \
+    --glob '!**/.git/**' \
+    --glob '!**/target/**' \
+    --glob '!**/docs/**' \
+    --glob '!**/*.md' \
+    --glob '!**/tests/**' \
+    --glob '!**/*.test.rs' \
+    --glob '!**/*_test.rs' \
+    --glob '!crates/fidc-core/src/strategy_ai.rs' \
+    --glob '!scripts/verify-no-legacy-data-source.sh' \
+    'exported_fused|fidc_fused|fusion|fused|wide_table|wide table|source_rows_export|exported_daily|merged_daily|daily_merged|merged_source|materialized[_ -]source|materialized_source_rows|source_rows_materialized|融合表|融合宽表' \
+    crates Cargo.toml \
+    2>/dev/null || true
+)"
+
+if [[ -n "$fused_hits" ]]; then
+  fail "exported fused tables are not allowed in fidc-backtest-engine runtime; use Strategy Factory Source Lake source rows directly" "$fused_hits"
+fi
+
+feature_store_hits="$(
+  rg -n \
+    --glob '!**/.git/**' \
+    --glob '!**/target/**' \
+    --glob '!**/docs/**' \
+    --glob '!**/*.md' \
+    --glob '!**/tests/**' \
+    --glob '!**/*.test.rs' \
+    --glob '!**/*_test.rs' \
+    --glob '!crates/fidc-core/src/strategy_ai.rs' \
+    --glob '!scripts/verify-no-legacy-data-source.sh' \
+    'research_feature_store|feature_store|FEATURE_STORE|daily_minute_current|FIDC_STRATEGY_FACTORY_ENABLE_FEATURE_STORE_CACHE|ALPHA_FACTORY_ENABLE_FEATURE_STORE_CACHE|ENABLE_FEATURE_STORE_CACHE' \
+    crates Cargo.toml \
+    2>/dev/null || true
+)"
+
+if [[ -n "$feature_store_hits" ]]; then
+  fail "historical feature-store paths are not allowed in fidc-backtest-engine runtime; use Strategy Factory Source Lake raw/indicator/artifact partitions and discardable caches" "$feature_store_hits"
+fi
+
+truth_csv_hits="$(
+  rg -n \
+    --glob '!**/.git/**' \
+    --glob '!**/target/**' \
+    --glob '!**/docs/**' \
+    --glob '!**/*.md' \
+    --glob '!**/tests/**' \
+    --glob '!**/*.test.rs' \
+    --glob '!**/*_test.rs' \
+    --glob '!crates/fidc-core/src/strategy_ai.rs' \
+    --glob '!scripts/verify-no-legacy-data-source.sh' \
+    'FIDC_BT_TRUTH_STOCK_LIST_CSV|OMNI_BT_TRUTH_STOCK_LIST_CSV|OMNI_BACKTEST_TRUTH_STOCK_LIST_CSV|selection_source=truth_csv|truth_stock_list|truth_csv' \
+    crates Cargo.toml \
+    2>/dev/null || true
+)"
+
+if [[ -n "$truth_csv_hits" ]]; then
+  fail "CSV truth stock-list overrides are not allowed in fidc-backtest-engine runtime; use Source Lake runtime spec selection only" "$truth_csv_hits"
+fi
+
+csv_snapshot_loader_hits="$(
+  rg -n \
+    --glob '!**/.git/**' \
+    --glob '!**/target/**' \
+    --glob '!**/docs/**' \
+    --glob '!**/*.md' \
+    --glob '!**/tests/**' \
+    --glob '!**/*.test.rs' \
+    --glob '!**/*_test.rs' \
+    --glob '!scripts/verify-no-legacy-data-source.sh' \
+    'from_csv_dir|from_partitioned_dir|instruments\.csv|candidate_flags\.csv|market\.csv|benchmark\.csv' \
+    crates Cargo.toml \
+    2>/dev/null || true
+)"
+
+if [[ -n "$csv_snapshot_loader_hits" ]]; then
+  fail "CSV snapshot loaders are not allowed in fidc-backtest-engine runtime; construct DataSet from Source Lake components" "$csv_snapshot_loader_hits"
+fi
+
+printf '[OK] fidc-backtest-engine has no legacy runtime data-source references\n'

scripts/verify-runtime-risk-contracts.sh

@@ -0,0 +1,64 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$ROOT_DIR"
+PYTHON_BIN="${PYTHON_BIN:-python3}"
+
+fail() {
+  local message="$1"
+  local details="${2:-}"
+  printf '[FAIL] %s\n' "$message" >&2
+  if [[ -n "$details" ]]; then
+    printf '%s\n' "$details" >&2
+  fi
+  exit 1
+}
+
+run_core_test() {
+  local filter="$1"
+  local tmp
+  tmp="$(mktemp)"
+  printf '[INFO] cargo test -p fidc-core %s\n' "$filter"
+  if cargo test -p fidc-core "$filter" -- --nocapture 2>&1 | tee "$tmp"; then
+    local passed_count
+    passed_count="$(
+      "$PYTHON_BIN" - "$tmp" <<'PY'
+import re
+import sys
+
+count = 0
+for line in open(sys.argv[1], encoding="utf-8", errors="replace"):
+    match = re.search(r"test result: ok\. (\d+) passed;", line)
+    if match:
+        count += int(match.group(1))
+print(count)
+PY
+    )"
+    rm -f "$tmp"
+    if [[ "$passed_count" -le 0 ]]; then
+      fail "cargo test filter matched 0 tests: package=fidc-core filter=${filter}"
+    fi
+    return 0
+  fi
+  local output
+  output="$(cat "$tmp")"
+  rm -f "$tmp"
+  fail "cargo test failed: package=fidc-core filter=${filter}" "$output"
+}
+
+run_core_test eligible_universe_does_not_require_candidate_risk_state_when_selection_risk_is_disabled
+run_core_test next_bar_open_eligible_universe_helper_does_not_block_on_decision_day_risk
+run_core_test platform_selection_uses_complete_static_risk_policy_before_universe_output
+run_core_test platform_next_open_defers_complete_static_selection_risk_before_universe_output
+run_core_test platform_next_open_selection_ignores_execution_day_limit_state
+run_core_test platform_next_open_selection_applies_explicit_signal_day_risk_filter
+run_core_test next_open_buy_risk_uses_execution_date_not_signal_date
+run_core_test next_open_buy_limit_risk_uses_open_not_close
+run_core_test next_open_sell_risk_uses_execution_date_not_signal_date
+run_core_test next_open_sell_limit_risk_uses_open_not_close
+run_core_test next_bar_open_sell_respects_allow_sell_policy_on_execution_day
+run_core_test volume_limit_uses_floor_for_odd_lot_sell
+run_core_test configurable_upper_limit_buy_filter_can_be_disabled
+
+printf '[OK] fidc-backtest-engine runtime risk contracts passed\n'