test: enable rebalance actions in portfolio risk lifecycle fixture

Cargo.toml

@@ -1,7 +1,6 @@
 [workspace]
 members = [
     "crates/fidc-core",
-    "crates/fidc-signal-client",
 ]
 resolver = "2"
 
@@ -12,7 +11,6 @@ version = "0.1.0"
 authors = ["OpenAI Codex"]
 
 [workspace.dependencies]
-rust_decimal = { version = "=1.39.0", features = ["serde-with-str"] }
 sha2 = "=0.10.9"
 ahash = "=0.8.12"
 chrono = { version = "=0.4.44", features = ["serde"] }

README.md

@@ -1,5 +1,3 @@
-<p><img src="assets/brand/fiPandaWithTitle.png" alt="FiPanda" width="144" height="144"></p>
-
 # fidc-backtest-engine
 
 面向中国 A 股和期货策略的 Rust 回测核心。仓库目标是提供平台自有的策略 DSL、执行模型、撮合模型和结果分析能力，最终由 `fidc-backtest-service` 对外提供策略运行服务。

assets/brand/README.md

@@ -1,11 +0,0 @@
-# FiPanda 品牌资源
-
-FIDC 系列共用用户提供的两张原始透明图片，不重绘、不裁切、不染色。
-
-- `fiPandaWithTitle.png`：带标题版，登录页、项目首页、独立报告使用。
-- `fipanda.png`：无标题版，顶部导航、小尺寸标识和系统图标使用。
-- `favicon-32.png`：由无标题版等比生成，供浏览器标签页使用。
-
-导航图标建议 28–42px；带标题版建议 96–160px。始终等比完整显示，保留透明背景，不为 Logo 增加大块容器或改变业务页面主题。项目名称、权限、交易合同与内部 FIDC 标识不因品牌图片变更而重命名。
-
-原图保存在 `omniquant/assets/brand/source/`；`manifest.json` 记录原图和显示资源的 SHA-256。需要更新时，在完整工作区运行 `node omniquant/scripts/sync-fipanda-branding.mjs`，统一生成八个仓库及可下载策略技能包的资源，禁止分别维护不同版本。

assets/brand/manifest.json

@@ -1,38 +0,0 @@
-{
-  "schema": "fidc.fipanda-brand/v1",
-  "brand": "FiPanda",
-  "sourceRepository": "omniquant",
-  "sources": [
-    {
-      "file": "fipanda.png",
-      "sha256": "ff7dc0677b7d9c8dc6d008d3391f27fd583e3de35560dab021c1e2f8f2c464e5"
-    },
-    {
-      "file": "fiPandaWithTitle.png",
-      "sha256": "01bfb6acb36830d9b1ce6f7dc8c718977d43af44572ee6a26991d6c6aa2847d6"
-    }
-  ],
-  "assets": [
-    {
-      "file": "fipanda.png",
-      "source": "fipanda.png",
-      "pixels": 192,
-      "usage": "navigation, compact icons, apple-touch-icon",
-      "sha256": "450aad3506ec3c67624b7705f4d8f851a9102fe950e7671a06fb1203dc1d9cf7"
-    },
-    {
-      "file": "fiPandaWithTitle.png",
-      "source": "fiPandaWithTitle.png",
-      "pixels": 384,
-      "usage": "login, project README, standalone reports",
-      "sha256": "d33846b3687ea69d43b4a1f17ceeb02662bd25f26fabc4c86c25b3475f20dede"
-    },
-    {
-      "file": "favicon-32.png",
-      "source": "fipanda.png",
-      "pixels": 32,
-      "usage": "browser tab icon",
-      "sha256": "ec3d7783457db284d46ae6e27833685203838637a7d68946ff85402725f8e420"
-    }
-  ]
-}

crates/fidc-core/Cargo.toml

@@ -6,7 +6,6 @@ license.workspace = true
 authors.workspace = true
 
 [dependencies]
-rust_decimal.workspace = true
 ahash.workspace = true
 chrono.workspace = true
 indexmap.workspace = true
@@ -16,4 +15,3 @@ serde.workspace = true
 serde_json.workspace = true
 sha2.workspace = true
 thiserror.workspace = true
-ta-lib = { git = "https://github.com/TA-Lib/ta-lib.git", rev = "dd5a90259a3f9e04e2da9f38bf0719a841b40108" }

crates/fidc-core/examples/factor-event-kernel.rs

@@ -1,42 +0,0 @@
-use fidc_core::factor_events::{self, Expr, Frame};
-use serde::Deserialize;
-use serde_json::{Value, json};
-use std::io::{self, Read};
-
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-struct Request {
-    expressions: std::collections::BTreeMap<String, Expr>,
-    frame: Frame,
-}
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut input = String::new();
-    io::stdin().read_to_string(&mut input)?;
-    let output = if input.trim().is_empty() {
-        factor_events::catalog()
-    } else if serde_json::from_str::<Value>(&input)?.get("rank_history").is_some() {
-        #[derive(Deserialize)]
-        #[serde(deny_unknown_fields)]
-        struct Rank { dates:Vec<chrono::NaiveDate>, universe:Vec<String>, values:std::collections::BTreeMap<String,Vec<Option<f64>>> }
-        let value:Value=serde_json::from_str(&input)?;
-        let request:Rank=serde_json::from_value(value["rank_history"].clone())?;
-        json!({"result":fidc_core::factor_cross_section::rank_history(&request.dates,&request.universe,&request.values)?})
-    } else {
-        let request: Request = serde_json::from_str(&input)?;
-        let results = request
-            .expressions
-            .iter()
-            .map(|(id, expr)| {
-                let result = match factor_events::evaluate(expr, &request.frame) {
-                    Ok(v) => json!({"result":v}),
-                    Err(e) => json!({"error":e}),
-                };
-                (id.clone(), result)
-            })
-            .collect::<std::collections::BTreeMap<String, Value>>();
-        json!({"contract":factor_events::CONTRACT,"results":results,"read_only":true})
-    };
-    println!("{}", serde_json::to_string(&output)?);
-    Ok(())
-}

crates/fidc-core/examples/market-event-kernel.rs

@@ -1,9 +0,0 @@
-use std::io::{self, Read};
-fn main() {
-    let mut input=String::new();io::stdin().read_to_string(&mut input).unwrap();
-    let request=serde_json::from_str(&input).unwrap();
-    match fidc_core::market_event_context::aggregate(request) {
-        Ok(value)=>println!("{}",serde_json::to_string(&value).unwrap()),
-        Err(error)=>{eprintln!("{error}");std::process::exit(1);}
-    }
-}

crates/fidc-core/examples/session-event-kernel.rs

@@ -1,26 +0,0 @@
-use std::io::Read;
-fn main() {
-    let mut input = String::new();
-    std::io::stdin().read_to_string(&mut input).unwrap();
-    let value: serde_json::Value = serde_json::from_str(&input).unwrap();
-    let spec: fidc_core::daily_patterns::PatternSpec =
-        serde_json::from_value(value["spec"].clone()).unwrap();
-    let bars: Vec<fidc_core::session_events::MinuteBar> =
-        serde_json::from_value(value["bars"].clone()).unwrap();
-    let result = fidc_core::session_events::evaluate(
-        &spec.validate().unwrap(),
-        value["symbol"].as_str().unwrap(),
-        &bars,
-        serde_json::from_value(value["decision_at"].clone()).unwrap(),
-    );
-    match result {
-        Ok(row) => println!(
-            "{}",
-            serde_json::json!({"contract":fidc_core::session_events::CONTRACT,"row":row,"read_only":true,"source_evidence_verified":false})
-        ),
-        Err(error) => {
-            eprintln!("{error}");
-            std::process::exit(1);
-        }
-    }
-}

crates/fidc-core/examples/signal-book-kernel.rs

@@ -1,15 +0,0 @@
-use std::io::{Read, Write};
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let mut raw=Vec::new();
-    std::io::stdin().take(64*1024*1024+1).read_to_end(&mut raw)?;
-    if raw.len()>64*1024*1024 {return Err("signal_book_transport_limit".into());}
-    let book:fidc_core::signal_contract::SignalBook=serde_json::from_slice(&raw)?;
-    let version=book.content_sha256()?;
-    let validated=book.validate()?;
-    let result=serde_json::json!({"schema":fidc_core::signal_contract::SIGNAL_BOOK_SCHEMA,
-        "versionSha256":version,"symbols":validated.symbols(),
-        "onlineAllowed":validated.require_observed().is_ok()});
-    std::io::stdout().write_all(serde_json::to_string(&result)?.as_bytes())?;
-    Ok(())
-}

crates/fidc-core/src/broker_stock_pool.rs

@@ -1,480 +0,0 @@
-//! Executes one frozen pool intent against real broker-simulator state.
-use super::*;
-use crate::holding_policy::HoldingLifecycleEvidence;
-use crate::stock_pool_execution as pool;
-use rust_decimal::{Decimal, prelude::ToPrimitive};
-
-fn decimal(value: f64, label: &str) -> Result<Decimal, BacktestError> {
-    if !value.is_finite() {
-        return Err(BacktestError::Execution(format!(
-            "stock_pool_nonfinite_{label}"
-        )));
-    }
-    value
-        .to_string()
-        .parse()
-        .map_err(|_| BacktestError::Execution(format!("stock_pool_decimal_range_{label}")))
-}
-
-fn pool_positions(
-    portfolio: &PortfolioState,
-    date: NaiveDate,
-) -> Result<Vec<pool::Position>, BacktestError> {
-    portfolio
-        .positions()
-        .values()
-        .filter(|p| p.quantity > 0)
-        .map(|p| {
-            Ok(pool::Position {
-                symbol: p.symbol.clone(),
-                quantity: Decimal::from(p.quantity),
-                closable_quantity: Decimal::from(p.sellable_qty(date)),
-                average_cost: decimal(p.average_cost, "position_cost")?,
-            })
-        })
-        .collect()
-}
-
-impl<C: CostModel, R: EquityRuleHooks> BrokerSimulator<C, R> {
-    fn pool_quote_inputs(
-        &self,
-        date: NaiveDate,
-        data: &DataSet,
-        symbols: &BTreeSet<String>,
-        execution_clock: Option<NaiveDateTime>,
-    ) -> Result<Vec<pool::MarketSnapshot>, BacktestError> {
-        symbols
-            .iter()
-            .map(|symbol| {
-                let snapshot = data.market(date, symbol).ok_or_else(|| {
-                    BacktestError::Execution(format!(
-                        "stock_pool_execution_snapshot_missing:{symbol}:{date}"
-                    ))
-                })?;
-                let instrument = data.instruments().get(symbol).ok_or_else(|| {
-                    BacktestError::Execution(format!("stock_pool_instrument_missing:{symbol}"))
-                })?;
-                let (price, prev, volume, amount, bid, ask, buy_price, sell_price) = if self
-                    .matching_type_uses_intraday_quotes()
-                {
-                    let time = self
-                        .runtime_intraday_start_time
-                        .get()
-                        .or(self.intraday_execution_start_time)
-                        .ok_or_else(|| {
-                            BacktestError::Execution(
-                                "stock_pool_intraday_execution_clock_required".into(),
-                            )
-                        })?;
-                    let clock = execution_clock
-                        .unwrap_or(date.and_time(time))
-                        .max(date.and_time(time));
-                    let quote = data
-                        .execution_quotes_on(date, symbol)
-                        .iter()
-                        .rev()
-                        .find(|quote| quote.timestamp <= clock)
-                        .ok_or_else(|| {
-                            BacktestError::Execution(format!(
-                                "stock_pool_execution_quote_missing:{symbol}:{clock}"
-                            ))
-                        })?;
-                    if !quote.last_price.is_finite() || quote.last_price <= 0.0 {
-                        return Err(BacktestError::Execution(format!(
-                            "stock_pool_execution_quote_invalid:{symbol}:{clock}"
-                        )));
-                    }
-                    let raw_buy = self
-                        .select_quote_reference_price(
-                            snapshot,
-                            quote,
-                            OrderSide::Buy,
-                            self.matching_type,
-                        )
-                        .ok_or_else(|| {
-                            BacktestError::Execution(format!(
-                                "stock_pool_buy_reference_missing:{symbol}:{clock}"
-                            ))
-                        })?;
-                    let raw_sell = self
-                        .select_quote_reference_price(
-                            snapshot,
-                            quote,
-                            OrderSide::Sell,
-                            self.matching_type,
-                        )
-                        .ok_or_else(|| {
-                            BacktestError::Execution(format!(
-                                "stock_pool_sell_reference_missing:{symbol}:{clock}"
-                            ))
-                        })?;
-                    let calibration = self.slippage_calibration(data, snapshot)?;
-                    let buy = self.quote_execution_price(
-                        snapshot,
-                        OrderSide::Buy,
-                        raw_buy,
-                        None,
-                        calibration.as_ref(),
-                    )?;
-                    let sell = self.quote_execution_price(
-                        snapshot,
-                        OrderSide::Sell,
-                        raw_sell,
-                        None,
-                        calibration.as_ref(),
-                    )?;
-                    (
-                        quote.last_price,
-                        snapshot.prev_close,
-                        Some(quote.volume_delta as f64),
-                        Some(quote.amount_delta),
-                        Some(quote.bid1),
-                        Some(quote.ask1),
-                        buy,
-                        sell,
-                    )
-                } else {
-                    let price = snapshot.price(self.effective_execution_price_field(date));
-                    if !price.is_finite() || price <= 0.0 {
-                        return Err(BacktestError::Execution(format!(
-                            "stock_pool_execution_price_missing:{symbol}:{date}"
-                        )));
-                    }
-                    // A daily open does not reveal the session's volume/turnover.
-                    let completed = self.effective_execution_price_field(date) == PriceField::Close;
-                    (
-                        price,
-                        snapshot.prev_close,
-                        completed.then_some(snapshot.volume as f64),
-                        None,
-                        Some(price),
-                        Some(price),
-                        self.snapshot_execution_price(data, snapshot, OrderSide::Buy, None)?,
-                        self.snapshot_execution_price(data, snapshot, OrderSide::Sell, None)?,
-                    )
-                };
-                Ok(pool::MarketSnapshot {
-                    symbol: symbol.clone(),
-                    last_price: decimal(price, "price")?,
-                    prev_close: Some(decimal(prev, "prev_close")?),
-                    volume: volume.map(|v| decimal(v, "volume")).transpose()?,
-                    turnover: amount.map(|v| decimal(v, "amount")).transpose()?,
-                    bid_price_1: bid.map(|v| decimal(v, "bid")).transpose()?,
-                    ask_price_1: ask.map(|v| decimal(v, "ask")).transpose()?,
-                    is_kcb: Some(instrument.board.eq_ignore_ascii_case("KSH")),
-                    instrument_rules: Some(pool::StockPoolInstrumentRules {
-                        price_tick: decimal(snapshot.price_tick, "price_tick")?,
-                        quantity_step: instrument.order_step_size().into(),
-                        minimum_buy_quantity: instrument.minimum_order_quantity().into(),
-                    }),
-                    buy_sizing_price: Some(decimal(buy_price, "buy_price")?),
-                    sell_sizing_price: Some(decimal(sell_price, "sell_price")?),
-                })
-            })
-            .collect()
-    }
-
-    pub(super) fn process_stock_pool_contract(
-        &self,
-        date: NaiveDate,
-        portfolio: &mut PortfolioState,
-        data: &DataSet,
-        contract: &pool::FrozenStockPoolIntent,
-        intraday_turnover: &mut BTreeMap<String, u32>,
-        execution_cursors: &mut IntradayExecutionLedger,
-        global_execution_cursor: &mut Option<NaiveDateTime>,
-        commission_state: &mut BTreeMap<u64, f64>,
-        report: &mut BrokerExecutionReport,
-    ) -> Result<(), BacktestError> {
-        if contract.signal_date > date
-            || contract.frozen_equity < Decimal::ZERO
-            || contract.generation.is_empty()
-            || contract.pool_id.trim().is_empty()
-        {
-            return Err(BacktestError::Execution(
-                "stock_pool_frozen_intent_invalid".into(),
-            ));
-        }
-        if self.matching_type == MatchingType::NextBarOpen && contract.signal_date >= date {
-            return Err(BacktestError::Execution(
-                "stock_pool_next_open_requires_prior_signal".into(),
-            ));
-        }
-        let mut selection = contract.selection.clone();
-        let mut members = contract.members.clone();
-        for symbol in &contract.selection.requested_symbols {
-            let instrument = data.instruments().get(symbol).ok_or_else(|| {
-                BacktestError::Execution(format!("stock_pool_instrument_missing:{symbol}"))
-            })?;
-            if portfolio.position(symbol).is_none()
-                && let Some(reason) = instrument.dated_market_absence_reason(date)
-            {
-                selection.requested_symbols.retain(|v| v != symbol);
-                selection.normal_trading_symbols.retain(|v| v != symbol);
-                selection.risk_eligible_symbols.retain(|v| v != symbol);
-                selection.final_symbols.retain(|v| v != symbol);
-                members.retain(|v| &v.symbol != symbol);
-                report.diagnostics.push(format!(
-                    "stock_pool_market_absence symbol={symbol} date={date} reason={reason}"
-                ));
-            }
-        }
-        let mut scope = selection
-            .requested_symbols
-            .iter()
-            .cloned()
-            .collect::<BTreeSet<_>>();
-        scope.extend(portfolio.positions().keys().cloned());
-        let official_dates = data.calendar().iter().collect::<Vec<_>>();
-        let initial_positions = pool_positions(portfolio, date)?;
-        let state = portfolio
-            .stock_pool_execution_state(&contract.pool_id)
-            .observe(
-                contract.signal_date,
-                date,
-                &official_dates,
-                &members,
-                &initial_positions,
-            )
-            .map_err(BacktestError::Execution)?;
-        portfolio
-            .set_stock_pool_execution_state(&contract.pool_id, state)
-            .map_err(BacktestError::Execution)?;
-        if self.has_open_orders() {
-            report
-                .diagnostics
-                .push("stock_pool_waiting_for_active_orders no_new_intent=true".into());
-            return Ok(());
-        }
-        let mut constraints = contract.constraints.clone();
-        constraints.execution_date = Some(date);
-        constraints.frozen_positions.clear();
-        let mut quote_scope = scope.clone();
-        for symbol in &scope {
-            let paused = data.market(date, symbol).is_some_and(|row| row.paused)
-                || data
-                    .candidate(date, symbol)
-                    .is_some_and(|row| row.is_paused);
-            if !paused {
-                continue;
-            }
-            quote_scope.remove(symbol);
-            if let Some(position) = portfolio
-                .position(symbol)
-                .filter(|position| position.quantity > 0)
-            {
-                constraints.frozen_positions.insert(
-                    symbol.clone(),
-                    pool::FrozenStockPoolPosition {
-                        trade_date: date,
-                        reason: "paused".into(),
-                        valuation_price: decimal(position.last_price, "paused_holding_valuation")?,
-                    },
-                );
-            } else {
-                selection
-                    .normal_trading_symbols
-                    .retain(|item| item != symbol);
-                selection
-                    .risk_eligible_symbols
-                    .retain(|item| item != symbol);
-                selection.final_symbols.retain(|item| item != symbol);
-                selection
-                    .exclusion_reasons
-                    .entry(symbol.clone())
-                    .or_default()
-                    .push("paused".into());
-            }
-        }
-        let before_positions = portfolio
-            .positions()
-            .keys()
-            .cloned()
-            .collect::<BTreeSet<_>>();
-        for side in [pool::OrderSide::Sell, pool::OrderSide::Buy] {
-            let quotes =
-                self.pool_quote_inputs(date, data, &quote_scope, *global_execution_cursor)?;
-            let positions = pool_positions(portfolio, date)?;
-            let execution_state = portfolio
-                .stock_pool_execution_state(&contract.pool_id)
-                .observe(
-                    contract.signal_date,
-                    date,
-                    &official_dates,
-                    &members,
-                    &positions,
-                )
-                .map_err(BacktestError::Execution)?;
-            constraints.pending_entry_symbols = execution_state.pending_symbols();
-            constraints.prior_target_weights = execution_state.last_target_weights.clone();
-            constraints.next_day_outside_exit_symbols = execution_state.next_day_exit_symbols(date);
-            let account = pool::AccountSnapshot {
-                total_equity: contract.frozen_equity,
-                cash: decimal(portfolio.cash(), "cash")?,
-                frozen_cash: Decimal::ZERO,
-            };
-            constraints.automatic_permissions.clear();
-            if contract.rule.automatic_trade_protection.enabled() {
-                for symbol in &scope {
-                    let position = portfolio.position(symbol).filter(|p| p.quantity > 0);
-                    let sold = self
-                        .same_day_sold_symbols
-                        .borrow()
-                        .iter()
-                        .rev()
-                        .find(|(day, symbols)| **day <= date && symbols.contains(symbol))
-                        .map(|(day, _)| *day);
-                    let evidence = HoldingLifecycleEvidence {
-                        has_position: position.is_some(),
-                        opened_date: position.and_then(|p| p.opened_date()),
-                        last_buy_date: position.and_then(|p| p.last_buy_date()),
-                        last_sell_date: sold,
-                    };
-                    let permission = contract
-                        .rule
-                        .automatic_trade_protection
-                        .evaluate(symbol, date, &evidence, data.calendar())
-                        .map_err(BacktestError::Execution)?;
-                    constraints
-                        .automatic_permissions
-                        .insert(symbol.clone(), permission);
-                }
-            }
-            if self
-                .risk_config
-                .static_rules
-                .forbid_same_day_rebuy_after_sell
-            {
-                constraints.same_day_sold_symbols.extend(
-                    self.same_day_sold_symbols
-                        .borrow()
-                        .get(&date)
-                        .into_iter()
-                        .flatten()
-                        .cloned(),
-                );
-            }
-            constraints.same_day_sold_symbols.extend(
-                before_positions
-                    .iter()
-                    .filter(|symbol| portfolio.position(symbol).is_none_or(|p| p.quantity == 0))
-                    .cloned(),
-            );
-            let fee =
-                |symbol: &str, side: pool::OrderSide, gross: Decimal| -> Result<Decimal, String> {
-                    let amount = gross
-                        .to_f64()
-                        .ok_or("stock_pool_cost_amount_out_of_range")?;
-                    decimal(
-                        self.cost_model
-                            .calculate_for_instrument(
-                                date,
-                                if side == pool::OrderSide::Buy {
-                                    OrderSide::Buy
-                                } else {
-                                    OrderSide::Sell
-                                },
-                                amount,
-                                data.instruments().get(symbol),
-                            )
-                            .total(),
-                        "fee",
-                    )
-                    .map_err(|e| e.to_string())
-                };
-            let plan = pool::build_stock_pool_target_plan_with_fee_model(
-                &selection,
-                &members,
-                &contract.rule,
-                &account,
-                &positions,
-                &quotes,
-                contract.invest_ratio_bps,
-                contract.reserve_cash,
-                &contract.out_of_pool_policy,
-                "full_rebalance",
-                &constraints,
-                &contract.generation,
-                Decimal::ZERO,
-                Decimal::ZERO,
-                Decimal::ZERO,
-                Some(&fee),
-            )
-            .map_err(BacktestError::Execution)?;
-            let updated = execution_state
-                .record_plan(contract.signal_date, &contract.generation, &plan)
-                .map_err(BacktestError::Execution)?;
-            portfolio
-                .set_stock_pool_execution_state(&contract.pool_id, updated)
-                .map_err(BacktestError::Execution)?;
-            report.diagnostics.push(format!("stock_pool_plan phase={side:?} generation={} requested_bps={} effective_bps={} budget={}",contract.generation,plan.requested_invest_ratio_bps,plan.effective_invest_ratio_bps,plan.budget));
-            let max_positions = constraints
-                .target_holding_count
-                .unwrap_or(selection.final_symbols.len());
-            for row in plan.rows {
-                if side == pool::OrderSide::Buy && row.side.is_none() {
-                    report.diagnostics.push(format!(
-                        "stock_pool_decision symbol={} status={} current={} target={} reason={}",
-                        row.symbol,
-                        row.status,
-                        row.current_quantity,
-                        row.target_quantity,
-                        row.reason
-                    ));
-                }
-                if row.side != Some(side) {
-                    continue;
-                }
-                if side == pool::OrderSide::Buy
-                    && portfolio
-                        .position(&row.symbol)
-                        .is_none_or(|p| p.quantity == 0)
-                    && Self::positive_position_count(portfolio) >= max_positions
-                {
-                    report.diagnostics.push(format!(
-                        "stock_pool_buy_deferred symbol={} reason=occupied_position_slots",
-                        row.symbol
-                    ));
-                    continue;
-                }
-                let target = row.target_quantity.to_i32().ok_or_else(|| {
-                    BacktestError::Execution("stock_pool_target_quantity_out_of_range".into())
-                })?;
-                let reason = row.source_intent.as_deref().unwrap_or("stock_pool_target");
-                if let Some(price) = row.limit_price {
-                    self.process_limit_target_shares(
-                        date,
-                        portfolio,
-                        data,
-                        &row.symbol,
-                        target,
-                        price.to_f64().ok_or_else(|| {
-                            BacktestError::Execution("stock_pool_limit_price_out_of_range".into())
-                        })?,
-                        reason,
-                        intraday_turnover,
-                        execution_cursors,
-                        global_execution_cursor,
-                        commission_state,
-                        report,
-                    )?;
-                } else {
-                    self.process_target_shares(
-                        date,
-                        portfolio,
-                        data,
-                        &row.symbol,
-                        target,
-                        reason,
-                        intraday_turnover,
-                        execution_cursors,
-                        global_execution_cursor,
-                        commission_state,
-                        report,
-                    )?;
-                }
-            }
-        }
-        Ok(())
-    }
-}

crates/fidc-core/src/cost.rs

@@ -5,7 +5,6 @@ use chrono::NaiveDate;
 use crate::events::OrderSide;
 use crate::fixed_point::{FixedChinaAShareCostModel, FixedMoney, FixedTradingCost};
 use crate::risk_control::TradingConstraintConfig;
-use crate::Instrument;
 
 #[derive(Debug, Clone, Copy)]
 pub struct TradingCost {
@@ -36,17 +35,6 @@ impl TradingCost {
 pub trait CostModel {
     fn calculate(&self, date: NaiveDate, side: OrderSide, gross_amount: f64) -> TradingCost;
 
-    fn calculate_for_instrument(&self, date: NaiveDate, side: OrderSide, gross_amount: f64, _instrument: Option<&Instrument>) -> TradingCost {
-        self.calculate(date, side, gross_amount)
-    }
-
-    fn calculate_with_order_state_for_instrument(
-        &self, date: NaiveDate, side: OrderSide, gross_amount: f64,
-        order_id: Option<u64>, commission_state: &mut BTreeMap<u64,f64>, _instrument: Option<&Instrument>,
-    ) -> TradingCost {
-        self.calculate_with_order_state(date, side, gross_amount, order_id, commission_state)
-    }
-
     fn calculate_with_order_state(
         &self,
         date: NaiveDate,
@@ -227,27 +215,6 @@ impl ChinaAShareCostModel {
 }
 
 impl CostModel for ChinaAShareCostModel {
-    fn calculate_for_instrument(&self, date: NaiveDate, side: OrderSide, gross_amount: f64, instrument: Option<&Instrument>) -> TradingCost {
-        let mut cost = self.calculate(date, side, gross_amount);
-        if instrument.is_some_and(Instrument::is_exchange_traded_fund) {
-            cost.stamp_tax = 0.0;
-            cost.transfer_fee = 0.0;
-        }
-        cost
-    }
-
-    fn calculate_with_order_state_for_instrument(
-        &self, date: NaiveDate, side: OrderSide, gross_amount: f64,
-        order_id: Option<u64>, commission_state: &mut BTreeMap<u64,f64>, instrument: Option<&Instrument>,
-    ) -> TradingCost {
-        let mut cost = self.calculate_with_order_state(date, side, gross_amount, order_id, commission_state);
-        if instrument.is_some_and(Instrument::is_exchange_traded_fund) {
-            cost.stamp_tax = 0.0;
-            cost.transfer_fee = 0.0;
-        }
-        cost
-    }
-
     fn calculate(&self, date: NaiveDate, side: OrderSide, gross_amount: f64) -> TradingCost {
         if gross_amount <= 0.0 {
             return TradingCost {
@@ -306,25 +273,6 @@ impl CostModel for ChinaAShareCostModel {
 mod tests {
     use super::*;
 
-    #[test]
-    fn fund_fees_use_admitted_instrument_type_and_share_the_order_commission_budget() {
-        let day=NaiveDate::from_ymd_opt(2026,9,11).unwrap();
-        let model=ChinaAShareCostModel::from_trading_constraints(TradingConstraintConfig{commission_rate:0.0003,minimum_commission:5.,transfer_fee_rate:0.00001,..Default::default()});
-        let mut instrument=Instrument{symbol:"510300.SH".into(),name:"fixture".into(),board:"ETF".into(),round_lot:100,listed_at:Some(day),delisted_at:None,status:"active".into()};
-        for side in [OrderSide::Buy,OrderSide::Sell] {
-            let cost=model.calculate_for_instrument(day,side,10_000.,Some(&instrument));
-            assert_eq!(cost.commission,5.);assert_eq!(cost.stamp_tax,0.);assert_eq!(cost.transfer_fee,0.);
-            let mut state=BTreeMap::new();
-            let one=model.calculate_with_order_state_for_instrument(day,side,1_000.,Some(1),&mut state,Some(&instrument));
-            let two=model.calculate_with_order_state_for_instrument(day,side,9_000.,Some(1),&mut state,Some(&instrument));
-            assert_eq!(one.total()+two.total(),cost.total());
-        }
-        instrument.board="SH".into();
-        let stock=model.calculate_for_instrument(day,OrderSide::Sell,10_000.,Some(&instrument));
-        assert_eq!(stock.stamp_tax,5.);assert_eq!(stock.transfer_fee,0.1);
-        assert_eq!(stock.total(),model.calculate(day,OrderSide::Sell,10_000.).total());
-    }
-
     #[test]
     fn default_quantizes_fees_to_micro_yuan() {
         let model = ChinaAShareCostModel::default();

crates/fidc-core/src/data.rs

@@ -491,7 +491,6 @@ pub struct DataSetSnapshotComponents {
     pub benchmarks: Vec<BenchmarkSnapshot>,
     pub corporate_actions: Vec<CorporateAction>,
     pub execution_quotes: Vec<IntradayExecutionQuote>,
-    pub completed_minute_bars: Vec<crate::session_events::MinuteBar>,
 }
 
 #[derive(Debug, Clone, Serialize)]
@@ -1419,7 +1418,6 @@ pub struct DataSet {
     eligible_universe_by_date: Arc<OnceLock<BTreeMap<NaiveDate, Vec<EligibleUniverseSnapshot>>>>,
     benchmark_code: String,
     futures_params_by_symbol: Arc<HashMap<String, Vec<FuturesTradingParameter>>>,
-    completed_minute_bars: Arc<BTreeMap<(NaiveDate,String),Vec<crate::session_events::MinuteBar>>>,
 }
 
 struct DailySymbolRows<'a, T> {
@@ -1852,9 +1850,9 @@ impl DataSet {
             .iter()
             .enumerate()
             .filter_map(|(symbol_id, series)| {
-                series
+                series.as_ref().map(|series| {
-                    .as_ref()
+                    (symbol_by_id[symbol_id].to_string(), Arc::clone(series))
-                    .map(|series| (symbol_by_id[symbol_id].to_string(), Arc::clone(series)))
+                })
             })
             .collect::<AHashMap<_, _>>();
 
@@ -1878,9 +1876,9 @@ impl DataSet {
             .iter()
             .enumerate()
             .filter_map(|(symbol_id, series)| {
-                series
+                series.as_ref().map(|series| {
-                    .as_ref()
+                    (symbol_by_id[symbol_id].to_string(), Arc::clone(series))
-                    .map(|series| (symbol_by_id[symbol_id].to_string(), Arc::clone(series)))
+                })
             })
             .collect::<AHashMap<_, _>>();
         let factor_texts = factor_texts
@@ -1902,10 +1900,16 @@ impl DataSet {
 
         let factor_market_cap_order_by_date =
             build_factor_market_cap_order(&factor_by_date, &factor_symbol_ids_by_date);
-        let market_row_positions_by_date =
+        let market_row_positions_by_date = build_dense_row_positions(
-            build_dense_row_positions(&market_by_date, &market_symbol_ids_by_date, symbol_count);
+            &market_by_date,
-        let factor_row_positions_by_date =
+            &market_symbol_ids_by_date,
-            build_dense_row_positions(&factor_by_date, &factor_symbol_ids_by_date, symbol_count);
+            symbol_count,
+        );
+        let factor_row_positions_by_date = build_dense_row_positions(
+            &factor_by_date,
+            &factor_symbol_ids_by_date,
+            symbol_count,
+        );
         let candidate_row_positions_by_date = build_dense_row_positions(
             &candidate_by_date,
             &candidate_symbol_ids_by_date,
@@ -1956,7 +1960,6 @@ impl DataSet {
             eligible_universe_by_date: Arc::new(OnceLock::new()),
             benchmark_code,
             futures_params_by_symbol: Arc::new(futures_params_by_symbol),
-            completed_minute_bars: Arc::new(BTreeMap::new()),
         })
     }
 
@@ -2318,10 +2321,7 @@ impl DataSet {
         }
 
         for (component, strong_count) in [
-            (
+            ("daily market panel", Arc::strong_count(&self.market_by_date)),
-                "daily market panel",
-                Arc::strong_count(&self.market_by_date),
-            ),
             (
                 "market series by symbol",
                 Arc::strong_count(&self.market_series_by_symbol),
@@ -2456,8 +2456,7 @@ impl DataSet {
             .flat_map(|rows_by_symbol| rows_by_symbol.values())
             .map(Vec::len)
             .sum();
-        let mut execution_quote_dates =
+        let mut execution_quote_dates = execution_quotes_by_date.keys().copied().collect::<Vec<_>>();
-            execution_quotes_by_date.keys().copied().collect::<Vec<_>>();
         execution_quote_dates.sort_unstable();
         self.execution_quotes_by_date = Arc::new(execution_quotes_by_date);
         self.execution_quote_dates = Arc::new(execution_quote_dates);
@@ -2630,21 +2629,9 @@ impl DataSet {
             benchmarks,
             corporate_actions,
             execution_quotes,
-            completed_minute_bars:self.completed_minute_bars.values().flatten().cloned().collect(),
         }
     }
 
-    pub fn with_completed_minute_bars(mut self,bars:Vec<crate::session_events::MinuteBar>)->Result<Self,String> {
-        self.completed_minute_bars=crate::session_events::bar_store(bars)?;Ok(self)
-    }
-
-    pub fn with_shared_completed_minute_bars(mut self,bars:crate::session_events::BarStore)->Self {self.completed_minute_bars=bars;self}
-    pub fn completed_minute_bar_count(&self)->usize {self.completed_minute_bars.values().map(Vec::len).sum()}
-
-    pub fn completed_minute_bars_on(&self,date:NaiveDate,symbol:&str)->&[crate::session_events::MinuteBar] {
-        self.completed_minute_bars.get(&(date,symbol.into())).map(Vec::as_slice).unwrap_or(&[])
-    }
-
     pub fn benchmark_series(&self) -> Vec<BenchmarkSnapshot> {
         self.benchmark_by_date.values().cloned().collect()
     }
@@ -3375,12 +3362,6 @@ impl DataSet {
             .unwrap_or(&[])
     }
 
-    pub fn is_reference_only_benchmark(&self, symbol: &str) -> bool {
-        if symbol != self.benchmark_code() { return false; }
-        let Some(symbol_id) = self.symbol_id(symbol) else { return true; };
-        !self.candidate_symbol_ids_by_date.values().any(|ids| ids.contains(&symbol_id))
-    }
-
     pub fn bundle_on(&self, date: NaiveDate) -> Result<DailySnapshotBundle, DataSetError> {
         let benchmark = self
             .benchmark(date)
@@ -5240,7 +5221,10 @@ mod tests {
             [data.symbol_id("000001.SZ").unwrap() as usize]
             .as_ref()
             .unwrap();
-        assert!(!Arc::ptr_eq(&market_series_before, market_series_after));
+        assert!(!Arc::ptr_eq(
+            &market_series_before,
+            market_series_after
+        ));
         assert!(Arc::ptr_eq(&daily_base_before, &market_series_after.base));
         assert_eq!(
             serde_json::to_value(market_series_after.snapshot_at(0)).unwrap(),
@@ -6194,8 +6178,11 @@ mod tests {
         let date = NaiveDate::parse_from_str("2025-01-02", "%Y-%m-%d").unwrap();
         let quote = IntradayExecutionQuote {
             date,
-            timestamp: NaiveDateTime::parse_from_str("2025-01-02 10:18:00", "%Y-%m-%d %H:%M:%S")
+            timestamp: NaiveDateTime::parse_from_str(
-                .unwrap(),
+                "2025-01-02 10:18:00",
+                "%Y-%m-%d %H:%M:%S",
+            )
+            .unwrap(),
             symbol: "000001.SZ".to_string(),
             last_price: 10.0,
             bid1: 10.0,
@@ -6235,7 +6222,7 @@ mod tests {
     }
 
     #[test]
-    fn baseline_selection_uses_dated_lifecycle_not_latest_undated_status() {
+    fn baseline_selection_uses_structured_instrument_dates_and_status_only() {
         let date = NaiveDate::parse_from_str("2025-01-02", "%Y-%m-%d").unwrap();
         let instrument = |name: &str, status: &str, delisted_at: Option<NaiveDate>| Instrument {
             symbol: "000001.SZ".to_string(),
@@ -6263,7 +6250,7 @@ mod tests {
             Some(&instrument("退市测试", "active", None)),
             date
         ));
-        assert!(instrument_passes_baseline_selection(
+        assert!(!instrument_passes_baseline_selection(
             Some(&instrument("正常名称", "delisted", None)),
             date
         ));
@@ -6378,16 +6365,13 @@ mod tests {
             "'adjustment_factor_backward1'",
         ] {
             for typed_value in [None, Some(1.0)] {
-                assert!(
+                assert!(matches!(
-                    matches!(
+                    normalize_factor_snapshots(vec![snapshot(
-                        normalize_factor_snapshots(vec![snapshot(
+                        typed_value,
-                            typed_value,
+                        BTreeMap::from([(Cow::Borrowed(field), 2.0)]),
-                            BTreeMap::from([(Cow::Borrowed(field), 2.0)]),
+                    )]),
-                        )]),
+                    Err(DataSetError::ReservedTypedFactorInExtraMap { .. })
-                        Err(DataSetError::ReservedTypedFactorInExtraMap { .. })
+                ), "reserved alias accepted: {field}");
-                    ),
-                    "reserved alias accepted: {field}"
-                );
             }
         }
     }

crates/fidc-core/src/engine.rs

@@ -91,9 +91,6 @@ impl Default for ProcessEventRetention {
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct DailyEquityPoint {
-    /// Close-of-signal-day cash baseline before lagged trading begins.
-    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
-    pub signal_baseline: bool,
     #[serde(with = "date_format")]
     pub date: NaiveDate,
     pub cash: f64,
@@ -112,14 +109,6 @@ pub struct DailyEquityPoint {
     pub diagnostics: String,
 }
 
-impl DailyEquityPoint {
-    pub fn benchmark_reference_close(&self) -> f64 {
-        if self.signal_baseline { self.benchmark_close }
-        else if self.benchmark_prev_close.is_finite() && self.benchmark_prev_close > f64::EPSILON { self.benchmark_prev_close }
-        else { self.benchmark_close }
-    }
-}
-
 #[derive(Debug, Clone)]
 pub struct BacktestResult {
     pub strategy_name: String,
@@ -345,7 +334,7 @@ impl BacktestResult {
         let mut previous_benchmark = self
             .equity_curve
             .first()
-            .map(DailyEquityPoint::benchmark_reference_close)
+            .map(|point| point.benchmark_prev_close)
             .unwrap_or_default();
         for point in &self.equity_curve {
             let point_nav = if point.unit_nav.is_finite() && point.unit_nav > 0.0 {
@@ -465,20 +454,13 @@ pub struct BacktestEngine<S, C, R> {
     futures_cost_model: FuturesTransactionCostModel,
     futures_validation_config: FuturesValidationConfig,
     execution_quote_loader: Option<ExecutionQuoteLoader>,
-    preplanned_decision_quote_symbols_by_date: Option<Arc<BTreeMap<NaiveDate, BTreeSet<String>>>>,
+    preplanned_decision_quote_symbols_by_date:
+        Option<Arc<BTreeMap<NaiveDate, BTreeSet<String>>>>,
     execution_quote_request_cache:
         BTreeSet<(NaiveDate, String, Option<NaiveTime>, Option<NaiveTime>)>,
-    execution_absence_notes: BTreeMap<NaiveDate, Vec<String>>,
-    execution_lifecycle_reported: BTreeSet<(String, String)>,
     risk_free_rate_contract: Option<RiskFreeRateContract>,
 }
 
-fn all_instruments_have_dated_absence(data: &DataSet, date: NaiveDate) -> bool {
-    let mut instruments = data.instruments().values()
-        .filter(|instrument| !data.is_reference_only_benchmark(&instrument.symbol)).peekable();
-    instruments.peek().is_some() && instruments.all(|instrument| instrument.dated_market_absence_reason(date).is_some())
-}
-
 fn backtest_execution_schedule(
     data: &DataSet,
     start_date: Option<NaiveDate>,
@@ -501,15 +483,10 @@ fn backtest_execution_schedule(
         if decision_lag_trading_days == 0 {
             if has_decision_inputs(execution_date) {
                 schedule.push((execution_date, Some((calendar_idx, execution_date))));
-            } else if all_instruments_have_dated_absence(data, execution_date) {
-                schedule.push((execution_date, None));
             }
             continue;
         }
         if !has_execution_market(execution_date) {
-            if all_instruments_have_dated_absence(data, execution_date) {
-                schedule.push((execution_date, None));
-            }
             continue;
         }
         let decision_slot = calendar_idx
@@ -520,7 +497,6 @@ fn backtest_execution_schedule(
                 schedule.push((execution_date, decision_slot));
             }
             None => schedule.push((execution_date, None)),
-            Some((_, decision_date)) if all_instruments_have_dated_absence(data, decision_date) => schedule.push((execution_date, None)),
             _ => {}
         }
     }
@@ -568,8 +544,6 @@ impl<S, C, R> BacktestEngine<S, C, R> {
             execution_quote_loader: None,
             preplanned_decision_quote_symbols_by_date: None,
             execution_quote_request_cache: BTreeSet::new(),
-            execution_absence_notes: BTreeMap::new(),
-            execution_lifecycle_reported: BTreeSet::new(),
             risk_free_rate_contract: None,
         }
     }
@@ -784,31 +758,6 @@ where
         end_time: Option<NaiveTime>,
         symbols: &mut BTreeSet<String>,
     ) -> Result<(), BacktestError> {
-        let mut available = BTreeSet::new();
-        for symbol in symbols.iter() {
-            let instrument = self.data.instrument(symbol).ok_or_else(|| BacktestError::Execution(format!(
-                "execution_data_missing reason=instrument_metadata_or_code_mapping_missing symbol={symbol} execution_date={execution_date}"
-            )))?;
-            if let Some(reason) = instrument.dated_market_absence_reason(execution_date) {
-                if self.data.price(execution_date, symbol, PriceField::Close).is_some()
-                    || !self.data.execution_quotes_on(execution_date, symbol).is_empty()
-                {
-                    return Err(BacktestError::Execution(format!(
-                        "execution_data_conflict reason={reason} symbol={symbol} execution_date={execution_date} listed_at={:?} delisted_at={:?}",
-                        instrument.listed_at, instrument.delisted_at
-                    )));
-                }
-                if self.execution_lifecycle_reported.insert((symbol.clone(), reason.to_string())) {
-                    self.execution_absence_notes.entry(execution_date).or_default().push(format!(
-                        "execution_data_absence reason={reason} symbol={symbol} execution_date={execution_date} listed_at={:?} delisted_at={:?} no_price_fill=true",
-                        instrument.listed_at, instrument.delisted_at
-                    ));
-                }
-                continue;
-            }
-            available.insert(symbol.clone());
-        }
-        *symbols = available;
         symbols.retain(|symbol| {
             let request_key = (execution_date, symbol.clone(), start_time, end_time);
             if self.execution_quote_request_cache.contains(&request_key) {
@@ -876,6 +825,9 @@ where
         let mut paused_with_quotes = Vec::new();
         let mut missing_daily_market = Vec::new();
         for symbol in requested_symbols {
+            let Some(_candidate) = self.data.candidate(execution_date, symbol) else {
+                continue;
+            };
             let Some(market) = self.data.market(execution_date, symbol) else {
                 missing_daily_market.push(symbol.clone());
                 continue;
@@ -2229,13 +2181,12 @@ where
                             date: execution_date,
                         })?;
                 let notes = join_text_parts(corporate_action_notes.into_iter());
-                let absence = all_instruments_have_dated_absence(&self.data, execution_date);
                 let diagnostics = join_text_parts(
-                    std::iter::once(if absence {
+                    std::iter::once(format!(
-                        format!("execution_data_absence reason=all_instruments_outside_dated_lifecycle execution_date={execution_date} cash_period_retained=true no_price_fill=true")
+                        "decision_lag_warmup lag_days={} execution_index={}",
-                    } else { format!("decision_lag_warmup lag_days={} execution_index={}", self.config.decision_lag_trading_days, execution_idx) })
+                        self.config.decision_lag_trading_days, execution_idx
-                    .chain(broker_diagnostics.into_iter())
+                    ))
-                    .chain(self.execution_absence_notes.remove(&execution_date).unwrap_or_default()),
+                    .chain(broker_diagnostics.into_iter()),
                 );
                 let holdings_for_day = portfolio.holdings_summary(execution_date);
                 let holding_start = result.daily_holdings.len();
@@ -2252,7 +2203,6 @@ where
                 previous_external_cash_flow_total = portfolio.external_cash_flow_total();
 
                 result.equity_curve.push(DailyEquityPoint {
-                    signal_baseline: execution_idx == 0,
                     date: execution_date,
                     cash: aggregate_cash,
                     market_value: aggregate_market_value,
@@ -2588,8 +2538,9 @@ where
                     .map(Arc::clone)
                 {
                     let empty_symbols = BTreeSet::new();
-                    let decision_quote_symbols =
+                    let decision_quote_symbols = preplanned
-                        preplanned.get(&execution_date).unwrap_or(&empty_symbols);
+                        .get(&execution_date)
+                        .unwrap_or(&empty_symbols);
                     self.ensure_execution_quotes_for_symbols_at_times(
                         execution_date,
                         decision_quote_symbols,
@@ -2849,16 +2800,9 @@ where
                 "bar:post",
             )?;
 
-            if should_run_minute_events(&intraday_schedule_rules, &self.subscriptions)
+            if should_run_minute_events(&intraday_schedule_rules, &self.subscriptions) {
-                || (self.broker.has_open_orders() && self.broker.matching_type_uses_intraday_quotes())
+                if self.execution_quote_loader.is_some() && !self.subscriptions.is_empty() {
-            {
+                    let mut minute_symbols = self.subscriptions.clone();
-                let unfiltered_minute_stream = self.subscriptions.is_empty();
-                let mut full_minute_symbols = self.subscriptions.clone();
-                if self.broker.matching_type_uses_intraday_quotes() {
-                    full_minute_symbols.extend(self.broker.open_order_views().into_iter().map(|order| order.symbol));
-                }
-                if self.execution_quote_loader.is_some() && !full_minute_symbols.is_empty() {
-                    let mut minute_symbols = full_minute_symbols.clone();
                     self.load_missing_execution_quotes(
                         execution_date,
                         None,
@@ -2869,11 +2813,11 @@ where
                 // Keep the iterator attached to an O(1) DataSet clone. This
                 // preserves the immutable quote snapshot for the day while
                 // allowing lazy quote loads and broker state updates on self.
-                let mut quote_data = self.data.clone();
+                let quote_data = self.data.clone();
                 let mut minute_quotes = quote_data
                     .execution_quotes_iter_on_date_for_symbols(
                         execution_date,
-                        (!unfiltered_minute_stream).then_some(&full_minute_symbols),
+                        (!self.subscriptions.is_empty()).then_some(&self.subscriptions),
                     )
                     .peekable();
                 let requires_minute_callbacks = self.strategy.requires_minute_callbacks();
@@ -2900,26 +2844,18 @@ where
                     .into_iter()
                     .peekable();
                 let mut minute_group = Vec::new();
-                let mut last_minute_timestamp = None;
                 // Merge the immutable quote stream with clock events. Equal
                 // timestamps form one event; scheduled callbacks run before
                 // `on_minute` below.
                 loop {
                     let next_quote_timestamp = minute_quotes.peek().map(|quote| quote.timestamp);
                     let next_schedule_timestamp = minute_schedule_timestamps.peek().copied();
-                    let next_expiry_timestamp = self.broker.next_day_order_expiry(execution_date)
-                        .map(|time| execution_date.and_time(time))
-                        .filter(|time| last_minute_timestamp.is_none_or(|last| last < *time));
                     let Some(minute_timestamp) =
-                        next_minute_event_timestamp(
+                        next_minute_event_timestamp(next_quote_timestamp, next_schedule_timestamp)
-                            next_minute_event_timestamp(next_quote_timestamp, next_schedule_timestamp),
-                            next_expiry_timestamp,
-                        )
                     else {
                         break;
                     };
                     let minute_time = minute_timestamp.time();
-                    last_minute_timestamp = Some(minute_timestamp);
                     minute_group.clear();
                     while minute_quotes
                         .peek()
@@ -2928,8 +2864,7 @@ where
                         minute_group.push(
                             minute_quotes
                                 .next()
-                                .expect("peeked minute quote must be available")
+                                .expect("peeked minute quote must be available"),
-                                .clone(),
                         );
                     }
                     let has_specific_schedule = next_schedule_timestamp == Some(minute_timestamp);
@@ -3001,10 +2936,7 @@ where
                         crate::strategy::StrategyDecision::default()
                     };
                     if requires_minute_callbacks {
-                        for quote in &minute_group {
+                        for &quote in &minute_group {
-                            if !self.subscriptions.is_empty() && !self.subscriptions.contains(&quote.symbol) {
-                                continue;
-                            }
                             minute_decision.merge_from(self.strategy.on_minute(
                                 &StrategyContext {
                                     execution_date,
@@ -3117,28 +3049,6 @@ where
                         ProcessEventKind::PostMinute,
                         format!("minute:{minute_timestamp}:post"),
                     )?;
-                    // A scheduled strategy need not subscribe to every
-                    // minute to keep a DAY/GTC limit order alive. Fetch the
-                    // resting symbols once, then resume the actual quote
-                    // clock strictly after the event already processed.
-                    let mut newly_pending = self.broker.open_order_views().into_iter()
-                        .map(|order| order.symbol)
-                        .filter(|symbol| !full_minute_symbols.contains(symbol))
-                        .collect::<BTreeSet<_>>();
-                    if !newly_pending.is_empty() && self.broker.matching_type_uses_intraday_quotes() {
-                        full_minute_symbols.extend(newly_pending.iter().cloned());
-                        if self.execution_quote_loader.is_some() {
-                            self.load_missing_execution_quotes(execution_date, None, None, &mut newly_pending)?;
-                        }
-                        drop(minute_quotes);
-                        quote_data = self.data.clone();
-                        minute_quotes = quote_data.execution_quotes_iter_on_date_for_symbols(
-                            execution_date, (!unfiltered_minute_stream).then_some(&full_minute_symbols),
-                        ).peekable();
-                        while minute_quotes.peek().is_some_and(|quote| quote.timestamp <= minute_timestamp) {
-                            minute_quotes.next();
-                        }
-                    }
                 }
                 drop(minute_group);
                 drop(minute_quotes);
@@ -3444,8 +3354,7 @@ where
                 decision
                     .diagnostics
                     .into_iter()
-                    .chain(broker_diagnostics.into_iter())
+                    .chain(broker_diagnostics.into_iter()),
-                    .chain(self.execution_absence_notes.remove(&execution_date).unwrap_or_default()),
             );
             let holdings_for_day = portfolio.holdings_summary(execution_date);
             let holding_start = result.daily_holdings.len();
@@ -3462,7 +3371,6 @@ where
             previous_external_cash_flow_total = portfolio.external_cash_flow_total();
 
             result.equity_curve.push(DailyEquityPoint {
-                signal_baseline: false,
                 date: execution_date,
                 cash: aggregate_cash,
                 market_value: aggregate_market_value,
@@ -4045,11 +3953,17 @@ where
             let Some(instrument) = self.data.instrument(&symbol) else {
                 continue;
             };
-            let is_unresolved = instrument.is_delisted_on_or_before(date);
+            let is_unresolved = instrument.is_delisted_on_or_before(date)
+                || (instrument.status.eq_ignore_ascii_case("delisted")
+                    && instrument.delisted_at.is_none()
+                    && self.data.market(date, &symbol).is_none());
             if !is_unresolved {
                 continue;
             }
-            let effective_delisted_at = instrument.delisted_at.expect("dated delisting checked");
+            let effective_delisted_at = instrument
+                .delisted_at
+                .or_else(|| self.data.calendar().previous_day(date))
+                .unwrap_or(date);
             let reason = format!(
                 concat!(
                     "unresolved_delisted_position symbol={} quantity={} effective_date={} status={} ",
@@ -4138,10 +4052,6 @@ fn execution_quote_symbols_for_decision(
 
     for intent in &decision.order_intents {
         match intent.unwrapped() {
-            OrderIntent::StockPool { contract } => {
-                symbols.extend(contract.selection.requested_symbols.iter().cloned());
-                symbols.extend(portfolio.positions().keys().cloned());
-            }
             OrderIntent::Shares { symbol, .. }
             | OrderIntent::LimitShares { symbol, .. }
             | OrderIntent::Lots { symbol, .. }
@@ -5622,34 +5532,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn wholly_prelisting_universe_retains_cash_days_without_fabricating_prices() {
-        let dates = [d(2025, 1, 2), d(2025, 1, 3), d(2025, 1, 6)];
-        let mut engine = engine_with_matching(MatchingType::CurrentBarClose, PriceField::Close, 0);
-        engine.config.end_date = Some(dates[2]);
-        let mut markets = vec![market(dates[2], 10.0, 10.0)];
-        markets.extend(dates.iter().map(|date| DailyMarketSnapshot { symbol: "000852.SH".into(), ..market(*date, 1000.0, 1000.0) }));
-        engine.data = DataSet::from_components(
-            vec![Instrument { listed_at: Some(dates[2]), ..default_instrument() }, Instrument { symbol: "000852.SH".into(), listed_at: None, ..default_instrument() }],
-            markets, vec![factor(dates[2])], vec![candidate(dates[2])],
-            dates.iter().map(|date| benchmark(*date)).collect(),
-        ).unwrap();
-        assert_eq!(super::backtest_execution_dates(&engine.data, Some(dates[0]), Some(dates[2]), 0), dates);
-        assert_eq!(super::backtest_execution_dates(&engine.data, Some(dates[0]), Some(dates[2]), 1), dates);
-        let result = engine.run().unwrap();
-        assert_eq!(result.equity_curve.len(), 3);
-        for point in &result.equity_curve[..2] {
-            assert_eq!(point.total_equity, 100_000.0);
-            assert_eq!(point.market_value, 0.0);
-            assert!(point.diagnostics.contains("cash_period_retained=true"));
-        }
-        assert!(result.order_events.is_empty());
-        assert!(engine.data.market(dates[0], SYMBOL).is_none());
-        assert!(result.equity_curve[0].signal_baseline);
-        assert!(!result.equity_curve[1].signal_baseline);
-        assert!(!super::all_instruments_have_dated_absence(&dataset(), dates[0]));
-    }
-
     fn engine_with_matching(
         matching_type: MatchingType,
         execution_price_field: PriceField,
@@ -5888,72 +5770,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn scheduled_day_limit_order_loads_later_quotes_without_strategy_minute_subscription() {
-        struct RestingLimit { quantity: i32 }
-        impl Strategy for RestingLimit {
-            fn name(&self) -> &str { "resting-limit" }
-            fn requires_minute_callbacks(&self) -> bool { false }
-            fn schedule_rules(&self) -> Vec<ScheduleRule> {
-                vec![ScheduleRule::daily("open", ScheduleStage::OnDay)
-                    .with_time_rule(ScheduleTimeRule::physical_time(9, 30))]
-            }
-            fn on_scheduled(&mut self, _: &StrategyContext<'_>, _: &ScheduleRule) -> Result<StrategyDecision, crate::BacktestError> {
-                Ok(StrategyDecision { order_intents: vec![OrderIntent::LimitTargetShares {
-                    symbol: SYMBOL.into(), target_quantity: self.quantity, limit_price: 10.0, reason: "resting-entry".into(),
-                }], ..StrategyDecision::default() })
-            }
-        }
-        for scenario in 0..4 {
-        let partial = scenario == 1;
-        let closing_only = scenario >= 2;
-        let date = if closing_only { d(2026, 7, 6) } else { d(2026, 6, 1) };
-        let quote = |hour, minute, price| IntradayExecutionQuote {
-            date, symbol: SYMBOL.into(), timestamp: date.and_hms_opt(hour, minute, 0).unwrap(),
-            last_price: price, bid1: price, ask1: price, bid1_volume: 10_000, ask1_volume: 10_000,
-            volume_delta: 10_000, amount_delta: price * 10_000.0, trading_phase: None,
-        };
-        let first = quote(9, 30, if partial { 9.8 } else { 10.2 });
-        let earlier = quote(9, 29, 9.0);
-        let unchanged = quote(9, 45, 10.2);
-        let later = quote(10, 0, if closing_only { 10.2 } else { 9.8 });
-        let last = if closing_only { quote(15, 0, if scenario == 2 { 9.8 } else { 10.2 }) } else { quote(10, 1, 9.8) };
-        let mut post_close = quote(15, 5, 9.7);
-        post_close.trading_phase = Some("post_close_fixed_price".into());
-        let mut data = dataset_from_market_and_candidates(vec![market(date, 10.2, 9.8)], vec![candidate(date)]);
-        data.add_execution_quotes(vec![first.clone()]);
-        let broker = BrokerSimulator::new(ChinaAShareCostModel::default(), ChinaEquityRuleHooks)
-            .with_matching_type(MatchingType::CurrentBarClose)
-            .with_intraday_execution_start_time(NaiveTime::from_hms_opt(9, 30, 0).unwrap())
-            .with_volume_limit(partial).with_volume_percent(0.01).with_liquidity_limit(false).with_inactive_limit(false);
-        let requests = Arc::new(Mutex::new(Vec::new()));
-        let captured = Arc::clone(&requests);
-        let mut engine = BacktestEngine::new(data, RestingLimit { quantity: if partial { 300 } else { 100 } }, broker, BacktestConfig {
-            initial_cash: 100_000.0, benchmark_code: "000852.SH".into(), start_date: Some(date), end_date: Some(date),
-            decision_lag_trading_days: 0, execution_price_field: PriceField::Close,
-        }).with_execution_quote_loader(move |request| {
-            captured.lock().unwrap().push((request.start_time, request.end_time));
-            Ok(vec![earlier.clone(), first.clone(), unchanged.clone(), later.clone(), last.clone(), post_close.clone()])
-        });
-        let result = engine.run().unwrap();
-        if scenario == 3 {
-            assert!(result.fills.is_empty(), "continuous DAY order must not migrate to post-close execution");
-            assert_eq!(result.order_events.len(), 2, "only initial pending and expiry are state changes");
-            assert_eq!(result.order_events.last().unwrap().status, crate::OrderStatus::Expired);
-            continue;
-        }
-        assert_eq!(result.fills.len(), if partial { 3 } else { 1 }, "resting DAY order must match later actual quotes: {:?}", result.order_events);
-        assert_eq!(result.fills[0].execution_timestamp, if partial { date.and_hms_opt(9, 30, 0) } else if closing_only { date.and_hms_opt(15, 0, 0) } else { date.and_hms_opt(10, 0, 0) });
-        assert_eq!(result.fills[0].price, 9.8);
-        assert_eq!(result.fills[0].quantity, 100);
-        assert_eq!(result.fills.iter().map(|fill| fill.quantity).sum::<u32>(), if partial { 300 } else { 100 });
-        assert!(result.fills.iter().all(|fill| fill.execution_timestamp >= date.and_hms_opt(9, 30, 0)));
-        assert_eq!(requests.lock().unwrap().as_slice(), &[(None, None)]);
-        assert!(!result.order_events.iter().any(|order| order.status == crate::OrderStatus::Expired));
-        assert_eq!(result.order_events.len(), if partial { 3 } else { 2 }, "unchanged pending attempts must not emit state transitions");
-        }
-    }
-
     #[test]
     fn scheduled_event_detail_records_actual_time_only_for_timed_rules() {
         let timed = ScheduleRule::daily("timed", ScheduleStage::OnDay)
@@ -6169,38 +5985,6 @@ mod tests {
             .expect("zero-volume stock may have no minute bars");
     }
 
-    #[test]
-    fn lifecycle_quote_filter_skips_only_dated_legal_absence_before_loading() {
-        let date = d(2025, 9, 10);
-        for (symbol, listed_at, delisted_at, reason) in [
-            ("920038.BJ", Some(d(2026, 8, 5)), None, "not_yet_listed"),
-            ("563360.SH", Some(d(2026, 8, 5)), None, "not_yet_listed"),
-            ("000001.SZ", Some(d(2010, 1, 1)), Some(d(2025, 9, 9)), "delisted"),
-        ] {
-            let instrument = Instrument { symbol: symbol.into(), listed_at, delisted_at, ..default_instrument() };
-            let data = DataSet::from_components(vec![instrument], vec![], vec![], vec![], vec![benchmark(date)]).unwrap();
-            let mut engine = full_day_coverage_engine(data, date);
-            engine.execution_quote_loader = Some(Box::new(|_| panic!("legal lifecycle absence must not load prices")));
-            engine.load_missing_execution_quotes(date, None, None, &mut BTreeSet::from([symbol.to_string()])).unwrap();
-            let notes = engine.execution_absence_notes.get(&date).unwrap();
-            assert!(notes[0].contains(reason));
-            assert!(notes[0].contains(symbol));
-            engine.load_missing_execution_quotes(date, None, None, &mut BTreeSet::from([symbol.to_string()])).unwrap();
-            assert_eq!(engine.execution_absence_notes[&date].len(), 1);
-        }
-    }
-
-    #[test]
-    fn unknown_identity_or_missing_candidate_does_not_waive_quote_coverage() {
-        let date = d(2025, 9, 10);
-        let data = DataSet::from_components(vec![default_instrument()], vec![], vec![], vec![], vec![benchmark(date)]).unwrap();
-        let mut engine = full_day_coverage_engine(data, date);
-        let error = engine.load_missing_execution_quotes(date, None, None, &mut BTreeSet::from(["unmapped".to_string()])).unwrap_err();
-        assert!(error.to_string().contains("instrument_metadata_or_code_mapping_missing"));
-        let error = engine.validate_full_day_execution_quote_coverage(date, &[SYMBOL.to_string()]).unwrap_err();
-        assert!(error.to_string().contains("missing_daily_market"));
-    }
-
     fn run_scheduled_next_open_with_dataset(dataset: DataSet) -> super::BacktestResult {
         run_scheduled_next_open_with_dataset_and_broker(
             dataset,
@@ -6810,33 +6594,17 @@ mod tests {
     }
 
     #[test]
-    fn next_bar_open_execution_risk_rejects_one_yuan_open_despite_higher_close() {
+    fn next_bar_open_execution_risk_rejects_execution_day_one_yuan_state() {
         let first = d(2025, 1, 2);
         let second = d(2025, 1, 3);
         let result = run_scheduled_next_open_with_dataset(dataset_with(
             market(first, 10.0, 11.5),
-            market(second, 0.9, 1.2),
+            market(second, 12.0, 99.0),
-            candidate(first),
-            candidate(second),
-        ));
-
-        assert_next_open_canceled_with_reason(&result, "one_yuan");
-    }
-
-    #[test]
-    fn next_bar_open_execution_risk_ignores_later_one_yuan_close() {
-        let first = d(2025, 1, 2);
-        let second = d(2025, 1, 3);
-        let result = run_scheduled_next_open_with_dataset(dataset_with(
-            market(first, 10.0, 11.5),
-            market(second, 1.2, 0.9),
             candidate(first),
             one_yuan_candidate(second),
         ));
 
-        assert_eq!(result.fills.len(), 1);
+        assert_next_open_canceled_with_reason(&result, "one_yuan");
-        assert_eq!(result.fills[0].date, second);
-        assert_eq!(result.fills[0].price, 1.2);
     }
 
     #[test]

crates/fidc-core/src/execution_capacity.rs

@@ -1,170 +0,0 @@
-//! Causal volume budgets. Session totals may audit fills, never size earlier orders.
-use chrono::{NaiveDate, NaiveDateTime};
-use serde::{Deserialize, Serialize};
-use thiserror::Error;
-
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum VolumeCapacityMode {
-    #[default]
-    ExecutionObservation,
-    CompletedBar,
-    SessionCapacityAudit,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Error)]
-pub enum CapacityError {
-    #[error("execution capacity ratio must be finite and in (0, 1]")]
-    InvalidRatio,
-    #[error("execution capacity decimal cannot be represented exactly")]
-    InvalidDecimal,
-    #[error("execution capacity observation has invalid time bounds")]
-    InvalidWindow,
-    #[error("execution capacity is not visible: available={available_at}, execution={execution_at}")]
-    NotVisible { available_at: NaiveDateTime, execution_at: NaiveDateTime },
-    #[error("execution capacity observation belongs to another session")]
-    WrongSession,
-    #[error("execution-time capacity is missing; daily session volume cannot size an earlier fill")]
-    MissingObservation,
-}
-
-/// Decimal semantics of the frozen JSON rate, evaluated without a float product.
-#[derive(Debug, Clone, Copy)]
-pub struct ParticipationRate {
-    numerator: u128,
-    denominator: u128,
-}
-
-impl ParticipationRate {
-    pub fn new(rate: f64) -> Result<Self, CapacityError> {
-        if !rate.is_finite() || rate <= 0.0 || rate > 1.0 {
-            return Err(CapacityError::InvalidRatio);
-        }
-        if rate < 1e-20 {
-            // Even u64::MAX shares at this rate cannot admit a single share.
-            return Ok(Self { numerator: 0, denominator: 1 });
-        }
-        if rate == 1.0 {
-            return Ok(Self { numerator: 1, denominator: 1 });
-        }
-        let text = rate.to_string();
-        let digits = text.strip_prefix("0.").ok_or(CapacityError::InvalidDecimal)?;
-        let digits = digits.trim_end_matches('0');
-        let numerator = digits.parse::<u128>().map_err(|_| CapacityError::InvalidDecimal)?;
-        let denominator = 10_u128.checked_pow(digits.len() as u32).ok_or(CapacityError::InvalidDecimal)?;
-        if numerator > u128::MAX / u128::from(u64::MAX) {
-            return Err(CapacityError::InvalidDecimal);
-        }
-        Ok(Self { numerator, denominator })
-    }
-
-    pub fn total_shares(self, market_shares: u64) -> u64 {
-        let total = u128::from(market_shares) * self.numerator / self.denominator;
-        u64::try_from(total).expect("participation rate cannot exceed the market shares")
-    }
-
-    pub fn remaining(self, market_shares: u64, consumed_shares: u64, requested: u32) -> u32 {
-        self.total_shares(market_shares).saturating_sub(consumed_shares).min(u64::from(requested)) as u32
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum VolumeObservationKind {
-    TradeIncrement,
-    CompletedBar,
-    CumulativeSession,
-}
-
-#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
-pub struct VolumeObservation {
-    pub kind: VolumeObservationKind,
-    pub start: NaiveDateTime,
-    pub end: NaiveDateTime,
-    pub available_at: NaiveDateTime,
-    pub shares: u64,
-}
-
-impl VolumeObservation {
-    pub fn visible_shares(self, execution_at: NaiveDateTime) -> Result<u64, CapacityError> {
-        if self.start > self.end || self.available_at < self.end {
-            return Err(CapacityError::InvalidWindow);
-        }
-        if self.available_at > execution_at {
-            return Err(CapacityError::NotVisible { available_at: self.available_at, execution_at });
-        }
-        if self.start.date() != self.end.date() || self.end.date() != execution_at.date() {
-            return Err(CapacityError::WrongSession);
-        }
-        Ok(self.shares)
-    }
-
-    pub fn remaining(self, execution_at: NaiveDateTime, rate: ParticipationRate, consumed: u64, requested: u32) -> Result<u32, CapacityError> {
-        Ok(rate.remaining(self.visible_shares(execution_at)?, consumed, requested))
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
-pub struct SessionCapacityAudit {
-    pub date: NaiveDate,
-    pub symbol: String,
-    pub filled_shares: u64,
-    pub session_shares: u64,
-    pub allowed_shares: u64,
-    pub passed: bool,
-}
-
-impl SessionCapacityAudit {
-    pub fn new(date: NaiveDate, symbol: String, filled_shares: u64, session_shares: u64, rate: ParticipationRate) -> Self {
-        let allowed_shares = rate.total_shares(session_shares);
-        Self { date, symbol, filled_shares, session_shares, allowed_shares, passed: filled_shares <= allowed_shares }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn decimal_participation_never_rounds_a_fractional_share_up_or_overflows() {
-        assert_eq!(ParticipationRate::new(0.58).unwrap().total_shares(50), 29);
-        assert_eq!(ParticipationRate::new(0.25).unwrap().total_shares(3), 0);
-        assert_eq!(ParticipationRate::new(0.5).unwrap().total_shares(3), 1);
-        assert_eq!(ParticipationRate::new(1.).unwrap().total_shares(u64::MAX), u64::MAX);
-        assert_eq!(ParticipationRate::new(0.25).unwrap().remaining(u64::MAX, 0, u32::MAX), u32::MAX);
-        assert_eq!(ParticipationRate::new(f64::MIN_POSITIVE).unwrap().total_shares(u64::MAX), 0);
-        for rate in [0., -1., f64::NAN, f64::INFINITY, 1.001] {
-            assert!(ParticipationRate::new(rate).is_err());
-        }
-    }
-
-    #[test]
-    fn completed_volume_cannot_be_used_for_an_earlier_open() {
-        let day = NaiveDate::from_ymd_opt(2025,1,2).unwrap();
-        let opening = day.and_hms_opt(9,30,0).unwrap();
-        let closing = day.and_hms_opt(15,0,0).unwrap();
-        let observation = VolumeObservation { kind:VolumeObservationKind::CompletedBar, start:opening, end:closing, available_at:closing, shares:10000 };
-        assert!(matches!(observation.visible_shares(opening), Err(CapacityError::NotVisible { .. })));
-        assert_eq!(observation.remaining(closing, ParticipationRate::new(0.25).unwrap(), 1000, 5000).unwrap(), 1500);
-        assert!(matches!(observation.visible_shares(closing+chrono::Duration::days(1)), Err(CapacityError::WrongSession)));
-    }
-
-    #[test]
-    fn delayed_publication_and_invalid_bounds_are_not_treated_as_zero_volume() {
-        let at = NaiveDate::from_ymd_opt(2025,1,2).unwrap().and_hms_opt(10,18,0).unwrap();
-        let observation = VolumeObservation { kind:VolumeObservationKind::TradeIncrement, start:at, end:at, available_at:at+chrono::Duration::seconds(1), shares:0 };
-        assert!(matches!(observation.visible_shares(at), Err(CapacityError::NotVisible { .. })));
-        assert_eq!(VolumeObservation { available_at:at-chrono::Duration::seconds(1), ..observation }.visible_shares(at), Err(CapacityError::InvalidWindow));
-        assert_eq!(VolumeObservation { available_at:at, ..observation }.visible_shares(at).unwrap(), 0);
-    }
-
-    #[test]
-    fn session_audit_changes_verdict_not_executed_quantity() {
-        let day = NaiveDate::from_ymd_opt(2025,1,2).unwrap();
-        let rate = ParticipationRate::new(0.25).unwrap();
-        let a = SessionCapacityAudit::new(day,"TEST".into(),1000,3000,rate);
-        let b = SessionCapacityAudit::new(day,"TEST".into(),1000,5000,rate);
-        assert!(!a.passed); assert!(b.passed);
-        assert_eq!(a.filled_shares,b.filled_shares);
-    }
-}

crates/fidc-core/src/execution_schedule.rs

@@ -1,61 +0,0 @@
-use chrono::NaiveDateTime;
-
-use crate::engine::BacktestError;
-
-/// Cumulative TWAP entitlement depends on the frozen clock, not future quotes.
-pub(crate) struct TwapSchedule {
-    start: NaiveDateTime,
-    end: NaiveDateTime,
-    quantity: u32,
-}
-
-impl TwapSchedule {
-    pub(crate) fn new(
-        start: Option<NaiveDateTime>,
-        end: Option<NaiveDateTime>,
-        quantity: u32,
-    ) -> Result<Self, BacktestError> {
-        let (Some(start), Some(end)) = (start, end) else {
-            return Err(BacktestError::Execution("TWAP requires an explicit start and end clock".into()));
-        };
-        if end < start || start.date() != end.date() {
-            return Err(BacktestError::Execution("TWAP requires an ordered same-session clock window".into()));
-        }
-        Ok(Self { start, end, quantity })
-    }
-
-    pub(crate) fn due_quantity(&self, at: NaiveDateTime, filled: u32) -> u32 {
-        if at < self.start {
-            return 0;
-        }
-        let entitlement = if at >= self.end {
-            self.quantity
-        } else {
-            let elapsed = (at - self.start).num_microseconds().expect("same-day interval") as u128;
-            let duration = (self.end - self.start).num_microseconds().expect("same-day interval") as u128;
-            (u128::from(self.quantity) * elapsed / duration) as u32
-        };
-        entitlement.saturating_sub(filled)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use chrono::{Duration, NaiveDate};
-
-    #[test]
-    fn clock_entitlements_are_exact_and_allow_backlog_without_future_quote_counts() {
-        let start = NaiveDate::from_ymd_opt(2025, 1, 2).unwrap().and_hms_opt(10, 0, 0).unwrap();
-        let end = start + Duration::minutes(10);
-        let schedule = TwapSchedule::new(Some(start), Some(end), 1_000).unwrap();
-        assert_eq!(schedule.due_quantity(start, 0), 0);
-        assert_eq!(schedule.due_quantity(start + Duration::minutes(2), 0), 200);
-        assert_eq!(schedule.due_quantity(start + Duration::minutes(5), 100), 400);
-        assert_eq!(schedule.due_quantity(end, 100), 900);
-        assert_eq!(schedule.due_quantity(end, 1_000), 0);
-        assert!(TwapSchedule::new(Some(start), None, 1_000).is_err());
-        assert!(TwapSchedule::new(Some(end), Some(start), 1_000).is_err());
-        assert_eq!(TwapSchedule::new(Some(start), Some(start), 1_000).unwrap().due_quantity(start, 0), 1_000);
-    }
-}

crates/fidc-core/src/factor_cross_section.rs

@@ -1,234 +0,0 @@
-//! Cross-sectional operators require an explicit complete universe, never a UI page.
-use serde::{Deserialize, Serialize};
-use std::collections::{BTreeMap, BTreeSet};
-
-pub const OPERATORS: &[&str] = &[
-    "RANK",
-    "PERCENTILE",
-    "TOP",
-    "BOTTOM",
-    "TOP_PERCENT",
-    "BOTTOM_PERCENT",
-    "WINSORIZE",
-    "INDUSTRY_NEUTRALIZE",
-    "SIZE_NEUTRALIZE",
-];
-
-#[derive(Clone, Debug, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct Observation {
-    pub symbol: String,
-    pub value: f64,
-    pub industry: Option<String>,
-    pub market_cap: Option<f64>,
-}
-#[derive(Debug, Serialize)]
-pub struct Output {
-    pub symbol: String,
-    pub value: f64,
-}
-
-/// Every date ranks the same frozen research universe; unknown inputs invalidate the whole date.
-pub fn rank_history(
-    dates: &[chrono::NaiveDate], universe: &[String], values: &BTreeMap<String, Vec<Option<f64>>>,
-) -> Result<serde_json::Value, String> {
-    use serde_json::json;
-    if dates.is_empty() || dates.windows(2).any(|w| w[0] >= w[1]) || universe.len() < 2
-        || universe.len() > 20_000 || dates.len().saturating_mul(universe.len()) > 2_000_000
-        || universe.iter().collect::<BTreeSet<_>>().len() != universe.len()
-        || values.keys().collect::<BTreeSet<_>>() != universe.iter().collect::<BTreeSet<_>>()
-        || values.values().any(|v| v.len() != dates.len() || v.iter().flatten().any(|v| !v.is_finite())) {
-        return Err("research_rank_history_incomplete_or_invalid_universe".into());
-    }
-    let mut rank = universe.iter().map(|s|(s.clone(),vec![None;dates.len()])).collect::<BTreeMap<_,_>>();
-    let mut percentile = rank.clone();
-    let mut unknown_dates = Vec::new();
-    for (i, date) in dates.iter().enumerate() {
-        let missing = universe.iter().filter(|s|values[*s][i].is_none()).collect::<Vec<_>>();
-        if !missing.is_empty() {
-            unknown_dates.push(json!({"date":date,"missing_count":missing.len(),"missing_symbol_sample":missing.iter().take(20).collect::<Vec<_>>(),"sample_limit":20}));
-            continue;
-        }
-        let observations = universe.iter().map(|s|Observation{symbol:s.clone(),value:values[s][i].unwrap(),industry:None,market_cap:None}).collect::<Vec<_>>();
-        for item in evaluate("RANK", universe, &observations, 0.0)? {rank.get_mut(&item.symbol).unwrap()[i]=Some(item.value);}
-        for item in evaluate("PERCENTILE", universe, &observations, 0.0)? {percentile.get_mut(&item.symbol).unwrap()[i]=Some(item.value);}
-    }
-    Ok(json!({"rank":rank,"percentile":percentile,"unknown_dates":unknown_dates,
-        "universe":universe,"dates":dates,"tie_policy":"average_rank_descending",
-        "membership_policy":"fixed_research_scope_not_historical_index_membership"}))
-}
-
-fn mean(values: &[f64]) -> f64 {
-    let base = values[0];
-    base + values
-        .iter()
-        .skip(1)
-        .map(|v| (v - base) / values.len() as f64)
-        .sum::<f64>()
-}
-fn quantile(sorted: &[f64], p: f64) -> f64 {
-    let x = p * (sorted.len() - 1) as f64;
-    let l = x.floor() as usize;
-    let r = x.ceil() as usize;
-    sorted[l] + (sorted[r] - sorted[l]) * (x - l as f64)
-}
-
-pub fn evaluate(
-    name: &str,
-    universe: &[String],
-    rows: &[Observation],
-    threshold: f64,
-) -> Result<Vec<Output>, String> {
-    let expected = universe.iter().collect::<BTreeSet<_>>();
-    if rows.is_empty()
-        || rows.len() > 20_000
-        || expected.len() != universe.len()
-        || rows.len() != universe.len()
-        || rows.iter().map(|r| &r.symbol).collect::<BTreeSet<_>>() != expected
-        || rows.iter().any(|r| !r.value.is_finite())
-    {
-        return Err("cross_section_incomplete_or_invalid_universe".into());
-    }
-    if !OPERATORS.contains(&name) || !threshold.is_finite() {
-        return Err("cross_section_operator_invalid".into());
-    }
-    if matches!(name, "TOP" | "BOTTOM") && (threshold < 1.0 || threshold.fract() != 0.0)
-        || matches!(name, "TOP_PERCENT" | "BOTTOM_PERCENT") && !(0.0..=1.0).contains(&threshold)
-        || name == "WINSORIZE" && !(0.0..0.5).contains(&threshold)
-    {
-        return Err("cross_section_threshold_invalid".into());
-    }
-    let mut sorted = rows.iter().map(|r| r.value).collect::<Vec<_>>();
-    sorted.sort_by(f64::total_cmp);
-    let mut industry_values: BTreeMap<&str, Vec<f64>> = BTreeMap::new();
-    if name == "INDUSTRY_NEUTRALIZE" {
-        for row in rows {
-            let industry = row
-                .industry
-                .as_deref()
-                .filter(|v| !v.trim().is_empty())
-                .ok_or("cross_section_pit_industry_missing")?;
-            industry_values.entry(industry).or_default().push(row.value);
-        }
-    }
-    let size = if name == "SIZE_NEUTRALIZE" {
-        let x = rows
-            .iter()
-            .map(|r| {
-                r.market_cap
-                    .filter(|v| v.is_finite() && *v > 0.0)
-                    .map(f64::ln)
-                    .ok_or("cross_section_market_cap_missing")
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-        let xm = mean(&x);
-        let ym = mean(&sorted);
-        let variance = x.iter().map(|v| (v - xm).powi(2)).sum::<f64>();
-        if variance == 0.0 || rows.len() < 3 {
-            return Err("cross_section_size_regression_unidentified".into());
-        }
-        let beta = x
-            .iter()
-            .zip(rows)
-            .map(|(x, y)| (x - xm) * (y.value - ym))
-            .sum::<f64>()
-            / variance;
-        Some((x, xm, ym, beta))
-    } else {
-        None
-    };
-    rows.iter()
-        .enumerate()
-        .map(|(index, row)| {
-            let low = sorted.partition_point(|v| *v < row.value);
-            let high = sorted.partition_point(|v| *v <= row.value);
-            let rank = (low + 1 + high) as f64 / 2.0;
-            let descending = (rows.len() + 1) as f64 - rank;
-            let percentile = if rows.len() == 1 {
-                0.5
-            } else {
-                (rank - 1.0) / (rows.len() - 1) as f64
-            };
-            let value = match name {
-                "RANK" => descending,
-                "PERCENTILE" => percentile,
-                "TOP" => f64::from(descending <= threshold),
-                "BOTTOM" => f64::from(rank <= threshold),
-                "TOP_PERCENT" => f64::from(descending <= threshold * rows.len() as f64),
-                "BOTTOM_PERCENT" => f64::from(rank <= threshold * rows.len() as f64),
-                "WINSORIZE" => row.value.clamp(
-                    quantile(&sorted, threshold),
-                    quantile(&sorted, 1.0 - threshold),
-                ),
-                "INDUSTRY_NEUTRALIZE" => {
-                    row.value - mean(&industry_values[row.industry.as_deref().unwrap()])
-                }
-                "SIZE_NEUTRALIZE" => {
-                    let (x, xm, ym, beta) = size.as_ref().unwrap();
-                    row.value - (ym + beta * (x[index] - xm))
-                }
-                _ => unreachable!(),
-            };
-            if !value.is_finite() {
-                return Err("cross_section_result_nonfinite".into());
-            }
-            Ok(Output {
-                symbol: row.symbol.clone(),
-                value,
-            })
-        })
-        .collect()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    #[test]
-    fn historical_ranks_keep_ties_and_unknown_full_cross_sections() {
-        let dates=["2026-09-07","2026-09-08","2026-09-09"].map(|d|d.parse().unwrap());
-        let universe=vec!["A".into(),"B".into(),"C".into()];
-        let values=BTreeMap::from([("A".into(),vec![None,Some(10.0),Some(20.0)]),("B".into(),vec![Some(10.0),Some(10.0),Some(10.0)]),("C".into(),vec![Some(20.0),Some(5.0),Some(15.0)])]);
-        let out=rank_history(&dates,&universe,&values).unwrap();
-        assert_eq!(out["rank"]["A"],serde_json::json!([null,1.5,1.0]));
-        assert_eq!(out["rank"]["C"],serde_json::json!([null,3.0,2.0]));
-        assert_eq!(out["unknown_dates"][0]["missing_count"],1);
-        let earlier=values.iter().map(|(s,v)|(s.clone(),v[..2].to_vec())).collect();
-        let first=rank_history(&dates[..2],&universe,&earlier).unwrap();
-        assert_eq!(&out["rank"]["A"].as_array().unwrap()[..2],first["rank"]["A"].as_array().unwrap());
-        assert!(rank_history(&dates,&universe[..2],&values).is_err());
-    }
-    fn rows() -> Vec<Observation> {
-        [1.0, 3.0, 3.0, 4.0]
-            .iter()
-            .enumerate()
-            .map(|(i, &value)| Observation {
-                symbol: format!("S{i}"),
-                value,
-                industry: Some(if i < 2 { "A" } else { "B" }.into()),
-                market_cap: Some(10.0 + i as f64),
-            })
-            .collect()
-    }
-    #[test]
-    fn ties_keep_equal_rank_and_missing_universe_rejects() {
-        let r = rows();
-        let u = r.iter().map(|r| r.symbol.clone()).collect::<Vec<_>>();
-        let out = evaluate("RANK", &u, &r, 0.0).unwrap();
-        assert_eq!(
-            out.iter().map(|r| r.value).collect::<Vec<_>>(),
-            vec![4.0, 2.5, 2.5, 1.0]
-        );
-        assert!(evaluate("RANK", &u, &r[..3], 0.0).is_err());
-    }
-    #[test]
-    fn neutralization_preserves_input_order() {
-        let r = rows();
-        let u = r.iter().map(|r| r.symbol.clone()).collect::<Vec<_>>();
-        let out = evaluate("INDUSTRY_NEUTRALIZE", &u, &r, 0.0).unwrap();
-        assert_eq!(
-            out.iter().map(|r| r.value).collect::<Vec<_>>(),
-            vec![-1.0, 1.0, -0.5, 0.5]
-        );
-        assert!(evaluate("TOP_PERCENT", &u, &r, 20.0).is_err());
-    }
-}

crates/fidc-core/src/factor_event_catalog.rs

@@ -1,52 +0,0 @@
-//! Indicator metadata is versioned independently from the numerical kernel.
-use crate::factor_events::{CONTRACT, OPERATORS, TA_REV};
-use serde_json::{Value, json};
-use ta_lib::abstract_api::{self, OptInputType};
-
-pub fn catalog() -> Value {
-    use sha2::{Digest, Sha256};
-    let mut implementation = Sha256::new();
-    for file in [include_bytes!("factor_events.rs").as_slice(), include_bytes!("factor_cross_section.rs").as_slice(),
-        include_bytes!("daily_patterns.rs").as_slice(),include_bytes!("market_event_context.rs").as_slice(),
-        include_bytes!("session_events.rs").as_slice(),include_bytes!("pattern_context.rs").as_slice(),TA_REV.as_bytes()] {implementation.update(file);}
-    let implementation_sha256=format!("{:x}",implementation.finalize());
-    let indicators: Vec<Value> = abstract_api::funcs().map(|f| json!({
-        "name":f.name, "group":format!("{:?}",f.group), "description":f.hint,
-        "inputs":f.inputs.iter().map(|p|json!({"name":p.param_name,"kind":format!("{:?}",p.kind),"flags":p.flags.0})).collect::<Vec<_>>(),
-        "parameters":f.opt_inputs.iter().map(|p|json!({"name":p.param_name,"label":p.display_name,"description":p.hint,"domain":parameter_domain(p.kind)})).collect::<Vec<_>>(),
-        "outputs":f.outputs.iter().enumerate().map(|(i,p)|json!({"index":i,"name":p.param_name,"kind":format!("{:?}",p.kind)})).collect::<Vec<_>>(),
-        "unstable_period":format!("{:?}",f.unst_id), "production_eligible":false,
-    })).collect();
-    json!({"contract":CONTRACT,"parameter_domain_contract":"fidc.indicator-parameter-domain/v1","expression_kernel_sha256":implementation_sha256,"library":{"name":"TA-Lib native Rust","revision":TA_REV,"license":"BSD-3-Clause"},
-        "execution_context_contract":crate::pattern_context::CONTRACT,
-        "execution_context_fields":crate::pattern_context::CONTEXT_FIELDS,
-        "market_event_context_contract":crate::market_event_context::CONTRACT,
-        "market_event_kernel_sha256":crate::market_event_context::implementation_sha256(),
-        "market_event_common_fields":crate::market_event_context::COMMON_FIELDS,
-        "market_event_industry_fields":crate::market_event_context::INDUSTRY_FIELDS,
-        "session_events":crate::session_events::EVENTS,"session_event_contract":crate::session_events::CONTRACT,
-        "indicators":indicators,"operators":OPERATORS,"cross_section_operators":crate::factor_cross_section::OPERATORS,"read_only":true,"live_routing":false,
-        "policies":{"null":"unknown_not_false","warmup":"null_until_full_history","recursive_seed":"frozen_input_start",
-        "breakout":"previous_window_excludes_current","boolean":"three_valued_logic","daily_execution":"next_completed_session",
-        "minute_execution":"strictly_after_completed_bar","cross_section":"requires_separate_complete_universe_contract"}})
-}
-
-pub(crate) fn parameter_domain(kind: OptInputType) -> Value {
-    match kind {
-        OptInputType::IntegerRange { min, max, default, .. } => json!({
-            "value_type":"integer", "minimum":min, "maximum":max, "default":default,
-        }),
-        OptInputType::RealRange { min, max, default, precision, .. } => json!({
-            "value_type":"number", "minimum":min, "maximum":max,
-            "default":default, "display_precision":precision,
-        }),
-        OptInputType::IntegerList { values, default } => json!({
-            "value_type":"integer", "default":default,
-            "choices":values.iter().map(|(value,label)|json!({"value":value,"label":label})).collect::<Vec<_>>(),
-        }),
-        OptInputType::RealList { values, default } => json!({
-            "value_type":"number", "default":default,
-            "choices":values.iter().map(|(value,label)|json!({"value":value,"label":label})).collect::<Vec<_>>(),
-        }),
-    }
-}

crates/fidc-core/src/factor_events.rs

@@ -1,936 +0,0 @@
-//! Causal, typed indicator/event expressions shared by research and trading.
-use chrono::{DateTime, FixedOffset};
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-use std::collections::BTreeMap;
-use ta_lib::{
-    Core,
-    abstract_api::{self, InputType, OptInputType, OutputType},
-};
-
-pub const CONTRACT: &str = "fidc_factor_event_expression_v1";
-pub const TA_REV: &str = "dd5a90259a3f9e04e2da9f38bf0719a841b40108";
-
-pub fn field_dependencies(expr: &Expr) -> std::collections::BTreeSet<String> {
-    let mut fields = std::collections::BTreeSet::new();
-    match expr {
-        Expr::Field { name } => {
-            fields.insert(name.clone());
-        }
-        Expr::Indicator { inputs, .. } => {
-            for e in inputs {
-                fields.extend(field_dependencies(e));
-            }
-        }
-        Expr::Operator { args, .. } => {
-            for e in args {
-                fields.extend(field_dependencies(e));
-            }
-        }
-        _ => {}
-    }
-    fields
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
-pub enum Expr {
-    Number {
-        value: f64,
-    },
-    Field {
-        name: String,
-    },
-    Indicator {
-        name: String,
-        #[serde(default)]
-        inputs: Vec<Expr>,
-        #[serde(default)]
-        parameters: BTreeMap<String, Value>,
-        #[serde(default)]
-        output: usize,
-    },
-    Operator {
-        name: String,
-        args: Vec<Expr>,
-        #[serde(default, skip_serializing_if = "Option::is_none")]
-        window: Option<usize>,
-    },
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct Frame {
-    pub symbol: String,
-    pub frequency: String,
-    pub decision_at: DateTime<FixedOffset>,
-    pub timestamps: Vec<DateTime<FixedOffset>>,
-    pub available_at: Vec<DateTime<FixedOffset>>,
-    pub fields: BTreeMap<String, Vec<Option<f64>>>,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
-#[serde(rename_all = "snake_case")]
-pub enum ValueType {
-    Number,
-    Boolean,
-}
-
-#[derive(Debug, Clone, Serialize)]
-pub struct Series {
-    pub value_type: ValueType,
-    pub values: Vec<Option<f64>>,
-}
-
-pub(crate) const OPERATORS: &[&str] = &[
-    "GT",
-    "GTE",
-    "LT",
-    "LTE",
-    "EQ",
-    "NEQ",
-    "BETWEEN",
-    "OUTSIDE",
-    "CROSS_ABOVE",
-    "CROSS_BELOW",
-    "BREAK_ABOVE",
-    "BREAK_BELOW",
-    "BREAK_HIGH",
-    "BREAK_LOW",
-    "CHANGE",
-    "DIFF",
-    "DELTA",
-    "PCT_CHANGE",
-    "LOG_RETURN",
-    "RISING",
-    "FALLING",
-    "NON_DECREASING",
-    "NON_INCREASING",
-    "TURN_UP",
-    "TURN_DOWN",
-    "BOTTOM_REVERSAL",
-    "TOP_REVERSAL",
-    "SLOPE",
-    "SLOPE_CHANGE",
-    "ACCELERATION",
-    "HHV",
-    "LLV",
-    "ARGMAX",
-    "ARGMIN",
-    "DISTANCE_TO_HIGH",
-    "DISTANCE_TO_LOW",
-    "NEW_HIGH",
-    "NEW_LOW",
-    "NEAR_HIGH",
-    "NEAR_LOW",
-    "BULLISH_DIVERGENCE",
-    "BEARISH_DIVERGENCE",
-    "ZSCORE",
-    "MINMAX",
-    "STANDARDIZE",
-    "NORMALIZE",
-    "COUNT",
-    "COUNT_TRUE",
-    "CONSECUTIVE",
-    "BARS_SINCE",
-    "DURATION",
-    "DAYS_SINCE",
-    "TIME_SINCE",
-    "REF",
-    "LAG",
-    "PREV",
-    "SHIFT",
-    "ROLLING_MEAN",
-    "ROLLING_SUM",
-    "ROLLING_STD",
-    "ROLLING_MAX",
-    "ROLLING_MIN",
-    "ROLLING_MEDIAN",
-    "ROLLING_CORR",
-    "ROLLING_COV",
-    "AND",
-    "OR",
-    "NOT",
-    "XOR",
-    "ADD",
-    "SUB",
-    "MUL",
-    "DIV",
-    "ABS",
-    "MAX",
-    "MIN",
-    "LOG",
-    "SQRT",
-    "POWER",
-    "CUMMAX",
-    "CUMMIN",
-    "SIGN",
-    "IF",
-];
-
-pub use crate::factor_event_catalog::catalog;
-
-impl Frame {
-    pub fn validate(&self) -> Result<(), String> {
-        let n = self.timestamps.len();
-        if self.symbol.is_empty()
-            || n == 0
-            || n > 200_000
-            || self.available_at.len() != n
-            || self.fields.len() > 100
-            || n.saturating_mul(self.fields.len()) > 1_000_000
-        {
-            return Err("factor_frame_invalid: identity/shape/limit".into());
-        }
-        if !["1d", "1w", "1m", "5m", "15m", "30m", "60m"].contains(&self.frequency.as_str()) {
-            return Err("factor_frame_invalid: unsupported_frequency".into());
-        }
-        for i in 0..n {
-            if (i > 0 && self.timestamps[i] <= self.timestamps[i - 1])
-                || self.available_at[i] < self.timestamps[i]
-                || self.available_at[i] > self.decision_at
-            {
-                return Err(format!(
-                    "factor_input_not_visible: {} index={i}",
-                    self.symbol
-                ));
-            }
-        }
-        for (field, values) in &self.fields {
-            if values.len() != n || values.iter().flatten().any(|v| !v.is_finite()) {
-                return Err(format!("factor_field_invalid: {} {field}", self.symbol));
-            }
-        }
-        Ok(())
-    }
-}
-
-pub fn evaluate(expr: &Expr, frame: &Frame) -> Result<Series, String> {
-    frame.validate()?;
-    fn cost(expr: &Expr, depth: usize, nodes: &mut usize) -> Result<usize, String> {
-        *nodes += 1;
-        if depth > 24 || *nodes > 256 {
-            return Err("factor_expression_size_exceeded".into());
-        }
-        let (children, own) = match expr {
-            Expr::Indicator {
-                inputs, parameters, ..
-            } => (
-                inputs.as_slice(),
-                parameters
-                    .values()
-                    .filter_map(Value::as_u64)
-                    .max()
-                    .unwrap_or(30)
-                    .min(1_000_000) as usize,
-            ),
-            Expr::Operator { args, window, .. } => (args.as_slice(), window.unwrap_or(1)),
-            _ => (&[][..], 1),
-        };
-        children.iter().try_fold(own, |total, child| {
-            Ok(total.saturating_add(cost(child, depth + 1, nodes)?))
-        })
-    }
-    if frame
-        .timestamps
-        .len()
-        .saturating_mul(cost(expr, 0, &mut 0)?)
-        > 20_000_000
-    {
-        return Err("factor_expression_compute_budget_exceeded".into());
-    }
-    evaluate_inner(expr, frame, 0)
-}
-
-fn evaluate_inner(expr: &Expr, frame: &Frame, depth: usize) -> Result<Series, String> {
-    if depth > 24 {
-        return Err("factor_expression_too_deep".into());
-    }
-    match expr {
-        Expr::Number { value } if value.is_finite() => Ok(Series {
-            value_type: ValueType::Number,
-            values: vec![Some(*value); frame.timestamps.len()],
-        }),
-        Expr::Number { .. } => Err("factor_constant_nonfinite".into()),
-        Expr::Field { name } => Ok(Series {
-            value_type: ValueType::Number,
-            values: frame
-                .fields
-                .get(name)
-                .ok_or_else(|| format!("factor_source_field_missing: {} {name}", frame.symbol))?
-                .clone(),
-        }),
-        Expr::Indicator {
-            name,
-            inputs,
-            parameters,
-            output,
-        } => indicator(name, inputs, parameters, *output, frame, depth),
-        Expr::Operator { name, args, window } => {
-            if args.len() > 16 {
-                return Err("factor_operator_arity_exceeded".into());
-            }
-            let args = args
-                .iter()
-                .map(|a| evaluate_inner(a, frame, depth + 1))
-                .collect::<Result<Vec<_>, _>>()?;
-            operator(name, &args, *window, frame)
-        }
-    }
-}
-
-fn indicator(
-    name: &str,
-    inputs: &[Expr],
-    parameters: &BTreeMap<String, Value>,
-    output: usize,
-    frame: &Frame,
-    depth: usize,
-) -> Result<Series, String> {
-    let id =
-        abstract_api::get_func_handle(name).ok_or_else(|| format!("indicator_unknown: {name}"))?;
-    let info = id.info();
-    if output >= info.outputs.len() {
-        return Err("indicator_output_invalid".into());
-    }
-    let real_count = info
-        .inputs
-        .iter()
-        .filter(|i| i.kind == InputType::Real)
-        .count();
-    if inputs.len() != real_count || info.inputs.iter().any(|i| i.kind == InputType::Integer) {
-        return Err(format!(
-            "indicator_inputs_invalid: {name} expects {real_count} real series"
-        ));
-    }
-    let mut data = inputs
-        .iter()
-        .map(|a| evaluate_inner(a, frame, depth + 1))
-        .collect::<Result<Vec<_>, _>>()?;
-    if data.iter().any(|s| s.value_type != ValueType::Number) {
-        return Err("indicator_requires_numeric_input".into());
-    }
-    let price_names = ["open", "high", "low", "close", "volume", "open_interest"];
-    let flags = info
-        .inputs
-        .iter()
-        .filter(|i| i.kind == InputType::Price)
-        .fold(0, |v, i| v | i.flags.0);
-    let mut price_indices = [None; 6];
-    for (i, field) in price_names.iter().enumerate() {
-        if flags & (1 << i) != 0 {
-            price_indices[i] = Some(data.len());
-            data.push(evaluate_inner(
-                &Expr::Field {
-                    name: (*field).into(),
-                },
-                frame,
-                depth + 1,
-            )?);
-        }
-    }
-    let core = Core::new();
-    let mut validation = id.new_call(&core);
-    for (key, v) in parameters {
-        let slot = info
-            .opt_inputs
-            .iter()
-            .position(|p| p.param_name == key)
-            .ok_or_else(|| format!("indicator_parameter_unknown: {name}.{key}"))?;
-        match info.opt_inputs[slot].kind {
-            OptInputType::IntegerRange { .. } | OptInputType::IntegerList { .. } => {
-                let v = v
-                    .as_i64()
-                    .and_then(|v| i32::try_from(v).ok())
-                    .ok_or("indicator_parameter_requires_integer")?;
-                validation.set_opt(slot, v).map_err(|e| format!("{e:?}"))?;
-            }
-            _ => {
-                validation
-                    .set_opt(
-                        slot,
-                        v.as_f64()
-                            .filter(|v| v.is_finite())
-                            .ok_or("indicator_parameter_requires_finite_number")?,
-                    )
-                    .map_err(|e| format!("{e:?}"))?;
-            }
-        }
-    }
-    let lookback = validation
-        .lookback()
-        .map_err(|e| format!("indicator_parameter_invalid: {name} {e:?}"))?;
-    let n = frame.timestamps.len();
-    let mut result = vec![None; n];
-    let mut start = 0;
-    // Never bridge missing source observations. Recursive indicators rewarm after a gap.
-    while start < n {
-        if data.iter().any(|s| s.values[start].is_none()) {
-            start += 1;
-            continue;
-        }
-        let mut end = start + 1;
-        while end < n && data.iter().all(|s| s.values[end].is_some()) {
-            end += 1;
-        }
-        if end - start <= lookback {
-            start = end;
-            continue;
-        }
-        let arrays = data
-            .iter()
-            .map(|s| {
-                s.values[start..end]
-                    .iter()
-                    .map(|v| v.unwrap())
-                    .collect::<Vec<_>>()
-            })
-            .collect::<Vec<_>>();
-        let mut float_out = (0..info.outputs.len())
-            .map(|_| vec![0.0; end - start])
-            .collect::<Vec<_>>();
-        let mut int_out = (0..info.outputs.len())
-            .map(|_| vec![0i32; end - start])
-            .collect::<Vec<_>>();
-        let mut call = id.new_call(&core);
-        for (key, v) in parameters {
-            let slot = info
-                .opt_inputs
-                .iter()
-                .position(|p| p.param_name == key)
-                .unwrap();
-            match info.opt_inputs[slot].kind {
-                OptInputType::IntegerRange { .. } | OptInputType::IntegerList { .. } => {
-                    call.set_opt(slot, v.as_i64().unwrap() as i32)
-                        .map_err(|e| format!("{e:?}"))?;
-                }
-                _ => {
-                    call.set_opt(slot, v.as_f64().unwrap())
-                        .map_err(|e| format!("{e:?}"))?;
-                }
-            }
-        }
-        let mut real_slot = 0;
-        for (slot, i) in info.inputs.iter().enumerate() {
-            if i.kind == InputType::Real {
-                call.set_input(slot, &arrays[real_slot])
-                    .map_err(|e| format!("{e:?}"))?;
-                real_slot += 1;
-            } else {
-                let p = price_indices.map(|i| i.map(|i| arrays[i].as_slice()));
-                call.set_price_input(slot, p[0], p[1], p[2], p[3], p[4], p[5])
-                    .map_err(|e| format!("{e:?}"))?;
-            }
-        }
-        for (slot, (floats, ints)) in float_out.iter_mut().zip(int_out.iter_mut()).enumerate() {
-            if info.outputs[slot].kind == OutputType::Real {
-                call.set_output(slot, floats)
-                    .map_err(|e| format!("{e:?}"))?;
-            } else {
-                call.set_int_output(slot, ints)
-                    .map_err(|e| format!("{e:?}"))?;
-            }
-        }
-        let range = call
-            .call(0, end - start - 1)
-            .map_err(|e| format!("indicator_failed: {name} {e:?}"))?;
-        drop(call);
-        for j in 0..range.count {
-            let value = if info.outputs[output].kind == OutputType::Real {
-                float_out[output][j]
-            } else {
-                int_out[output][j] as f64
-            };
-            if !value.is_finite() {
-                return Err(format!(
-                    "indicator_nonfinite: {name} index={}",
-                    start + range.beg_idx + j
-                ));
-            }
-            result[start + range.beg_idx + j] = Some(value);
-        }
-        start = end;
-    }
-    Ok(Series {
-        value_type: ValueType::Number,
-        values: result,
-    })
-}
-
-fn average(v: &[f64]) -> f64 {
-    v[0] + v
-        .iter()
-        .skip(1)
-        .map(|x| (x - v[0]) / v.len() as f64)
-        .sum::<f64>()
-}
-fn slope(v: &[f64]) -> f64 {
-    let x = (v.len() - 1) as f64 / 2.0;
-    let y = average(v);
-    let num = v
-        .iter()
-        .enumerate()
-        .map(|(i, v)| (i as f64 - x) * (v - y))
-        .sum::<f64>();
-    let den = (0..v.len()).map(|i| (i as f64 - x).powi(2)).sum::<f64>();
-    num / den
-}
-fn boolean(v: bool) -> Option<f64> {
-    Some(if v { 1.0 } else { 0.0 })
-}
-
-fn operator(
-    name: &str,
-    args: &[Series],
-    window: Option<usize>,
-    frame: &Frame,
-) -> Result<Series, String> {
-    if !OPERATORS.contains(&name) {
-        return Err(format!("operator_not_registered: {name}"));
-    }
-    let bool_input = matches!(
-        name,
-        "AND"
-            | "OR"
-            | "NOT"
-            | "XOR"
-            | "COUNT"
-            | "COUNT_TRUE"
-            | "CONSECUTIVE"
-            | "BARS_SINCE"
-            | "DURATION"
-            | "DAYS_SINCE"
-            | "TIME_SINCE"
-    );
-    let lag = matches!(name, "REF" | "LAG" | "PREV" | "SHIFT");
-    if args.is_empty()
-        || (name == "IF"
-            && (args.len() != 3
-                || args[0].value_type != ValueType::Boolean
-                || args[1].value_type != args[2].value_type))
-        || (!lag
-            && name != "IF"
-            && args
-                .iter()
-                .any(|a| (a.value_type == ValueType::Boolean) != bool_input))
-    {
-        return Err(format!("operator_input_type_invalid: {name}"));
-    }
-    let arity = match name {
-        "BETWEEN" | "OUTSIDE" | "IF" => 3,
-        "GT" | "GTE" | "LT" | "LTE" | "EQ" | "NEQ" | "CROSS_ABOVE" | "CROSS_BELOW"
-        | "BREAK_ABOVE" | "BREAK_BELOW" | "ADD" | "SUB" | "MUL" | "DIV" | "MAX" | "MIN"
-        | "POWER" | "XOR" | "ROLLING_CORR" | "ROLLING_COV" | "NEAR_HIGH" | "NEAR_LOW"
-        | "BULLISH_DIVERGENCE" | "BEARISH_DIVERGENCE" => 2,
-        "AND" | "OR" => args.len(),
-        _ => 1,
-    };
-    if args.len() != arity {
-        return Err(format!("operator_arity_invalid: {name}"));
-    }
-    let windowed = matches!(
-        name,
-        "BREAK_HIGH"
-            | "BREAK_LOW"
-            | "RISING"
-            | "FALLING"
-            | "NON_DECREASING"
-            | "NON_INCREASING"
-            | "SLOPE"
-            | "SLOPE_CHANGE"
-            | "HHV"
-            | "LLV"
-            | "ARGMAX"
-            | "ARGMIN"
-            | "DISTANCE_TO_HIGH"
-            | "DISTANCE_TO_LOW"
-            | "NEW_HIGH"
-            | "NEW_LOW"
-            | "NEAR_HIGH"
-            | "NEAR_LOW"
-            | "BULLISH_DIVERGENCE"
-            | "BEARISH_DIVERGENCE"
-            | "ZSCORE"
-            | "STANDARDIZE"
-            | "MINMAX"
-            | "NORMALIZE"
-            | "COUNT"
-            | "COUNT_TRUE"
-    ) || name.starts_with("ROLLING_");
-    let n = window.unwrap_or(1);
-    if n == 0
-        || n > 10_000
-        || (windowed && window.is_none())
-        || (matches!(
-            name,
-            "SLOPE"
-                | "SLOPE_CHANGE"
-                | "ZSCORE"
-                | "STANDARDIZE"
-                | "ROLLING_STD"
-                | "ROLLING_CORR"
-                | "ROLLING_COV"
-        ) && n < 2)
-    {
-        return Err(format!("operator_window_invalid: {name}"));
-    }
-    let returns_bool = matches!(
-        name,
-        "GT" | "GTE"
-            | "LT"
-            | "LTE"
-            | "EQ"
-            | "NEQ"
-            | "BETWEEN"
-            | "OUTSIDE"
-            | "CROSS_ABOVE"
-            | "CROSS_BELOW"
-            | "BREAK_ABOVE"
-            | "BREAK_BELOW"
-            | "BREAK_HIGH"
-            | "BREAK_LOW"
-            | "RISING"
-            | "FALLING"
-            | "NON_DECREASING"
-            | "NON_INCREASING"
-            | "TURN_UP"
-            | "TURN_DOWN"
-            | "BOTTOM_REVERSAL"
-            | "TOP_REVERSAL"
-            | "NEW_HIGH"
-            | "NEW_LOW"
-            | "NEAR_HIGH"
-            | "NEAR_LOW"
-            | "BULLISH_DIVERGENCE"
-            | "BEARISH_DIVERGENCE"
-            | "AND"
-            | "OR"
-            | "NOT"
-            | "XOR"
-    );
-    let len = frame.timestamps.len();
-    let mut out = vec![None; len];
-    let mut last_true = None;
-    let mut consecutive = Some(0usize);
-    let mut extreme: Option<f64> = None;
-    let mut cumulative_complete = true;
-    for i in 0..len {
-        let a = args[0].values[i];
-        let b = args.get(1).and_then(|a| a.values[i]);
-        let at = |j: usize| args[0].values.get(j).copied().flatten();
-        let history = |end: usize, count: usize| -> Option<Vec<f64>> {
-            if end < count {
-                None
-            } else {
-                args[0].values[end - count..end].iter().copied().collect()
-            }
-        };
-        out[i] = match name {
-            "IF" => a.and_then(|a| {
-                if a == 1.0 {
-                    args[1].values[i]
-                } else {
-                    args[2].values[i]
-                }
-            }),
-            "SIGN" => a.map(|v| {
-                if v == 0.0 {
-                    0.0
-                } else if v > 0.0 {
-                    1.0
-                } else {
-                    -1.0
-                }
-            }),
-            "CUMMAX" | "CUMMIN" => {
-                cumulative_complete &= a.is_some();
-                extreme = a.filter(|_| cumulative_complete).map(|v| {
-                    extreme.map_or(v, |p| if name == "CUMMAX" { p.max(v) } else { p.min(v) })
-                });
-                extreme
-            }
-            "AND" => {
-                if args.iter().any(|a| a.values[i] == Some(0.0)) {
-                    Some(0.0)
-                } else if args.iter().any(|a| a.values[i].is_none()) {
-                    None
-                } else {
-                    Some(1.0)
-                }
-            }
-            "OR" => {
-                if args.iter().any(|a| a.values[i] == Some(1.0)) {
-                    Some(1.0)
-                } else if args.iter().any(|a| a.values[i].is_none()) {
-                    None
-                } else {
-                    Some(0.0)
-                }
-            }
-            "NOT" => a.map(|v| 1.0 - v),
-            "XOR" => a.zip(b).and_then(|(a, b)| boolean(a != b)),
-            "GT" | "GTE" | "LT" | "LTE" | "EQ" | "NEQ" => a.zip(b).and_then(|(a, b)| {
-                boolean(match name {
-                    "GT" => a > b,
-                    "GTE" => a >= b,
-                    "LT" => a < b,
-                    "LTE" => a <= b,
-                    "EQ" => a == b,
-                    _ => a != b,
-                })
-            }),
-            "BETWEEN" | "OUTSIDE" => a.zip(b).zip(args[2].values[i]).and_then(|((a, b), c)| {
-                if b > c {
-                    None
-                } else {
-                    boolean((a >= b && a <= c) == (name == "BETWEEN"))
-                }
-            }),
-            "CROSS_ABOVE" | "CROSS_BELOW" | "BREAK_ABOVE" | "BREAK_BELOW" => {
-                if i == 0 {
-                    None
-                } else {
-                    a.zip(b).zip(at(i - 1).zip(args[1].values[i - 1])).and_then(
-                        |((a, b), (p, q))| {
-                            boolean(if name.ends_with("ABOVE") {
-                                p <= q && a > b
-                            } else {
-                                p >= q && a < b
-                            })
-                        },
-                    )
-                }
-            }
-            "REF" | "LAG" | "PREV" | "SHIFT" => i.checked_sub(n).and_then(at),
-            "CHANGE" | "DIFF" | "DELTA" | "PCT_CHANGE" | "LOG_RETURN" => a
-                .zip(i.checked_sub(n).and_then(at))
-                .and_then(|(a, p)| match name {
-                    "PCT_CHANGE" => {
-                        if p == 0.0 {
-                            None
-                        } else {
-                            Some(a / p - 1.0)
-                        }
-                    }
-                    "LOG_RETURN" => {
-                        if a <= 0.0 || p <= 0.0 {
-                            None
-                        } else {
-                            Some((a / p).ln())
-                        }
-                    }
-                    _ => Some(a - p),
-                }),
-            "ACCELERATION" => a
-                .zip(i.checked_sub(n).and_then(at))
-                .zip(i.checked_sub(n * 2).and_then(at))
-                .map(|((a, p), q)| a - 2.0 * p + q),
-            "BULLISH_DIVERGENCE" | "BEARISH_DIVERGENCE" => {
-                if i < n || n < 4 {
-                    None
-                } else {
-                    let price: Option<Vec<f64>> =
-                        args[0].values[i - n..=i].iter().copied().collect();
-                    let indicator: Option<Vec<f64>> =
-                        args[1].values[i - n..=i].iter().copied().collect();
-                    price.zip(indicator).and_then(|(price, indicator)| {
-                        let low = name == "BULLISH_DIVERGENCE";
-                        let pivots = (1..n)
-                            .filter(|&j| {
-                                if low {
-                                    price[j] < price[j - 1] && price[j] < price[j + 1]
-                                } else {
-                                    price[j] > price[j - 1] && price[j] > price[j + 1]
-                                }
-                            })
-                            .collect::<Vec<_>>();
-                        if pivots.last() != Some(&(n - 1)) || pivots.len() < 2 {
-                            return boolean(false);
-                        }
-                        let a = pivots[pivots.len() - 2];
-                        let b = n - 1;
-                        boolean(if low {
-                            price[b] < price[a] && indicator[b] > indicator[a]
-                        } else {
-                            price[b] > price[a] && indicator[b] < indicator[a]
-                        })
-                    })
-                }
-            }
-            "TURN_UP" | "TURN_DOWN" | "BOTTOM_REVERSAL" | "TOP_REVERSAL" => {
-                if i < 2 {
-                    None
-                } else {
-                    a.zip(at(i - 1)).zip(at(i - 2)).and_then(|((a, p), q)| {
-                        if name == "ACCELERATION" {
-                            Some(a - 2.0 * p + q)
-                        } else {
-                            boolean(if matches!(name, "TURN_UP" | "BOTTOM_REVERSAL") {
-                                p < q && a > p
-                            } else {
-                                p > q && a < p
-                            })
-                        }
-                    })
-                }
-            }
-            "ABS" => a.map(f64::abs),
-            "LOG" => a.filter(|v| *v > 0.0).map(f64::ln),
-            "SQRT" => a.filter(|v| *v >= 0.0).map(f64::sqrt),
-            "ADD" => a.zip(b).map(|(a, b)| a + b),
-            "SUB" => a.zip(b).map(|(a, b)| a - b),
-            "MUL" => a.zip(b).map(|(a, b)| a * b),
-            "DIV" => a.zip(b).filter(|(_, b)| *b != 0.0).map(|(a, b)| a / b),
-            "MAX" => a.zip(b).map(|(a, b)| a.max(b)),
-            "MIN" => a.zip(b).map(|(a, b)| a.min(b)),
-            "POWER" => a.zip(b).map(|(a, b)| a.powf(b)),
-            "BARS_SINCE" | "DAYS_SINCE" | "TIME_SINCE" => {
-                if a == Some(1.0) {
-                    last_true = Some(i);
-                }
-                if a.is_none() {
-                    last_true = None;
-                }
-                last_true.map(|t| {
-                    if name == "BARS_SINCE" {
-                        (i - t) as f64
-                    } else {
-                        let secs = (frame.timestamps[i] - frame.timestamps[t]).num_seconds() as f64;
-                        if name == "DAYS_SINCE" {
-                            secs / 86400.0
-                        } else {
-                            secs
-                        }
-                    }
-                })
-            }
-            "CONSECUTIVE" | "DURATION" => {
-                consecutive = match a {
-                    Some(1.0) => consecutive.map(|v| v + 1),
-                    Some(_) => Some(0),
-                    None => None,
-                };
-                consecutive.map(|v| v as f64)
-            }
-            "BREAK_HIGH" | "NEW_HIGH" | "BREAK_LOW" | "NEW_LOW" => {
-                a.zip(history(i, n)).and_then(|(a, v)| {
-                    boolean(if matches!(name, "BREAK_HIGH" | "NEW_HIGH") {
-                        a > v.into_iter().fold(f64::NEG_INFINITY, f64::max)
-                    } else {
-                        a < v.into_iter().fold(f64::INFINITY, f64::min)
-                    })
-                })
-            }
-            "RISING" | "FALLING" | "NON_DECREASING" | "NON_INCREASING" => history(i + 1, n + 1)
-                .and_then(|v| {
-                    boolean(v.windows(2).all(|p| match name {
-                        "RISING" => p[1] > p[0],
-                        "FALLING" => p[1] < p[0],
-                        "NON_DECREASING" => p[1] >= p[0],
-                        _ => p[1] <= p[0],
-                    }))
-                }),
-            "SLOPE_CHANGE" => history(i + 1, n)
-                .zip(history(i, n))
-                .map(|(a, b)| slope(&a) - slope(&b)),
-            _ => history(i + 1, n).and_then(|mut v| {
-                let mean = average(&v);
-                let lo = v.iter().copied().fold(f64::INFINITY, f64::min);
-                let hi = v.iter().copied().fold(f64::NEG_INFINITY, f64::max);
-                let variance = v.iter().map(|v| (v - mean).powi(2)).sum::<f64>() / n as f64;
-                match name {
-                    "HHV" | "ROLLING_MAX" => Some(hi),
-                    "LLV" | "ROLLING_MIN" => Some(lo),
-                    "ARGMAX" => v.iter().rposition(|x| *x == hi).map(|p| (n - 1 - p) as f64),
-                    "ARGMIN" => v.iter().rposition(|x| *x == lo).map(|p| (n - 1 - p) as f64),
-                    "DISTANCE_TO_HIGH" => {
-                        if hi == 0.0 {
-                            None
-                        } else {
-                            Some(v[n - 1] / hi - 1.0)
-                        }
-                    }
-                    "DISTANCE_TO_LOW" => {
-                        if lo == 0.0 {
-                            None
-                        } else {
-                            Some(v[n - 1] / lo - 1.0)
-                        }
-                    }
-                    "NEAR_HIGH" | "NEAR_LOW" => b.filter(|b| *b >= 0.0).and_then(|b| {
-                        let base = if name == "NEAR_HIGH" { hi } else { lo };
-                        if base == 0.0 {
-                            None
-                        } else {
-                            boolean((v[n - 1] / base - 1.0).abs() <= b)
-                        }
-                    }),
-                    "ZSCORE" | "STANDARDIZE" => {
-                        if variance == 0.0 {
-                            None
-                        } else {
-                            Some((v[n - 1] - mean) / variance.sqrt())
-                        }
-                    }
-                    "MINMAX" | "NORMALIZE" => {
-                        if hi == lo {
-                            None
-                        } else {
-                            Some((v[n - 1] - lo) / (hi - lo))
-                        }
-                    }
-                    "ROLLING_MEAN" => Some(mean),
-                    "ROLLING_SUM" | "COUNT" | "COUNT_TRUE" => Some(v.iter().sum()),
-                    "ROLLING_STD" => Some(variance.sqrt()),
-                    "ROLLING_MEDIAN" => {
-                        v.sort_by(f64::total_cmp);
-                        Some(if n % 2 == 1 {
-                            v[n / 2]
-                        } else {
-                            (v[n / 2 - 1] + v[n / 2]) / 2.0
-                        })
-                    }
-                    "SLOPE" => Some(slope(&v)),
-                    "ROLLING_CORR" | "ROLLING_COV" => {
-                        let b: Option<Vec<f64>> =
-                            args[1].values[i + 1 - n..=i].iter().copied().collect();
-                        b.and_then(|b| {
-                            let bm = average(&b);
-                            let cov = v
-                                .iter()
-                                .zip(&b)
-                                .map(|(a, b)| (a - mean) * (b - bm))
-                                .sum::<f64>()
-                                / n as f64;
-                            if name == "ROLLING_COV" {
-                                Some(cov)
-                            } else {
-                                let bv = b.iter().map(|b| (b - bm).powi(2)).sum::<f64>() / n as f64;
-                                let d = (variance * bv).sqrt();
-                                if d == 0.0 { None } else { Some(cov / d) }
-                            }
-                        })
-                    }
-                    _ => None,
-                }
-            }),
-        }
-        .filter(|v| v.is_finite());
-    }
-    Ok(Series {
-        value_type: if name == "IF" {
-            args[1].value_type
-        } else if lag {
-            args[0].value_type
-        } else if returns_bool {
-            ValueType::Boolean
-        } else {
-            ValueType::Number
-        },
-        values: out,
-    })
-}
-
-#[cfg(test)]
-#[path = "factor_events_tests.rs"]
-mod tests;

crates/fidc-core/src/factor_events_tests.rs

@@ -1,161 +0,0 @@
-use super::*;
-use serde_json::json;
-use crate::factor_event_catalog::parameter_domain;
-
-#[test]
-fn every_parameter_domain_is_structured_and_matches_native_defaults() {
-    for function in abstract_api::funcs() {
-        let handle = abstract_api::get_func_handle(function.name).unwrap();
-        let core = Core::new();
-        let mut call = handle.new_call(&core);
-        for (index, parameter) in function.opt_inputs.iter().enumerate() {
-            let domain = parameter_domain(parameter.kind);
-            let default = domain["default"].as_f64().unwrap();
-            assert!(default.is_finite(), "{} {}", function.name, parameter.param_name);
-            if let Some(choices) = domain.get("choices") {
-                assert!(choices.as_array().unwrap().iter().any(|v| v["value"].as_f64() == Some(default)));
-            } else {
-                assert!(default >= domain["minimum"].as_f64().unwrap());
-                assert!(default <= domain["maximum"].as_f64().unwrap());
-            }
-            if domain["value_type"] == "integer" {
-                assert_eq!(default.fract(), 0.0);
-                call.set_opt(index, default as i32).unwrap();
-            } else {
-                call.set_opt(index, default).unwrap();
-            }
-        }
-        assert!(call.lookback().is_ok(), "{}", function.name);
-    }
-}
-
-#[test]
-fn parameter_domains_keep_enumeration_labels_without_debug_string_parsing() {
-    let catalog = catalog();
-    assert_eq!(catalog["parameter_domain_contract"], "fidc.indicator-parameter-domain/v1");
-    let indicators = catalog["indicators"].as_array().unwrap();
-    let rsi = indicators.iter().find(|v| v["name"] == "RSI").unwrap();
-    assert_eq!(rsi["parameters"][0]["domain"]["minimum"], 2);
-    let stoch = indicators.iter().find(|v| v["name"] == "STOCH").unwrap();
-    let ma_type = stoch["parameters"].as_array().unwrap().iter().find(|p| p["name"] == "optInSlowK_MAType").unwrap();
-    assert!(ma_type["domain"]["choices"].as_array().unwrap().iter().any(|v| v["label"] == "EMA" && v["value"] == 1));
-}
-
-fn frame(values: Vec<Option<f64>>) -> Frame {
-    let start = DateTime::parse_from_rfc3339("2026-09-01T15:30:00+08:00").unwrap();
-    let times = (0..values.len())
-        .map(|i| start + chrono::Duration::days(i as i64))
-        .collect::<Vec<_>>();
-    Frame {
-        symbol: "TEST".into(),
-        frequency: "1d".into(),
-        decision_at: *times.last().unwrap(),
-        available_at: times.clone(),
-        timestamps: times,
-        fields: BTreeMap::from([("close".into(), values)]),
-    }
-}
-fn expr(v: Value) -> Expr {
-    serde_json::from_value(v).unwrap()
-}
-#[test]
-fn ta_sma_real_values_and_parameter_validation() {
-    let frame = frame(vec![Some(1.0), Some(2.0), Some(3.0), Some(4.0)]);
-    let e = expr(
-        json!({"kind":"indicator","name":"SMA","inputs":[{"kind":"field","name":"close"}],"parameters":{"optInTimePeriod":3}}),
-    );
-    assert_eq!(
-        evaluate(&e, &frame).unwrap().values,
-        vec![None, None, Some(2.0), Some(3.0)]
-    );
-    let bad = expr(
-        json!({"kind":"indicator","name":"SMA","inputs":[{"kind":"field","name":"close"}],"parameters":{"period":3}}),
-    );
-    assert!(
-        evaluate(&bad, &frame)
-            .unwrap_err()
-            .contains("parameter_unknown")
-    );
-}
-#[test]
-fn cross_is_event_not_state_and_never_uses_future() {
-    let f = frame(vec![
-        Some(9.0),
-        Some(10.0),
-        Some(11.0),
-        Some(12.0),
-        Some(8.0),
-    ]);
-    let e = expr(
-        json!({"kind":"operator","name":"CROSS_ABOVE","args":[{"kind":"field","name":"close"},{"kind":"number","value":10.0}]}),
-    );
-    assert_eq!(
-        evaluate(&e, &f).unwrap().values,
-        vec![None, Some(0.0), Some(1.0), Some(0.0), Some(0.0)]
-    );
-    let mut invalid = f.clone();
-    invalid.available_at[4] = invalid.decision_at + chrono::Duration::seconds(1);
-    assert!(evaluate(&e, &invalid).is_err());
-}
-#[test]
-fn missing_is_not_zero_and_breakout_excludes_current() {
-    let f = frame(vec![Some(1.0), Some(2.0), Some(3.0), None, Some(5.0)]);
-    let e = expr(
-        json!({"kind":"operator","name":"BREAK_HIGH","window":2,"args":[{"kind":"field","name":"close"}]}),
-    );
-    assert_eq!(
-        evaluate(&e, &f).unwrap().values,
-        vec![None, None, Some(1.0), None, None]
-    );
-    let zero = expr(
-        json!({"kind":"operator","name":"DIV","args":[{"kind":"field","name":"close"},{"kind":"number","value":0}]}),
-    );
-    assert!(
-        evaluate(&zero, &f)
-            .unwrap()
-            .values
-            .iter()
-            .all(Option::is_none)
-    );
-}
-#[test]
-fn ta_rewarms_after_gap_and_const_zscore_is_unknown() {
-    let f = frame(vec![Some(1.0), Some(1.0), None, Some(2.0), Some(2.0)]);
-    let e = expr(
-        json!({"kind":"indicator","name":"SMA","inputs":[{"kind":"field","name":"close"}],"parameters":{"optInTimePeriod":2}}),
-    );
-    assert_eq!(
-        evaluate(&e, &f).unwrap().values,
-        vec![None, Some(1.0), None, None, Some(2.0)]
-    );
-    let e = expr(
-        json!({"kind":"operator","name":"ZSCORE","window":2,"args":[{"kind":"field","name":"close"}]}),
-    );
-    assert!(evaluate(&e, &f).unwrap().values.iter().all(Option::is_none));
-}
-#[test]
-fn no_event_has_no_bars_since_and_type_errors_reject() {
-    let f = frame(vec![Some(1.0), Some(1.0), Some(1.0)]);
-    let state = json!({"kind":"operator","name":"GT","args":[{"kind":"field","name":"close"},{"kind":"number","value":5}]});
-    let e = expr(json!({"kind":"operator","name":"BARS_SINCE","args":[state]}));
-    assert!(evaluate(&e, &f).unwrap().values.iter().all(Option::is_none));
-    assert!(
-        evaluate(
-            &expr(
-                json!({"kind":"operator","name":"NOT","args":[{"kind":"field","name":"close"}]})
-            ),
-            &f
-        )
-        .is_err()
-    );
-}
-#[test]
-fn literal_unknown_fields_reject_and_catalog_is_not_trading_permission() {
-    assert!(
-        serde_json::from_value::<Expr>(json!({"kind":"number","value":1,"account_id":2}))
-            .is_err()
-    );
-    let c = catalog();
-    assert!(c["indicators"].as_array().unwrap().len() > 190);
-    assert_eq!(c["live_routing"], false);
-}

crates/fidc-core/src/holding_policy.rs

@@ -1,369 +0,0 @@
-use chrono::NaiveDate;
-use serde::{Deserialize, Serialize};
-
-use crate::TradingCalendar;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum TradingActionOrigin {
-    Strategy,
-    Manual,
-}
-
-#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct AutomaticTradeProtection {
-    #[serde(default, deserialize_with = "optional_days")]
-    pub buy_protection_days: u32,
-    #[serde(default, deserialize_with = "optional_days")]
-    pub sell_cooldown_days: u32,
-    #[serde(default, deserialize_with = "optional_days")]
-    pub max_holding_days: u32,
-    #[serde(default, deserialize_with = "optional_locks")]
-    pub locks: Vec<AutomaticTradeLock>,
-}
-
-pub fn deserialize_optional_policy<'de, D: serde::Deserializer<'de>>(
-    deserializer: D,
-) -> Result<AutomaticTradeProtection, D::Error> {
-    Ok(Option::<AutomaticTradeProtection>::deserialize(deserializer)?.unwrap_or_default())
-}
-
-fn optional_days<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result<u32, D::Error> {
-    let raw = serde_json::Value::deserialize(deserializer)?;
-    if raw.is_null() {
-        return Ok(0);
-    }
-    raw.as_f64()
-        .filter(|value| {
-            value.is_finite() && value.fract() == 0.0 && *value >= 0.0 && *value <= 3650.0
-        })
-        .map(|value| value as u32)
-        .ok_or_else(|| serde::de::Error::custom("protection days must be integers in 0..3650"))
-}
-
-fn optional_locks<'de, D: serde::Deserializer<'de>>(
-    deserializer: D,
-) -> Result<Vec<AutomaticTradeLock>, D::Error> {
-    Ok(Option::<Vec<AutomaticTradeLock>>::deserialize(deserializer)?.unwrap_or_default())
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct AutomaticTradeLock {
-    pub symbol: String,
-    pub start_date: NaiveDate,
-    pub end_date: Option<NaiveDate>,
-}
-
-#[derive(Debug, Clone, Default, PartialEq, Eq)]
-pub struct HoldingLifecycleEvidence {
-    pub has_position: bool,
-    pub opened_date: Option<NaiveDate>,
-    pub last_buy_date: Option<NaiveDate>,
-    pub last_sell_date: Option<NaiveDate>,
-}
-
-#[derive(Debug, Clone, Default, PartialEq, Eq)]
-pub struct AutomaticTradePermission {
-    pub buy_denial: Option<&'static str>,
-    pub sell_denial: Option<&'static str>,
-    pub max_holding_exit: bool,
-}
-
-impl AutomaticTradeProtection {
-    pub fn enabled(&self) -> bool {
-        self.buy_protection_days > 0
-            || self.sell_cooldown_days > 0
-            || self.max_holding_days > 0
-            || !self.locks.is_empty()
-    }
-
-    pub fn validate(&self) -> Result<(), String> {
-        if [
-            self.buy_protection_days,
-            self.sell_cooldown_days,
-            self.max_holding_days,
-        ]
-        .into_iter()
-        .any(|days| days > 3650)
-        {
-            return Err("automatic_trade_holding_days_out_of_range: expected 0..3650".into());
-        }
-        if self.locks.len() > 2000 {
-            return Err("automatic_trade_locks_limit: maximum 2000 intervals".into());
-        }
-        for lock in &self.locks {
-            let valid_symbol = lock.symbol.split_once('.').is_some_and(|(code, venue)| {
-                code.len() == 6
-                    && code.bytes().all(|ch| ch.is_ascii_digit())
-                    && matches!(venue, "SH" | "SZ" | "BJ")
-            });
-            if !valid_symbol {
-                return Err(format!(
-                    "automatic_trade_lock_invalid_symbol: {}",
-                    lock.symbol
-                ));
-            }
-            if lock.end_date.is_some_and(|end| end < lock.start_date) {
-                return Err(format!(
-                    "automatic_trade_lock_invalid_interval: {}",
-                    lock.symbol
-                ));
-            }
-        }
-        Ok(())
-    }
-
-    pub fn evaluate(
-        &self,
-        symbol: &str,
-        execution_date: NaiveDate,
-        evidence: &HoldingLifecycleEvidence,
-        calendar: &TradingCalendar,
-    ) -> Result<AutomaticTradePermission, String> {
-        self.validate()?;
-        if self.locks.iter().any(|lock| {
-            lock.symbol == symbol
-                && lock.start_date <= execution_date
-                && lock.end_date.is_none_or(|end| execution_date <= end)
-        }) {
-            return Ok(AutomaticTradePermission {
-                buy_denial: Some("automatic_trade_locked"),
-                sell_denial: Some("automatic_trade_locked"),
-                max_holding_exit: false,
-            });
-        }
-        let elapsed = |date: NaiveDate| -> Result<usize, String> {
-            let start = calendar.index_of(date).ok_or_else(|| {
-                format!(
-                    "automatic_trade_holding_calendar_missing: symbol={symbol} fact_date={date}"
-                )
-            })?;
-            let end = calendar.index_of(execution_date).ok_or_else(|| format!("automatic_trade_holding_calendar_missing: symbol={symbol} execution_date={execution_date}"))?;
-            end.checked_sub(start).ok_or_else(|| format!("automatic_trade_holding_future_fact: symbol={symbol} fact_date={date} execution_date={execution_date}"))
-        };
-        let mut decision = AutomaticTradePermission::default();
-        if self.buy_protection_days > 0
-            && evidence.has_position
-            && let Some(date) = evidence.last_buy_date
-            && elapsed(date)? <= self.buy_protection_days as usize
-        {
-            decision.sell_denial = Some("buy_fill_protection");
-        }
-        if self.sell_cooldown_days > 0
-            && let Some(date) = evidence.last_sell_date
-            && elapsed(date)? <= self.sell_cooldown_days as usize
-        {
-            decision.buy_denial = Some("sell_fill_cooldown");
-        }
-        if self.max_holding_days > 0 && evidence.has_position {
-            let opened = evidence.opened_date.ok_or_else(|| format!("automatic_trade_opened_date_missing: symbol={symbol}; require confirmed position lifecycle evidence"))?;
-            decision.max_holding_exit = elapsed(opened)? >= self.max_holding_days as usize
-                && decision.sell_denial.is_none();
-            if decision.max_holding_exit {
-                decision.buy_denial = Some("maximum_holding_exit");
-            }
-        }
-        Ok(decision)
-    }
-
-    /// The caller supplies origin from its authenticated execution path, never
-    /// from an untrusted order-body flag. Broker and ordinary risk checks remain.
-    pub fn evaluate_for_origin(
-        &self,
-        origin: TradingActionOrigin,
-        symbol: &str,
-        execution_date: NaiveDate,
-        evidence: &HoldingLifecycleEvidence,
-        calendar: &TradingCalendar,
-    ) -> Result<AutomaticTradePermission, String> {
-        self.validate()?;
-        match origin {
-            TradingActionOrigin::Strategy => {
-                self.evaluate(symbol, execution_date, evidence, calendar)
-            }
-            TradingActionOrigin::Manual => Ok(AutomaticTradePermission::default()),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    fn d(value: &str) -> NaiveDate {
-        NaiveDate::parse_from_str(value, "%Y-%m-%d").unwrap()
-    }
-    fn calendar() -> TradingCalendar {
-        TradingCalendar::new(
-            [
-                "2026-09-11",
-                "2026-09-14",
-                "2026-09-15",
-                "2026-09-16",
-                "2026-09-17",
-            ]
-            .into_iter()
-            .map(d)
-            .collect(),
-        )
-    }
-
-    #[test]
-    fn three_complete_sessions_protect_through_wednesday_not_72_hours() {
-        let policy = AutomaticTradeProtection {
-            buy_protection_days: 3,
-            sell_cooldown_days: 3,
-            ..Default::default()
-        };
-        let evidence = HoldingLifecycleEvidence {
-            has_position: true,
-            last_buy_date: Some(d("2026-09-11")),
-            last_sell_date: Some(d("2026-09-11")),
-            ..Default::default()
-        };
-        for day in ["2026-09-11", "2026-09-14", "2026-09-15", "2026-09-16"] {
-            let decision = policy
-                .evaluate("000001.SZ", d(day), &evidence, &calendar())
-                .unwrap();
-            assert_eq!(decision.sell_denial, Some("buy_fill_protection"));
-            assert_eq!(decision.buy_denial, Some("sell_fill_cooldown"));
-        }
-        assert_eq!(
-            policy
-                .evaluate("000001.SZ", d("2026-09-17"), &evidence, &calendar())
-                .unwrap(),
-            AutomaticTradePermission::default()
-        );
-    }
-
-    #[test]
-    fn absolute_locks_are_inclusive_and_override_timed_exit_without_changing_other_symbols() {
-        let policy = AutomaticTradeProtection {
-            max_holding_days: 1,
-            locks: vec![AutomaticTradeLock {
-                symbol: "000001.SZ".into(),
-                start_date: d("2026-09-11"),
-                end_date: Some(d("2026-09-16")),
-            }],
-            ..Default::default()
-        };
-        let evidence = HoldingLifecycleEvidence {
-            has_position: true,
-            opened_date: Some(d("2026-09-11")),
-            ..Default::default()
-        };
-        let locked = policy
-            .evaluate("000001.SZ", d("2026-09-16"), &evidence, &calendar())
-            .unwrap();
-        assert_eq!(locked.sell_denial, Some("automatic_trade_locked"));
-        assert!(!locked.max_holding_exit);
-        assert!(
-            policy
-                .evaluate("600000.SH", d("2026-09-16"), &evidence, &calendar())
-                .unwrap()
-                .max_holding_exit
-        );
-        assert!(
-            policy
-                .evaluate("000001.SZ", d("2026-09-17"), &evidence, &calendar())
-                .unwrap()
-                .max_holding_exit
-        );
-    }
-
-    #[test]
-    fn zero_disabled_and_missing_calendar_or_opened_date_are_not_inferred() {
-        let evidence = HoldingLifecycleEvidence {
-            has_position: true,
-            ..Default::default()
-        };
-        assert_eq!(
-            AutomaticTradeProtection::default()
-                .evaluate(
-                    "000001.SZ",
-                    d("2026-09-17"),
-                    &evidence,
-                    &TradingCalendar::new(vec![])
-                )
-                .unwrap(),
-            AutomaticTradePermission::default()
-        );
-        let policy = AutomaticTradeProtection {
-            max_holding_days: 1,
-            ..Default::default()
-        };
-        assert!(
-            policy
-                .evaluate("000001.SZ", d("2026-09-17"), &evidence, &calendar())
-                .unwrap_err()
-                .contains("opened_date_missing")
-        );
-        let evidence = HoldingLifecycleEvidence {
-            opened_date: Some(d("2026-09-10")),
-            ..evidence
-        };
-        assert!(
-            policy
-                .evaluate("000001.SZ", d("2026-09-17"), &evidence, &calendar())
-                .unwrap_err()
-                .contains("calendar_missing")
-        );
-    }
-
-    #[test]
-    fn manual_origin_only_bypasses_automatic_policy_not_an_order_or_broker_permission() {
-        let policy = AutomaticTradeProtection {
-            locks: vec![AutomaticTradeLock {
-                symbol: "000001.SZ".into(),
-                start_date: d("2026-09-11"),
-                end_date: None,
-            }],
-            ..Default::default()
-        };
-        assert_eq!(
-            policy
-                .evaluate_for_origin(
-                    TradingActionOrigin::Manual,
-                    "000001.SZ",
-                    d("2026-09-14"),
-                    &HoldingLifecycleEvidence::default(),
-                    &calendar()
-                )
-                .unwrap(),
-            AutomaticTradePermission::default()
-        );
-        assert_eq!(
-            policy
-                .evaluate_for_origin(
-                    TradingActionOrigin::Strategy,
-                    "000001.SZ",
-                    d("2026-09-14"),
-                    &HoldingLifecycleEvidence::default(),
-                    &calendar()
-                )
-                .unwrap()
-                .buy_denial,
-            Some("automatic_trade_locked")
-        );
-    }
-
-    #[test]
-    fn opening_date_follows_fills_not_partial_sales_or_corporate_conversions() {
-        let mut portfolio = crate::PortfolioState::new(100_000.0);
-        let position = portfolio.position_mut("000001.SZ");
-        position.buy(d("2026-09-11"), 100, 10.0);
-        position.buy(d("2026-09-14"), 200, 10.0);
-        position.sell(100, 10.0).unwrap();
-        assert_eq!(position.opened_date(), Some(d("2026-09-11")));
-        portfolio
-            .apply_successor_conversion("000001.SZ", "000002.SZ", 2.0, 0.0)
-            .unwrap();
-        let successor = portfolio.position_mut("000002.SZ");
-        assert_eq!(successor.opened_date(), Some(d("2026-09-11")));
-        assert_eq!(successor.last_buy_date(), Some(d("2026-09-14")));
-        successor.sell(400, 5.0).unwrap();
-        assert_eq!(successor.opened_date(), None);
-        successor.buy(d("2026-09-17"), 100, 5.0);
-        assert_eq!(successor.opened_date(), Some(d("2026-09-17")));
-    }
-}

crates/fidc-core/src/instrument.rs

@@ -27,12 +27,6 @@ pub struct Instrument {
 }
 
 impl Instrument {
-    /// Classification from the admitted security master, never a code prefix
-    /// or a name substring. This does not grant T+0 settlement eligibility.
-    pub fn is_exchange_traded_fund(&self) -> bool {
-        matches!(self.board.trim().to_ascii_uppercase().as_str(), "ETF" | "EXCHANGE_TRADED_FUND")
-    }
-
     pub fn effective_round_lot(&self) -> u32 {
         self.round_lot.max(1)
     }
@@ -76,17 +70,8 @@ impl Instrument {
 
     pub fn is_active_on(&self, date: NaiveDate) -> bool {
         self.listed_at.is_none_or(|listed_at| listed_at <= date)
-            && !self.is_delisted_on_or_before(date)
+            && !self.is_delisted_before(date)
-    }
+            && !(self.status.eq_ignore_ascii_case("inactive") && self.delisted_at.is_none())
-
-    pub fn dated_market_absence_reason(&self, date: NaiveDate) -> Option<&'static str> {
-        if self.listed_at.is_some_and(|listed| date < listed) {
-            Some("not_yet_listed")
-        } else if self.is_delisted_on_or_before(date) {
-            Some("delisted")
-        } else {
-            None
-        }
     }
 }
 
@@ -122,25 +107,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn lifecycle_is_dated_and_latest_undated_terminal_status_is_not_historical_evidence() {
-        let mut item = instrument("BJS", 100);
-        let listing = chrono::NaiveDate::from_ymd_opt(2026, 8, 5).unwrap();
-        let removal = chrono::NaiveDate::from_ymd_opt(2026, 9, 10).unwrap();
-        item.listed_at = Some(listing);
-        item.delisted_at = Some(removal);
-        assert_eq!(item.dated_market_absence_reason(listing.pred_opt().unwrap()), Some("not_yet_listed"));
-        assert!(item.is_active_on(listing));
-        assert!(!item.is_active_on(removal));
-        assert_eq!(item.dated_market_absence_reason(removal), Some("delisted"));
-        item.delisted_at = None;
-        for status in ["delisting", "delisted", "inactive", "terminated"] {
-            item.status = status.into();
-            assert!(item.is_active_on(listing));
-            assert_eq!(item.dated_market_absence_reason(listing), None);
-        }
-    }
-
     #[test]
     fn order_quantity_rules_are_case_insensitive_without_allocating_normalized_boards() {
         let kcb = instrument(" kSh ", 100);

crates/fidc-core/src/lib.rs

@@ -2,15 +2,6 @@ pub mod broker;
 pub mod calendar;
 pub mod cost;
 pub mod data;
-pub mod daily_patterns;
-pub mod pattern_context;
-pub mod session_events;
-pub mod factor_events;
-pub mod execution_capacity;
-mod execution_schedule;
-mod factor_event_catalog;
-pub mod factor_cross_section;
-pub mod market_event_context;
 pub mod engine;
 pub mod event_bus;
 pub mod events;
@@ -28,14 +19,6 @@ pub mod risk_control;
 pub mod rules;
 pub mod scheduler;
 pub mod strategy;
-pub mod holding_policy;
-pub mod stock_pool_candidates;
-pub mod stock_pool_indicators;
-pub mod stock_pool_execution;
-pub mod stock_pool_index_policy;
-pub mod stock_pool_market_cap;
-pub mod stock_pool_state;
-pub mod signal_contract;
 pub mod strategy_ai;
 pub mod universe;
 

crates/fidc-core/src/market_event_context.rs

@@ -1,257 +0,0 @@
-//! Complete published daily cross sections, independent of trading candidates and accounts.
-use chrono::NaiveDate;
-use serde::{Deserialize, Serialize};
-use std::collections::{BTreeMap, BTreeSet};
-
-pub const CONTRACT: &str = "fidc_market_event_context_v1";
-pub fn implementation_sha256() -> String {
-    use sha2::{Digest, Sha256};
-    format!("{:x}", Sha256::digest(include_bytes!("market_event_context.rs")))
-}
-pub const COMMON_FIELDS: &[&str] = &[
-    "market_breadth", "market_return", "market_limit_up_count", "market_limit_down_count",
-    "market_limit_up_rate", "market_broken_limit_rate", "market_high_board", "market_profit_effect",
-];
-pub const INDUSTRY_FIELDS: &[&str] = &[
-    "industry_close", "industry_return_20", "industry_breadth", "industry_rank", "industry_size",
-];
-
-#[derive(Clone, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct Observation {
-    pub symbol: String,
-    pub industry: Option<String>,
-    pub close: Option<f64>,
-    pub high: Option<f64>,
-    pub previous_close: Option<f64>,
-    pub upper_limit: Option<f64>,
-    pub lower_limit: Option<f64>,
-    pub no_limit: Option<bool>,
-    pub paused: Option<bool>,
-}
-
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct Day {
-    pub date: NaiveDate,
-    pub universe: Vec<String>,
-    pub rows: Vec<Observation>,
-}
-
-#[derive(Default, Clone, Deserialize, Serialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct State {
-    pub last_date: Option<NaiveDate>,
-    pub streaks: BTreeMap<String, Option<u32>>,
-    pub limit_ups: BTreeSet<String>,
-    pub industry_history: BTreeMap<String, Vec<f64>>,
-}
-
-#[derive(Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct Request {
-    pub days: Vec<Day>,
-    #[serde(default)]
-    pub previous: State,
-}
-
-#[derive(Serialize)]
-pub struct OutputDay {
-    pub date: NaiveDate,
-    pub common: BTreeMap<String, Option<f64>>,
-    pub industries: BTreeMap<String, BTreeMap<String, Option<f64>>>,
-    pub members: BTreeMap<String, Option<String>>,
-    pub securities: usize,
-    pub active: usize,
-    pub paused: usize,
-    pub no_limit: usize,
-    pub profit_effect_members: Vec<String>,
-    pub profit_effect_missing: Vec<String>,
-    pub industry_missing: Vec<String>,
-}
-
-#[derive(Serialize)]
-pub struct Output {
-    pub contract: &'static str,
-    pub days: Vec<OutputDay>,
-    pub state: State,
-}
-
-fn positive(value: Option<f64>, symbol: &str, field: &str) -> Result<f64, String> {
-    value.filter(|v| v.is_finite() && *v > 0.0)
-        .ok_or_else(|| format!("market_event_input_invalid: {symbol} {field}"))
-}
-fn average(values: impl Iterator<Item = f64>, n: usize) -> f64 {
-    values.map(|v| v / n as f64).sum()
-}
-
-pub fn aggregate(request: Request) -> Result<Output, String> {
-    let mut state = request.previous;
-    if request.days.is_empty() || request.days.len() > 30
-        || request.days.iter().map(|d| d.rows.len()).sum::<usize>() > 60_000
-        || state.streaks.len() > 20_000 || state.limit_ups.len() > 20_000
-        || state.industry_history.len() > 2000
-        || state.industry_history.values().any(|v| v.is_empty() || v.len() > 21
-            || v.iter().any(|x| !x.is_finite() || *x <= 0.0))
-        || state.last_date.is_none() && (!state.streaks.is_empty() || !state.limit_ups.is_empty() || !state.industry_history.is_empty()) {
-        return Err("market_event_history_budget_or_state_invalid".into());
-    }
-    let mut output = Vec::new();
-    for day in request.days {
-        if state.last_date.is_some_and(|d| d >= day.date)
-            || day.universe.is_empty() || day.universe.len() > 20_000
-            || day.universe.iter().collect::<BTreeSet<_>>().len() != day.universe.len()
-            || day.rows.len() != day.universe.len()
-            || day.rows.iter().map(|r| &r.symbol).collect::<BTreeSet<_>>() != day.universe.iter().collect::<BTreeSet<_>>() {
-            return Err(format!("market_event_incomplete_cross_section: {}", day.date));
-        }
-        let mut returns = BTreeMap::new();
-        let mut groups: BTreeMap<String, Vec<f64>> = BTreeMap::new();
-        let mut members = BTreeMap::new();
-        let mut streaks = BTreeMap::new();
-        let mut ups = BTreeSet::new();
-        let mut downs = 0; let mut touched = 0; let mut broken = 0; let mut paused = 0; let mut unlimited = 0;
-        for row in &day.rows {
-            let industry = row.industry.clone().filter(|s| !s.trim().is_empty());
-            members.insert(row.symbol.clone(), industry.clone());
-            match row.paused {
-                Some(true) => {
-                    paused += 1;
-                    streaks.insert(row.symbol.clone(), state.streaks.get(&row.symbol).copied().flatten());
-                    continue;
-                },
-                Some(false) => {},
-                None => return Err(format!("market_event_pause_state_missing: {} {}", day.date, row.symbol)),
-            }
-            let c = positive(row.close, &row.symbol, "close")?;
-            let h = positive(row.high, &row.symbol, "high")?;
-            let p = positive(row.previous_close, &row.symbol, "previous_close")?;
-            if h + 1e-8 < c { return Err(format!("market_event_high_below_close: {}", row.symbol)); }
-            let change = c / p - 1.0;
-            returns.insert(row.symbol.clone(), change);
-            if let Some(industry) = industry { groups.entry(industry).or_default().push(change); }
-            let is_up = match row.no_limit {
-                Some(true) => { unlimited += 1; false },
-                Some(false) => {
-                    let upper = positive(row.upper_limit, &row.symbol, "upper_limit")?;
-                    let lower = positive(row.lower_limit, &row.symbol, "lower_limit")?;
-                    if lower >= upper || c > upper + 1e-8 || c < lower - 1e-8 {
-                        return Err(format!("market_event_limit_bounds_invalid: {} {}", day.date, row.symbol));
-                    }
-                    let at_up = (c - upper).abs() <= 1e-8;
-                    if (c - lower).abs() <= 1e-8 { downs += 1; }
-                    if h >= upper - 1e-8 { touched += 1; if !at_up { broken += 1; } }
-                    at_up
-                },
-                None => return Err(format!("market_event_limit_policy_missing: {}", row.symbol)),
-            };
-            if is_up {
-                ups.insert(row.symbol.clone());
-                // The first observed limit-up may already be a continuing streak.
-                streaks.insert(row.symbol.clone(), state.streaks.get(&row.symbol).copied().flatten().map(|v| v + 1));
-            } else { streaks.insert(row.symbol.clone(), Some(0)); }
-        }
-        let active = returns.len();
-        if active == 0 { return Err(format!("market_event_no_active_market: {}", day.date)); }
-        let previous_ups = state.limit_ups.iter().cloned().collect::<Vec<_>>();
-        let profit_missing = previous_ups.iter().filter(|s| !returns.contains_key(*s)).cloned().collect::<Vec<_>>();
-        let profit = if previous_ups.is_empty() || !profit_missing.is_empty() { None }
-            else { Some(average(previous_ups.iter().map(|s| returns[s]), previous_ups.len())) };
-        let board = if ups.iter().any(|s| streaks[s].is_none()) { None }
-            else { Some(ups.iter().map(|s| streaks[s].unwrap()).max().unwrap_or(0) as f64) };
-        let common = BTreeMap::from([
-            ("market_breadth".into(), Some(returns.values().filter(|v| **v > 0.0).count() as f64 / active as f64)),
-            ("market_return".into(), Some(average(returns.values().copied(), active))),
-            ("market_limit_up_count".into(), Some(ups.len() as f64)),
-            ("market_limit_down_count".into(), Some(downs as f64)),
-            ("market_limit_up_rate".into(), (touched > 0).then(|| ups.len() as f64 / touched as f64)),
-            ("market_broken_limit_rate".into(), (touched > 0).then(|| broken as f64 / touched as f64)),
-            ("market_high_board".into(), board),
-            ("market_profit_effect".into(), profit),
-        ]);
-        let mut industries = BTreeMap::new();
-        // A disappeared group breaks its continuous history; no stale NAV is carried forward.
-        state.industry_history.retain(|key, _| groups.contains_key(key));
-        for (industry, values) in groups {
-            let history = state.industry_history.entry(industry.clone()).or_default();
-            let nav = history.last().copied().unwrap_or(1.0) * (1.0 + average(values.iter().copied(), values.len()));
-            history.push(nav);
-            if history.len() > 21 { history.remove(0); }
-            let momentum = (history.len() == 21).then(|| nav / history[0] - 1.0);
-            industries.insert(industry, BTreeMap::from([
-                ("industry_close".into(), Some(nav)), ("industry_return_20".into(), momentum),
-                ("industry_breadth".into(), Some(values.iter().filter(|v| **v > 0.0).count() as f64 / values.len() as f64)),
-            ]));
-        }
-        let universe = industries.keys().cloned().collect::<Vec<_>>();
-        let known = industries.values().all(|g| g["industry_return_20"].is_some());
-        let ranks = if known && !universe.is_empty() {
-            crate::factor_cross_section::evaluate("RANK", &universe, &industries.iter().map(|(s,g)|
-                crate::factor_cross_section::Observation {symbol:s.clone(), value:g["industry_return_20"].unwrap(),industry:None,market_cap:None}).collect::<Vec<_>>(),0.0)?
-                .into_iter().map(|r|(r.symbol,r.value)).collect::<BTreeMap<_,_>>()
-        } else { BTreeMap::new() };
-        for (name, fields) in &mut industries {
-            fields.insert("industry_rank".into(), ranks.get(name).copied());
-            fields.insert("industry_size".into(), Some(universe.len() as f64));
-        }
-        let industry_missing=members.iter().filter(|(_,group)|group.is_none()).map(|(s,_)|s.clone()).collect::<Vec<_>>();
-        if !industry_missing.is_empty() {
-            // An unclassified member may belong to any group; never silently shrink a group.
-            state.industry_history.clear();
-            for fields in industries.values_mut() { for value in fields.values_mut() { *value=None; } }
-        }
-        output.push(OutputDay { date:day.date, common, industries, members, securities:day.rows.len(), active, paused,
-            no_limit:unlimited, profit_effect_members:previous_ups, profit_effect_missing:profit_missing, industry_missing });
-        state.last_date = Some(day.date); state.streaks = streaks; state.limit_ups = ups;
-    }
-    Ok(Output {contract:CONTRACT, days:output, state})
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    fn day(n: u32, up: bool) -> Day {
-        Day {date:NaiveDate::from_ymd_opt(2026,9,n).unwrap(), universe:vec!["A".into(),"B".into()], rows:vec![
-            Observation{symbol:"A".into(),industry:Some("I".into()),close:Some(if up {11.0}else{10.0}),high:Some(11.0),previous_close:Some(10.0),upper_limit:Some(11.0),lower_limit:Some(9.0),no_limit:Some(false),paused:Some(false)},
-            Observation{symbol:"B".into(),industry:Some("J".into()),close:Some(9.0),high:Some(10.0),previous_close:Some(10.0),upper_limit:Some(11.0),lower_limit:Some(9.0),no_limit:Some(false),paused:Some(false)}]}
-    }
-    #[test]
-    fn formulas_use_real_limits_and_full_denominators() {
-        let r=aggregate(Request{days:vec![day(1,false),day(2,true),day(3,true)],previous:State::default()}).unwrap();
-        let d=&r.days[1];
-        assert_eq!(d.common["market_breadth"],Some(0.5));
-        assert_eq!(d.common["market_limit_down_count"],Some(1.0));
-        assert_eq!(d.common["market_limit_up_rate"],Some(1.0));
-        assert_eq!(r.days[0].common["market_limit_up_rate"],Some(0.0));
-        assert_eq!(r.days[0].common["market_broken_limit_rate"],Some(1.0));
-        assert_eq!(r.days[2].common["market_high_board"],Some(2.0));
-        assert!((r.days[2].common["market_profit_effect"].unwrap()-0.1).abs()<1e-12);
-        assert_eq!(r.days[0].common["market_profit_effect"],None);
-    }
-    #[test]
-    fn missing_duplicate_and_unproven_limit_states_fail() {
-        let mut d=day(1,true);d.rows.pop();assert!(aggregate(Request{days:vec![d],previous:State::default()}).is_err());
-        let mut d=day(1,true);d.rows[0].upper_limit=None;assert!(aggregate(Request{days:vec![d],previous:State::default()}).is_err());
-        let mut d=day(1,true);d.rows[0].no_limit=Some(true);d.rows[0].upper_limit=None;
-        assert_eq!(aggregate(Request{days:vec![d],previous:State::default()}).unwrap().days[0].no_limit,1);
-    }
-    #[test]
-    fn chunking_and_future_append_preserve_history() {
-        let first=aggregate(Request{days:vec![day(1,false),day(2,true)],previous:State::default()}).unwrap();
-        let next=aggregate(Request{days:vec![day(3,true)],previous:first.state}).unwrap();
-        let full=aggregate(Request{days:vec![day(1,false),day(2,true),day(3,true)],previous:State::default()}).unwrap();
-        assert_eq!(serde_json::to_value(&first.days).unwrap(),serde_json::to_value(&full.days[..2]).unwrap());
-        assert_eq!(serde_json::to_value(&next.days).unwrap(),serde_json::to_value(&full.days[2..]).unwrap());
-        let unknown=aggregate(Request{days:vec![day(1,true)],previous:State::default()}).unwrap();
-        assert_eq!(unknown.days[0].common["market_high_board"],None);
-    }
-    #[test]
-    fn missing_industry_does_not_invent_groups_or_disable_independent_market_facts() {
-        let mut missing=day(2,true);missing.rows[0].industry=None;
-        let r=aggregate(Request{days:vec![day(1,false),missing,day(3,true)],previous:State::default()}).unwrap();
-        assert_eq!(r.days[1].common["market_breadth"],Some(0.5));
-        assert_eq!(r.days[1].industry_missing,vec!["A"]);
-        assert!(r.days[1].industries.values().flat_map(|g|g.values()).all(Option::is_none));
-        assert_eq!(r.days[2].industries["I"]["industry_return_20"],None);
-    }
-}

crates/fidc-core/src/metrics.rs

@@ -108,7 +108,13 @@ pub fn compute_backtest_metrics(
     };
 
     let trade_days = equity_curve.len();
-    let benchmark_start = first_point.benchmark_reference_close();
+    let benchmark_start = if first_point.benchmark_prev_close.is_finite()
+        && first_point.benchmark_prev_close > f64::EPSILON
+    {
+        first_point.benchmark_prev_close
+    } else {
+        first_point.benchmark_close
+    };
     let explicit_unit_nav = equity_curve.iter().any(|point| {
         point.external_cash_flow.abs() > f64::EPSILON
             || (point.unit_nav.is_finite()
@@ -558,9 +564,7 @@ fn alpha_beta(
 }
 
 fn drawdown_stats(nav: &[f64]) -> (f64, usize) {
-    // NAV is measured against the pre-period capital. The first real loss
+    let mut peak = 0.0_f64;
-    // must not become a new zero-drawdown baseline.
-    let mut peak = 1.0_f64;
     let mut max_drawdown = 0.0_f64;
     let mut duration = 0_usize;
     let mut max_duration = 0_usize;
@@ -769,28 +773,6 @@ fn safe_div(numerator: f64, denominator: f64, fallback: f64) -> f64 {
 mod tests {
     use super::*;
 
-    #[test]
-    fn drawdown_includes_initial_nav_without_adding_a_trading_day() {
-        let (drawdown, duration) = drawdown_stats(&[0.9, 0.99]);
-        assert!((drawdown + 0.1).abs() < 1e-12);
-        assert_eq!(duration, 2);
-        assert_eq!(drawdown_stats(&[1.0, 1.1, 1.1]), (0.0, 0));
-        assert_eq!(drawdown_stats(&[0.0]), (-1.0, 1));
-        assert_eq!(drawdown_stats(&[]), (0.0, 0));
-    }
-
-    #[test]
-    fn first_day_loss_is_preserved_in_shared_backtest_metrics() {
-        let curve = vec![
-            equity_point("2025-01-03", 99.16648349337, 98.81608059815, 100.0),
-            equity_point("2025-01-06", 99.68551588547, 98.65392198168, 98.81608059815),
-        ];
-        let metrics = compute_backtest_metrics(&curve, &[], &[], &[], 100.0, None).unwrap();
-        assert!((metrics.max_drawdown + 0.0083351650663).abs() < 1e-12);
-        assert_eq!(metrics.total_trade_days, 2);
-        assert_eq!(metrics.max_drawdown_duration_days, 2);
-    }
-
     fn equity_point(
         date: &str,
         total_equity: f64,
@@ -798,7 +780,6 @@ mod tests {
         benchmark_prev_close: f64,
     ) -> DailyEquityPoint {
         DailyEquityPoint {
-            signal_baseline: false,
             date: NaiveDate::parse_from_str(date, "%Y-%m-%d").unwrap(),
             cash: total_equity,
             market_value: 0.0,
@@ -823,21 +804,11 @@ mod tests {
         assert!((metrics.benchmark_cumulative_return - expected).abs() < 1e-12);
     }
 
-    #[test]
-    fn signal_baseline_uses_same_close_for_strategy_and_benchmark() {
-        let mut baseline=equity_point("2026-09-04",100.0,4548.0499,4552.5784);
-        baseline.signal_baseline=true;
-        let curve=vec![baseline,equity_point("2026-09-08",104.0,4558.7371,4575.0245)];
-        let metrics=compute_backtest_metrics(&curve,&[],&[],&[],100.0,None).unwrap();
-        assert!((metrics.benchmark_cumulative_return-(4558.7371/4548.0499-1.0)).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 {
-                signal_baseline: false,
                 date: NaiveDate::from_ymd_opt(2025, 1, 3).unwrap(),
                 cash: 220.0,
                 market_value: 0.0,

crates/fidc-core/src/pattern_context.rs

@@ -1,427 +0,0 @@
-//! Explicit reference identities and frozen rank universes shared by all daily runtimes.
-use crate::{
-    daily_patterns::{dataset_series, evaluate_with_context, PatternSpec, ResearchContext},
-    factor_events::{field_dependencies, Expr},
-    DataSet,
-};
-use chrono::NaiveDate;
-use serde::{Deserialize, Serialize};
-use serde_json::Value;
-use std::collections::{BTreeMap, BTreeSet};
-
-pub const CONTRACT: &str = "fidc_pattern_execution_context_v1";
-pub const CONTEXT_FIELDS: &[&str] = &[
-    "index_open",
-    "index_high",
-    "index_low",
-    "index_close",
-    "scope_rank",
-    "scope_percentile",
-    "scope_size",
-];
-const STOCK_FIELDS: &[&str] = &[
-    "open",
-    "high",
-    "low",
-    "close",
-    "volume",
-    "raw_open",
-    "raw_high",
-    "raw_low",
-    "raw_close",
-    "prev_close",
-    "amount",
-];
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct ExecutionContext {
-    pub contract: String,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub benchmark: Option<String>,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub rank_expression: Option<Expr>,
-    #[serde(default, skip_serializing_if = "Vec::is_empty")]
-    pub rank_universe: Vec<String>,
-}
-
-fn valid_symbol(s: &str) -> bool {
-    let Some((code, market)) = s.split_once('.') else {
-        return false;
-    };
-    code.len() == 6
-        && code.bytes().all(|c| c.is_ascii_digit())
-        && matches!(market, "SH" | "SZ" | "BJ" | "CSI")
-}
-
-impl ExecutionContext {
-    pub fn fields(&self, expression: &Expr) -> BTreeSet<String> {
-        let mut fields = field_dependencies(expression);
-        if let Some(rank) = &self.rank_expression {
-            fields.extend(field_dependencies(rank));
-        }
-        fields
-    }
-    pub fn validate(&self, expression: &Expr) -> Result<(), String> {
-        if self.contract != CONTRACT {
-            return Err("pattern_context_contract_invalid".into());
-        }
-        let needed = field_dependencies(expression);
-        let ranked = needed.iter().any(|f| f.starts_with("scope_"));
-        if ranked != self.rank_expression.is_some() || !ranked && !self.rank_universe.is_empty() {
-            return Err("pattern_rank_expression_and_universe_required".into());
-        }
-        if ranked
-            && (self.rank_universe.len() < 2
-                || self.rank_universe.len() > 20_000
-                || self.rank_universe.iter().any(|s| !valid_symbol(s))
-                || self.rank_universe.iter().collect::<BTreeSet<_>>().len()
-                    != self.rank_universe.len())
-        {
-            return Err("pattern_rank_universe_invalid".into());
-        }
-        if let Some(rank) = &self.rank_expression {
-            let fields = field_dependencies(rank);
-            if fields
-                .iter()
-                .any(|f| !STOCK_FIELDS.contains(&f.as_str()) && !f.starts_with("index_"))
-            {
-                return Err("pattern_rank_expression_invalid_or_recursive".into());
-            }
-        }
-        let fields = self.fields(expression);
-        if fields
-            .iter()
-            .any(|f| !STOCK_FIELDS.contains(&f.as_str()) && !CONTEXT_FIELDS.contains(&f.as_str()))
-        {
-            return Err("pattern_context_unmapped_field".into());
-        }
-        let index = fields.iter().any(|f| f.starts_with("index_"));
-        if index != self.benchmark.is_some()
-            || self
-                .benchmark
-                .as_ref()
-                .is_some_and(|s| !valid_symbol(s) || s.ends_with(".BJ"))
-        {
-            return Err("pattern_reference_index_required".into());
-        }
-        if !index && !ranked {
-            return Err("pattern_unused_context".into());
-        }
-        Ok(())
-    }
-}
-
-pub fn build_dataset_context(
-    spec: &PatternSpec,
-    data: &DataSet,
-    date: NaiveDate,
-) -> Result<ResearchContext, String> {
-    let Some(config) = &spec.execution_context else {
-        return Ok(ResearchContext::default());
-    };
-    config.validate(
-        spec.expression
-            .as_ref()
-            .ok_or("pattern_context_requires_expression")?,
-    )?;
-    let days = data.calendar().trailing_days(date, spec.history_len());
-    if days.len() != spec.history_len() || days.last() != Some(&date) {
-        return Err("pattern_context_calendar_incomplete".into());
-    }
-    let needed = config.fields(spec.expression.as_ref().unwrap());
-    let mut context = ResearchContext::default();
-    if let Some(symbol) = &config.benchmark {
-        for name in needed.iter().filter(|f| f.starts_with("index_")) {
-            let values = days
-                .iter()
-                .map(|d| {
-                    let value = if let Some(b) = data.market(*d, symbol) {
-                        match name.as_str() {
-                            "index_open" => Some(b.open),
-                            "index_high" => Some(b.high),
-                            "index_low" => Some(b.low),
-                            "index_close" => Some(b.close),
-                            _ => None,
-                        }
-                    } else if let Some(b) = data.benchmark(*d).filter(|b| &b.benchmark == symbol) {
-                        match name.as_str() {
-                            "index_open" => Some(b.open),
-                            "index_close" => Some(b.close),
-                            _ => None,
-                        }
-                    } else {
-                        None
-                    };
-                    value
-                        .filter(|v| v.is_finite() && *v > 0.0)
-                        .map(Some)
-                        .ok_or_else(|| format!("pattern_reference_missing: {symbol} {d} {name}"))
-                })
-                .collect::<Result<Vec<_>, _>>()?;
-            context.common.insert(name.clone(), values);
-        }
-    }
-    if let Some(expression) = &config.rank_expression {
-        let mut input = spec.clone();
-        input.execution_context = None;
-        input.expression = Some(expression.clone());
-        let mut values = BTreeMap::new();
-        for symbol in &config.rank_universe {
-            let row = evaluate_with_context(
-                &input,
-                &days,
-                &dataset_series(data, &days, symbol),
-                &context.common,
-                true,
-            )?;
-            if let Some(reason) = row.exclusion {
-                return Err(format!("pattern_rank_member_incomplete: {symbol} {reason}"));
-            }
-            values.insert(
-                symbol.clone(),
-                serde_json::from_value::<Vec<Option<f64>>>(
-                    row.values["expression"]["values"].clone(),
-                )
-                .map_err(|e| e.to_string())?,
-            );
-        }
-        let ranks =
-            crate::factor_cross_section::rank_history(&days, &config.rank_universe, &values)?;
-        for symbol in &config.rank_universe {
-            let decode = |value: &Value| {
-                serde_json::from_value::<Vec<Option<f64>>>(value.clone()).map_err(|e| e.to_string())
-            };
-            context.by_symbol.insert(
-                symbol.clone(),
-                BTreeMap::from([
-                    ("scope_rank".into(), decode(&ranks["rank"][symbol])?),
-                    (
-                        "scope_percentile".into(),
-                        decode(&ranks["percentile"][symbol])?,
-                    ),
-                    (
-                        "scope_size".into(),
-                        vec![Some(config.rank_universe.len() as f64); days.len()],
-                    ),
-                ]),
-            );
-        }
-    }
-    Ok(context)
-}
-
-pub fn specs_in_value(value: &Value) -> Result<Vec<PatternSpec>, String> {
-    let mut specs = Vec::new();
-    match value {
-        Value::String(text) => specs.extend(crate::daily_patterns::expression_specs(text)?),
-        Value::Array(items) => {
-            for v in items {
-                specs.extend(specs_in_value(v)?);
-            }
-        }
-        Value::Object(items) => {
-            for v in items.values() {
-                specs.extend(specs_in_value(v)?);
-            }
-        }
-        _ => {}
-    }
-    Ok(specs)
-}
-
-pub fn required_symbols(value: &Value) -> Result<(BTreeSet<String>, BTreeSet<String>), String> {
-    let (mut indices, mut stocks) = (BTreeSet::new(), BTreeSet::new());
-    for spec in specs_in_value(value)? {
-        if let Some(context) = spec.execution_context {
-            if let Some(index) = context.benchmark {
-                indices.insert(index);
-            }
-            stocks.extend(context.rank_universe);
-        }
-    }
-    Ok((indices, stocks))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{BenchmarkSnapshot, DailyFactorSnapshot, DailyMarketSnapshot, Instrument};
-    use serde_json::json;
-    #[test]
-    fn normalized_rule_does_not_turn_an_omitted_window_into_explicit_null() {
-        let expression:Expr=serde_json::from_value(json!({"kind":"operator","name":"GT","args":[{"kind":"field","name":"close"},{"kind":"number","value":1}]})).unwrap();
-        assert!(serde_json::to_value(expression).unwrap().get("window").is_none());
-    }
-    fn data(future: bool, reference: bool) -> DataSet {
-        let mut days = vec![
-            NaiveDate::from_ymd_opt(2026, 9, 4).unwrap(),
-            NaiveDate::from_ymd_opt(2026, 9, 7).unwrap(),
-            NaiveDate::from_ymd_opt(2026, 9, 8).unwrap(),
-        ];
-        if future {
-            days.push(NaiveDate::from_ymd_opt(2026, 9, 9).unwrap());
-        }
-        let symbols = vec!["000001.SZ", "000002.SZ", "000003.SZ"];
-        let mut instruments = symbols
-            .iter()
-            .map(|s| Instrument {
-                symbol: s.to_string(),
-                name: s.to_string(),
-                board: "SZ_MAIN".into(),
-                round_lot: 100,
-                listed_at: None,
-                delisted_at: None,
-                status: "active".into(),
-            })
-            .collect::<Vec<_>>();
-        if reference {
-            instruments.push(Instrument {
-                symbol: "399006.SZ".into(),
-                name: "reference".into(),
-                board: "INDEX".into(),
-                round_lot: 1,
-                listed_at: None,
-                delisted_at: None,
-                status: "active".into(),
-            });
-        }
-        let mut market = vec![];
-        let mut factors = vec![];
-        let mut benchmark = vec![];
-        for (i, d) in days.iter().enumerate() {
-            for (n, s) in symbols.iter().enumerate() {
-                let c = [
-                    [10., 12., 11., 1000.],
-                    [10., 11., 12., 1.],
-                    [10., 10., 13., 1.],
-                ][n][i];
-                market.push(DailyMarketSnapshot {
-                    date: *d,
-                    symbol: s.to_string(),
-                    timestamp: None,
-                    day_open: c,
-                    open: c,
-                    high: c,
-                    low: c,
-                    close: c,
-                    last_price: c,
-                    bid1: c,
-                    ask1: c,
-                    prev_close: 10.,
-                    volume: 100000,
-                    minute_volume: 0,
-                    bid1_volume: 10000,
-                    ask1_volume: 10000,
-                    trading_phase: None,
-                    paused: false,
-                    upper_limit: c * 2.,
-                    lower_limit: c / 2.,
-                    price_tick: 0.01,
-                });
-                factors.push(DailyFactorSnapshot {
-                    date: *d,
-                    symbol: s.to_string(),
-                    market_cap_bn: 1.,
-                    free_float_cap_bn: 1.,
-                    pe_ttm: 10.,
-                    turnover_ratio: None,
-                    effective_turnover_ratio: None,
-                    adjustment_factor_backward1: Some(1.),
-                    extra_factors: Default::default(),
-                });
-            }
-            if reference {
-                let mut row = market.last().unwrap().clone();
-                row.symbol = "399006.SZ".into();
-                row.open = 30.;
-                row.high = 30.;
-                row.low = 30.;
-                row.close = 30.;
-                market.push(row);
-            }
-            benchmark.push(BenchmarkSnapshot {
-                date: *d,
-                benchmark: "000300.SH".into(),
-                open: 4000.,
-                close: 4000.,
-                prev_close: 4000.,
-                volume: 1000,
-            });
-        }
-        DataSet::from_components(instruments, market, factors, vec![], benchmark).unwrap()
-    }
-    fn spec(rank: bool) -> PatternSpec {
-        let expression = if rank {
-            json!({"kind":"operator","name":"GT","args":[{"kind":"field","name":"scope_rank"},{"kind":"number","value":2}]})
-        } else {
-            json!({"kind":"operator","name":"LT","args":[{"kind":"field","name":"index_close"},{"kind":"number","value":100}]})
-        };
-        let context = if rank {
-            json!({"contract":CONTRACT,"rank_expression":{"kind":"operator","name":"PCT_CHANGE","window":1,"args":[{"kind":"field","name":"close"}]},"rank_universe":["000001.SZ","000002.SZ","000003.SZ"]})
-        } else {
-            json!({"contract":CONTRACT,"benchmark":"399006.SZ"})
-        };
-        serde_json::from_value::<PatternSpec>(json!({"template":"expression","parameters":{"history_window":3},"expression":expression,"execution_context":context})).unwrap().validate().unwrap()
-    }
-    #[test]
-    fn dataset_rank_is_full_scope_causal_and_equal_to_pure_cross_section() {
-        let spec = spec(true);
-        let date = NaiveDate::from_ymd_opt(2026, 9, 8).unwrap();
-        let original = build_dataset_context(&spec, &data(false, true), date).unwrap();
-        let future = build_dataset_context(&spec, &data(true, true), date).unwrap();
-        assert_eq!(original.by_symbol, future.by_symbol);
-        assert_eq!(original.by_symbol["000001.SZ"]["scope_rank"][2], Some(3.));
-        assert_eq!(original.by_symbol["000002.SZ"]["scope_rank"][2], Some(2.));
-        assert_eq!(original.by_symbol["000003.SZ"]["scope_rank"][2], Some(1.));
-        assert!(
-            crate::daily_patterns::evaluate_dataset(&spec, &data(false, true), date, "000001.SZ")
-                .unwrap()
-                .matched
-        );
-        let mut incomplete = data(false, true).snapshot_components();
-        incomplete.market.retain(|r| r.symbol != "000003.SZ");
-        let broken = DataSet::from_components(
-            incomplete.instruments,
-            incomplete.market,
-            incomplete.factors,
-            incomplete.candidates,
-            incomplete.benchmarks,
-        )
-        .unwrap();
-        assert!(build_dataset_context(&spec, &broken, date).is_err());
-    }
-    #[test]
-    fn reference_index_never_defaults_to_performance_benchmark() {
-        let spec = spec(false);
-        let date = NaiveDate::from_ymd_opt(2026, 9, 8).unwrap();
-        assert!(
-            crate::daily_patterns::evaluate_dataset(&spec, &data(false, true), date, "000001.SZ")
-                .unwrap()
-                .matched
-        );
-        assert!(build_dataset_context(&spec, &data(false, false), date)
-            .unwrap_err()
-            .contains("399006.SZ"));
-    }
-    #[test]
-    fn runtime_contract_rejects_missing_range_and_recursive_ranks() {
-        let mut missing = spec(true);
-        missing
-            .execution_context
-            .as_mut()
-            .unwrap()
-            .rank_universe
-            .clear();
-        assert!(missing.validate().is_err());
-        let mut recursive = spec(true);
-        recursive
-            .execution_context
-            .as_mut()
-            .unwrap()
-            .rank_expression = Some(Expr::Field {
-            name: "scope_rank".into(),
-        });
-        assert!(recursive.validate().is_err());
-    }
-}

crates/fidc-core/src/platform_runtime_schema.rs

@@ -227,8 +227,6 @@ const RUNTIME_HELPER_FUNCTIONS: &[&str] = &[
     "factor",
     "day_factor",
     "rolling_mean",
-    "pattern_signal",
-    "pattern_score",
     "rolling_mean_current",
     "rolling_max_current",
     "rolling_return_stddev_current",

crates/fidc-core/src/platform_stock_pool.rs

@@ -1,236 +0,0 @@
-//! Stock pools emit one frozen framework intent, not a lossy code-strategy translation.
-use super::*;
-use crate::stock_pool_execution as pool;
-use rust_decimal::Decimal;
-
-impl PlatformExprStrategy {
-    pub(super) fn stock_pool_decision(
-        &mut self,
-        ctx: &StrategyContext<'_>,
-    ) -> Result<StrategyDecision, BacktestError> {
-        let program = self
-            .config
-            .stock_pool
-            .as_ref()
-            .ok_or_else(|| BacktestError::Execution("stock_pool_program_missing".into()))?
-            .clone();
-        let mut constraints = pool::stock_pool_constraints_from_configuration(
-            &program.allocation_policy,
-            &program.stop_take_policy,
-        )
-        .map_err(BacktestError::Execution)?;
-        if let Some(policy) = constraints
-            .market_timing_policy
-            .as_ref()
-            .filter(|policy| policy.enabled)
-        {
-            let before_close = !ctx.is_lagged_execution()
-                && ctx
-                    .active_datetime
-                    .is_some_and(|at| at.time() < NaiveTime::from_hms_opt(15, 0, 0).unwrap());
-            let as_of = if before_close {
-                ctx.data
-                    .previous_trading_date(ctx.decision_date, 1)
-                    .ok_or_else(|| {
-                        BacktestError::Execution(
-                            "market_timing_previous_completed_session_missing".into(),
-                        )
-                    })?
-            } else {
-                ctx.decision_date
-            };
-            let required = policy
-                .required_history()
-                .map_err(BacktestError::Execution)?;
-            let mut dates = ctx
-                .data
-                .calendar()
-                .iter()
-                .filter(|date| *date <= as_of)
-                .collect::<Vec<_>>();
-            if dates.len() < required {
-                return Err(BacktestError::Execution(format!(
-                    "market_timing_official_calendar_incomplete:required={required}:available={}",
-                    dates.len()
-                )));
-            }
-            dates = dates.split_off(dates.len() - required);
-            let index = policy.index_code.as_ref().expect("validated index policy");
-            let closes = dates
-                .iter()
-                .map(|date| {
-                    let row = ctx.data.market(*date, index).ok_or_else(|| {
-                        BacktestError::Execution(format!(
-                            "market_timing_completed_index_row_missing:{index}:{date}"
-                        ))
-                    })?;
-                    Ok(crate::stock_pool_index_policy::IndexClose {
-                        date: *date,
-                        close: row.close,
-                    })
-                })
-                .collect::<Result<Vec<_>, BacktestError>>()?;
-            constraints.market_timing_input =
-                Some(crate::stock_pool_index_policy::MarketTimingInput {
-                    index_code: index.clone(),
-                    as_of_date: as_of,
-                    official_dates: dates,
-                    closes,
-                });
-        }
-        let rule = pool::normalize_stock_pool_execution_rule(
-            Some(&program.timing_policy),
-            !self.config.buy_filter_expr.trim().is_empty(),
-            !self.config.stop_loss_expr.trim().is_empty()
-                || !self.config.take_profit_expr.trim().is_empty()
-                || !self.config.position_target_rules.is_empty(),
-        )
-        .map_err(BacktestError::Execution)?;
-        if self.config.in_skip_window(ctx.decision_date) {
-            return Ok(StrategyDecision::default());
-        }
-        let day = self.day_state(ctx, ctx.decision_date)?;
-        let (market_date, universe_date, factor_date) = self.selection_dates(ctx);
-        let (low, high) = self.market_cap_band(ctx, &day)?;
-        let (ranked, mut diagnostics, risk_decisions) = self.select_symbols(
-            ctx,
-            market_date,
-            universe_date,
-            factor_date,
-            &day,
-            low,
-            high,
-            usize::MAX,
-        )?;
-        let held = ctx
-            .portfolio
-            .positions()
-            .values()
-            .filter(|p| p.quantity > 0)
-            .map(|p| p.symbol.clone())
-            .collect::<BTreeSet<_>>();
-        if !self.config.buy_filter_expr.trim().is_empty() {
-            for symbol in &ranked {
-                let stock =
-                    self.stock_state_with_factor_date(ctx, market_date, factor_date, symbol)?;
-                if !self.eval_bool(ctx, &self.config.buy_filter_expr, &day, Some(&stock), None)? {
-                    constraints
-                        .buy_denials
-                        .insert(symbol.clone(), vec!["frozen_buy_condition_not_met".into()]);
-                }
-            }
-        }
-        let native_exits = self.current_stop_take_exit_symbols(ctx, ctx.decision_date, &day)?;
-        for symbol in native_exits {
-            constraints.position_target_bps.insert(symbol, 0);
-        }
-        for (symbol, (bps, _)) in
-            self.current_position_target_rules(ctx, ctx.decision_date, factor_date, &day)?
-        {
-            constraints
-                .position_target_bps
-                .entry(symbol)
-                .and_modify(|old| *old = (*old).min(bps))
-                .or_insert(bps);
-        }
-        let limit = constraints.target_holding_count.unwrap_or(ranked.len());
-        let final_symbols = ranked
-            .iter()
-            .filter(|symbol| !constraints.position_target_bps.contains_key(*symbol))
-            .take(limit)
-            .cloned()
-            .collect();
-        let generation = format!(
-            "stock-pool:{}:{}:{}",
-            program.pool_id,
-            program.version_id,
-            ctx.active_datetime
-                .map(|date| date.to_string())
-                .unwrap_or_else(|| ctx.decision_date.to_string())
-        );
-        let selection = pool::StockPoolSelection {
-            trade_date: ctx.decision_date,
-            requested_symbols: ranked.clone(),
-            normal_trading_symbols: ranked.clone(),
-            risk_eligible_symbols: ranked.clone(),
-            final_symbols,
-            exclusion_reasons: BTreeMap::new(),
-            inherited_from_generation: None,
-            explicit_empty: program.members.is_empty()
-                && self.config.candidate_symbols_by_date.is_empty(),
-            generation: Some(generation.clone()),
-        };
-        let by_symbol = program
-            .members
-            .iter()
-            .map(|member| (member.symbol.as_str(), member))
-            .collect::<BTreeMap<_, _>>();
-        let mut scope = ranked.clone();
-        // Kept rules are execution metadata, not additional selection candidates.
-        for symbol in held {
-            if by_symbol.contains_key(symbol.as_str()) && !scope.contains(&symbol) {
-                scope.push(symbol)
-            }
-        }
-        let members = scope
-            .iter()
-            .enumerate()
-            .map(|(index, symbol)| {
-                let mut member = by_symbol
-                    .get(symbol.as_str())
-                    .map(|member| (*member).clone())
-                    .unwrap_or_else(|| pool::StockPoolMemberSpec {
-                        symbol: symbol.clone(),
-                        requested_order: index as i32,
-                        recommendation_reason: String::new(),
-                        target_weight_bps: None,
-                        stop_loss: constraints.default_stop_loss,
-                        take_profit: constraints.default_take_profit,
-                    });
-                member.requested_order = index as i32;
-                member
-            })
-            .collect();
-        let (base_ratio, reserve_cash) =
-            pool::stock_pool_funding_from_configuration(&program.allocation_policy)
-                .map_err(BacktestError::Execution)?;
-        let ratio = self
-            .config
-            .position_exposure_schedule
-            .range(..=ctx.decision_date)
-            .next_back()
-            .map(|(_, value)| (*value * 10000.).round() as i64)
-            .unwrap_or(i64::from(base_ratio));
-        let invest_ratio_bps = i32::try_from(ratio)
-            .ok()
-            .filter(|ratio| (0..=10000).contains(ratio))
-            .ok_or_else(|| BacktestError::Execution("stock_pool_invest_ratio_invalid".into()))?;
-        let signal_equity =
-            self.signal_visible_total_value(ctx, ctx.decision_date, ctx.is_lagged_execution());
-        let frozen_equity = signal_equity
-            .to_string()
-            .parse::<Decimal>()
-            .map_err(|_| BacktestError::Execution("stock_pool_signal_equity_invalid".into()))?;
-        diagnostics.push(format!("stock_pool_signal_frozen generation={generation} candidate_count={} frozen_equity={frozen_equity}",ranked.len()));
-        Ok(StrategyDecision {
-            order_intents: vec![OrderIntent::StockPool {
-                contract: Box::new(pool::FrozenStockPoolIntent {
-                    pool_id:program.pool_id.clone(),
-                    signal_date: ctx.decision_date,
-                    frozen_equity,
-                    selection,
-                    members,
-                    rule,
-                    constraints,
-                    invest_ratio_bps,
-                    reserve_cash,
-                    out_of_pool_policy: program.out_of_pool_policy,
-                    generation,
-                }),
-            }],
-            diagnostics,
-            risk_decisions,
-            ..Default::default()
-        })
-    }
-}

crates/fidc-core/src/platform_strategy_spec.rs

@@ -17,12 +17,6 @@ use crate::{
 #[derive(Debug, Clone, Default, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct StrategyRuntimeSpec {
-    #[serde(default,alias="stock_pool")]
-    pub stock_pool:Option<crate::stock_pool_execution::StockPoolProgram>,
-    #[serde(default)]
-    pub signal_book: Option<crate::signal_contract::SignalBook>,
-    #[serde(default)]
-    pub signal_book_ref: Option<crate::signal_contract::SignalBookReference>,
     #[serde(default, alias = "strategy_id")]
     pub strategy_id: Option<String>,
     #[serde(default)]
@@ -650,7 +644,7 @@ fn normalize_risk_policy_aliases_in_value(value: &mut Value) -> Result<(), Strin
 /// contract can legitimately arrive with both spellings.  Canonicalise those
 /// pairs once at the boundary, while rejecting conflicting values instead of
 /// silently choosing one.
-pub fn normalize_strategy_aliases_in_value(value: &mut Value) -> Result<(), String> {
+fn normalize_strategy_aliases_in_value(value: &mut Value) -> Result<(), String> {
     normalize_strategy_aliases_in_value_inner(value, false)
 }
 
@@ -666,7 +660,7 @@ fn normalize_strategy_aliases_in_value_inner(
             for (key, child) in object.iter_mut() {
                 normalize_strategy_aliases_in_value_inner(
                     child,
-                    in_risk_policy || matches!(key.as_str(), "riskPolicy" | "risk_policy" | "automaticTradeProtection" | "automatic_trade_protection"),
+                    in_risk_policy || matches!(key.as_str(), "riskPolicy" | "risk_policy"),
                 )?;
             }
         }
@@ -681,14 +675,11 @@ fn normalize_strategy_aliases_in_value_inner(
 }
 
 const STRATEGY_ALIAS_GROUPS: &[(&str, &[&str])] = &[
-    ("signalBook", &["signal_book"]),
-    ("signalBookRef", &["signal_book_ref"]),
     ("strategyId", &["strategy_id"]),
     ("tradeTimes", &["trade_times"]),
     ("signalSymbol", &["signal_symbol"]),
     ("engineConfig", &["engine_config"]),
     ("runtimeExpressions", &["runtime_expressions"]),
-    ("automaticTradeProtection", &["automatic_trade_protection"]),
     ("rebalanceSchedule", &["rebalance_schedule"]),
     ("skipWindows", &["skip_windows"]),
     ("dynamicRange", &["dynamic_range"]),
@@ -723,8 +714,10 @@ const STRATEGY_ALIAS_GROUPS: &[(&str, &[&str])] = &[
     ),
     ("stampTaxRateAfterChange", &["stamp_tax_rate_after_change"]),
     ("stampTaxChangeDate", &["stamp_tax_change_date"]),
-    ("volumeLimit", &["volume_limit", "volumeLimitEnabled", "volume_limit_enabled"]),
+    ("volumeLimit", &["volume_limit"]),
-    ("liquidityLimit", &["liquidity_limit", "liquidityLimitEnabled", "liquidity_limit_enabled"]),
+    ("volumeLimitEnabled", &["volume_limit_enabled"]),
+    ("liquidityLimit", &["liquidity_limit"]),
+    ("liquidityLimitEnabled", &["liquidity_limit_enabled"]),
     ("volumePercent", &["volume_percent"]),
     ("riskPolicy", &["risk_policy"]),
     ("strictValueBudget", &["strict_value_budget"]),
@@ -748,16 +741,6 @@ fn strategy_alias_values_semantically_equal(left: &Value, right: &Value) -> bool
         return true;
     }
     match (left, right) {
-        (Value::Number(left), Value::Number(right)) => {
-            const MAX_EXACT: i64 = 9_007_199_254_740_992;
-            let exact_integer = |value: &serde_json::Number| {
-                value.as_i64().filter(|v| (-MAX_EXACT..=MAX_EXACT).contains(v)).map(|v| v as f64)
-                    .or_else(|| value.as_u64().filter(|v| *v <= MAX_EXACT as u64).map(|v| v as f64))
-            };
-            if left.is_f64() && !right.is_f64() { exact_integer(right).zip(left.as_f64()).is_some_and(|(a,b)| a==b) }
-            else if right.is_f64() && !left.is_f64() { exact_integer(left).zip(right.as_f64()).is_some_and(|(a,b)| a==b) }
-            else { false }
-        }
         (Value::String(left), Value::String(right)) => left.trim() == right.trim(),
         (Value::String(left), Value::Number(right))
         | (Value::Number(right), Value::String(left)) => left
@@ -914,10 +897,6 @@ pub struct StrategyExpressionSelectionConfig {
     pub current_day_precomputed_factors: Option<bool>,
     #[serde(default, alias = "candidate_symbols_by_date")]
     pub candidate_symbols_by_date: BTreeMap<String, Vec<String>>,
-    #[serde(default, alias = "preserve_candidate_order")]
-    pub preserve_candidate_order: bool,
-    #[serde(default, alias = "candidate_source_book")]
-    pub candidate_source_book: Option<crate::stock_pool_candidates::CandidateSourceBook>,
 }
 
 #[derive(Debug, Clone, Default, Deserialize, Serialize)]
@@ -1011,8 +990,6 @@ pub struct StrategyExpressionOrderingConfig {
 #[derive(Debug, Clone, Default, Deserialize, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct StrategyExpressionTradingConfig {
-    #[serde(default, alias = "automatic_trade_protection")]
-    pub automatic_trade_protection: Option<crate::holding_policy::AutomaticTradeProtection>,
     #[serde(default, alias = "buy_filter_expr")]
     pub buy_filter_expr: Option<String>,
     #[serde(default)]
@@ -1534,6 +1511,7 @@ fn normalize_slippage_model_name(value: &str) -> String {
         | "price_rate"
         | "price_ratio_slippage"
         | "priceratioslippage" => "price_ratio".to_string(),
+        "dynamic_volume_volatility" => "dynamic".to_string(),
         other => other.to_string(),
     }
 }
@@ -1578,13 +1556,11 @@ fn parse_slippage_model(
     impact_coefficient: Option<f64>,
     volatility_coefficient: Option<f64>,
     max_value: Option<f64>,
-) -> Result<SlippageModel, String> {
+) -> Option<SlippageModel> {
-    for (name, parameter) in [("slippageValue", value), ("slippageImpactCoefficient", impact_coefficient),
+    let value = valid_non_negative(value);
-        ("slippageVolatilityCoefficient", volatility_coefficient), ("slippageMaxValue", max_value)] {
+    let impact_coefficient = valid_non_negative(impact_coefficient);
-        if parameter.is_some_and(|number| !number.is_finite() || number < 0.0) {
+    let volatility_coefficient = valid_non_negative(volatility_coefficient);
-            return Err(format!("{name} must be finite and non-negative"));
+    let max_value = valid_non_negative(max_value);
-        }
-    }
     let model = model
         .map(normalize_slippage_model_name)
         .filter(|item| !item.is_empty())
@@ -1597,23 +1573,16 @@ fn parse_slippage_model(
         });
 
     match model.as_str() {
-        "none" => Ok(SlippageModel::None),
+        "none" => Some(SlippageModel::None),
-        "price_ratio" => Ok(SlippageModel::PriceRatio(value.unwrap_or(0.0))),
+        "price_ratio" => Some(SlippageModel::PriceRatio(value.unwrap_or(0.0))),
-        "tick_size" => Ok(SlippageModel::TickSize(value.unwrap_or(0.0))),
+        "tick_size" => Some(SlippageModel::TickSize(value.unwrap_or(0.0))),
-        "limit_price" => Ok(SlippageModel::LimitPrice),
+        "limit_price" => Some(SlippageModel::LimitPrice),
-        "historical_volume_volatility" => {
+        "dynamic" => Some(SlippageModel::Dynamic(DynamicSlippageConfig::new(
-            let max_ratio = max_value.or(value).unwrap_or(0.01);
+            impact_coefficient.unwrap_or(0.5),
-            if max_ratio >= 1.0 {
+            volatility_coefficient.unwrap_or(0.3),
-                return Err("historical slippage maximum must be less than 1".into());
+            max_value.or(value).unwrap_or(0.01),
-            }
+        ))),
-            Ok(SlippageModel::HistoricalVolumeVolatility(DynamicSlippageConfig::new(
+        _ => None,
-                impact_coefficient.unwrap_or(0.5), volatility_coefficient.unwrap_or(0.3), max_ratio,
-            )))
-        },
-        "dynamic" | "dynamic_volume_volatility" => Err(
-            "retired_slippage_model: dynamic used unfinished daily data; explicitly select historical_volume_volatility or another supported model".into()
-        ),
-        _ => Err(format!("unsupported slippageModel: {model}")),
     }
 }
 
@@ -1644,19 +1613,20 @@ fn apply_execution_behavior_overrides(
         || slippage_volatility_coefficient.is_some()
         || slippage_max_value.is_some()
     {
-        cfg.slippage_model = parse_slippage_model(
+        if let Some(parsed) = parse_slippage_model(
             slippage_model,
             slippage_value,
             slippage_impact_coefficient,
             slippage_volatility_coefficient,
             slippage_max_value,
-        )?;
+        ) {
+            cfg.slippage_model = parsed;
+        }
     }
     if strict_value_budget == Some(false) {
         return Err("strictValueBudget=false is not supported".to_string());
     }
     cfg.strict_value_budget = true;
-
     if let Some(rate) = sell_then_buy_delay_slippage_rate {
         if !rate.is_finite() || !(0.0..1.0).contains(&rate) {
             return Err(
@@ -2140,29 +2110,12 @@ pub fn platform_expr_config_from_spec(
             if let Some(enabled) = selection.current_day_precomputed_factors {
                 cfg.current_day_precomputed_factors = enabled;
             }
-            if selection.preserve_candidate_order && selection.candidate_symbols_by_date.is_empty() {
-                return Err("preserveCandidateOrder requires a dated candidate book".to_string());
-            }
-            if let Some(book) = &selection.candidate_source_book {
-                if !selection.preserve_candidate_order {
-                    return Err("candidateSourceBook requires preserveCandidateOrder=true".into());
-                }
-                let expected = book.resolved_symbols()?.into_iter()
-                    .map(|(date, symbols)| (date.to_string(), symbols)).collect::<BTreeMap<_, _>>();
-                if expected != selection.candidate_symbols_by_date {
-                    return Err("candidateSourceBook differs from resolved candidateSymbolsByDate".into());
-                }
-                if cfg.selection_limit_expr.trim() == "pool_candidate_count" {
-                    cfg.max_positions = expected.values().map(Vec::len).max().unwrap_or(0).max(1);
-                }
-            }
             for (raw_date, raw_symbols) in &selection.candidate_symbols_by_date {
                 let trade_date = NaiveDate::parse_from_str(raw_date, "%Y-%m-%d").map_err(|_| {
                     format!("candidateSymbolsByDate contains invalid date: {raw_date}")
                 })?;
                 let mut symbols = BTreeSet::new();
-                let mut order = BTreeMap::new();
+                for raw_symbol in raw_symbols {
-                for (index, raw_symbol) in raw_symbols.iter().enumerate() {
                     let symbol = normalize_symbol(raw_symbol, None);
                     let valid = symbol.rsplit_once('.').is_some_and(|(code, exchange)| {
                         code.len() == 6
@@ -2179,12 +2132,8 @@ pub fn platform_expr_config_from_spec(
                             "candidateSymbolsByDate contains duplicate date/symbol: {raw_date} {symbol}"
                         ));
                     }
-                    order.insert(symbol, index);
                 }
                 cfg.candidate_symbols_by_date.insert(trade_date, symbols);
-                if selection.preserve_candidate_order {
-                    cfg.candidate_order_by_date.insert(trade_date, order);
-                }
             }
         }
         if let Some(allocation) = runtime_expr.allocation.as_ref()
@@ -2367,10 +2316,6 @@ pub fn platform_expr_config_from_spec(
             }
         }
         if let Some(trading) = runtime_expr.trading.as_ref() {
-            if let Some(policy) = &trading.automatic_trade_protection {
-                policy.validate()?;
-                cfg.automatic_trade_protection = policy.clone();
-            }
             if let Some(expr) = trading.buy_filter_expr.as_ref() {
                 cfg.buy_filter_expr = expr.clone();
             }
@@ -2593,10 +2538,6 @@ pub fn platform_expr_config_from_spec(
         cfg.benchmark_symbol = normalize_symbol(&cfg.benchmark_symbol, None);
     }
     let trade_times = spec_trade_times(spec);
-    if crate::pattern_context::specs_in_value(&serde_json::to_value(spec).map_err(|e|e.to_string())?)?.iter().any(|p|p.template=="session_event") {
-        if trade_times.is_empty() {return Err("session_event_requires_explicit_trade_times".into());}
-        cfg.session_event_times=trade_times.clone();
-    }
     let explicit_trading_schedule = spec
         .runtime_expressions
         .as_ref()
@@ -2654,57 +2595,6 @@ pub fn platform_expr_config_from_spec(
     }
     cfg.strict_value_budget = true;
 
-    if spec.runtime_expressions.as_ref().and_then(|runtime| runtime.selection.as_ref())
-        .is_some_and(|selection| selection.candidate_source_book.is_some())
-        && (cfg.matching_type != MatchingType::NextBarOpen || !cfg.current_day_precomputed_factors) {
-        return Err("daily candidate source book requires completed signal-day factors and next_bar_open".into());
-    }
-
-    let signal_book = match (&spec.signal_book,&spec.signal_book_ref) {
-        (Some(_),Some(_)) => return Err("inline_and_registered_signal_book_are_mutually_exclusive".into()),
-        (Some(raw),None) => Some(std::sync::Arc::new(raw.clone().validate()?)),
-        (None,Some(reference)) => crate::signal_contract::cached_signal_book(reference)?,
-        (None,None) => None,
-    };
-    if let Some(book) = signal_book {
-        if cfg.explicit_actions.len() != 1 || !matches!(cfg.explicit_actions[0], PlatformTradeAction::ConsumeSignal) {
-            return Err("signal_book_requires_one_consume_signal_action".into());
-        }
-        if !cfg.signal_rebalance_dates.is_empty() && cfg.signal_rebalance_dates != book.decision_dates() {
-            return Err("signal_book_schedule_does_not_match_strategy".into());
-        }
-        cfg.rotation_enabled = false;
-        cfg.signal_rebalance_dates = book.decision_dates();
-        cfg.initial_subscriptions.extend(book.symbols());
-        cfg.signal_book = Some(book);
-    } else if spec.signal_book_ref.is_some() {
-        if cfg.explicit_actions.len()!=1 || !matches!(cfg.explicit_actions[0],PlatformTradeAction::ConsumeSignal) {
-            return Err("signal_book_requires_one_consume_signal_action".into());
-        }
-        cfg.rotation_enabled=false;
-    } else if cfg.explicit_actions.iter().any(|action| matches!(action, PlatformTradeAction::ConsumeSignal)) {
-        return Err("consume_signal_requires_verified_signal_book".into());
-    }
-
-    let has_automatic_policy = spec.runtime_expressions.as_ref().and_then(|runtime| runtime.trading.as_ref()).is_some_and(|trading| trading.automatic_trade_protection.is_some());
-    if has_automatic_policy {
-        let limit = i64::from(cfg.automatic_trade_protection.max_holding_days);
-        if cfg.max_holding_days.is_some_and(|previous| previous != limit) {
-            return Err("conflicting maximum holding policies".into());
-        }
-        cfg.max_holding_days = (limit > 0).then_some(limit);
-    }
-    if let Some(pool)=&spec.stock_pool {
-        if cfg.signal_book.is_some() || spec.signal_book_ref.is_some() || !cfg.explicit_actions.is_empty(){return Err("stock_pool_program_cannot_mix_other_order_programs".into())}
-        let secondary_buy=!cfg.buy_filter_expr.trim().is_empty();
-        let secondary_sell=spec.runtime_expressions.as_ref().and_then(|runtime|runtime.risk.as_ref()).is_some_and(|risk|risk.stop_loss_expr.is_some()||risk.take_profit_expr.is_some()) || !cfg.position_target_rules.is_empty();
-        pool.validate(secondary_buy,secondary_sell)?;
-        cfg.stock_pool=Some(pool.clone());
-        cfg.hold_until_exit_enabled=false;
-        cfg.daily_top_up_enabled=false;
-        cfg.daily_position_target_adjust_enabled=false;
-        cfg.target_portfolio_daily_enabled=false;
-    }
     Ok(cfg)
 }
 
@@ -2857,7 +2747,6 @@ fn parse_platform_trade_action(
         None => None,
     };
     match kind.as_str() {
-        "consume_signal" if when_expr.is_none() && time_in_force.is_none() => Some(PlatformTradeAction::ConsumeSignal),
         "target_portfolio_smart" => Some(PlatformTradeAction::TargetPortfolioSmart {
             target_weights_expr: action
                 .target_weights_expr
@@ -3256,16 +3145,6 @@ fn normalize_board(symbol: &str, raw_board: Option<&str>) -> String {
 mod tests {
     use super::*;
 
-    #[test]
-    fn numeric_strategy_aliases_accept_exact_zero_but_never_hide_rounding_or_conflicts() {
-        let cfg = platform_expr_config_from_value("fees", "000001.SZ", &serde_json::json!({
-            "execution":{"minimumCommission":0.0,"minimum_commission":0}
-        })).unwrap();
-        assert_eq!(cfg.minimum_commission, Some(0.0));
-        assert!(!strategy_alias_values_semantically_equal(&serde_json::json!(9007199254740992u64), &serde_json::json!(9007199254740993u64)));
-        assert!(!strategy_alias_values_semantically_equal(&serde_json::json!(0.0), &serde_json::json!(1)));
-    }
-
     #[test]
     fn parses_buy_filter_as_a_separate_trading_condition() {
         let cfg = platform_expr_config_from_value("buy-guard", "000001.SZ", &serde_json::json!({
@@ -3380,25 +3259,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn frozen_candidate_order_is_explicit_and_preserves_source_positions() {
-        let mut spec = serde_json::json!({"runtimeExpressions": {"selection": {
-            "candidateSymbolsByDate": {
-                "2025-01-02": ["600000.SH", "000001.SZ"], "2025-01-03": []
-            }
-        }}});
-        let date = NaiveDate::from_ymd_opt(2025, 1, 2).unwrap();
-        let legacy = platform_expr_config_from_value("", "", &spec).unwrap();
-        assert!(legacy.candidate_order_by_date.is_empty());
-        spec["runtimeExpressions"]["selection"]["preserveCandidateOrder"] = serde_json::json!(true);
-        let ordered = platform_expr_config_from_value("", "", &spec).unwrap();
-        assert_eq!(ordered.candidate_order_by_date[&date]["600000.SH"], 0);
-        assert_eq!(ordered.candidate_order_by_date[&date]["000001.SZ"], 1);
-        assert!(ordered.candidate_order_by_date[&NaiveDate::from_ymd_opt(2025, 1, 3).unwrap()].is_empty());
-        spec["runtimeExpressions"]["selection"]["candidateSymbolsByDate"] = serde_json::json!({});
-        assert!(platform_expr_config_from_value("", "", &spec).unwrap_err().to_string().contains("dated candidate book"));
-    }
-
     #[test]
     fn rejects_invalid_or_duplicate_static_universe_symbols() {
         let invalid = serde_json::json!({
@@ -4202,28 +4062,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn execution_limit_aliases_normalize_to_one_serde_field_without_touching_policy() {
-        for section in ["execution", "engineConfig"] {
-            let mut spec = serde_json::json!({});
-            spec[section] = serde_json::json!({
-                "volumeLimit": false, "volumeLimitEnabled": false, "volume_limit_enabled": false,
-                "liquidityLimit": true, "liquidityLimitEnabled": true, "liquidity_limit_enabled": true,
-                "riskPolicy": {"volumeLimitEnabled": false, "liquidityLimitEnabled": true}
-            });
-            let cfg = platform_expr_config_from_value("test", "000300.SH", &spec).unwrap();
-            assert!(!cfg.risk_config.trading_constraints.volume_limit_enabled);
-            assert!(cfg.risk_config.trading_constraints.liquidity_limit_enabled);
-            super::normalize_strategy_aliases_in_value(&mut spec).unwrap();
-            assert!(spec[section].get("volumeLimitEnabled").is_none());
-            assert!(spec[section].get("liquidity_limit_enabled").is_none());
-            assert_eq!(spec[section]["riskPolicy"]["liquidityLimitEnabled"], true);
-            spec[section]["liquidity_limit_enabled"] = serde_json::json!(false);
-            assert!(platform_expr_config_from_value("test", "000300.SH", &spec)
-                .unwrap_err().to_string().contains("conflicting alias values"));
-        }
-    }
-
     #[test]
     fn canonicalizes_duplicate_execution_aliases_without_changing_strategy_intent() {
         let spec = serde_json::json!({
@@ -4407,10 +4245,10 @@ mod tests {
     }
 
     #[test]
-    fn parses_explicit_historical_slippage_into_platform_config() {
+    fn parses_dynamic_slippage_into_platform_config() {
         let spec = serde_json::json!({
             "execution": {
-                "slippageModel": "historical_volume_volatility",
+                "slippageModel": "dynamic",
                 "slippageImpactCoefficient": 0.6,
                 "slippageVolatilityCoefficient": 0.2,
                 "slippageMaxValue": 0.015
@@ -4421,20 +4259,10 @@ mod tests {
 
         assert_eq!(
             cfg.slippage_model,
-            SlippageModel::HistoricalVolumeVolatility(DynamicSlippageConfig::new(0.6, 0.2, 0.015))
+            SlippageModel::Dynamic(DynamicSlippageConfig::new(0.6, 0.2, 0.015))
         );
     }
 
-    #[test]
-    fn retired_or_unknown_slippage_models_do_not_fall_back_to_fixed_or_none() {
-        for model in ["dynamic", "dynamic_volume_volatility", "dynamic-volume-volatility", "unknown"] {
-            let spec = serde_json::json!({"execution": {"slippageModel": model, "slippageValue": 0.002}});
-            assert!(platform_expr_config_from_value("", "", &spec).is_err(), "{model}");
-        }
-        let spec = serde_json::json!({"execution": {"slippageModel": "historical_volume_volatility", "slippageImpactCoefficient": -1}});
-        assert!(platform_expr_config_from_value("", "", &spec).is_err());
-    }
-
     #[test]
     fn engine_stock_ma_filter_generates_price_and_volume_expr() {
         let spec = serde_json::json!({
@@ -4630,20 +4458,6 @@ mod tests {
         assert_eq!(cfg.delayed_limit_open_exit_time, None);
     }
 
-    #[test]
-    fn session_rotation_keeps_every_declared_clock_not_only_the_last_one() {
-        use crate::Strategy;
-        let literal=serde_json::to_string(&serde_json::json!({"template":"session_event","session_event":"INTRADAY_VOLUME_SPIKE","parameters":{}}).to_string()).unwrap();
-        let mut spec=serde_json::json!({"rebalance":{"tradeTimes":["09:35","10:40","14:59"]},"runtimeExpressions":{"schedule":{"frequency":"daily","time":"14:59"},"trading":{"rotationEnabled":true,"buyFilterExpr":format!("pattern_signal({literal})")}},"execution":{"matchingType":"minute_last"}});
-        let config=platform_expr_config_from_value("session","000300.SH",&spec).unwrap();
-        assert_eq!(config.session_event_times.len(),3);
-        let strategy=crate::PlatformExprStrategy::new(config);
-        assert_eq!(strategy.schedule_rules().len(),3);
-        assert_eq!(strategy.decision_quote_times().len(),3);
-        spec["rebalance"]["tradeTimes"]=serde_json::json!([]);
-        assert!(platform_expr_config_from_value("session","000300.SH",&spec).unwrap_err().to_string().contains("explicit_trade_times"));
-    }
-
     #[test]
     fn explicit_trading_schedule_overrides_rebalance_trade_times() {
         let spec = serde_json::json!({

crates/fidc-core/src/portfolio.rs

@@ -60,8 +60,6 @@ pub struct PositionLot {
 pub struct Position {
     pub symbol: String,
     pub quantity: u32,
-    opened_date: Option<NaiveDate>,
-    last_buy_date: Option<NaiveDate>,
     // ALV-compatible moving average execution price; partial sells do not rebase it.
     pub average_price: f64,
     // ALV-compatible moving average including buy costs; partial sells do not rebase it.
@@ -90,8 +88,6 @@ impl Position {
         Self {
             symbol: symbol.into(),
             quantity: 0,
-            opened_date: None,
-            last_buy_date: None,
             average_price: 0.0,
             average_cost: 0.0,
             last_price: 0.0,
@@ -118,12 +114,6 @@ impl Position {
         self.quantity == 0
     }
 
-    pub fn opened_date(&self) -> Option<NaiveDate> {
-        self.opened_date
-    }
-
-    pub fn last_buy_date(&self) -> Option<NaiveDate> { self.last_buy_date }
-
     pub fn buy(&mut self, date: NaiveDate, quantity: u32, price: f64) {
         self.buy_with_mark_price(date, quantity, price, price);
     }
@@ -140,10 +130,6 @@ impl Position {
         }
 
         let previous_quantity = self.quantity;
-        self.last_buy_date = Some(self.last_buy_date.map_or(date, |previous| previous.max(date)));
-        if previous_quantity == 0 {
-            self.opened_date = Some(date);
-        }
         let previous_average_price = self.average_price;
         let previous_average_cost = self.average_cost;
         let gross_amount = fixed_money_or_panic(
@@ -281,7 +267,6 @@ impl Position {
             .checked_add(total_proceeds)
             .ok_or_else(|| "fixed-point day sell value overflow".to_string())?;
         if self.quantity == 0 {
-            self.opened_date = None;
             self.average_price = 0.0;
             self.recalculate_average_cost();
         } else {
@@ -676,7 +661,6 @@ pub struct PortfolioState {
     cash_receivables: Vec<CashReceivable>,
     pending_cash_flows: Vec<PendingCashFlow>,
     day_sold_symbols: BTreeSet<String>,
-    stock_pool_states: std::collections::BTreeMap<String,crate::stock_pool_state::StockPoolExecutionState>,
 }
 
 #[derive(Debug, Clone)]
@@ -713,7 +697,6 @@ impl PortfolioState {
             cash_receivables: Vec::new(),
             pending_cash_flows: Vec::new(),
             day_sold_symbols: BTreeSet::new(),
-            stock_pool_states: std::collections::BTreeMap::new(),
         }
     }
 
@@ -723,15 +706,6 @@ impl PortfolioState {
         self.initial_cash.to_f64()
     }
 
-    pub(crate) fn stock_pool_execution_state(&self,pool_id:&str)->crate::stock_pool_state::StockPoolExecutionState{
-        self.stock_pool_states.get(pool_id).cloned().unwrap_or_default()
-    }
-
-    pub(crate) fn set_stock_pool_execution_state(&mut self,pool_id:&str,state:crate::stock_pool_state::StockPoolExecutionState)->Result<(),String>{
-        if pool_id.trim().is_empty(){return Err("stock_pool_state_identity_missing".into())}
-        state.validate()?;self.stock_pool_states.insert(pool_id.into(),state);Ok(())
-    }
-
     pub fn initial_cash(&self) -> f64 {
         self.initial_cash.to_f64()
     }
@@ -1073,6 +1047,8 @@ impl PortfolioState {
             let unresolved_delisting = current_market_missing
                 && data.instrument(&position.symbol).is_some_and(|instrument| {
                     instrument.is_delisted_on_or_before(date)
+                        || (instrument.status.eq_ignore_ascii_case("delisted")
+                            && instrument.delisted_at.is_none())
                 });
             if unresolved_delisting {
                 position.last_price = 0.0;
@@ -1092,13 +1068,11 @@ impl PortfolioState {
                 position.refresh_day_pnl();
                 continue;
             }
-            let confirmed_pause = data.market(date, &position.symbol).is_some_and(|row| row.paused)
-                || data.candidate(date, &position.symbol).is_some_and(|row| row.is_paused);
             let price = data
                 .price(date, &position.symbol, field)
-                .or_else(|| confirmed_pause.then(|| data.price_on_or_before(date, &position.symbol, field)).flatten())
+                .or_else(|| data.price_on_or_before(date, &position.symbol, field))
                 .or_else(|| {
-                    (confirmed_pause && position.last_price.is_finite() && position.last_price > 0.0)
+                    (position.last_price.is_finite() && position.last_price > 0.0)
                         .then_some(position.last_price)
                 })
                 .ok_or_else(|| DataSetError::MissingSnapshot {
@@ -1250,8 +1224,6 @@ impl PortfolioState {
         }
 
         let old_quantity = old_position.quantity;
-        let old_opened_date = old_position.opened_date;
-        let old_last_buy_date = old_position.last_buy_date;
         let last_price = old_position.last_price;
         let old_average_price = old_position.average_price;
         let old_average_cost = old_position.average_cost;
@@ -1291,14 +1263,6 @@ impl PortfolioState {
             .entry(new_symbol.to_string())
             .or_insert_with(|| Position::new(new_symbol));
         let successor_quantity_before = successor.quantity;
-        successor.opened_date = match (successor.opened_date, old_opened_date) {
-            (Some(current), Some(previous)) => Some(current.min(previous)),
-            (current, previous) => current.or(previous),
-        };
-        successor.last_buy_date = match (successor.last_buy_date, old_last_buy_date) {
-            (Some(current), Some(previous)) => Some(current.max(previous)),
-            (current, previous) => current.or(previous),
-        };
         let successor_average_price_before = successor.average_price;
         let successor_average_cost_before = successor.average_cost;
         successor.lots.extend(converted_lots);
@@ -1810,7 +1774,7 @@ mod tests {
     }
 
     #[test]
-    fn portfolio_missing_market_requires_formal_suspension_before_carrying_price() {
+    fn portfolio_carries_last_price_when_position_market_row_is_missing() {
         let prev_date = NaiveDate::from_ymd_opt(2025, 5, 26).unwrap();
         let missing_date = NaiveDate::from_ymd_opt(2025, 5, 27).unwrap();
         let mut portfolio = PortfolioState::new(10_000.0);
@@ -1868,23 +1832,9 @@ mod tests {
             .update_prices(prev_date, &dataset, PriceField::Close)
             .expect("previous close");
         portfolio.begin_trading_day();
-        let error = portfolio
+        portfolio
             .update_prices(missing_date, &dataset, PriceField::Close)
-            .expect_err("unclassified missing current price must not be filled from history");
+            .expect("missing current row should carry previous close");
-        assert!(error.to_string().contains("601028.SH"));
-        let paused_dataset = DataSet::from_components(
-            vec![dataset.instrument("601028.SH").unwrap().clone()],
-            vec![dataset.market(prev_date, "601028.SH").unwrap().clone()],
-            Vec::new(),
-            vec![crate::data::CandidateEligibility {
-                date: missing_date, symbol: "601028.SH".into(), is_st: false, is_star_st: false,
-                is_new_listing: false, is_paused: true, allow_buy: false, allow_sell: false,
-                is_kcb: false, is_one_yuan: false, risk_level_code: None,
-            }],
-            vec![dataset.benchmark(prev_date).unwrap().clone()],
-        ).unwrap();
-        portfolio.update_prices(missing_date, &paused_dataset, PriceField::Close)
-            .expect("dated suspension permits keeping the last known valuation, not creating a fill");
 
         let position = portfolio.position("601028.SH").expect("position");
         assert!((position.last_price - 10.3).abs() < 1e-6);

crates/fidc-core/src/risk_control.rs

@@ -138,16 +138,6 @@ pub struct FidcRiskDecisionAudit {
 }
 
 impl FidcRiskDecisionAudit {
-    pub fn rejected_buy_plan(date: NaiveDate, symbol: &str, reason: &str) -> Self {
-        Self {
-            date, symbol: symbol.into(), scope: RiskCheckScope::Buy,
-            stage: "buy_planning".into(), accepted: false,
-            rule_code: reason.into(), reason: reason.into(),
-            config_version: Some("inline_risk_policy".into()), data_epoch: date.to_string(),
-            selection_batch_id: None, order_id: None,
-        }
-    }
-
     pub fn rejected_selection(
         date: NaiveDate,
         symbol: impl Into<String>,
@@ -218,8 +208,14 @@ impl ChinaAShareRiskControl {
         {
             return Some("inactive_or_delisted");
         }
-        // Latest reference status has no historical as-of date. Execution-day
+        let status = instrument.status.trim().to_ascii_lowercase();
-        // risk snapshots remain authoritative; missing quotes are not waived.
+        let terminal_status = matches!(
+            status.as_str(),
+            "inactive" | "delisted" | "terminated" | "expired"
+        );
+        if terminal_status && instrument.delisted_at.is_none() {
+            return Some("inactive_or_delisted");
+        }
         None
     }
 
@@ -414,11 +410,10 @@ impl ChinaAShareRiskControl {
         }
         let reject_one_yuan = match scope {
             RiskCheckScope::Selection => config.static_rules.reject_one_yuan_selection,
-            RiskCheckScope::Buy => false,
+            RiskCheckScope::Buy => config.static_rules.reject_one_yuan_buy,
             RiskCheckScope::Sell => false,
         };
         if reject_one_yuan
-            && !instrument.is_some_and(Instrument::is_exchange_traded_fund)
             && (candidate.is_one_yuan
                 || (market.day_open.is_finite() && market.day_open > 0.0 && market.day_open <= 1.0))
         {
@@ -488,15 +483,6 @@ impl ChinaAShareRiskControl {
         ) {
             return Some(reason);
         }
-        if !check_price.is_finite() || check_price <= 0.0 {
-            return Some("invalid execution price");
-        }
-        // Daily candidate flags can describe the later close. Execution
-        // price constraints must use this order's actual pricing clock.
-        if config.static_rules.reject_one_yuan_buy && check_price <= 1.0
-            && !instrument.is_some_and(Instrument::is_exchange_traded_fund) {
-            return Some("one_yuan");
-        }
         if config.static_rules.respect_allow_buy_sell && !candidate.allow_buy {
             return Some("buy_disabled");
         }
@@ -678,6 +664,7 @@ fn missing_buy_risk_state_rejected(code: &str, config: &FidcRiskControlConfig) -
             || config.static_rules.reject_new_listing_buy
             || config.static_rules.reject_kcb_buy
             || config.static_rules.reject_bjse_buy
+            || config.static_rules.reject_one_yuan_buy
             || config.static_rules.reject_upper_limit_buy
             || config.static_rules.respect_allow_buy_sell;
     }
@@ -754,7 +741,7 @@ fn missing_single_field_rejected(
         },
         "is_one_yuan" | "one_yuan" => match scope {
             RiskCheckScope::Selection => config.static_rules.reject_one_yuan_selection,
-            RiskCheckScope::Buy => false,
+            RiskCheckScope::Buy => config.static_rules.reject_one_yuan_buy,
             RiskCheckScope::Sell => false,
         },
         "allow_buy" => match scope {
@@ -798,6 +785,7 @@ fn missing_single_field_rejected(
                     || config.static_rules.reject_new_listing_buy
                     || config.static_rules.reject_kcb_buy
                     || config.static_rules.reject_bjse_buy
+                    || config.static_rules.reject_one_yuan_buy
                     || config.static_rules.reject_upper_limit_buy
                     || config.static_rules.respect_allow_buy_sell
             }
@@ -855,7 +843,7 @@ mod tests {
                 Some(&instrument("delisted", None)),
                 date,
             ),
-            None
+            Some("inactive_or_delisted")
         );
         assert_eq!(
             ChinaAShareRiskControl::instrument_rejection_reason(
@@ -914,75 +902,6 @@ mod tests {
         position
     }
 
-    #[test]
-    fn one_yuan_buy_rule_uses_execution_price_not_later_close_or_earlier_open() {
-        let day = d(2025, 2, 6);
-        let mut candidate = candidate(day);
-        let mut snapshot = market(day, 1.2, 0.5);
-        let config = FidcRiskControlConfig::default();
-        candidate.is_one_yuan = true;
-        snapshot.day_open = 0.9;
-        snapshot.close = 0.8;
-        assert_eq!(ChinaAShareRiskControl::buy_rejection_reason_with_config(
-            day, &candidate, &snapshot, None, 1.2, &config), None);
-        candidate.is_one_yuan = false;
-        snapshot.day_open = 1.2;
-        snapshot.close = 1.3;
-        for price in [0.9, 1.0] {
-            assert_eq!(ChinaAShareRiskControl::buy_rejection_reason_with_config(
-                day, &candidate, &snapshot, None, price, &config), Some("one_yuan"));
-        }
-        let mut relaxed = config;
-        relaxed.static_rules.reject_one_yuan_buy = false;
-        assert_eq!(ChinaAShareRiskControl::buy_rejection_reason_with_config(
-            day, &candidate, &snapshot, None, 0.9, &relaxed), None);
-    }
-
-    #[test]
-    fn fund_identity_excludes_stock_one_yuan_rule_but_not_actual_price_and_pause_checks() {
-        let day=d(2025,2,6);
-        let mut candidate=candidate(day);
-        let mut snapshot=market(day,1.2,0.5);
-        snapshot.lower_limit=0.01;snapshot.upper_limit=10.;
-        let instrument=Instrument{symbol:candidate.symbol.clone(),name:"fixture fund".into(),board:"ETF".into(),round_lot:100,listed_at:Some(d(2024,1,2)),delisted_at:None,status:"active".into()};
-        let config=FidcRiskControlConfig::default();
-        assert_eq!(ChinaAShareRiskControl::buy_rejection_reason_with_config(day,&candidate,&snapshot,Some(&instrument),0.9,&config),None);
-        assert_eq!(ChinaAShareRiskControl::buy_rejection_reason_with_config(day,&candidate,&snapshot,Some(&instrument),0.,&config),Some("invalid execution price"));
-        candidate.is_paused=true;snapshot.paused=true;
-        assert_eq!(ChinaAShareRiskControl::buy_rejection_reason_with_config(day,&candidate,&snapshot,Some(&instrument),0.9,&config),Some("paused"));
-    }
-
-    #[test]
-    fn execution_quote_covers_missing_one_yuan_flag_but_not_other_risk_facts() {
-        let day = d(2025, 2, 6);
-        let mut candidate = candidate(day);
-        let snapshot = market(day, 1.2, 0.5);
-        let config = FidcRiskControlConfig::default();
-        candidate.risk_level_code = Some("missing_risk_state:is_one_yuan".into());
-        assert_eq!(ChinaAShareRiskControl::buy_rejection_reason_with_config(
-            day, &candidate, &snapshot, None, 1.2, &config), None);
-        candidate.risk_level_code = Some("missing_risk_state:is_st".into());
-        assert_eq!(ChinaAShareRiskControl::buy_rejection_reason_with_config(
-            day, &candidate, &snapshot, None, 1.2, &config), Some("missing_risk_state"));
-        candidate.risk_level_code = None;
-        for price in [0.0, f64::NAN, f64::INFINITY] {
-            assert_eq!(ChinaAShareRiskControl::buy_rejection_reason_with_config(
-                day, &candidate, &snapshot, None, price, &config), Some("invalid execution price"));
-        }
-    }
-
-    #[test]
-    fn explicit_one_yuan_selection_policy_still_uses_selection_facts() {
-        let day = d(2025, 2, 6);
-        let mut candidate = candidate(day);
-        candidate.is_one_yuan = true;
-        let snapshot = market(day, 1.2, 0.5);
-        let mut config = FidcRiskControlConfig::default();
-        config.static_rules.reject_one_yuan_selection = true;
-        assert_eq!(ChinaAShareRiskControl::selection_rejection_reason_with_config(
-            day, &candidate, &snapshot, None, &config), Some("one_yuan"));
-    }
-
     #[test]
     fn sell_rejection_respects_allow_sell_policy_on_execution_day() {
         let prev_date = d(2024, 4, 16);

crates/fidc-core/src/session_events.rs

@@ -1,398 +0,0 @@
-//! Completed, same-session minute events. These bars never become execution quotes.
-use crate::{
-    daily_patterns::{PatternResult, PatternSpec},
-    factor_events::{Expr, Frame},
-};
-use chrono::{FixedOffset, NaiveDateTime, NaiveTime, TimeZone, Timelike};
-use serde::{Deserialize, Serialize};
-use serde_json::{json, Value};
-use std::collections::BTreeMap;
-use std::sync::Arc;
-
-pub const CONTRACT: &str = "fidc_completed_session_events_v1";
-pub const EVENTS: &[&str] = &[
-    "PRICE_CROSS_VWAP_UP",
-    "PRICE_CROSS_VWAP_DOWN",
-    "INTRADAY_HIGH_BREAKOUT",
-    "INTRADAY_LOW_BREAKDOWN",
-    "OPENING_RANGE_BREAKOUT_UP",
-    "OPENING_RANGE_BREAKOUT_DOWN",
-    "INTRADAY_VOLUME_SPIKE",
-    "MORNING_HIGH_BREAKOUT",
-    "MORNING_LOW_BREAKDOWN",
-    "AFTERNOON_MOMENTUM_UP",
-    "AFTERNOON_MOMENTUM_DOWN",
-    "LATE_SESSION_STRENGTH",
-    "LATE_SESSION_WEAKNESS",
-];
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct MinuteBar {
-    pub symbol: String,
-    pub timestamp: NaiveDateTime,
-    pub available_at: NaiveDateTime,
-    pub open: f64,
-    pub high: f64,
-    pub low: f64,
-    pub close: f64,
-    pub volume: f64,
-    pub amount: f64,
-}
-pub type BarStore = Arc<BTreeMap<(chrono::NaiveDate, String), Vec<MinuteBar>>>;
-pub fn bar_store(bars: Vec<MinuteBar>) -> Result<BarStore, String> {
-    let mut groups = BTreeMap::<(chrono::NaiveDate, String), Vec<MinuteBar>>::new();
-    for bar in bars {
-        groups
-            .entry((bar.timestamp.date(), bar.symbol.clone()))
-            .or_default()
-            .push(bar);
-    }
-    for rows in groups.values_mut() {
-        rows.sort_by_key(|r| r.timestamp);
-        if rows
-            .windows(2)
-            .any(|pair| pair[0].timestamp == pair[1].timestamp)
-        {
-            return Err("duplicate_completed_minute_bar".into());
-        }
-    }
-    Ok(Arc::new(groups))
-}
-fn f(name: &str) -> Expr {
-    Expr::Field { name: name.into() }
-}
-fn n(value: f64) -> Expr {
-    Expr::Number { value }
-}
-fn op(name: &str, args: Vec<Expr>, window: Option<usize>) -> Expr {
-    Expr::Operator {
-        name: name.into(),
-        args,
-        window,
-    }
-}
-fn time(minutes: u32) -> NaiveTime {
-    NaiveTime::from_hms_opt(minutes / 60, minutes % 60, 0).unwrap()
-}
-
-pub fn is_regular_label(t: NaiveTime) -> bool {
-    t.second() == 0 && (time(570) <= t && t <= time(690) || time(780) < t && t <= time(900))
-}
-
-pub fn expression(event: &str, p: &BTreeMap<String, Value>) -> Result<Expr, String> {
-    let cross = |up: bool, a: Expr, b: Expr| {
-        op(
-            if up { "CROSS_ABOVE" } else { "CROSS_BELOW" },
-            vec![a, b],
-            None,
-        )
-    };
-    Ok(match event {
-        "PRICE_CROSS_VWAP_UP" => cross(true, f("close"), f("session_vwap")),
-        "PRICE_CROSS_VWAP_DOWN" => cross(false, f("close"), f("session_vwap")),
-        "INTRADAY_HIGH_BREAKOUT" => op(
-            "GT",
-            vec![
-                f("close"),
-                op("LAG", vec![op("CUMMAX", vec![f("high")], None)], Some(1)),
-            ],
-            None,
-        ),
-        "INTRADAY_LOW_BREAKDOWN" => op(
-            "LT",
-            vec![
-                f("close"),
-                op("LAG", vec![op("CUMMIN", vec![f("low")], None)], Some(1)),
-            ],
-            None,
-        ),
-        "OPENING_RANGE_BREAKOUT_UP" => cross(true, f("close"), f("opening_high")),
-        "OPENING_RANGE_BREAKOUT_DOWN" => cross(false, f("close"), f("opening_low")),
-        "MORNING_HIGH_BREAKOUT" => cross(true, f("close"), f("morning_high")),
-        "MORNING_LOW_BREAKDOWN" => cross(false, f("close"), f("morning_low")),
-        "AFTERNOON_MOMENTUM_UP" => cross(true, f("afternoon_return"), n(0.)),
-        "AFTERNOON_MOMENTUM_DOWN" => cross(false, f("afternoon_return"), n(0.)),
-        "LATE_SESSION_STRENGTH" => cross(true, f("late_return"), n(0.)),
-        "LATE_SESSION_WEAKNESS" => cross(false, f("late_return"), n(0.)),
-        "INTRADAY_VOLUME_SPIKE" => op(
-            "GTE",
-            vec![
-                f("volume"),
-                op(
-                    "MUL",
-                    vec![
-                        op(
-                            "LAG",
-                            vec![op(
-                                "ROLLING_MEAN",
-                                vec![f("volume")],
-                                Some(p["volume_window"].as_u64().unwrap() as usize),
-                            )],
-                            Some(1),
-                        ),
-                        n(p["volume_multiple"].as_f64().unwrap()),
-                    ],
-                    None,
-                ),
-            ],
-            None,
-        ),
-        _ => return Err("session_event_not_registered".into()),
-    })
-}
-
-pub fn evaluate(
-    spec: &PatternSpec,
-    symbol: &str,
-    bars: &[MinuteBar],
-    decision: NaiveDateTime,
-) -> Result<PatternResult, String> {
-    let mut result = PatternResult {
-        symbol: symbol.into(),
-        name: None,
-        matched: false,
-        score: None,
-        checks: vec![],
-        values: json!({}),
-        anchor: Value::Null,
-        exclusion: None,
-    };
-    if bars.is_empty() {
-        return Err(format!(
-            "session_source_missing: {symbol} {}",
-            decision.date()
-        ));
-    }
-    let visible = bars
-        .iter()
-        .filter(|b| {
-            b.timestamp.date() == decision.date()
-                && b.timestamp < decision
-                && b.available_at <= decision
-        })
-        .collect::<Vec<_>>();
-    if visible.is_empty() {
-        result.exclusion = Some(json!({"reason":"session_before_first_completed_bar"}));
-        return Ok(result);
-    }
-    let last = visible.last().unwrap().timestamp;
-    let expected = (570..=690)
-        .chain(781..=900)
-        .map(|m| decision.date().and_time(time(m)))
-        .filter(|t| *t < decision)
-        .last();
-    if expected != Some(last) {
-        return Err(format!(
-            "session_latest_bar_missing: {symbol} expected={expected:?} actual={last}"
-        ));
-    }
-    let mut indexed = BTreeMap::new();
-    for b in &visible {
-        if b.symbol != symbol
-            || !is_regular_label(b.timestamp.time())
-            || b.available_at < b.timestamp
-            || [b.open, b.high, b.low, b.close, b.volume, b.amount]
-                .iter()
-                .any(|v| !v.is_finite())
-            || b.low <= 0.
-            || b.open <= 0.
-            || b.close <= 0.
-            || b.high < b.open.max(b.close)
-            || b.low > b.open.min(b.close)
-            || b.volume < 0.
-            || b.amount < 0.
-            || indexed.insert(b.timestamp, b).is_some()
-        {
-            return Err(format!("session_bar_invalid: {symbol} {}", b.timestamp));
-        }
-    }
-    for minute in (571..=690).chain(781..=900) {
-        let stamp = decision.date().and_time(time(minute));
-        if stamp <= last && !indexed.contains_key(&stamp) {
-            return Err(format!(
-                "session_bar_gap: {symbol} {stamp}; no filling or calendar compression"
-            ));
-        }
-    }
-    let opening_end = time(570 + spec.n("opening_minutes") as u32);
-    let (mut volume, mut amount) = (0., 0.);
-    let (mut opening_high, mut opening_low) = (f64::NEG_INFINITY, f64::INFINITY);
-    let (mut morning_high, mut morning_low) = (f64::NEG_INFINITY, f64::INFINITY);
-    let (mut morning_close, mut late_close) = (None, None);
-    let mut fields: BTreeMap<String, Vec<Option<f64>>> = [
-        "open",
-        "high",
-        "low",
-        "close",
-        "volume",
-        "amount",
-        "session_vwap",
-        "opening_high",
-        "opening_low",
-        "morning_high",
-        "morning_low",
-        "afternoon_return",
-        "late_return",
-    ]
-    .into_iter()
-    .map(|s| (s.into(), vec![]))
-    .collect();
-    let mut timestamps = vec![];
-    let mut available_at = vec![];
-    let zone = FixedOffset::east_opt(8 * 3600).unwrap();
-    for b in indexed.values() {
-        let t = b.timestamp.time();
-        volume += b.volume;
-        amount += b.amount;
-        if t <= opening_end {
-            opening_high = opening_high.max(b.high);
-            opening_low = opening_low.min(b.low);
-        }
-        if t <= time(690) {
-            morning_high = morning_high.max(b.high);
-            morning_low = morning_low.min(b.low);
-        }
-        if t == time(690) {
-            morning_close = Some(b.close);
-        }
-        if t == time(870) {
-            late_close = Some(b.close);
-        }
-        for (name, value) in [
-            ("open", Some(b.open)),
-            ("high", Some(b.high)),
-            ("low", Some(b.low)),
-            ("close", Some(b.close)),
-            ("volume", Some(b.volume)),
-            ("amount", Some(b.amount)),
-            ("session_vwap", (volume > 0.).then_some(amount / volume)),
-            ("opening_high", (t >= opening_end).then_some(opening_high)),
-            ("opening_low", (t >= opening_end).then_some(opening_low)),
-            ("morning_high", (t >= time(690)).then_some(morning_high)),
-            ("morning_low", (t >= time(690)).then_some(morning_low)),
-            ("afternoon_return", morning_close.map(|v| b.close / v - 1.)),
-            ("late_return", late_close.map(|v| b.close / v - 1.)),
-        ] {
-            fields.get_mut(name).unwrap().push(value);
-        }
-        timestamps.push(zone.from_local_datetime(&b.timestamp).single().unwrap());
-        available_at.push(zone.from_local_datetime(&b.available_at).single().unwrap());
-    }
-    let frame = Frame {
-        symbol: symbol.into(),
-        frequency: "1m".into(),
-        decision_at: zone.from_local_datetime(&decision).single().unwrap(),
-        timestamps,
-        available_at,
-        fields,
-    };
-    let event = spec
-        .session_event
-        .as_deref()
-        .ok_or("session_event_id_required")?;
-    let values = crate::factor_events::evaluate(&expression(event, &spec.parameters)?, &frame)?;
-    let latest = values.values.last().copied().flatten();
-    result.score = latest;
-    result.matched = latest == Some(1.);
-    result.values = json!({"session_event":event,"session_contract":CONTRACT,"expression":values,"signal_bar_end":last,"decision_at":decision,"bars":visible.len(),"bar_times":frame.timestamps.iter().map(|t|t.format("%Y-%m-%dT%H:%M:%S").to_string()).collect::<Vec<_>>(),"close":visible.last().unwrap().close,"session_return":visible.last().unwrap().close/visible.first().unwrap().open-1.,"price_policy":"same_session_raw_ohlcv"});
-    if latest.is_none() {
-        result.exclusion = Some(json!({"reason":"session_warmup_or_undefined"}));
-    } else {
-        result.checks.push(json!({"label":"分钟事件","actual":latest,"operator":"==","threshold":1,"passed":result.matched}));
-    }
-    Ok(result)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    fn spec(event: &str) -> PatternSpec {
-        serde_json::from_value::<PatternSpec>(
-            json!({"template":"session_event","session_event":event,"parameters":{}}),
-        )
-        .unwrap()
-        .validate()
-        .unwrap()
-    }
-    fn bars() -> Vec<MinuteBar> {
-        let date = chrono::NaiveDate::from_ymd_opt(2026, 9, 8).unwrap();
-        (570..=690)
-            .chain(781..=900)
-            .enumerate()
-            .map(|(i, m)| {
-                let timestamp = date.and_time(time(m));
-                let price = 100. + (i % 17) as f64 / 10.;
-                let volume = if i % 39 == 0 { 1000. } else { 100. };
-                MinuteBar {
-                    symbol: "300395.SZ".into(),
-                    timestamp,
-                    available_at: timestamp,
-                    open: price,
-                    high: price + 0.1,
-                    low: price - 0.1,
-                    close: price,
-                    volume,
-                    amount: volume * price,
-                }
-            })
-            .collect()
-    }
-    #[test]
-    fn all_thirteen_events_return_native_boolean_series() {
-        let bars = bars();
-        let decision = "2026-09-08T15:00:01".parse().unwrap();
-        for event in EVENTS {
-            let value = evaluate(&spec(event), "300395.SZ", &bars, decision).unwrap();
-            assert!(value.score.is_some(), "{event}");
-            assert_eq!(value.values["expression"]["value_type"], "boolean");
-        }
-    }
-    #[test]
-    fn decision_uses_the_previous_completed_label_and_future_prices_do_not_rewrite() {
-        let mut bars = bars();
-        let decision = "2026-09-08T10:02:00".parse().unwrap();
-        for event in EVENTS {
-            let before = evaluate(&spec(event), "300395.SZ", &bars, decision).unwrap();
-            for bar in &mut bars {
-                if bar.timestamp >= decision {
-                    bar.open = 1000.;
-                    bar.close = 1000.;
-                    bar.high = 1001.;
-                    bar.low = 999.;
-                }
-            }
-            let after = evaluate(&spec(event), "300395.SZ", &bars, decision).unwrap();
-            assert_eq!(before.values, after.values);
-            assert_eq!(after.values["signal_bar_end"], "2026-09-08T10:01:00");
-        }
-    }
-    #[test]
-    fn gaps_and_stale_last_bars_do_not_become_false_or_repeated_signals() {
-        let mut values = bars();
-        let decision = "2026-09-08T10:02:00".parse().unwrap();
-        values.retain(|r| r.timestamp.time() != time(600));
-        assert!(evaluate(&spec(EVENTS[0]), "300395.SZ", &values, decision)
-            .unwrap_err()
-            .contains("session_bar_gap"));
-        let stale = bars()
-            .into_iter()
-            .filter(|r| r.timestamp.time() < time(601))
-            .collect::<Vec<_>>();
-        assert!(evaluate(&spec(EVENTS[0]), "300395.SZ", &stale, decision)
-            .unwrap_err()
-            .contains("latest_bar_missing"));
-    }
-    #[test]
-    fn opening_range_is_unavailable_before_the_range_has_completed() {
-        let value = evaluate(
-            &spec("OPENING_RANGE_BREAKOUT_UP"),
-            "300395.SZ",
-            &bars(),
-            "2026-09-08T09:59:01".parse().unwrap(),
-        )
-        .unwrap();
-        assert_eq!(value.score, None);
-        assert!(!value.matched);
-    }
-}

crates/fidc-core/src/signal_contract.rs

@@ -1,590 +0,0 @@
-//! Immutable, account-independent trading signals. Quantity and execution
-//! prices are intentionally absent; the existing broker owns those decisions.
-
-use std::collections::{BTreeMap, BTreeSet};
-use std::sync::{Arc, Mutex, OnceLock, Weak};
-
-use chrono::{DateTime, FixedOffset, NaiveDate, NaiveDateTime, NaiveTime, Utc};
-use serde::{Deserialize, Serialize};
-use sha2::{Digest, Sha256};
-
-use crate::strategy::{OrderIntent, StrategyContext};
-use crate::portfolio::PortfolioState;
-
-pub const SIGNAL_BOOK_SCHEMA: &str = "fidc.signal-book/v2";
-
-#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase", deny_unknown_fields)]
-pub struct SignalBookReference {
-    pub book_id: String,
-    pub version_sha256: String,
-    pub artifact_sha256: String,
-}
-
-impl SignalBookReference {
-    pub fn validate(&self) -> Result<(), String> {
-        if !valid_sha(&self.version_sha256) || !valid_sha(&self.artifact_sha256)
-            || self.book_id != format!("signal_book_{}",self.version_sha256)
-        { return Err("signal_book_reference_invalid".into()); }
-        Ok(())
-    }
-}
-
-#[derive(Default)]
-struct SignalCache {
-    entries: BTreeMap<String,Weak<ValidatedSignalBook>>,
-    retained: std::collections::VecDeque<(String,Arc<ValidatedSignalBook>,usize)>,
-}
-
-fn signal_cache() -> &'static Mutex<SignalCache> {
-    static CACHE: OnceLock<Mutex<SignalCache>> = OnceLock::new();
-    CACHE.get_or_init(||Mutex::new(SignalCache::default()))
-}
-
-pub fn cached_signal_book(reference: &SignalBookReference) -> Result<Option<Arc<ValidatedSignalBook>>,String> {
-    reference.validate()?;
-    let cache=signal_cache().lock().map_err(|_|"signal_cache_lock_failed")?;
-    let book=cache.entries.get(&reference.artifact_sha256).and_then(Weak::upgrade);
-    if book.as_ref().is_some_and(|book|book.version_sha256()!=reference.version_sha256) {
-        return Err("signal_book_cached_version_mismatch".into());
-    }
-    Ok(book)
-}
-
-pub fn register_signal_book(reference: &SignalBookReference, body: &[u8]) -> Result<Arc<ValidatedSignalBook>,String> {
-    use sha2::{Digest,Sha256};
-    reference.validate()?;
-    if body.len()>64*1024*1024 || format!("{:x}",Sha256::digest(body))!=reference.artifact_sha256 {
-        return Err("signal_book_artifact_hash_or_size_invalid".into());
-    }
-    let raw:SignalBook=serde_json::from_slice(body).map_err(|error|format!("signal_book_decode_failed: {error}"))?;
-    if raw.version_sha256!=reference.version_sha256 { return Err("signal_book_version_mismatch".into()); }
-    let book=Arc::new(raw.validate()?);
-    let mut cache=signal_cache().lock().map_err(|_|"signal_cache_lock_failed")?;
-    cache.entries.retain(|_,value|value.strong_count()>0);
-    if let Some(existing)=cache.entries.get(&reference.artifact_sha256).and_then(Weak::upgrade) { return Ok(existing); }
-    cache.entries.insert(reference.artifact_sha256.clone(),Arc::downgrade(&book));
-    let estimated=body.len().saturating_mul(4);
-    if estimated<=128*1024*1024 {
-        cache.retained.push_back((reference.artifact_sha256.clone(),book.clone(),estimated));
-        while cache.retained.len()>4 || cache.retained.iter().map(|entry|entry.2).sum::<usize>()>128*1024*1024 {
-            cache.retained.pop_front();
-        }
-    }
-    Ok(book)
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
-#[serde(rename_all = "snake_case")]
-pub enum SignalProvenance {
-    Observed,
-    Reconstructed,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
-#[serde(rename_all = "snake_case")]
-pub enum SignalFrequency {
-    Daily,
-    Minute,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(tag = "kind", rename_all = "snake_case", deny_unknown_fields)]
-pub enum SignalAction {
-    TargetWeight { symbol: String, weight: f64 },
-    BuyCondition { symbol: String, allowed: bool },
-    Exit { symbol: String },
-    Reduce { symbol: String, remaining_ratio: f64 },
-}
-
-impl SignalAction {
-    fn symbol(&self) -> &str {
-        match self {
-            Self::TargetWeight { symbol, .. }
-            | Self::BuyCondition { symbol, .. }
-            | Self::Exit { symbol }
-            | Self::Reduce { symbol, .. } => symbol,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase", deny_unknown_fields)]
-pub struct SignalSnapshot {
-    pub signal_at: DateTime<Utc>,
-    pub decision_at: DateTime<Utc>,
-    pub input_as_of: DateTime<Utc>,
-    pub input_available_at: DateTime<Utc>,
-    pub generated_at: DateTime<Utc>,
-    pub published_at: DateTime<Utc>,
-    pub input_sha256: String,
-    pub complete_targets: bool,
-    pub actions: Vec<SignalAction>,
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(rename_all = "camelCase", deny_unknown_fields)]
-pub struct SignalBook {
-    pub schema: String,
-    pub version_sha256: String,
-    pub generator_sha256: String,
-    pub model_sha256: Option<String>,
-    pub knowledge_cutoff: Option<DateTime<Utc>>,
-    pub provenance: SignalProvenance,
-    pub frequency: SignalFrequency,
-    pub expected_decisions: Vec<DateTime<Utc>>,
-    pub snapshots: Vec<SignalSnapshot>,
-}
-
-#[derive(Debug, Clone)]
-pub struct ValidatedSignalBook {
-    book: SignalBook,
-    index: BTreeMap<NaiveDateTime, usize>,
-}
-
-fn valid_sha(value: &str) -> bool {
-    value.len() == 64 && value.bytes().all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
-}
-
-fn shanghai(value: DateTime<Utc>) -> NaiveDateTime {
-    value.with_timezone(&FixedOffset::east_opt(8 * 3600).expect("Shanghai offset")).naive_local()
-}
-
-impl SignalBook {
-    pub fn content_sha256(&self) -> Result<String, String> {
-        let mut value=serde_json::to_value(self).map_err(|error|error.to_string())?;
-        value.as_object_mut().ok_or("signal_book_object_required")?.remove("versionSha256");
-        value["knowledgeCutoff"]=self.knowledge_cutoff.map(|at|serde_json::json!(at.timestamp_micros())).unwrap_or(serde_json::Value::Null);
-        value["expectedDecisions"]=serde_json::json!(self.expected_decisions.iter().map(DateTime::timestamp_micros).collect::<Vec<_>>());
-        for (raw,snapshot) in value["snapshots"].as_array_mut().ok_or("signal_snapshots_required")?.iter_mut().zip(&self.snapshots) {
-            let object=raw.as_object_mut().ok_or("signal_snapshot_required")?;
-            object.remove("generatedAt");
-            object.remove("publishedAt");
-            for (key,at) in [("signalAt",snapshot.signal_at),("decisionAt",snapshot.decision_at),
-                            ("inputAsOf",snapshot.input_as_of),("inputAvailableAt",snapshot.input_available_at)] {
-                object.insert(key.into(),serde_json::json!(at.timestamp_micros()));
-            }
-            for (raw,action) in object.get_mut("actions").and_then(serde_json::Value::as_array_mut).ok_or("signal_actions_required")?.iter_mut().zip(&snapshot.actions) {
-                match action {
-                    SignalAction::TargetWeight{weight,..}=>raw["weight"]=serde_json::json!(format!("{:016x}",weight.to_bits())),
-                    SignalAction::Reduce{remaining_ratio,..}=>raw["remaining_ratio"]=serde_json::json!(format!("{:016x}",remaining_ratio.to_bits())),
-                    _=>{}
-                }
-            }
-        }
-        fn sorted(value:serde_json::Value)->serde_json::Value {
-            match value {
-                serde_json::Value::Object(map)=>serde_json::Value::Object(map.into_iter().map(|(key,value)|(key,sorted(value)))
-                    .collect::<BTreeMap<_,_>>().into_iter().collect()),
-                serde_json::Value::Array(rows)=>serde_json::Value::Array(rows.into_iter().map(sorted).collect()),
-                other=>other,
-            }
-        }
-        let raw=serde_json::to_vec(&sorted(value)).map_err(|error|error.to_string())?;
-        Ok(format!("{:x}",Sha256::digest(raw)))
-    }
-
-    pub fn validate(self) -> Result<ValidatedSignalBook, String> {
-        if self.schema != SIGNAL_BOOK_SCHEMA || !valid_sha(&self.version_sha256)
-            || !valid_sha(&self.generator_sha256)
-        {
-            return Err("signal_book_identity_invalid".into());
-        }
-        if self.model_sha256.as_ref().is_some_and(|value| !valid_sha(value))
-            || self.model_sha256.is_some() != self.knowledge_cutoff.is_some()
-        { return Err("signal_model_training_identity_incomplete".into()); }
-        if self.expected_decisions.is_empty() || self.expected_decisions.len() > 100_000
-            || self.expected_decisions.len() != self.snapshots.len()
-        {
-            return Err("signal_book_decision_coverage_incomplete".into());
-        }
-        let mut index = BTreeMap::new();
-        let mut previous = None;
-        let mut total_actions = 0usize;
-        for (number, (expected, snapshot)) in self.expected_decisions.iter().zip(&self.snapshots).enumerate() {
-            if [*expected,snapshot.signal_at,snapshot.input_as_of,snapshot.input_available_at,snapshot.generated_at,snapshot.published_at]
-                .iter().any(|at|at.timestamp_subsec_nanos()%1000!=0) || self.knowledge_cutoff.is_some_and(|at|at.timestamp_subsec_nanos()%1000!=0) {
-                return Err("signal_timestamp_requires_microsecond_precision".into());
-            }
-            if snapshot.decision_at != *expected || previous.is_some_and(|value| value >= *expected) {
-                return Err("signal_book_decisions_duplicate_or_unordered".into());
-            }
-            previous = Some(*expected);
-            if self.knowledge_cutoff.is_some_and(|cutoff| cutoff > snapshot.signal_at) || snapshot.signal_at > *expected
-                || snapshot.input_available_at > snapshot.signal_at || snapshot.input_as_of > snapshot.input_available_at
-                || snapshot.published_at < snapshot.generated_at || !valid_sha(&snapshot.input_sha256)
-                || snapshot.generated_at < snapshot.input_available_at
-                || self.knowledge_cutoff.is_some_and(|cutoff| snapshot.generated_at < cutoff)
-            {
-                return Err("signal_book_future_or_invalid_input".into());
-            }
-            if self.provenance == SignalProvenance::Observed && snapshot.published_at > *expected {
-                return Err("observed_signal_not_available_at_decision".into());
-            }
-            total_actions = total_actions.checked_add(snapshot.actions.len()).ok_or("signal_book_action_limit")?;
-            if total_actions > 2_000_000 { return Err("signal_book_action_limit".into()); }
-            let mut action_keys = BTreeSet::new();
-            let mut target_symbols = BTreeSet::new();
-            let mut reductions = BTreeSet::new();
-            let mut total_weight = 0.0;
-            for action in &snapshot.actions {
-                let symbol = action.symbol();
-                if symbol.is_empty() || symbol.trim() != symbol { return Err("signal_symbol_invalid".into()); }
-                let kind = match action {
-                    SignalAction::TargetWeight { weight, .. } => {
-                        if !weight.is_finite() || !(0.0..=1.0).contains(weight) { return Err("signal_target_weight_invalid".into()); }
-                        target_symbols.insert(symbol);
-                        total_weight += weight;
-                        "target"
-                    }
-                    SignalAction::BuyCondition { .. } => "buy_condition",
-                    SignalAction::Exit { .. } => { reductions.insert(symbol); "exit" }
-                    SignalAction::Reduce { remaining_ratio, .. } => {
-                        if !remaining_ratio.is_finite() || !(0.0..1.0).contains(remaining_ratio) { return Err("signal_reduction_invalid".into()); }
-                        reductions.insert(symbol);
-                        "reduce"
-                    }
-                };
-                if !action_keys.insert((symbol, kind)) { return Err("signal_action_duplicate".into()); }
-            }
-            if total_weight > 1.0 + 1e-12 { return Err("signal_target_exposure_exceeds_one".into()); }
-            if snapshot.complete_targets && !reductions.is_empty() {
-                return Err("complete_target_snapshot_cannot_mix_relative_exits".into());
-            }
-            if !target_symbols.is_disjoint(&reductions) { return Err("signal_target_exit_conflict".into()); }
-            for symbol in &reductions {
-                if action_keys.contains(&(*symbol, "exit")) && action_keys.contains(&(*symbol, "reduce")) {
-                    return Err("signal_exit_reduction_conflict".into());
-                }
-            }
-            index.insert(shanghai(*expected), number);
-        }
-        if self.content_sha256()? != self.version_sha256 {
-            return Err("signal_book_content_hash_mismatch".into());
-        }
-        Ok(ValidatedSignalBook { book: self, index })
-    }
-}
-
-impl ValidatedSignalBook {
-    pub fn require_observed(&self) -> Result<(), String> {
-        if self.book.provenance != SignalProvenance::Observed {
-            return Err("reconstructed_signal_forbidden_in_online_execution".into());
-        }
-        Ok(())
-    }
-
-    pub fn version_sha256(&self) -> &str { &self.book.version_sha256 }
-    pub fn generator_sha256(&self) -> &str { &self.book.generator_sha256 }
-
-    pub fn decision_dates(&self) -> BTreeSet<NaiveDate> {
-        self.index.keys().map(|value| value.date()).collect()
-    }
-
-    pub fn symbols(&self) -> BTreeSet<String> {
-        self.book.snapshots.iter().flat_map(|snapshot| &snapshot.actions)
-            .map(|action| action.symbol().to_owned()).collect()
-    }
-
-    pub fn snapshot_for(&self, ctx: &StrategyContext<'_>) -> Result<&SignalSnapshot, String> {
-        let snapshot = self.snapshot_at(ctx.execution_date, ctx.current_time(), ctx.is_lagged_execution())?;
-        if self.book.provenance == SignalProvenance::Observed && ctx.current_datetime().is_none() {
-            return Err("observed_signal_consumption_clock_missing".into());
-        }
-        let consumption_clock=ctx.current_datetime()
-            .unwrap_or(ctx.decision_date.and_hms_opt(15,0,0).expect("completed decision session"));
-        let lagged_daily=ctx.is_lagged_execution() && self.book.frequency==SignalFrequency::Daily;
-        if lagged_daily && shanghai(snapshot.input_as_of).date()>ctx.decision_date {
-            return Err("next_open_signal_contains_execution_session_inputs".into());
-        }
-        if shanghai(snapshot.input_available_at)>consumption_clock || shanghai(snapshot.signal_at)>consumption_clock {
-            return Err("signal_not_available_at_consumption_clock".into());
-        }
-        if self.book.provenance == SignalProvenance::Observed
-            && (shanghai(snapshot.generated_at)>consumption_clock || shanghai(snapshot.published_at)>consumption_clock) {
-            return Err("observed_signal_published_after_consumption_clock".into());
-        }
-        Ok(snapshot)
-    }
-
-    pub fn is_due_on(&self, execution_date: NaiveDate) -> bool {
-        self.index.range(execution_date.and_hms_opt(0,0,0).expect("session start")..)
-            .next().is_some_and(|(at,_)|at.date()==execution_date)
-    }
-
-    fn snapshot_at(&self, execution_date: NaiveDate, current_time: Option<NaiveTime>, lagged: bool) -> Result<&SignalSnapshot, String> {
-        let at = if self.book.frequency == SignalFrequency::Daily && lagged {
-            execution_date.and_hms_opt(9, 30, 0).expect("next open")
-        } else {
-            execution_date.and_time(current_time.unwrap_or(NaiveTime::from_hms_opt(15, 0, 0).expect("daily close")))
-        };
-        self.index.get(&at).map(|index| &self.book.snapshots[*index])
-            .ok_or_else(|| format!("signal_snapshot_missing_at_decision: {at}"))
-    }
-
-    pub fn intents(&self, ctx: &StrategyContext<'_>) -> Result<Vec<OrderIntent>, String> {
-        let snapshot = self.snapshot_for(ctx)?;
-        self.snapshot_intents(snapshot, ctx.portfolio)
-    }
-
-    fn snapshot_intents(&self, snapshot: &SignalSnapshot, portfolio: &PortfolioState) -> Result<Vec<OrderIntent>, String> {
-        let reason = format!("信号执行 version={} decision={}", self.book.version_sha256, snapshot.decision_at);
-        let mut intents = Vec::new();
-        let mut weights = BTreeMap::new();
-        for action in &snapshot.actions {
-            match action {
-                SignalAction::TargetWeight { symbol, weight } if snapshot.complete_targets => {
-                    weights.insert(symbol.clone(), *weight);
-                }
-                SignalAction::TargetWeight { symbol, weight } => intents.push(OrderIntent::TargetPercent {
-                    symbol: symbol.clone(), target_percent: *weight, reason: reason.clone(),
-                }),
-                SignalAction::Exit { symbol } => intents.push(OrderIntent::TargetPercent {
-                    symbol: symbol.clone(), target_percent: 0.0, reason: reason.clone(),
-                }),
-                SignalAction::Reduce { symbol, remaining_ratio } => {
-                    if let Some(position) = portfolio.position(symbol).filter(|position| position.quantity > 0) {
-                        let quantity = (f64::from(position.quantity) * remaining_ratio).floor() as u32;
-                        let target_quantity = i32::try_from(quantity).map_err(|_| "signal_reduction_quantity_overflow")?;
-                        intents.push(OrderIntent::TargetShares { symbol: symbol.clone(), target_quantity, reason: reason.clone() });
-                    }
-                }
-                SignalAction::BuyCondition { .. } => {}
-            }
-        }
-        if snapshot.complete_targets {
-            if weights.is_empty() {
-                for position in portfolio.positions().values().filter(|position| position.quantity > 0) {
-                    intents.push(OrderIntent::TargetPercent { symbol: position.symbol.clone(), target_percent: 0.0, reason: reason.clone() });
-                }
-            } else {
-                intents.push(OrderIntent::TargetPortfolioSmart { target_weights: weights,
-                    order_prices: None, valuation_prices: None, reason });
-            }
-        }
-        Ok(intents)
-    }
-
-    pub fn buy_denials(&self, ctx: &StrategyContext<'_>) -> Result<BTreeMap<String, String>, String> {
-        Ok(self.snapshot_for(ctx)?.actions.iter().filter_map(|action| match action {
-            SignalAction::BuyCondition { symbol, allowed: false } => Some((symbol.clone(), "信号买入条件未满足".into())),
-            _ => None,
-        }).collect())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use chrono::Duration;
-    use serde_json::json;
-
-    fn book() -> SignalBook {
-        let decision: DateTime<Utc> = "2025-01-07T09:30:00+08:00".parse().unwrap();
-        let source: DateTime<Utc> = "2025-01-06T15:00:00+08:00".parse().unwrap();
-        seal(SignalBook {
-            schema: SIGNAL_BOOK_SCHEMA.into(), version_sha256: "a".repeat(64), generator_sha256: "b".repeat(64),
-            model_sha256: Some("d".repeat(64)),
-            knowledge_cutoff: Some("2024-12-31T15:00:00+08:00".parse().unwrap()),
-            provenance: SignalProvenance::Reconstructed, frequency: SignalFrequency::Daily,
-            expected_decisions: vec![decision], snapshots: vec![SignalSnapshot {
-                signal_at: source,
-                decision_at: decision, input_as_of: source, input_available_at: source,
-                generated_at: decision + Duration::days(10), published_at: decision + Duration::days(10),
-                input_sha256: "c".repeat(64), complete_targets: true,
-                actions: vec![SignalAction::TargetWeight { symbol: "000001.SZ".into(), weight: 0.5 }],
-            }],
-        })
-    }
-
-    fn seal(mut book:SignalBook)->SignalBook {
-        book.version_sha256=book.content_sha256().unwrap();
-        book
-    }
-
-    fn at_context<T>(at: Option<NaiveDateTime>, action: impl FnOnce(&StrategyContext<'_>) -> T) -> T {
-        let data = crate::DataSet::from_components(vec![], vec![], vec![], vec![], vec![crate::BenchmarkSnapshot {
-            date:NaiveDate::from_ymd_opt(2025,1,6).unwrap(), benchmark:"clock-fixture".into(),
-            open:100.0, close:100.0, prev_close:100.0, volume:1,
-        }]).unwrap();
-        let portfolio = PortfolioState::new(10_000.0);
-        let symbols = BTreeSet::new();
-        action(&StrategyContext {
-            execution_date: NaiveDate::from_ymd_opt(2025,1,7).unwrap(),
-            decision_date: NaiveDate::from_ymd_opt(2025,1,6).unwrap(), decision_index:0,
-            data:&data, portfolio:&portfolio, futures_account:None, open_orders:&[],
-            dynamic_universe:None, subscriptions:&symbols, process_events:&[], active_process_event:None,
-            active_datetime:at, order_events:&[], fills:&[],
-        })
-    }
-
-    #[test]
-    fn observed_next_open_never_backdates_a_morning_publication_into_yesterdays_orders() {
-        let mut raw = book();
-        raw.provenance=SignalProvenance::Observed;
-        raw.snapshots[0].generated_at="2025-01-07T08:45:00+08:00".parse().unwrap();
-        raw.snapshots[0].published_at="2025-01-07T08:46:00+08:00".parse().unwrap();
-        let value=seal(raw).validate().unwrap();
-        for clock in ["2025-01-06T15:00:00", "2025-01-07T08:45:00"] {
-            at_context(Some(clock.parse().unwrap()), |ctx| {
-                assert_eq!(value.intents(ctx).unwrap_err(),"observed_signal_published_after_consumption_clock");
-                assert!(ctx.portfolio.positions().is_empty());
-            });
-        }
-        at_context(Some("2025-01-07T09:30:00".parse().unwrap()), |ctx| {
-            assert_eq!(value.intents(ctx).unwrap().len(),1);
-            assert!(ctx.portfolio.positions().is_empty());
-        });
-        at_context(None, |ctx| assert_eq!(value.intents(ctx).unwrap_err(),"observed_signal_consumption_clock_missing"));
-    }
-
-    #[test]
-    fn reconstruction_ignores_research_wall_clock_but_never_early_input_availability() {
-        let value=book().validate().unwrap();
-        at_context(Some("2025-01-06T15:00:00".parse().unwrap()), |ctx| assert!(value.intents(ctx).is_ok()));
-        at_context(Some("2025-01-06T14:59:59".parse().unwrap()), |ctx| {
-            assert_eq!(value.intents(ctx).unwrap_err(),"signal_not_available_at_consumption_clock");
-        });
-        let mut raw=book();
-        raw.snapshots[0].input_as_of="2025-01-07T08:30:00+08:00".parse().unwrap();
-        raw.snapshots[0].input_available_at=raw.snapshots[0].input_as_of;
-        raw.snapshots[0].signal_at=raw.snapshots[0].input_as_of;
-        let value=seal(raw).validate().unwrap();
-        at_context(Some("2025-01-07T09:30:00".parse().unwrap()), |ctx| {
-            assert_eq!(value.intents(ctx).unwrap_err(),"next_open_signal_contains_execution_session_inputs");
-        });
-    }
-
-    #[test]
-    fn historical_reconstruction_is_not_online_publication() {
-        let validated = book().validate().unwrap();
-        assert!(validated.require_observed().unwrap_err().contains("reconstructed"));
-        let mut observed = book();
-        observed.provenance = SignalProvenance::Observed;
-        assert!(observed.clone().validate().unwrap_err().contains("not_available"));
-        observed.snapshots[0].generated_at = observed.snapshots[0].decision_at;
-        observed.snapshots[0].published_at = observed.snapshots[0].decision_at;
-        seal(observed).validate().unwrap().require_observed().unwrap();
-    }
-
-    #[test]
-    fn rejects_future_inputs_and_model_knowledge() {
-        for field in 0..3 {
-            let mut value = book();
-            let future = value.snapshots[0].decision_at + Duration::seconds(1);
-            match field {
-                0 => value.snapshots[0].input_as_of = future,
-                1 => value.snapshots[0].input_available_at = future,
-                _ => value.knowledge_cutoff = Some(future),
-            }
-            assert!(value.validate().unwrap_err().contains("future"));
-        }
-    }
-
-    #[test]
-    fn rejects_quantities_prices_and_unknown_signal_fields() {
-        for name in ["quantity", "execution_price", "account_id", "cash"] {
-            let mut action = json!({"kind":"target_weight","symbol":"000001.SZ","weight":0.5});
-            action[name] = json!(100);
-            assert!(serde_json::from_value::<SignalAction>(action).is_err());
-        }
-    }
-
-    #[test]
-    fn coverage_and_duplicate_actions_fail_closed() {
-        let mut value = book();
-        value.expected_decisions.push(value.expected_decisions[0] + Duration::days(1));
-        assert!(value.validate().unwrap_err().contains("coverage"));
-        let mut value = book();
-        value.snapshots.push(value.snapshots[0].clone());
-        value.expected_decisions.push(value.expected_decisions[0]);
-        assert!(value.validate().unwrap_err().contains("duplicate"));
-        let mut value = book();
-        let repeated = value.snapshots[0].actions[0].clone();
-        value.snapshots[0].actions.push(repeated);
-        assert!(value.validate().unwrap_err().contains("duplicate"));
-    }
-
-    #[test]
-    fn rejects_overallocation_nonfinite_and_ambiguous_actions() {
-        for weight in [f64::NAN, f64::INFINITY, -0.1, 1.1] {
-            let mut value = book();
-            value.snapshots[0].actions[0] = SignalAction::TargetWeight { symbol: "000001.SZ".into(), weight };
-            assert!(value.validate().is_err());
-        }
-        let mut value = book();
-        value.snapshots[0].actions.push(SignalAction::TargetWeight { symbol:"000002.SZ".into(),weight:0.6 });
-        assert!(value.validate().unwrap_err().contains("exposure"));
-        let mut value = book();
-        value.snapshots[0].actions.push(SignalAction::Exit {symbol:"000001.SZ".into()});
-        assert!(value.validate().is_err());
-    }
-
-    #[test]
-    fn next_open_uses_decision_session_and_never_nearest_signal() {
-        let value = book().validate().unwrap();
-        let day = NaiveDate::from_ymd_opt(2025,1,7).unwrap();
-        assert!(value.snapshot_at(day, NaiveTime::from_hms_opt(9,30,0), true).is_ok());
-        assert!(value.snapshot_at(day, NaiveTime::from_hms_opt(14,59,0), false).is_err());
-        assert!(value.snapshot_at(day + Duration::days(1), None, true).is_err());
-    }
-
-    #[test]
-    fn reduction_is_resolved_from_each_accounts_actual_position() {
-        let mut raw = book();
-        raw.snapshots[0].complete_targets = false;
-        raw.snapshots[0].actions = vec![SignalAction::Reduce {symbol:"000001.SZ".into(),remaining_ratio:0.5}];
-        let value = seal(raw).validate().unwrap();
-        let day = NaiveDate::from_ymd_opt(2025,1,3).unwrap();
-        for (held, expected) in [(1000,500),(3000,1500)] {
-            let mut portfolio = PortfolioState::new(100_000.0);
-            portfolio.position_mut("000001.SZ").buy(day,held,10.0);
-            let result = value.snapshot_intents(&value.book.snapshots[0],&portfolio).unwrap();
-            assert!(matches!(result[0],OrderIntent::TargetShares {target_quantity,..} if target_quantity==expected));
-            assert_eq!(portfolio.position("000001.SZ").unwrap().quantity,held);
-        }
-        assert!(value.snapshot_intents(&value.book.snapshots[0],&PortfolioState::new(10_000.0)).unwrap().is_empty());
-    }
-
-    #[test]
-    fn empty_complete_snapshot_clears_only_that_accounts_holdings() {
-        let mut raw = book();
-        raw.snapshots[0].actions.clear();
-        let value = seal(raw).validate().unwrap();
-        let day = NaiveDate::from_ymd_opt(2025,1,3).unwrap();
-        let mut portfolio = PortfolioState::new(100_000.0);
-        portfolio.position_mut("000002.SZ").buy(day,200,10.0);
-        let result = value.snapshot_intents(&value.book.snapshots[0],&portfolio).unwrap();
-        assert!(matches!(&result[0],OrderIntent::TargetPercent {symbol,target_percent,..} if symbol=="000002.SZ" && *target_percent==0.0));
-    }
-
-    #[test]
-    fn platform_spec_consumes_book_without_running_another_selection() {
-        let spec = json!({"signalBook":book(),"runtimeExpressions":{"trading":{"actions":[{"kind":"consume_signal"}]}}});
-        let config = crate::platform_strategy_spec::platform_expr_config_from_value("signal-fixture","000001.SZ",&spec).unwrap();
-        assert!(!config.rotation_enabled && config.signal_book.is_some());
-        assert!(matches!(config.explicit_actions.as_slice(),[crate::PlatformTradeAction::ConsumeSignal]));
-    }
-
-    #[test]
-    fn changed_valid_contents_must_not_reuse_a_version_hash() {
-        let mut raw=book();
-        raw.snapshots[0].actions=vec![SignalAction::TargetWeight{symbol:"000001.SZ".into(),weight:0.4}];
-        assert_eq!(raw.clone().validate().unwrap_err(),"signal_book_content_hash_mismatch");
-        seal(raw).validate().unwrap();
-    }
-
-    #[test]
-    fn completed_daily_inputs_may_be_published_after_market_close() {
-        let mut raw=book();
-        raw.expected_decisions=vec!["2026-07-07T09:30:00+08:00".parse().unwrap()];
-        raw.snapshots[0].decision_at=raw.expected_decisions[0];
-        raw.snapshots[0].input_as_of="2026-07-06T15:30:00+08:00".parse().unwrap();
-        raw.snapshots[0].input_available_at="2026-07-06T16:00:00+08:00".parse().unwrap();
-        raw.snapshots[0].signal_at=raw.snapshots[0].input_available_at;
-        raw.snapshots[0].generated_at=raw.snapshots[0].input_available_at;
-        raw.snapshots[0].published_at=raw.snapshots[0].generated_at;
-        raw.provenance=SignalProvenance::Observed;
-        seal(raw).validate().unwrap().require_observed().unwrap();
-    }
-}

crates/fidc-core/src/stock_pool_candidates.rs

@@ -1,229 +0,0 @@
-//! Candidate provenance and ordering; contains no market-data or broker I/O.
-use std::collections::{BTreeMap, BTreeSet};
-
-use chrono::NaiveDate;
-use serde::{Deserialize, Serialize};
-
-pub const CANDIDATE_SOURCES_SCHEMA: u32 = 1;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum CandidateSourceMode {
-    Manual,
-    FilteredManual,
-    Automatic,
-    Mixed,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
-#[serde(rename_all = "snake_case")]
-pub enum CandidateSourcePriority {
-    #[default]
-    ManualFirst,
-    AutomaticFirst,
-    ListOrder,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct CandidateSourcePolicy {
-    pub schema_version: u32,
-    pub mode: CandidateSourceMode,
-    #[serde(default)]
-    pub priority: CandidateSourcePriority,
-    #[serde(default)]
-    pub merged_order: Vec<String>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct CandidateMember {
-    pub symbol: String,
-    pub manual: bool,
-    pub automatic: bool,
-}
-
-fn symbols(values: &[String], label: &str) -> Result<Vec<String>, String> {
-    let mut seen = BTreeSet::new();
-    values.iter().map(|value| {
-        let symbol = value.trim().to_ascii_uppercase();
-        if !symbol.rsplit_once('.').is_some_and(|(code, exchange)| {
-            code.len() == 6 && code.bytes().all(|byte| byte.is_ascii_digit())
-                && matches!(exchange, "SH" | "SZ" | "BJ")
-        }) {
-            return Err(format!("{label}: invalid qualified security code {value}"));
-        }
-        if !seen.insert(symbol.clone()) {
-            return Err(format!("{label}: duplicate security {symbol}"));
-        }
-        Ok(symbol)
-    }).collect()
-}
-
-impl CandidateSourcePolicy {
-    pub fn validate(&self) -> Result<(), String> {
-        if self.schema_version != CANDIDATE_SOURCES_SCHEMA {
-            return Err("candidate_sources schema_version must be 1".into());
-        }
-        symbols(&self.merged_order, "candidate_sources.merged_order")?;
-        if self.mode != CandidateSourceMode::Mixed && self.priority != CandidateSourcePriority::ManualFirst {
-            return Err("candidate source priority only applies to mixed sources".into());
-        }
-        if self.priority != CandidateSourcePriority::ListOrder && !self.merged_order.is_empty() {
-            return Err("merged_order requires list_order priority".into());
-        }
-        Ok(())
-    }
-
-    pub fn uses_screen(&self) -> bool {
-        self.mode != CandidateSourceMode::Manual
-    }
-
-    pub fn validate_screen_binding(&self, manual: &[String], has_screen: bool) -> Result<(), String> {
-        self.validate()?;
-        symbols(manual, "manual candidates")?;
-        if self.uses_screen() != has_screen {
-            return Err("candidate source mode and screen contract must agree".into());
-        }
-        if self.mode == CandidateSourceMode::FilteredManual && manual.is_empty() {
-            return Err("filtered_manual requires manual members; an empty scope must not become all-market".into());
-        }
-        Ok(())
-    }
-}
-
-/// Overlap between two valid sources denotes one member with both provenance
-/// flags. Duplicates *within* a source are invalid evidence, not fixed by dedup.
-pub fn resolve_candidates(
-    policy: &CandidateSourcePolicy,
-    manual: &[String],
-    automatic: Option<&[String]>,
-) -> Result<Vec<CandidateMember>, String> {
-    policy.validate_screen_binding(manual, automatic.is_some())?;
-    let manual = symbols(manual, "manual candidates")?;
-    let automatic = automatic.map(|values| symbols(values, "automatic candidates")).transpose()?.unwrap_or_default();
-    let manual_set = manual.iter().cloned().collect::<BTreeSet<_>>();
-    let auto_set = automatic.iter().cloned().collect::<BTreeSet<_>>();
-    if policy.mode == CandidateSourceMode::FilteredManual && !auto_set.is_subset(&manual_set) {
-        return Err("filtered_manual snapshot contains a security outside the manual scope".into());
-    }
-    let mut ordered = match policy.mode {
-        CandidateSourceMode::Manual => manual.clone(),
-        CandidateSourceMode::FilteredManual | CandidateSourceMode::Automatic => automatic.clone(),
-        CandidateSourceMode::Mixed => {
-            let (first, second) = if policy.priority == CandidateSourcePriority::AutomaticFirst {
-                (&automatic, &manual)
-            } else { (&manual, &automatic) };
-            let mut union = first.clone();
-            let mut seen = first.iter().cloned().collect::<BTreeSet<_>>();
-            union.extend(second.iter().filter(|symbol| seen.insert((*symbol).clone())).cloned());
-            union
-        }
-    };
-    if policy.priority == CandidateSourcePriority::ListOrder {
-        let present = ordered.iter().cloned().collect::<BTreeSet<_>>();
-        let prefix = symbols(&policy.merged_order, "candidate_sources.merged_order")?
-            .into_iter().filter(|symbol| present.contains(symbol)).collect::<Vec<_>>();
-        let selected = prefix.iter().cloned().collect::<BTreeSet<_>>();
-        let tail = ordered.into_iter().filter(|symbol| !selected.contains(symbol));
-        ordered = prefix.into_iter().chain(tail).collect();
-    }
-    Ok(ordered.into_iter().map(|symbol| CandidateMember {
-        manual: manual_set.contains(&symbol), automatic: auto_set.contains(&symbol), symbol,
-    }).collect())
-}
-
-/// Raw daily automatic candidates remain unchanged. Every resolved list is
-/// derived by the shared kernel; absent dates never inherit yesterday's list.
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct CandidateSourceBook {
-    pub schema_version: u32,
-    pub policy: CandidateSourcePolicy,
-    pub manual_symbols: Vec<String>,
-    pub automatic_symbols_by_date: BTreeMap<NaiveDate, Vec<String>>,
-    pub source_snapshot_sha256: String,
-    pub source_coverage_sha256: String,
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub execution_symbols: Option<Vec<String>>,
-}
-
-impl CandidateSourceBook {
-    pub fn resolve(&self) -> Result<BTreeMap<NaiveDate, Vec<CandidateMember>>, String> {
-        if self.schema_version != CANDIDATE_SOURCES_SCHEMA || !self.policy.uses_screen() {
-            return Err("candidate source book requires schema 1 and a screened source".into());
-        }
-        for value in [&self.source_snapshot_sha256, &self.source_coverage_sha256] {
-            if value.len() != 64 || !value.bytes().all(|byte| byte.is_ascii_hexdigit()) {
-                return Err("candidate source book requires snapshot and coverage SHA256".into());
-            }
-        }
-        if self.automatic_symbols_by_date.is_empty() {
-            return Err("candidate source book requires explicit covered trading dates".into());
-        }
-        let scope = self.execution_symbols.as_ref().map(|values| symbols(values, "candidate execution scope")
-            .map(|values| values.into_iter().collect::<BTreeSet<_>>())).transpose()?;
-        self.automatic_symbols_by_date.iter().map(|(day, values)| {
-            resolve_candidates(&self.policy, &self.manual_symbols, Some(values))
-                .map(|members| (*day, members.into_iter().filter(|member| scope.as_ref().is_none_or(|scope| scope.contains(&member.symbol))).collect()))
-        }).collect()
-    }
-
-    pub fn resolved_symbols(&self) -> Result<BTreeMap<NaiveDate, Vec<String>>, String> {
-        Ok(self.resolve()?.into_iter().map(|(date, values)|
-            (date, values.into_iter().map(|member| member.symbol).collect())).collect())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    fn list(values: &[&str]) -> Vec<String> { values.iter().map(|value| value.to_string()).collect() }
-    fn policy(mode: CandidateSourceMode, priority: CandidateSourcePriority) -> CandidateSourcePolicy {
-        CandidateSourcePolicy { schema_version: 1, mode, priority, merged_order: vec![] }
-    }
-    #[test]
-    fn mixed_sources_preserve_priority_and_both_provenances() {
-        let manual = list(&["600000.SH", "000001.SZ"]);
-        let automatic = list(&["000002.SZ", "000001.SZ"]);
-        for (priority, expected) in [
-            (CandidateSourcePriority::ManualFirst, list(&["600000.SH", "000001.SZ", "000002.SZ"])),
-            (CandidateSourcePriority::AutomaticFirst, list(&["000002.SZ", "000001.SZ", "600000.SH"])),
-        ] {
-            let result = resolve_candidates(&policy(CandidateSourceMode::Mixed, priority), &manual, Some(&automatic)).unwrap();
-            assert_eq!(result.iter().map(|value| value.symbol.clone()).collect::<Vec<_>>(), expected);
-            let overlap = result.iter().find(|value| value.symbol == "000001.SZ").unwrap();
-            assert!(overlap.manual && overlap.automatic);
-        }
-    }
-    #[test]
-    fn list_order_reuses_explicit_prefix_and_appends_new_candidates() {
-        let mut p = policy(CandidateSourceMode::Mixed, CandidateSourcePriority::ListOrder);
-        p.merged_order = list(&["000002.SZ", "600036.SH", "600000.SH"]);
-        let result = resolve_candidates(&p, &list(&["600000.SH", "000001.SZ"]), Some(&list(&["000002.SZ", "000003.SZ"]))).unwrap();
-        assert_eq!(result.into_iter().map(|row| row.symbol).collect::<Vec<_>>(), list(&["000002.SZ", "600000.SH", "000001.SZ", "000003.SZ"]));
-    }
-    #[test]
-    fn missing_snapshot_duplicate_input_and_empty_filtered_scope_fail() {
-        let p = policy(CandidateSourceMode::Mixed, CandidateSourcePriority::ManualFirst);
-        assert!(resolve_candidates(&p, &[], None).is_err());
-        assert!(resolve_candidates(&p, &[], Some(&list(&["000001.SZ", "000001.sz"]))).is_err());
-        let p = policy(CandidateSourceMode::FilteredManual, CandidateSourcePriority::ManualFirst);
-        assert!(resolve_candidates(&p, &[], Some(&[])).unwrap_err().contains("all-market"));
-        assert!(resolve_candidates(&p, &list(&["000001.SZ"]), Some(&list(&["600000.SH"]))).is_err());
-    }
-    #[test]
-    fn zero_automatic_day_keeps_manual_members_without_inheriting_old_auto_targets() {
-        let day1 = NaiveDate::from_ymd_opt(2026, 9, 9).unwrap();
-        let day2 = NaiveDate::from_ymd_opt(2026, 9, 10).unwrap();
-        let book = CandidateSourceBook { schema_version: 1,
-            policy: policy(CandidateSourceMode::Mixed, CandidateSourcePriority::AutomaticFirst),
-            manual_symbols: list(&["510300.SH"]),
-            automatic_symbols_by_date: BTreeMap::from([(day1, list(&["000001.SZ"])), (day2, vec![])]),
-            source_snapshot_sha256: "a".repeat(64), source_coverage_sha256: "b".repeat(64), execution_symbols:None };
-        let result = book.resolved_symbols().unwrap();
-        assert_eq!(result[&day1], list(&["000001.SZ", "510300.SH"]));
-        assert_eq!(result[&day2], list(&["510300.SH"]));
-        let mut auto = book; auto.policy = policy(CandidateSourceMode::Automatic, CandidateSourcePriority::ManualFirst);
-        assert!(auto.resolved_symbols().unwrap()[&day2].is_empty());
-    }
-}

crates/fidc-core/src/stock_pool_frozen.rs

@@ -1,150 +0,0 @@
-//! Dated non-tradability and valuation are separate from execution quotations.
-use super::*;
-
-pub(super) fn validate(
-    signal_date: NaiveDate,
-    constraints: &StockPoolDecisionConstraints,
-    current: &BTreeMap<String, (Decimal, Decimal, Decimal)>,
-) -> Result<(), String> {
-    for (symbol, fact) in &constraints.frozen_positions {
-        if constraints.execution_date != Some(fact.trade_date)
-            || fact.trade_date < signal_date
-            || fact.reason != "paused"
-            || fact.valuation_price <= Decimal::ZERO
-            || current.get(symbol).is_none_or(|row| row.0 <= Decimal::ZERO)
-        {
-            return Err(format!("stock_pool_frozen_position_invalid:{symbol}"));
-        }
-    }
-    if constraints
-        .prior_target_weights
-        .iter()
-        .any(|(symbol, weight)| {
-            normalize_stock_symbol(symbol).as_ref() != Some(symbol)
-                || !(0..=10_000).contains(weight)
-        })
-    {
-        return Err("stock_pool_prior_target_weights_invalid".into());
-    }
-    Ok(())
-}
-
-pub(super) fn valuation(
-    symbol: &str,
-    quotes: &HashMap<String, &MarketSnapshot>,
-    frozen: &BTreeMap<String, FrozenStockPoolPosition>,
-) -> Result<Decimal, String> {
-    frozen
-        .get(symbol)
-        .map(|fact| fact.valuation_price)
-        .or_else(|| quotes.get(symbol).map(|quote| quote.last_price))
-        .filter(|price| *price > Decimal::ZERO)
-        .ok_or_else(|| format!("{symbol} confirmed holding valuation missing"))
-}
-
-pub(super) fn weights(
-    original: &[String],
-    active: &[String],
-    members: &[StockPoolMemberSpec],
-    explicit: &BTreeMap<String, i32>,
-    constraints: &StockPoolDecisionConstraints,
-    reserved_slots: usize,
-    target_count: usize,
-) -> Result<BTreeMap<String, i32>, String> {
-    let count = original.len() + reserved_slots;
-    let order = members
-        .iter()
-        .map(|member| (&member.symbol, member.requested_order))
-        .collect::<BTreeMap<_, _>>();
-    let mut original_budget_symbols = original.to_vec();
-    for symbol in constraints.frozen_positions.keys() {
-        if order.contains_key(symbol) && !original_budget_symbols.contains(symbol) {
-            original_budget_symbols.push(symbol.clone());
-        }
-    }
-    if original_budget_symbols.len() != original.len() {
-        original_budget_symbols
-            .sort_by_key(|symbol| order.get(symbol).copied().unwrap_or(i32::MAX));
-    }
-    let initial = original_budget_symbols
-        .iter()
-        .enumerate()
-        .map(|(index, symbol)| {
-            let weight = if explicit.is_empty() {
-                if count == 0 {
-                    0
-                } else {
-                    10_000 / count as i32 + i32::from(index < 10_000 % count)
-                }
-            } else {
-                *explicit.get(symbol).unwrap_or(&0)
-            };
-            (symbol.clone(), weight)
-        })
-        .collect::<Vec<_>>();
-    let mut frozen = BTreeMap::new();
-    for symbol in constraints.frozen_positions.keys() {
-        let weight = explicit
-            .get(symbol)
-            .copied()
-            .or_else(|| constraints.prior_target_weights.get(symbol).copied())
-            .or_else(|| {
-                initial
-                    .iter()
-                    .find(|(key, _)| key == symbol)
-                    .map(|(_, weight)| *weight)
-            })
-            .ok_or_else(|| format!("stock_pool_frozen_position_target_weight_missing:{symbol}"))?;
-        frozen.insert(symbol.clone(), weight);
-    }
-    let frozen_total = frozen.values().copied().sum::<i32>();
-    if frozen_total > 10_000 {
-        return Err("stock_pool_frozen_position_weights_exceed_budget".into());
-    }
-    let mut free = initial
-        .into_iter()
-        .filter(|(symbol, _)| !frozen.contains_key(symbol))
-        .map(|(symbol, weight)| (symbol, weight as u32))
-        .collect::<Vec<_>>();
-    let total = free.iter().map(|(_, weight)| *weight).sum::<u32>();
-    let available = (10_000 - frozen_total) as u32;
-    // A paused holding removed from today's candidates still owns its prior
-    // budget. Scale only the new tradable allocation, never the frozen leg.
-    if total > available {
-        let mut remainder = available;
-        for (_, weight) in &mut free {
-            *weight = (u64::from(*weight) * u64::from(available) / u64::from(total)) as u32;
-            remainder -= *weight;
-        }
-        for (_, weight) in free.iter_mut().take(remainder as usize) {
-            *weight += 1;
-        }
-    }
-    let excluded = free
-        .iter()
-        .filter(|(symbol, _)| !active.contains(symbol))
-        .map(|(symbol, _)| symbol.clone())
-        .collect();
-    let candidates = active
-        .iter()
-        .filter(|symbol| !frozen.contains_key(*symbol))
-        .cloned()
-        .collect::<Vec<_>>();
-    let allocated = crate::platform_expr_strategy::replenish_target_weight_bps(
-        &free,
-        &candidates,
-        &excluded,
-        target_count.saturating_sub(
-            frozen
-                .keys()
-                .filter(|symbol| original.contains(symbol))
-                .count(),
-        ),
-    );
-    frozen.extend(
-        allocated
-            .into_iter()
-            .map(|(symbol, weight)| (symbol, weight as i32)),
-    );
-    Ok(frozen)
-}

crates/fidc-core/src/stock_pool_index_cap.rs

@@ -1,93 +0,0 @@
-//! Index exposure is independent of relative-weight maintenance. Reduce the
-//! existing proportions only when the portfolio exceeds its index budget.
-use super::*;
-
-pub(super) struct IndexCapTarget {
-    pub quantity: Decimal,
-    pub blocked_by_t1: bool,
-}
-
-pub(super) fn remaining_index_targets(
-    current: &BTreeMap<String, (Decimal, Decimal, Decimal)>,
-    members: &HashMap<String, &StockPoolMemberSpec>,
-    automatic: &BTreeMap<String, crate::holding_policy::AutomaticTradePermission>,
-    already_planned: &[StockPoolPlanRow],
-    quotes: &HashMap<String, &MarketSnapshot>,
-    frozen: &BTreeMap<String, FrozenStockPoolPosition>,
-    budget: Decimal,
-) -> Result<BTreeMap<String, IndexCapTarget>, String> {
-    struct Entry {
-        symbol: String,
-        quantity: Decimal,
-        minimum: Decimal,
-        price: Decimal,
-    }
-    let other = already_planned
-        .iter()
-        .map(|row| (&row.symbol, row))
-        .collect::<BTreeMap<_, _>>();
-    let mut fixed = Decimal::ZERO;
-    let mut entries = Vec::new();
-    for (symbol, (quantity, closable, _)) in current.iter().filter(|(_, row)| row.0 > Decimal::ZERO)
-    {
-        let price = super::frozen::valuation(symbol, quotes, frozen)?;
-        let minimum = (*quantity - *closable).max(Decimal::ZERO);
-        let remaining = other
-            .get(symbol)
-            .map(|row| row.target_quantity.min(*quantity))
-            .unwrap_or(*quantity)
-            .max(minimum);
-        if frozen.contains_key(symbol)
-            || automatic
-                .get(symbol)
-                .is_some_and(|permission| permission.sell_denial.is_some())
-        {
-            fixed += *quantity * price;
-        } else if members.contains_key(symbol) && remaining > Decimal::ZERO {
-            entries.push(Entry {
-                symbol: symbol.clone(),
-                quantity: remaining,
-                minimum,
-                price,
-            });
-        } else {
-            fixed += remaining * price;
-        }
-    }
-    let mut remaining = entries
-        .iter()
-        .map(|row| row.quantity * row.price)
-        .sum::<Decimal>();
-    let mut available = (budget - fixed).max(Decimal::ZERO);
-    if remaining <= available {
-        return Ok(BTreeMap::new());
-    }
-    // The highest non-sellable proportions are fixed first; the remainder
-    // keeps its existing relative weights. No planned sale funds a new buy.
-    entries.sort_by(|left, right| {
-        (right.minimum / right.quantity)
-            .cmp(&(left.minimum / left.quantity))
-            .then_with(|| left.symbol.cmp(&right.symbol))
-    });
-    let mut result = BTreeMap::new();
-    for row in entries {
-        let scale = if remaining > Decimal::ZERO {
-            (available / remaining).min(Decimal::ONE)
-        } else {
-            Decimal::ZERO
-        };
-        let desired = (row.quantity * scale).floor();
-        let blocked = desired < row.minimum;
-        let target = desired.max(row.minimum).min(row.quantity);
-        remaining -= row.quantity * row.price;
-        available = (available - target * row.price).max(Decimal::ZERO);
-        result.insert(
-            row.symbol,
-            IndexCapTarget {
-                quantity: target,
-                blocked_by_t1: blocked,
-            },
-        );
-    }
-    Ok(result)
-}

crates/fidc-core/src/stock_pool_index_policy.rs

@@ -1,344 +0,0 @@
-//! Explicit index timing, shared by historical and online stock-pool planners.
-//! Inputs are completed official sessions, not a shortened available-row window.
-use chrono::NaiveDate;
-use serde::{Deserialize, Serialize};
-use sha2::{Digest, Sha256};
-
-#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
-#[serde(default, deny_unknown_fields)]
-pub struct MarketTimingPolicy {
-    pub enabled: bool,
-    pub index_code: Option<String>,
-    pub fast_window: Option<usize>,
-    pub slow_window: Option<usize>,
-    pub volatility_window: Option<usize>,
-    pub drawdown_window: Option<usize>,
-    pub bull_exposure: Option<f64>,
-    pub bear_exposure: Option<f64>,
-    pub volatility_threshold: Option<f64>,
-    pub volatility_cap: Option<f64>,
-    pub drawdown_threshold: Option<f64>,
-    pub drawdown_cap: Option<f64>,
-}
-
-impl MarketTimingPolicy {
-    pub fn from_allocation(value: &serde_json::Value) -> Result<Self, String> {
-        let raw = value.get("market_timing").filter(|value| !value.is_null());
-        let policy = raw
-            .map(|raw| serde_json::from_value::<Self>(raw.clone()))
-            .transpose()
-            .map_err(|error| format!("market_timing_invalid:{error}"))?
-            .unwrap_or_default();
-        policy.validate()?;
-        Ok(policy)
-    }
-
-    pub fn validate(&self) -> Result<(), String> {
-        if let Some(index) = &self.index_code {
-            let valid = index.split_once('.').is_some_and(|(code, exchange)| {
-                (6..=12).contains(&code.len())
-                    && code
-                        .bytes()
-                        .all(|v| v.is_ascii_uppercase() || v.is_ascii_digit())
-                    && matches!(exchange, "SH" | "SZ" | "CSI" | "CNI")
-            });
-            if !valid {
-                return Err("market_timing_index_code_invalid".into());
-            }
-        } else if self.enabled {
-            return Err("market_timing_index_code_required".into());
-        }
-        for (key, value) in [
-            ("fast_window", self.fast_window),
-            ("slow_window", self.slow_window),
-            ("volatility_window", self.volatility_window),
-            ("drawdown_window", self.drawdown_window),
-        ] {
-            match value {
-                Some(value) if !(2..=250).contains(&value) => {
-                    return Err(format!("market_timing_{key}_must_be_2_to_250"));
-                }
-                None if self.enabled => return Err(format!("market_timing_{key}_required")),
-                _ => {}
-            }
-        }
-        if let (Some(fast), Some(slow)) = (self.fast_window, self.slow_window) {
-            if fast >= slow {
-                return Err("market_timing_fast_window_must_be_less_than_slow_window".into());
-            }
-        }
-        for (key, value) in [
-            ("bull_exposure", self.bull_exposure),
-            ("bear_exposure", self.bear_exposure),
-            ("volatility_threshold", self.volatility_threshold),
-            ("volatility_cap", self.volatility_cap),
-            ("drawdown_threshold", self.drawdown_threshold),
-            ("drawdown_cap", self.drawdown_cap),
-        ] {
-            match value {
-                Some(value) if !value.is_finite() || !(0.0..=1.0).contains(&value) => {
-                    return Err(format!("market_timing_{key}_must_be_in_0_to_1"));
-                }
-                None if self.enabled => return Err(format!("market_timing_{key}_required")),
-                _ => {}
-            }
-        }
-        Ok(())
-    }
-
-    pub fn required_history(&self) -> Result<usize, String> {
-        self.validate()?;
-        if !self.enabled {
-            return Ok(0);
-        }
-        Ok(self
-            .slow_window
-            .unwrap()
-            .max(self.volatility_window.unwrap() + 1)
-            .max(self.drawdown_window.unwrap()))
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct IndexClose {
-    pub date: NaiveDate,
-    pub close: f64,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct MarketTimingInput {
-    pub index_code: String,
-    pub as_of_date: NaiveDate,
-    pub official_dates: Vec<NaiveDate>,
-    pub closes: Vec<IndexClose>,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-pub struct MarketTimingEvaluation {
-    pub index_code: String,
-    pub as_of_date: NaiveDate,
-    pub window_start: NaiveDate,
-    pub session_count: usize,
-    pub fast_ma: f64,
-    pub slow_ma: f64,
-    pub volatility: f64,
-    pub drawdown: f64,
-    pub exposure: f64,
-    pub reason_codes: Vec<String>,
-    pub policy_sha256: String,
-    pub input_sha256: String,
-    pub kernel_sha256: String,
-}
-
-pub fn implementation_sha256() -> String {
-    format!(
-        "{:x}",
-        Sha256::digest(include_bytes!("stock_pool_index_policy.rs"))
-    )
-}
-
-pub fn evaluate(
-    policy: &MarketTimingPolicy,
-    input: &MarketTimingInput,
-    decision_date: NaiveDate,
-) -> Result<MarketTimingEvaluation, String> {
-    let needed = policy.required_history()?;
-    if needed == 0 {
-        return Err("market_timing_disabled_has_no_evaluation".into());
-    }
-    if policy.index_code.as_deref() != Some(input.index_code.as_str()) {
-        return Err("market_timing_input_index_mismatch".into());
-    }
-    if input.as_of_date > decision_date {
-        return Err("market_timing_future_input".into());
-    }
-    if input.official_dates.len() != needed
-        || input.closes.len() != needed
-        || input.official_dates.last() != Some(&input.as_of_date)
-        || input
-            .official_dates
-            .windows(2)
-            .any(|pair| pair[0] >= pair[1])
-    {
-        return Err("market_timing_official_calendar_incomplete".into());
-    }
-    if input
-        .closes
-        .iter()
-        .zip(&input.official_dates)
-        .any(|(row, date)| row.date != *date || !row.close.is_finite() || row.close <= 0.)
-    {
-        return Err("market_timing_completed_index_rows_incomplete".into());
-    }
-    let closes = input.closes.iter().map(|row| row.close).collect::<Vec<_>>();
-    let mean = |window: usize| closes[needed - window..].iter().sum::<f64>() / window as f64;
-    let fast_ma = mean(policy.fast_window.unwrap());
-    let slow_ma = mean(policy.slow_window.unwrap());
-    let returns = closes[needed - policy.volatility_window.unwrap() - 1..]
-        .windows(2)
-        .map(|pair| pair[1] / pair[0] - 1.)
-        .collect::<Vec<_>>();
-    let average = returns.iter().sum::<f64>() / returns.len() as f64;
-    let volatility = (returns
-        .iter()
-        .map(|value| (value - average).powi(2))
-        .sum::<f64>()
-        / (returns.len() - 1) as f64)
-        .sqrt();
-    let peak = closes[needed - policy.drawdown_window.unwrap()..]
-        .iter()
-        .copied()
-        .fold(f64::NEG_INFINITY, f64::max);
-    let drawdown = 1. - closes[needed - 1] / peak;
-    let bullish = fast_ma > slow_ma;
-    let mut exposure = if bullish {
-        policy.bull_exposure.unwrap()
-    } else {
-        policy.bear_exposure.unwrap()
-    };
-    let mut reason_codes = vec![
-        if bullish {
-            "fast_above_slow"
-        } else {
-            "fast_not_above_slow"
-        }
-        .into(),
-    ];
-    if volatility >= policy.volatility_threshold.unwrap() {
-        exposure = exposure.min(policy.volatility_cap.unwrap());
-        reason_codes.push("volatility_cap".into());
-    }
-    if drawdown >= policy.drawdown_threshold.unwrap() {
-        exposure = exposure.min(policy.drawdown_cap.unwrap());
-        reason_codes.push("drawdown_cap".into());
-    }
-    if [fast_ma, slow_ma, volatility, drawdown, exposure]
-        .iter()
-        .any(|value| !value.is_finite())
-    {
-        return Err("market_timing_nonfinite_result".into());
-    }
-    let hash = |value: &serde_json::Value| -> Result<String, String> {
-        Ok(format!(
-            "{:x}",
-            Sha256::digest(serde_json::to_vec(value).map_err(|error| error.to_string())?)
-        ))
-    };
-    Ok(MarketTimingEvaluation {
-        index_code: input.index_code.clone(),
-        as_of_date: input.as_of_date,
-        window_start: input.official_dates[0],
-        session_count: needed,
-        fast_ma,
-        slow_ma,
-        volatility,
-        drawdown,
-        exposure,
-        reason_codes,
-        policy_sha256: hash(&serde_json::to_value(policy).map_err(|error| error.to_string())?)?,
-        input_sha256: hash(&serde_json::to_value(input).map_err(|error| error.to_string())?)?,
-        kernel_sha256: implementation_sha256(),
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    fn policy() -> MarketTimingPolicy {
-        serde_json::from_value(serde_json::json!({"enabled":true,"index_code":"000300.SH","fast_window":10,"slow_window":30,
-        "volatility_window":20,"drawdown_window":60,"bull_exposure":1.0,"bear_exposure":0.3,"volatility_threshold":0.025,
-        "volatility_cap":0.3,"drawdown_threshold":0.08,"drawdown_cap":0.2})).unwrap()
-    }
-    fn input(values: Vec<f64>) -> MarketTimingInput {
-        let dates = (0..values.len())
-            .map(|i| {
-                NaiveDate::from_ymd_opt(2026, 1, 1).unwrap() + chrono::Duration::days(i as i64)
-            })
-            .collect::<Vec<_>>();
-        MarketTimingInput {
-            index_code: "000300.SH".into(),
-            as_of_date: *dates.last().unwrap(),
-            closes: dates
-                .iter()
-                .zip(values)
-                .map(|(date, close)| IndexClose { date: *date, close })
-                .collect(),
-            official_dates: dates,
-        }
-    }
-    #[test]
-    fn trend_and_caps_match_the_declared_math_and_keep_zero_meaningful() {
-        for (prices, expected) in [
-            ((0..60).map(|i| 100. + i as f64).collect(), 1.),
-            ((0..60).map(|i| 200. - i as f64).collect(), 0.2),
-            (
-                (0..59)
-                    .map(|i| 100. + i as f64 * 0.1)
-                    .chain([150.])
-                    .collect(),
-                0.3,
-            ),
-        ] {
-            let input = input(prices);
-            let result = evaluate(&policy(), &input, input.as_of_date).unwrap();
-            assert_eq!(result.exposure, expected);
-            assert_eq!(result.session_count, 60);
-            assert_eq!(result.input_sha256.len(), 64);
-        }
-        let input = input(vec![100.; 60]);
-        let mut zero = policy();
-        zero.bear_exposure = Some(0.);
-        assert_eq!(
-            evaluate(&zero, &input, input.as_of_date).unwrap().exposure,
-            0.
-        );
-    }
-    #[test]
-    fn missing_or_duplicate_or_future_rows_never_shorten_the_window() {
-        let base = input(vec![100.; 60]);
-        let mut invalid = base.clone();
-        invalid.closes.remove(5);
-        assert!(evaluate(&policy(), &invalid, base.as_of_date).is_err());
-        let mut invalid = base.clone();
-        invalid.closes[5].date = invalid.closes[4].date;
-        assert!(evaluate(&policy(), &invalid, base.as_of_date).is_err());
-        let mut invalid = base.clone();
-        invalid.closes[5].close = f64::NAN;
-        assert!(evaluate(&policy(), &invalid, base.as_of_date).is_err());
-        assert!(
-            evaluate(
-                &policy(),
-                &base,
-                base.as_of_date - chrono::Duration::days(1)
-            )
-            .is_err()
-        );
-        let mut invalid = base.clone();
-        invalid.index_code = "000852.SH".into();
-        assert!(evaluate(&policy(), &invalid, base.as_of_date).is_err());
-    }
-    #[test]
-    fn disabled_is_optional_but_enabled_parameters_are_not_invented() {
-        assert_eq!(
-            MarketTimingPolicy::from_allocation(&serde_json::Value::Null)
-                .unwrap()
-                .required_history()
-                .unwrap(),
-            0
-        );
-        assert!(
-            MarketTimingPolicy::from_allocation(
-                &serde_json::json!({"market_timing":{"enabled":true}})
-            )
-            .is_err()
-        );
-        let mut invalid = policy();
-        invalid.fast_window = invalid.slow_window;
-        assert!(invalid.validate().is_err());
-        let mut invalid = policy();
-        invalid.volatility_window = Some(250);
-        assert_eq!(invalid.required_history().unwrap(), 251);
-    }
-}

crates/fidc-core/src/stock_pool_indicators.rs

@@ -1,179 +0,0 @@
-//! Shared causal indicator calculation for stock-pool screening.
-use std::collections::{BTreeMap, BTreeSet};
-use chrono::NaiveDate;
-use serde::{Deserialize, Serialize};
-use serde_json::json;
-
-use crate::factor_events::{self, Expr, Frame};
-
-pub fn implementation_sha256() -> String {
-    use sha2::{Digest,Sha256};
-    let mut identity=Sha256::new();
-    identity.update(include_bytes!("stock_pool_indicators.rs"));
-    identity.update(factor_events::catalog()["expression_kernel_sha256"].as_str().expect("native kernel identity"));
-    format!("{:x}",identity.finalize())
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-#[serde(deny_unknown_fields)]
-pub struct IndicatorSpec {
-    pub indicator: String,
-    pub field: String,
-    pub window: usize,
-    #[serde(default)]
-    pub output: Option<String>,
-}
-
-#[derive(Debug, Clone, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct InputSeries {
-    pub frame: Frame,
-    /// Source-admitted historical suspension/lifecycle gaps, not guessed from
-    /// missing prices. The pure endpoint never certifies those source facts.
-    #[serde(default)]
-    pub admitted_missing_dates: BTreeSet<NaiveDate>,
-}
-
-#[derive(Debug, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct Request {
-    pub specs: BTreeMap<String, IndicatorSpec>,
-    pub series: Vec<InputSeries>,
-    pub output_start_date: NaiveDate,
-    pub output_end_date: NaiveDate,
-}
-
-#[derive(Debug, Serialize)]
-pub struct OutputSeries {
-    pub symbol: String,
-    pub indices: Vec<usize>,
-    pub values: BTreeMap<String, Vec<Option<f64>>>,
-}
-
-pub fn evaluate(request: Request) -> Result<Vec<OutputSeries>, String> {
-    let row_count: usize = request.series.iter().map(|series| series.frame.timestamps.len()).sum();
-    if request.specs.is_empty() || request.specs.len() > 64 || row_count > 60_000
-        || row_count.saturating_mul(request.specs.len()) > 1_000_000
-        || request.output_start_date > request.output_end_date {
-        return Err("stock_pool_indicator_request_budget_or_range_invalid".into());
-    }
-    for spec in request.specs.values() {
-        if !matches!(spec.indicator.as_str(), "ma" | "ema" | "kdj") || !(2..=10_000).contains(&spec.window)
-            || !matches!(spec.field.as_str(), "close" | "volume" | "high" | "low")
-            || (spec.indicator == "kdj" && !matches!(spec.output.as_deref(), Some("k" | "d" | "j"))) {
-            return Err("stock_pool_indicator_spec_invalid".into());
-        }
-    }
-    let mut seen = BTreeSet::new();
-    let mut result = Vec::new();
-    for series in request.series {
-        let frame = series.frame;
-        frame.validate()?;
-        if frame.frequency != "1d" { return Err("stock_pool_indicators_require_daily_source".into()); }
-        if series.admitted_missing_dates.iter().any(|day| !frame.timestamps.iter().any(|stamp| stamp.date_naive() == *day)) {
-            return Err("admitted_missing_date_is_outside_the_input_frame".into());
-        }
-        if !seen.insert(frame.symbol.clone()) { return Err("stock_pool_indicator_duplicate_symbol".into()); }
-        let indices = frame.timestamps.iter().enumerate().filter(|(_, stamp)| {
-            let day = stamp.date_naive(); request.output_start_date <= day && day <= request.output_end_date
-        }).map(|(index, _)| index).collect::<Vec<_>>();
-        let mut values = BTreeMap::new();
-        for (key, spec) in &request.specs {
-            let fields: Vec<&str> = if spec.indicator == "kdj" { vec!["high", "low", "close"] } else { vec![&spec.field] };
-            for field in &fields {
-                let raw = frame.fields.get(*field).ok_or_else(|| format!("indicator_field_missing:{field}"))?;
-                if raw.len() != frame.timestamps.len() { return Err("indicator_field_length_mismatch".into()); }
-            }
-            for index in 0..frame.timestamps.len() {
-                let valid = fields.iter().all(|field| frame.fields[*field][index].is_some_and(f64::is_finite));
-                if valid {
-                    if fields.iter().any(|field| frame.fields[*field][index].is_some_and(|value| if *field == "volume" { value < 0.0 } else { value <= 0.0 })) {
-                        return Err(format!("indicator_input_value_invalid:{}:{}", frame.symbol, frame.timestamps[index]));
-                    }
-                    if spec.indicator == "kdj" {
-                        let (hi, lo, close) = (frame.fields["high"][index].unwrap(), frame.fields["low"][index].unwrap(), frame.fields["close"][index].unwrap());
-                        if hi < lo || close < lo || close > hi { return Err(format!("indicator_ohlc_invalid:{}:{}", frame.symbol, frame.timestamps[index])); }
-                    }
-                }
-                else if !series.admitted_missing_dates.contains(&frame.timestamps[index].date_naive()) {
-                    return Err(format!("unclassified_indicator_input_gap:{}:{}", frame.symbol, frame.timestamps[index]));
-                }
-            }
-            let native_values = {
-                // The native KDJ has its own initialisation and lookback. Do
-                // not recreate it as STOCH or an independently seeded loop.
-                // Preserve admitted NULL rows too: the shared kernel defines
-                // gap/warmup semantics; compressing the calendar changes them.
-                let expression: Expr = serde_json::from_value(if spec.indicator == "kdj" {
-                    json!({"kind":"indicator","name":"KDJ","inputs":[],
-                        "parameters":{"optInFastK_Period":spec.window,"optInSlowK_Period":3,
-                            "optInSlowK_MAType":13,"optInSlowD_Period":3,"optInSlowD_MAType":13},
-                        "output":match spec.output.as_deref() { Some("k") => 0, Some("d") => 1, _ => 2 }})
-                } else {
-                    json!({"kind":"indicator","name":if spec.indicator == "ma" {"SMA"} else {"EMA"},
-                        "inputs":[{"kind":"field","name":spec.field}],"parameters":{"optInTimePeriod":spec.window}})
-                }).map_err(|error| error.to_string())?;
-                factor_events::evaluate(&expression, &frame)?.values
-            };
-            values.insert(key.clone(), indices.iter().map(|index| native_values[*index]).collect());
-        }
-        result.push(OutputSeries { symbol: frame.symbol, indices, values });
-    }
-    Ok(result)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    fn request() -> Request {
-        serde_json::from_value(json!({"specs":{"ma":{"indicator":"ma","field":"close","window":3},"ema":{"indicator":"ema","field":"close","window":3},"j":{"indicator":"kdj","field":"close","window":3,"output":"j"}},
-            "series":[{"frame":{"symbol":"000001.SZ","frequency":"1d","decision_at":"2026-09-10T17:00:00+08:00",
-                "timestamps":["2026-09-07T15:00:00+08:00","2026-09-08T15:00:00+08:00","2026-09-09T15:00:00+08:00","2026-09-10T15:00:00+08:00"],
-                "available_at":["2026-09-07T16:00:00+08:00","2026-09-08T16:00:00+08:00","2026-09-09T16:00:00+08:00","2026-09-10T16:00:00+08:00"],
-                "fields":{"close":[1.,2.,3.,4.],"high":[2.,3.,4.,5.],"low":[0.5,1.,2.,3.]}}}],
-            "output_start_date":"2026-09-09","output_end_date":"2026-09-10"})).unwrap()
-    }
-    #[test]
-    fn uses_shared_ma_ema_and_preserves_recursive_prefix_before_output_window() {
-        let rows = evaluate(request()).unwrap();
-        assert_eq!(rows[0].indices,vec![2,3]);
-        assert_eq!(rows[0].values["ma"],vec![Some(2.),Some(3.)]);
-        assert_eq!(rows[0].values["ema"],vec![Some(2.),Some(3.)]);
-        assert_eq!(rows[0].values["j"], vec![None, None]); // KDJ has a longer native lookback.
-        let mut later = request(); later.output_start_date = NaiveDate::from_ymd_opt(2026,9,10).unwrap();
-        assert_eq!(evaluate(later).unwrap()[0].values["ema"],vec![rows[0].values["ema"][1]]);
-    }
-    #[test]
-    fn kdj_uses_the_same_frozen_native_kernel_as_event_conditions() {
-        let mut data = request();
-        let frame = &mut data.series[0].frame;
-        for i in 4..16 {
-            let day = NaiveDate::from_ymd_opt(2026,9,7).unwrap() + chrono::Duration::days(i);
-            frame.timestamps.push(chrono::DateTime::parse_from_rfc3339(&format!("{day}T15:00:00+08:00")).unwrap());
-            frame.available_at.push(chrono::DateTime::parse_from_rfc3339(&format!("{day}T16:00:00+08:00")).unwrap());
-            frame.fields.get_mut("close").unwrap().push(Some(i as f64 + 1.));
-            frame.fields.get_mut("high").unwrap().push(Some(i as f64 + 2.));
-            frame.fields.get_mut("low").unwrap().push(Some(i as f64));
-        }
-        frame.decision_at = chrono::DateTime::parse_from_rfc3339("2026-09-23T17:00:00+08:00").unwrap();
-        data.output_start_date=NaiveDate::from_ymd_opt(2026,9,7).unwrap();
-        data.output_end_date=NaiveDate::from_ymd_opt(2026,9,22).unwrap();
-        let native:Expr=serde_json::from_value(json!({"kind":"indicator","name":"KDJ","inputs":[],"parameters":{"optInFastK_Period":3},"output":2})).unwrap();
-        let expected=factor_events::evaluate(&native,frame).unwrap().values;
-        assert!(expected.iter().any(Option::is_some));
-        assert_eq!(evaluate(data).unwrap()[0].values["j"],expected);
-    }
-    #[test]
-    fn missing_inputs_require_source_admission_and_future_inputs_fail() {
-        let mut data = request(); data.series[0].frame.fields.get_mut("close").unwrap()[1] = None;
-        assert!(evaluate(data).unwrap_err().contains("unclassified_indicator_input_gap"));
-        let mut data = request(); data.series[0].frame.available_at[3] = chrono::DateTime::parse_from_rfc3339("2026-09-11T16:00:00+08:00").unwrap();
-        assert!(evaluate(data).is_err());
-        let mut data=request();data.series[0].frame.fields.get_mut("close").unwrap()[1]=None;
-        data.series[0].admitted_missing_dates.insert(NaiveDate::from_ymd_opt(2026,9,8).unwrap());
-        let native:Expr=serde_json::from_value(json!({"kind":"indicator","name":"EMA","inputs":[{"kind":"field","name":"close"}],"parameters":{"optInTimePeriod":3}})).unwrap();
-        let expected=factor_events::evaluate(&native,&data.series[0].frame).unwrap().values;
-        assert_eq!(expected[2..], [None,None]);
-        assert_eq!(evaluate(data).unwrap()[0].values["ema"],expected[2..]);
-    }
-}

crates/fidc-core/src/stock_pool_market_cap.rs

@@ -1,108 +0,0 @@
-//! Configurable index-to-market-cap band. Values are CNY, not implicit yi.
-use chrono::NaiveDate;
-use serde::{Deserialize, Serialize};
-use sha2::{Digest, Sha256};
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct IndexMarketCapPolicy {
-    pub schema_version: u32,
-    pub index_code: String,
-    pub field: String,
-    pub value_unit: String,
-    pub index_low: f64,
-    pub index_high: f64,
-    pub lower_at_low: f64,
-    pub lower_at_high: f64,
-    pub upper_at_low: f64,
-    pub upper_at_high: f64,
-}
-
-impl IndexMarketCapPolicy {
-    pub fn validate(&self) -> Result<(), String> {
-        if self.schema_version != 1 || self.value_unit != "CNY"
-            || !matches!(self.field.as_str(), "market_cap" | "float_market_cap")
-        { return Err("index_market_cap_contract_invalid".into()); }
-        let index = self.index_code.split_once('.').is_some_and(|(code, exchange)| {
-            (6..=12).contains(&code.len())
-                && code.bytes().all(|byte| byte.is_ascii_uppercase() || byte.is_ascii_digit())
-                && matches!(exchange, "SH" | "SZ" | "CSI" | "CNI")
-        });
-        if !index { return Err("index_market_cap_index_invalid".into()); }
-        if [self.index_low,self.index_high,self.lower_at_low,self.lower_at_high,self.upper_at_low,self.upper_at_high]
-            .iter().any(|value| !value.is_finite() || *value <= 0.)
-            || self.index_low >= self.index_high || self.lower_at_low > self.upper_at_low
-            || self.lower_at_high > self.upper_at_high
-        { return Err("index_market_cap_bounds_invalid".into()); }
-        Ok(())
-    }
-    pub fn band(&self, close: f64) -> Result<(f64, f64), String> {
-        self.validate()?;
-        if !close.is_finite() || close <= 0. { return Err("index_market_cap_close_invalid".into()); }
-        let t = (close.clamp(self.index_low,self.index_high) - self.index_low) / (self.index_high-self.index_low);
-        Ok((self.lower_at_low + t*(self.lower_at_high-self.lower_at_low),
-            self.upper_at_low + t*(self.upper_at_high-self.upper_at_low)))
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct IndexMarketCapRow { pub date: NaiveDate, pub close: f64 }
-
-#[derive(Debug, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct Request {
-    pub policy: IndexMarketCapPolicy,
-    pub official_dates: Vec<NaiveDate>,
-    pub index_code: String,
-    pub closes: Vec<IndexMarketCapRow>,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize)]
-pub struct Band { pub date: NaiveDate, pub index_close: f64, pub lower: f64, pub upper: f64 }
-
-pub fn implementation_sha256() -> String { format!("{:x}", Sha256::digest(include_bytes!("stock_pool_market_cap.rs"))) }
-
-pub fn evaluate(input: &Request) -> Result<Vec<Band>, String> {
-    input.policy.validate()?;
-    if input.index_code != input.policy.index_code || input.official_dates.is_empty()
-        || input.official_dates.len() > 4000 || input.official_dates.len() != input.closes.len()
-        || input.official_dates.windows(2).any(|pair| pair[0]>=pair[1])
-        || input.closes.iter().zip(&input.official_dates).any(|(row, day)| row.date != *day)
-    { return Err("index_market_cap_calendar_or_identity_mismatch".into()); }
-    input.closes.iter().map(|row| {
-        let (lower,upper)=input.policy.band(row.close)?;
-        Ok(Band{date:row.date,index_close:row.close,lower,upper})
-    }).collect()
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    fn policy()->IndexMarketCapPolicy {
-        serde_json::from_value(serde_json::json!({"schema_version":1,"index_code":"000300.SH","field":"market_cap","value_unit":"CNY",
-            "index_low":4000,"index_high":6000,"lower_at_low":2000000000_f64,"lower_at_high":3000000000_f64,
-            "upper_at_low":5000000000_f64,"upper_at_high":8000000000_f64})).unwrap()
-    }
-    #[test]
-    fn interpolates_declared_endpoints_and_clamps_without_business_defaults(){
-        assert_eq!(policy().band(3000.).unwrap(),(2e9,5e9));
-        assert_eq!(policy().band(5000.).unwrap(),(2.5e9,6.5e9));
-        assert_eq!(policy().band(7000.).unwrap(),(3e9,8e9));
-        let mut decreasing=policy();decreasing.lower_at_low=3e9;decreasing.lower_at_high=2e9;
-        assert_eq!(decreasing.band(5000.).unwrap(),(2.5e9,6.5e9));
-        assert!(policy().band(f64::NAN).is_err());
-        let mut invalid=policy();invalid.value_unit="亿元".into();assert!(invalid.validate().is_err());
-        invalid=policy();invalid.index_high=4000.;assert!(invalid.validate().is_err());
-        invalid=policy();invalid.lower_at_low=9e9;assert!(invalid.validate().is_err());
-    }
-    #[test]
-    fn missing_duplicate_or_mismatched_index_inputs_do_not_shrink_the_calendar(){
-        let day=NaiveDate::from_ymd_opt(2026,9,11).unwrap();
-        let mut input=Request{policy:policy(),official_dates:vec![day],index_code:"000300.SH".into(),closes:vec![IndexMarketCapRow{date:day,close:5000.}]};
-        assert_eq!(evaluate(&input).unwrap()[0].lower,2.5e9);
-        input.official_dates.push(day);assert!(evaluate(&input).is_err());input.official_dates.pop();
-        input.index_code="932000.CSI".into();assert!(evaluate(&input).is_err());
-        input.index_code="000300.SH".into();input.closes.clear();assert!(evaluate(&input).is_err());
-    }
-}

crates/fidc-core/src/stock_pool_state.rs

@@ -1,261 +0,0 @@
-//! Durable intent progress, deliberately separate from actual-fill holding
-//! protection. A published target starts no holding/protection timer.
-use std::collections::{BTreeMap, BTreeSet};
-
-use chrono::NaiveDate;
-use rust_decimal::Decimal;
-use serde::{Deserialize, Serialize};
-
-use crate::stock_pool_execution::{
-    Position, StockPoolMemberSpec, StockPoolPlan, normalize_stock_symbol,
-};
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct StockPoolEntryProgress {
-    pub pending: bool,
-    pub observed_holding: bool,
-    pub first_decision_date: NaiveDate,
-    pub latest_generation: String,
-    pub latest_target_value: Decimal,
-    /// Fully funded entry goal, fixed at the last plan. Reconcile against
-    /// actual holdings before repricing, never against today's market value.
-    #[serde(default, skip_serializing_if = "Option::is_none")]
-    pub completion_quantity: Option<Decimal>,
-}
-
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
-#[serde(deny_unknown_fields)]
-pub struct StockPoolExecutionState {
-    pub schema_version: u32,
-    pub last_execution_date: Option<NaiveDate>,
-    pub entries: BTreeMap<String, StockPoolEntryProgress>,
-    #[serde(default)]
-    pub last_target_weights: BTreeMap<String, i32>,
-    /// First signal excluding an actually held member; not an acquisition date.
-    pub removed_since: BTreeMap<String, NaiveDate>,
-}
-
-pub struct StockPoolGoalObservation<'a> {
-    pub symbol: &'a str,
-    pub target_weight_bps: i32,
-    pub target_value: Decimal,
-    pub current_quantity: Decimal,
-    pub target_quantity: Decimal,
-    pub status: &'a str,
-}
-
-impl Default for StockPoolExecutionState {
-    fn default() -> Self {
-        Self {
-            schema_version: 1,
-            last_execution_date: None,
-            entries: BTreeMap::new(),
-            last_target_weights: BTreeMap::new(),
-            removed_since: BTreeMap::new(),
-        }
-    }
-}
-
-impl StockPoolExecutionState {
-    pub fn validate(&self) -> Result<(), String> {
-        if self.schema_version != 1
-            || self.entries.len() > 10000
-            || self.removed_since.len() > 10000
-        {
-            return Err("stock_pool_execution_state_invalid_schema_or_size".into());
-        }
-        for symbol in self
-            .entries
-            .keys()
-            .chain(self.removed_since.keys())
-            .chain(self.last_target_weights.keys())
-        {
-            if normalize_stock_symbol(symbol).as_ref() != Some(symbol) {
-                return Err("stock_pool_execution_state_invalid_symbol".into());
-            }
-        }
-        if self.last_target_weights.len() > 10000
-            || self
-                .last_target_weights
-                .values()
-                .any(|value| !(0..=10000).contains(value))
-        {
-            return Err("stock_pool_execution_state_invalid_weights".into());
-        }
-        if self.entries.values().any(|entry| {
-            entry.latest_target_value < Decimal::ZERO
-                || entry.completion_quantity.is_some_and(|quantity| quantity <= Decimal::ZERO)
-                || entry.latest_generation.is_empty()
-                || self
-                    .last_execution_date
-                    .is_none_or(|last| entry.first_decision_date > last)
-        }) || self
-            .removed_since
-            .values()
-            .any(|day| self.last_execution_date.is_none_or(|last| *day > last))
-        {
-            return Err("stock_pool_execution_state_invalid_goal_or_clock".into());
-        }
-        Ok(())
-    }
-
-    pub fn observe(
-        &self,
-        decision_date: NaiveDate,
-        execution_date: NaiveDate,
-        official_dates: &[NaiveDate],
-        members: &[StockPoolMemberSpec],
-        positions: &[Position],
-    ) -> Result<Self, String> {
-        self.validate()?;
-        if decision_date > execution_date
-            || !official_dates.contains(&execution_date)
-            || !official_dates.contains(&decision_date)
-            || official_dates.windows(2).any(|pair| pair[0] >= pair[1])
-            || self
-                .last_execution_date
-                .is_some_and(|last| last > execution_date)
-        {
-            return Err("stock_pool_execution_state_requires_monotone_official_clock".into());
-        }
-        let mut next = self.clone();
-        next.last_execution_date = Some(execution_date);
-        let members = members
-            .iter()
-            .map(|member| member.symbol.clone())
-            .collect::<BTreeSet<_>>();
-        let held = positions
-            .iter()
-            .filter(|position| position.quantity > Decimal::ZERO)
-            .map(|position| position.symbol.clone())
-            .collect::<BTreeSet<_>>();
-        next.entries.retain(|symbol, entry| {
-            // Confirmed flat starts a new cycle. A still-unfilled fresh target
-            // may remain pending while the latest pool still requests it.
-            !(entry.observed_holding && !held.contains(symbol))
-                && (members.contains(symbol) || held.contains(symbol))
-        });
-        next.last_target_weights
-            .retain(|symbol, _| members.contains(symbol) || held.contains(symbol));
-        for (symbol, entry) in &mut next.entries {
-            entry.observed_holding |= held.contains(symbol);
-            if entry.pending
-                && entry.completion_quantity.is_some_and(|goal| {
-                    positions.iter().any(|position| {
-                        &position.symbol == symbol && position.quantity >= goal
-                    })
-                })
-            {
-                entry.pending = false;
-            }
-        }
-        next.removed_since
-            .retain(|symbol, _| held.contains(symbol) && !members.contains(symbol));
-        for symbol in held.difference(&members) {
-            next.removed_since
-                .entry(symbol.clone())
-                .or_insert(decision_date);
-        }
-        next.validate()?;
-        Ok(next)
-    }
-
-    pub fn pending_symbols(&self) -> BTreeSet<String> {
-        self.entries
-            .iter()
-            .filter(|(_, entry)| entry.pending)
-            .map(|(symbol, _)| symbol.clone())
-            .collect()
-    }
-
-    pub fn next_day_exit_symbols(&self, execution_date: NaiveDate) -> BTreeSet<String> {
-        self.removed_since
-            .iter()
-            .filter(|(_, removed)| **removed < execution_date)
-            .map(|(symbol, _)| symbol.clone())
-            .collect()
-    }
-
-    pub fn record_plan(
-        &self,
-        decision_date: NaiveDate,
-        generation: &str,
-        plan: &StockPoolPlan,
-    ) -> Result<Self, String> {
-        self.record_targets(
-            decision_date,
-            generation,
-            plan.rows.iter().map(|row| StockPoolGoalObservation {
-                symbol: &row.symbol,
-                target_weight_bps: row.target_weight_bps,
-                target_value: row.target_value,
-                current_quantity: row.current_quantity,
-                target_quantity: row.target_quantity,
-                status: &row.status,
-            }),
-        )
-    }
-
-    pub fn record_targets<'a>(
-        &self,
-        decision_date: NaiveDate,
-        generation: &str,
-        rows: impl IntoIterator<Item = StockPoolGoalObservation<'a>>,
-    ) -> Result<Self, String> {
-        self.validate()?;
-        if generation.is_empty()
-            || self
-                .last_execution_date
-                .is_none_or(|date| decision_date > date)
-        {
-            return Err("stock_pool_execution_state_plan_clock_invalid".into());
-        }
-        let mut next = self.clone();
-        for row in rows {
-            if row.target_weight_bps > 0 {
-                next.last_target_weights
-                    .insert(row.symbol.into(), row.target_weight_bps);
-            }
-            let eligible = row.target_weight_bps > 0 && row.target_value > Decimal::ZERO;
-            let completion_quantity = (row.status == "READY"
-                && row.target_quantity > row.current_quantity)
-                .then_some(row.target_quantity);
-            let satisfied = matches!(
-                row.status,
-                "ALREADY_SATISFIED"
-                    | "ENTRY_TARGET_ALREADY_SATISFIED"
-                    | "BELOW_MINIMUM_TRADE_UNIT_ALREADY_SATISFIED"
-            );
-            if row.current_quantity == Decimal::ZERO && eligible && satisfied {
-                next.entries.remove(row.symbol);
-                continue;
-            }
-            if let Some(entry) = next.entries.get_mut(row.symbol) {
-                entry.latest_generation = generation.into();
-                entry.latest_target_value = row.target_value;
-                if entry.pending && completion_quantity.is_some() {
-                    entry.completion_quantity = completion_quantity;
-                }
-                entry.observed_holding |= row.current_quantity > Decimal::ZERO;
-                if entry.pending && eligible && satisfied {
-                    entry.pending = false;
-                }
-            } else if eligible && row.current_quantity == Decimal::ZERO && !satisfied {
-                next.entries.insert(
-                    row.symbol.into(),
-                    StockPoolEntryProgress {
-                        pending: true,
-                        observed_holding: false,
-                        first_decision_date: decision_date,
-                        latest_generation: generation.into(),
-                        latest_target_value: row.target_value,
-                        completion_quantity,
-                    },
-                );
-            }
-        }
-        next.validate()?;
-        Ok(next)
-    }
-}

crates/fidc-core/src/strategy.rs

@@ -1070,9 +1070,6 @@ pub enum TargetPortfolioOrderPricing {
 
 #[derive(Debug, Clone)]
 pub enum OrderIntent {
-    StockPool {
-        contract: Box<crate::stock_pool_execution::FrozenStockPoolIntent>,
-    },
     WithTimeInForce {
         intent: Box<OrderIntent>,
         time_in_force: OrderTimeInForce,
@@ -1234,7 +1231,6 @@ pub enum OrderIntent {
 impl OrderIntent {
     fn collect_potential_buy_symbols(&self, open_orders: &[OpenOrderView], symbols: &mut BTreeSet<String>) {
         match self.unwrapped() {
-            Self::StockPool { contract } => { symbols.extend(contract.selection.requested_symbols.iter().cloned()); }
             Self::Shares { symbol, quantity, .. } | Self::LimitShares { symbol, quantity, .. } if *quantity > 0 => { symbols.insert(symbol.clone()); }
             Self::Lots { symbol, lots, .. } | Self::LimitLots { symbol, lots, .. } if *lots > 0 => { symbols.insert(symbol.clone()); }
             Self::TargetShares { symbol, target_quantity, .. } | Self::LimitTargetShares { symbol, target_quantity, .. } if *target_quantity > 0 => { symbols.insert(symbol.clone()); }
@@ -1315,7 +1311,6 @@ impl OrderIntent {
 
     pub fn supports_time_in_force(&self, time_in_force: OrderTimeInForce) -> bool {
         let intent = self.unwrapped();
-        if matches!(intent, Self::StockPool { .. }) { return time_in_force == OrderTimeInForce::Day; }
         if matches!(
             intent,
             Self::CancelOrder { .. }

crates/fidc-core/src/strategy_ai.rs

@@ -264,10 +264,6 @@ pub fn built_in_strategy_manual() -> StrategyAiManual {
                 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.automatic_trade_protection(...)".to_string(),
-                detail: r#"当前股票/ETF策略的独立自动交易保护：trading.automatic_trade_protection({"buy_protection_days":3,"sell_cooldown_days":3,"max_holding_days":90,"locks":[{"symbol":"000001.SZ","start_date":"2026-09-11","end_date":null}]})。配置冻结到 runtimeExpressions.trading.automaticTradeProtection，回测、paper/live 共用内核；不并入全局风控。0/null/未填关闭对应周期；成交日及之后N个完整正式交易日内，买入保护禁止自动卖出及止盈止损，卖出冷却禁止自动增加仓位；只由真实成交启动或延长，拒绝/未成交/撤单不启动。最长持有按首次实际建仓后的正式交易日计数，加仓与部分卖出不重置，清仓后再开仓重置；日期锁定两端包含且高于自动退出，持仓占用真实预算和槽位。人工交易通过独立服务路径执行，仍校验权限、券商及T+1，不接受客户端origin旁路。持仓来源、实际成交或正式日历缺失时明确拒绝；期货与股票期货混合账户尚不支持此能力，不得悄悄忽略。旧trading.max_holding_days仍保留旧含义，不得和新配置声明不同最大周期。"#.to_string(),
-            },
             ManualSection {
                 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(),

crates/fidc-core/tests/automatic_trade_protection.rs

@@ -1,336 +0,0 @@
-use chrono::NaiveDate;
-use fidc_core::holding_policy::{AutomaticTradeLock, AutomaticTradeProtection};
-use fidc_core::{
-    BacktestConfig, BacktestEngine, BenchmarkSnapshot, BrokerSimulator, CandidateEligibility,
-    ChinaAShareCostModel, ChinaEquityRuleHooks, DailyMarketSnapshot, DataSet, Instrument,
-    MatchingType, OrderSide, PlatformExplicitOrderKind, PlatformExprStrategy,
-    PlatformExprStrategyConfig, PlatformTradeAction, PriceField,
-};
-
-fn d(day: u32) -> NaiveDate {
-    NaiveDate::from_ymd_opt(2026, 9, day).unwrap()
-}
-fn data() -> DataSet {
-    let dates = [11, 14, 15, 16, 17, 18].map(d);
-    DataSet::from_components(
-        vec![Instrument {
-            symbol: "000001.SZ".into(),
-            name: "测试".into(),
-            board: "SZ".into(),
-            round_lot: 100,
-            listed_at: Some(NaiveDate::from_ymd_opt(2020, 1, 1).unwrap()),
-            delisted_at: None,
-            status: "active".into(),
-        }],
-        dates
-            .iter()
-            .map(|date| DailyMarketSnapshot {
-                date: *date,
-                symbol: "000001.SZ".into(),
-                timestamp: Some(format!("{date} 15:00:00")),
-                day_open: 10.0,
-                open: 10.0,
-                high: 10.0,
-                low: 10.0,
-                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".into()),
-                paused: false,
-                upper_limit: 11.0,
-                lower_limit: 9.0,
-                price_tick: 0.01,
-            })
-            .collect(),
-        dates
-            .iter()
-            .map(|date| fidc_core::DailyFactorSnapshot {
-                date: *date,
-                symbol: "000001.SZ".into(),
-                market_cap_bn: 10.0,
-                free_float_cap_bn: 10.0,
-                pe_ttm: 10.0,
-                turnover_ratio: None,
-                effective_turnover_ratio: None,
-                adjustment_factor_backward1: Some(1.0),
-                extra_factors: Default::default(),
-            })
-            .collect(),
-        dates
-            .iter()
-            .map(|date| CandidateEligibility {
-                date: *date,
-                symbol: "000001.SZ".into(),
-                is_st: false,
-                is_star_st: false,
-                is_new_listing: false,
-                is_paused: false,
-                allow_buy: true,
-                allow_sell: true,
-                is_kcb: false,
-                is_one_yuan: false,
-                risk_level_code: None,
-            })
-            .collect(),
-        dates
-            .iter()
-            .map(|date| BenchmarkSnapshot {
-                date: *date,
-                benchmark: "000300.SH".into(),
-                open: 100.0,
-                close: 100.0,
-                prev_close: 100.0,
-                volume: 1_000_000,
-            })
-            .collect(),
-    )
-    .unwrap()
-}
-fn action(quantity: &str, when: &str) -> PlatformTradeAction {
-    PlatformTradeAction::Order {
-        kind: PlatformExplicitOrderKind::Shares,
-        symbol: "000001.SZ".into(),
-        amount_expr: quantity.into(),
-        when_expr: Some(when.into()),
-        limit_price_expr: None,
-        time_in_force: None,
-        start_time_expr: None,
-        end_time_expr: None,
-        reason: "configured_strategy_action".into(),
-    }
-}
-fn run(policy: AutomaticTradeProtection) -> fidc_core::BacktestResult {
-    let mut config = PlatformExprStrategyConfig::generic();
-    config.signal_symbol = "000001.SZ".into();
-    config.benchmark_symbol = "000300.SH".into();
-    config.rotation_enabled = false;
-    config.automatic_trade_protection = policy;
-    config.explicit_actions = vec![
-        action(
-            "100",
-            "decision_date == \"2026-09-11\" || decision_date == \"2026-09-18\"",
-        ),
-        action("-100", "decision_date >= \"2026-09-14\""),
-    ];
-    config.matching_type = MatchingType::CurrentBarClose;
-    let broker = BrokerSimulator::new(ChinaAShareCostModel::default(), ChinaEquityRuleHooks)
-        .with_matching_type(MatchingType::CurrentBarClose);
-    BacktestEngine::new(
-        data(),
-        PlatformExprStrategy::new(config),
-        broker,
-        BacktestConfig {
-            initial_cash: 10_000.0,
-            benchmark_code: "000300.SH".into(),
-            start_date: Some(d(11)),
-            end_date: Some(d(18)),
-            decision_lag_trading_days: 0,
-            execution_price_field: PriceField::Close,
-        },
-    )
-    .run()
-    .unwrap()
-}
-
-#[test]
-fn framework_protection_uses_fills_and_covers_explicit_strategy_orders() {
-    let result = run(AutomaticTradeProtection {
-        buy_protection_days: 3,
-        sell_cooldown_days: 3,
-        ..Default::default()
-    });
-    assert_eq!(
-        result
-            .fills
-            .iter()
-            .map(|fill| (fill.date, fill.side, fill.quantity))
-            .collect::<Vec<_>>(),
-        vec![(d(11), OrderSide::Buy, 100), (d(17), OrderSide::Sell, 100)]
-    );
-    assert!(!result.order_events.iter().any(|order| order.date == d(14)
-        || order.date == d(15)
-        || order.date == d(16)
-        || order.date == d(18)));
-}
-
-#[test]
-fn absolute_lock_blocks_initial_strategy_buy_without_a_rejected_order() {
-    let result = run(AutomaticTradeProtection {
-        locks: vec![AutomaticTradeLock {
-            symbol: "000001.SZ".into(),
-            start_date: d(11),
-            end_date: None,
-        }],
-        ..Default::default()
-    });
-    assert!(result.fills.is_empty());
-    assert!(result.order_events.is_empty());
-}
-
-#[test]
-fn maximum_holding_policy_applies_to_discrete_strategies_and_yields_to_buy_protection() {
-    let result = run(AutomaticTradeProtection {
-        max_holding_days: 1,
-        buy_protection_days: 3,
-        sell_cooldown_days: 3,
-        ..Default::default()
-    });
-    assert_eq!(
-        result
-            .fills
-            .iter()
-            .map(|fill| (fill.date, fill.side))
-            .collect::<Vec<_>>(),
-        vec![(d(11), OrderSide::Buy), (d(17), OrderSide::Sell)]
-    );
-    assert!(
-        result
-            .order_events
-            .iter()
-            .any(|order| order.reason == "max_holding_days_exit")
-    );
-}
-
-#[test]
-fn serialized_framework_policy_survives_shared_alias_normalization_and_rejects_conflicts() {
-    let policy = serde_json::json!({"buy_protection_days":3,"sell_cooldown_days":3,"max_holding_days":90,"locks":[{"symbol":"000001.SZ","start_date":"2026-09-11","end_date":null}]});
-    for key in ["automaticTradeProtection", "automatic_trade_protection"] {
-        let value = serde_json::json!({"runtimeExpressions":{"trading":{key:policy}}});
-        let cfg = fidc_core::platform_expr_config_from_value("test", "000001.SZ", &value).unwrap();
-        assert_eq!(cfg.automatic_trade_protection.buy_protection_days, 3);
-        assert_eq!(cfg.max_holding_days, Some(90));
-        assert_eq!(cfg.automatic_trade_protection.locks.len(), 1);
-    }
-    let conflict = serde_json::json!({"runtimeExpressions":{"trading":{"maxHoldingDays":30,"automaticTradeProtection":policy}}});
-    assert!(
-        fidc_core::platform_expr_config_from_value("test", "000001.SZ", &conflict)
-            .unwrap_err()
-            .to_string()
-            .contains("conflicting maximum")
-    );
-    let unknown = serde_json::json!({"runtimeExpressions":{"trading":{"automaticTradeProtection":{"origin":"manual"}}}});
-    assert!(fidc_core::platform_expr_config_from_value("test", "000001.SZ", &unknown).is_err());
-}
-
-#[test]
-fn locked_holding_keeps_its_slot_even_when_cash_can_buy_the_next_candidate() {
-    let base = data();
-    let dates = [11, 14, 15, 16, 17, 18].map(d);
-    let symbols = ["000001.SZ", "000002.SZ"];
-    let dataset = DataSet::from_components(
-        symbols
-            .iter()
-            .map(|symbol| {
-                let mut row = base.instruments()["000001.SZ"].clone();
-                row.symbol = (*symbol).into();
-                row
-            })
-            .collect(),
-        dates
-            .iter()
-            .flat_map(|date| {
-                symbols.iter().map(|symbol| {
-                    let mut row = base.market(*date, "000001.SZ").unwrap().clone();
-                    row.symbol = (*symbol).into();
-                    row
-                })
-            })
-            .collect(),
-        dates
-            .iter()
-            .flat_map(|date| {
-                symbols.iter().map(|symbol| {
-                    let mut row = base.factor(*date, "000001.SZ").unwrap().clone();
-                    row.symbol = (*symbol).into();
-                    row
-                })
-            })
-            .collect(),
-        dates
-            .iter()
-            .flat_map(|date| {
-                symbols.iter().map(|symbol| {
-                    let mut row = base.candidate(*date, "000001.SZ").unwrap().clone();
-                    row.symbol = (*symbol).into();
-                    row
-                })
-            })
-            .collect(),
-        dates
-            .iter()
-            .map(|date| BenchmarkSnapshot {
-                date: *date,
-                benchmark: "000300.SH".into(),
-                open: 100.0,
-                close: 100.0,
-                prev_close: 100.0,
-                volume: 100_000,
-            })
-            .collect(),
-    )
-    .unwrap();
-    let mut config = PlatformExprStrategyConfig::generic();
-    config.signal_symbol = "000001.SZ".into();
-    config.benchmark_symbol = "000300.SH".into();
-    config.strategy_name = "protection_test".into();
-    config.max_positions = 1;
-    config.selection_limit_expr = "1".into();
-    config.refresh_rate = 1;
-    config.exposure_expr = "0.5".into();
-    config.market_cap_lower_expr = "0".into();
-    config.market_cap_upper_expr = "100".into();
-    config.stock_filter_expr="(decision_date == \"2026-09-11\" && symbol == \"000001.SZ\") || (decision_date != \"2026-09-11\" && symbol == \"000002.SZ\")".into();
-    config.automatic_trade_protection = AutomaticTradeProtection {
-        locks: vec![AutomaticTradeLock {
-            symbol: "000001.SZ".into(),
-            start_date: d(14),
-            end_date: Some(d(16)),
-        }],
-        ..Default::default()
-    };
-    let broker = BrokerSimulator::new(ChinaAShareCostModel::default(), ChinaEquityRuleHooks)
-        .with_matching_type(MatchingType::CurrentBarClose);
-    let result = BacktestEngine::new(
-        dataset,
-        PlatformExprStrategy::new(config),
-        broker,
-        BacktestConfig {
-            initial_cash: 10_000.0,
-            benchmark_code: "000300.SH".into(),
-            start_date: Some(d(11)),
-            end_date: Some(d(18)),
-            decision_lag_trading_days: 0,
-            execution_price_field: PriceField::Close,
-        },
-    )
-    .run()
-    .unwrap();
-    assert_eq!(
-        result
-            .fills
-            .first()
-            .map(|fill| (fill.symbol.as_str(), fill.date)),
-        Some(("000001.SZ", d(11)))
-    );
-    assert!(
-        !result
-            .fills
-            .iter()
-            .any(|fill| [d(14), d(15), d(16)].contains(&fill.date)),
-        "{:?}",
-        result.fills
-    );
-    assert!(
-        result.fills.iter().any(|fill| fill.symbol == "000002.SZ"
-            && fill.side == OrderSide::Buy
-            && fill.date == d(17)),
-        "{:?}",
-        result.fills
-    );
-}

crates/fidc-core/tests/decision_quote_preload.rs

@@ -2,7 +2,7 @@ use chrono::{Duration, NaiveDate, NaiveTime};
 use fidc_core::{
     BacktestConfig, BacktestEngine, BenchmarkSnapshot, BrokerSimulator, CandidateEligibility,
     ChinaAShareCostModel, ChinaEquityRuleHooks, DailyFactorSnapshot, DailyMarketSnapshot, DataSet,
-    Instrument, IntradayExecutionQuote, MatchingType, OrderIntent, PriceField, Strategy, StrategyContext,
+    IntradayExecutionQuote, MatchingType, OrderIntent, PriceField, Strategy, StrategyContext,
     StrategyDecision,
 };
 use std::collections::{BTreeMap, BTreeSet};
@@ -16,18 +16,6 @@ fn t(hour: u32, minute: u32, second: u32) -> NaiveTime {
     NaiveTime::from_hms_opt(hour, minute, second).expect("valid time")
 }
 
-fn fixture_instruments() -> Vec<Instrument> {
-    vec![Instrument {
-        symbol: "000001.SZ".to_string(),
-        name: "quote-plan-fixture".to_string(),
-        board: "SZ".to_string(),
-        round_lot: 100,
-        listed_at: Some(d(2020, 1, 1)),
-        delisted_at: None,
-        status: "active".to_string(),
-    }]
-}
-
 #[derive(Default)]
 struct DecisionQuoteReader {
     day_count: usize,
@@ -102,7 +90,7 @@ impl Strategy for NoLoaderDecisionQuoteStrategy {
 
 fn single_day_quote_plan_data(date: NaiveDate) -> DataSet {
     DataSet::from_components(
-        fixture_instruments(),
+        Vec::new(),
         vec![DailyMarketSnapshot {
             date,
             symbol: "000001.SZ".to_string(),
@@ -265,7 +253,7 @@ 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(
-        fixture_instruments(),
+        Vec::new(),
         vec![
             DailyMarketSnapshot {
                 date: first,
@@ -435,7 +423,7 @@ 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(
-        fixture_instruments(),
+        Vec::new(),
         vec![
             DailyMarketSnapshot {
                 date: first,
@@ -670,7 +658,7 @@ 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(
-        fixture_instruments(),
+        Vec::new(),
         vec![
             DailyMarketSnapshot {
                 date: first,

crates/fidc-core/tests/engine_hooks.rs

@@ -2143,15 +2143,15 @@ fn strategy_context_exposes_advanced_data_helpers() {
 fn engine_runs_minute_hooks_and_executes_minute_orders() {
     let date = d(2025, 1, 2);
     let data = DataSet::from_components_with_actions_and_quotes(
-        ["000001.SZ", "000002.SZ"].into_iter().map(|symbol| Instrument {
+        vec![Instrument {
-            symbol: symbol.to_string(),
+            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(),
-        }).collect(),
+        }],
         vec![DailyMarketSnapshot {
             date,
             symbol: "000001.SZ".to_string(),
@@ -2174,7 +2174,7 @@ fn engine_runs_minute_hooks_and_executes_minute_orders() {
             upper_limit: 11.0,
             lower_limit: 9.0,
             price_tick: 0.01,
-        }, market_row(date, "000002.SZ", 20.0, 20.4)],
+        }],
         vec![DailyFactorSnapshot {
             date,
             symbol: "000001.SZ".to_string(),
@@ -4162,7 +4162,7 @@ impl Strategy for BuyMissingRowThenHoldStrategy {
 }
 
 #[test]
-fn engine_rejects_an_unexplained_missing_holding_close() {
+fn engine_carries_position_price_when_current_market_row_is_missing() {
     let date1 = d(2025, 5, 26);
     let date2 = d(2025, 5, 27);
     let data = DataSet::from_components(
@@ -4230,16 +4230,20 @@ fn engine_rejects_an_unexplained_missing_holding_close() {
         },
     );
 
-    let error = engine
+    let result = engine
         .run()
-        .expect_err("unknown missing market data must not become a carried close");
+        .expect("backtest should not fail on one missing holding row");
-    let detail = format!("{error:?}");
+    assert_eq!(result.equity_curve.len(), 2);
-    assert!(detail.contains("MissingSnapshot") && detail.contains("close price"));
+    assert!(
-    assert!(detail.contains("601028.SH") && detail.contains("2025-05-27"));
+        result
+            .daily_holdings
+            .iter()
+            .any(|holding| holding.date == date2 && holding.symbol == "601028.SH")
+    );
 }
 
 #[test]
-fn platform_strategy_cannot_hide_missing_valuation_by_skipping_stop_take() {
+fn platform_strategy_skips_position_stop_take_when_current_market_row_is_missing() {
     let date1 = d(2025, 5, 26);
     let date2 = d(2025, 5, 27);
     let data = DataSet::from_components(
@@ -4329,10 +4333,14 @@ fn platform_strategy_cannot_hide_missing_valuation_by_skipping_stop_take() {
         },
     );
 
-    let error = engine
+    let result = engine
         .run()
-        .expect_err("skipping a stop condition cannot fabricate the missing valuation");
+        .expect("platform strategy should hold through a missing current market row");
-    let detail = format!("{error:?}");
+    assert_eq!(result.equity_curve.len(), 2);
-    assert!(detail.contains("MissingSnapshot") && detail.contains("close price"));
+    assert!(
-    assert!(detail.contains("601028.SH") && detail.contains("2025-05-27"));
+        result
+            .daily_holdings
+            .iter()
+            .any(|holding| holding.date == date2 && holding.symbol == "601028.SH")
+    );
 }

crates/fidc-core/tests/explicit_order_flow.rs

@@ -1740,9 +1740,8 @@ fn broker_applies_price_ratio_slippage_on_snapshot_fills() {
 }
 
 #[test]
-fn broker_applies_explicit_historical_slippage_on_snapshot_fills() {
+fn broker_applies_dynamic_slippage_on_snapshot_fills() {
     let date = NaiveDate::from_ymd_opt(2024, 1, 10).unwrap();
-    let previous_date = NaiveDate::from_ymd_opt(2024, 1, 9).unwrap();
     let data = DataSet::from_components(
         vec![Instrument {
             symbol: "000002.SZ".to_string(),
@@ -1753,20 +1752,20 @@ fn broker_applies_explicit_historical_slippage_on_snapshot_fills() {
             delisted_at: None,
             status: "active".to_string(),
         }],
-        [previous_date, date].into_iter().map(|day| DailyMarketSnapshot {
+        vec![DailyMarketSnapshot {
-            date: day,
+            date,
             symbol: "000002.SZ".to_string(),
-            timestamp: Some(format!("{day} 15:00:00")),
+            timestamp: Some("2024-01-10 10:18:00".to_string()),
             day_open: 10.0,
             open: 10.0,
-            high: if day == previous_date { 10.1 } else { 10.9 },
+            high: 10.1,
-            low: if day == previous_date { 9.9 } else { 9.1 },
+            low: 9.9,
-            close: if day == previous_date { 10.0 } else { 10.8 },
+            close: 10.0,
             last_price: 10.0,
             bid1: 9.99,
             ask1: 10.01,
             prev_close: 10.0,
-            volume: if day == previous_date { 100_000 } else { 2_000_000 },
+            volume: 100_000,
             minute_volume: 100_000,
             bid1_volume: 80_000,
             ask1_volume: 80_000,
@@ -1775,7 +1774,7 @@ fn broker_applies_explicit_historical_slippage_on_snapshot_fills() {
             upper_limit: 11.0,
             lower_limit: 9.0,
             price_tick: 0.01,
-        }).collect(),
+        }],
         vec![DailyFactorSnapshot {
             date,
             symbol: "000002.SZ".to_string(),
@@ -1787,8 +1786,8 @@ fn broker_applies_explicit_historical_slippage_on_snapshot_fills() {
             adjustment_factor_backward1: None,
             extra_factors: BTreeMap::new(),
         }],
-        [previous_date, date].into_iter().map(|day| CandidateEligibility {
+        vec![CandidateEligibility {
-            date: day,
+            date,
             symbol: "000002.SZ".to_string(),
             is_st: false,
             is_star_st: false,
@@ -1799,15 +1798,15 @@ fn broker_applies_explicit_historical_slippage_on_snapshot_fills() {
             is_kcb: false,
             is_one_yuan: false,
             risk_level_code: None,
-        }).collect(),
+        }],
-        [previous_date, date].into_iter().map(|day| BenchmarkSnapshot {
+        vec![BenchmarkSnapshot {
-            date: day,
+            date,
             benchmark: "000300.SH".to_string(),
             open: 100.0,
             close: 100.0,
             prev_close: 99.0,
             volume: 1_000_000,
-        }).collect(),
+        }],
     )
     .expect("dataset");
     let mut portfolio = PortfolioState::new(1_000_000.0);
@@ -1816,9 +1815,7 @@ fn broker_applies_explicit_historical_slippage_on_snapshot_fills() {
         ChinaEquityRuleHooks::default(),
         PriceField::Open,
     )
-    .with_volume_limit(false)
+    .with_slippage_model(SlippageModel::Dynamic(DynamicSlippageConfig::new(
-    .with_liquidity_limit(false)
-    .with_slippage_model(SlippageModel::HistoricalVolumeVolatility(DynamicSlippageConfig::new(
         0.5, 0.3, 0.1,
     )));
 
@@ -3080,24 +3077,23 @@ fn broker_executes_algo_twap_percent_across_window_quotes() {
         )
         .expect("broker execution");
 
-    assert_eq!(report.fill_events.len(), 2);
+    assert_eq!(report.fill_events.len(), 3);
     assert_eq!(
         report
             .fill_events
             .iter()
             .map(|fill| fill.quantity)
             .sum::<u32>(),
-        200
+        300
     );
     assert!(report.fill_events.iter().all(|fill| fill.quantity == 100));
-    assert!(report.fill_events.iter().all(|fill| fill.execution_timestamp.is_some_and(|at| at >= date.and_hms_opt(10, 15, 0).unwrap())));
     assert_eq!(
         report
             .process_events
             .iter()
             .filter(|event| event.kind == ProcessEventKind::Trade)
             .count(),
-        2
+        3
     );
 }
 

crates/fidc-core/tests/fixtures/stock_pool_disabled_stops_compiled.json

@@ -1,275 +0,0 @@
-{
-  "strategyId": "fixture_hold_without_stops_backtest",
-  "version": "1.0.0",
-  "market": "CN_A",
-  "benchmark": {
-    "instrumentId": "000300.SH",
-    "fallbackInstrumentId": "000300.SH",
-    "note": "必须使用真实指数链路；若 000852.SH 不可用，应直接报错而不是退化到其他标的。"
-  },
-  "universe": {
-    "exclude": [],
-    "implementationNotes": [
-      "ST、停牌、退市、新股、科创、一元、涨跌停、同日卖出禁买、成交量和费用由 riskPolicy / RiskLimits 统一执行",
-      "上市日期与退市日期取自 instrument 结构化字段，不再使用股票名称做 ST/退市判断",
-      "盘中 current_price / last_price 由策略交易时刻批量 tick 查询驱动"
-    ],
-    "include": [
-      "000001.SZ",
-      "000002.SZ"
-    ]
-  },
-  "selectors": [
-    {
-      "type": "dynamicRange",
-      "field": "market_cap",
-      "lowerExpr": "0",
-      "upperExpr": "1000000000000",
-      "mapping": "close -> strategy_factory_source_lake.runtime_fields.close"
-    },
-    {
-      "type": "filter",
-      "expr": "(close > 0)"
-    },
-    {
-      "type": "rank",
-      "orderBy": [
-        "market_cap asc"
-      ],
-      "limitExpr": "2"
-    }
-  ],
-  "rebalance": {
-    "frequencyDays": 1,
-    "tradeTimes": [],
-    "dailyApproximation": "日线回测按 matching_type 撮合；分钟线回测按交易时刻分钟价格撮合",
-    "schedule": {
-      "frequency": "daily"
-    }
-  },
-  "risk": {
-    "takeProfitExpr": "",
-    "stopLossExpr": "",
-    "indexThrottleExpr": "max(0.0, 1.0000000000 - 0.0000 / max(total_equity, 1.0))",
-    "stopTakeReferencePriceMode": "position_average_entry_price"
-  },
-  "seasonality": {
-    "skipWindows": []
-  },
-  "execution": {
-    "selectionGranularity": "strategy_factory_source_lake.daily_source_rows_v1",
-    "executionGranularity": "daily_or_minute_bar",
-    "priceSource": "current_bar_close_or_next_bar_open_or_minute_bar",
-    "matchingType": "current_bar_close",
-    "rebalanceCashMode": "sell_then_buy",
-    "slippageModel": "none",
-    "slippageValue": 0,
-    "riskPolicy": {
-      "rejectStSelection": false,
-      "rejectStarStSelection": false,
-      "rejectPausedSelection": false,
-      "rejectInactiveSelection": false,
-      "rejectNewListingSelection": false,
-      "rejectKcbSelection": false,
-      "rejectBjseSelection": false,
-      "rejectOneYuanSelection": false,
-      "rejectUpperLimitSelection": false,
-      "rejectLowerLimitSelection": false,
-      "rejectStBuy": true,
-      "rejectStarStBuy": true,
-      "rejectPausedBuy": true,
-      "rejectInactiveBuy": true,
-      "rejectNewListingBuy": true,
-      "rejectKcbBuy": true,
-      "rejectBjseBuy": true,
-      "rejectOneYuanBuy": true,
-      "rejectUpperLimitBuy": true,
-      "rejectPausedSell": true,
-      "rejectInactiveSell": true,
-      "rejectLowerLimitSell": true,
-      "respectAllowBuySell": true,
-      "forbidSameDayRebuyAfterSell": true,
-      "blacklistEnabled": true,
-      "blacklistedSymbols": [],
-      "allowMarketOrders": true,
-      "liveTradingEnabled": false,
-      "volumeLimitEnabled": true,
-      "liquidityLimitEnabled": true,
-      "volumePercent": 0.25,
-      "maxOrderQuantity": 1000000,
-      "maxOrderNotional": 100000000,
-      "maxSymbolPosition": 10000000,
-      "commissionRate": 0.0003,
-      "minimumCommission": 5,
-      "stampTaxRateBeforeChange": 0.001,
-      "stampTaxRateAfterChange": 0.0005,
-      "stampTaxChangeDate": "2023-08-28"
-    },
-    "sourceLanguage": "engine-script",
-    "sourceKind": "platform-strategy",
-    "extractor": "omniquant-engine-script-v2",
-    "sellThenBuyDelaySlippageRate": 0,
-    "strictValueBudget": true
-  },
-  "factorRefs": [
-    "close"
-  ],
-  "runtimeExpressions": {
-    "prelude": "",
-    "schedule": {
-      "frequency": "daily"
-    },
-    "selection": {
-      "limitExpr": "2",
-      "candidateLimitExpr": "2",
-      "marketCapField": "close",
-      "marketCapLowerExpr": "0",
-      "marketCapUpperExpr": "1000000000000",
-      "stockFilterExpr": "(close > 0)"
-    },
-    "risk": {
-      "exposureExpr": "max(0.0, 1.0000000000 - 0.0000 / max(total_equity, 1.0))",
-      "stopLossExpr": "",
-      "takeProfitExpr": "",
-      "stopTakeReferencePriceMode": "position_average_entry_price"
-    },
-    "allocation": {
-      "buyScaleExpr": "1.0"
-    },
-    "ordering": {
-      "rankBy": "market_cap",
-      "rankExpr": "(symbol == \"000001.SZ\" || symbol == \"000002.SZ\") ? (symbol == \"000001.SZ\" ? (0) : (1)) : 2",
-      "rankOrder": "asc"
-    },
-    "trading": {
-      "rotationEnabled": true,
-      "subscriptionGuardRequired": false,
-      "stage": "on_day",
-      "actions": []
-    }
-  },
-  "engineConfig": {
-    "templateId": "fixture_hold_without_stops_backtest",
-    "benchmarkSymbol": "000300.SH",
-    "signalSymbol": "000300.SH",
-    "rankLimit": 2,
-    "refreshRate": 1,
-    "rsiRate": 1.0001,
-    "dynamicRange": {
-      "baseIndexLevel": 2000,
-      "baseCapFloor": 7,
-      "capSpan": 1000000000000,
-      "xs": 0.008
-    },
-    "stopLossMultiplier": null,
-    "takeProfitMultiplier": null,
-    "matchingType": "current_bar_close",
-    "rebalanceCashMode": "sell_then_buy",
-    "slippageModel": "none",
-    "slippageValue": 0,
-    "riskPolicy": {
-      "rejectStSelection": false,
-      "rejectStarStSelection": false,
-      "rejectPausedSelection": false,
-      "rejectInactiveSelection": false,
-      "rejectNewListingSelection": false,
-      "rejectKcbSelection": false,
-      "rejectBjseSelection": false,
-      "rejectOneYuanSelection": false,
-      "rejectUpperLimitSelection": false,
-      "rejectLowerLimitSelection": false,
-      "rejectStBuy": true,
-      "rejectStarStBuy": true,
-      "rejectPausedBuy": true,
-      "rejectInactiveBuy": true,
-      "rejectNewListingBuy": true,
-      "rejectKcbBuy": true,
-      "rejectBjseBuy": true,
-      "rejectOneYuanBuy": true,
-      "rejectUpperLimitBuy": true,
-      "rejectPausedSell": true,
-      "rejectInactiveSell": true,
-      "rejectLowerLimitSell": true,
-      "respectAllowBuySell": true,
-      "forbidSameDayRebuyAfterSell": true,
-      "blacklistEnabled": true,
-      "blacklistedSymbols": [],
-      "allowMarketOrders": true,
-      "liveTradingEnabled": false,
-      "volumeLimitEnabled": true,
-      "liquidityLimitEnabled": true,
-      "volumePercent": 0.25,
-      "maxOrderQuantity": 1000000,
-      "maxOrderNotional": 100000000,
-      "maxSymbolPosition": 10000000,
-      "commissionRate": 0.0003,
-      "minimumCommission": 5,
-      "stampTaxRateBeforeChange": 0.001,
-      "stampTaxRateAfterChange": 0.0005,
-      "stampTaxChangeDate": "2023-08-28"
-    },
-    "skipWindows": [],
-    "rebalanceSchedule": {
-      "frequency": "daily"
-    },
-    "dividendReinvestment": false,
-    "sellThenBuyDelaySlippageRate": 0,
-    "strictValueBudget": true
-  },
-  "stockPool": {
-    "schema_version": 1,
-    "pool_id": "fixture-pool",
-    "version_id": "fixture-version",
-    "members": [
-      {
-        "symbol": "000001.SZ",
-        "requested_order": 0,
-        "recommendation_reason": "",
-        "target_weight_bps": null,
-        "stop_loss": null,
-        "take_profit": null
-      },
-      {
-        "symbol": "000002.SZ",
-        "requested_order": 1,
-        "recommendation_reason": "",
-        "target_weight_bps": null,
-        "stop_loss": null,
-        "take_profit": null
-      }
-    ],
-    "allocation_policy": {
-      "target_holding_count": 2,
-      "portfolio_policy": {
-        "schema_version": 1,
-        "membership": "retain_holdings",
-        "rebalance_weights": false
-      },
-      "invest_ratio_bps": 10000,
-      "reserve_cash": 0
-    },
-    "timing_policy": {
-      "schema_version": 1,
-      "auto_execute": true,
-      "freeze_time": "00:00",
-      "window_start": "09:30",
-      "window_end": "15:00",
-      "trigger_mode": "scheduled_bar",
-      "pricing_mode": "first_tick",
-      "automatic_trade_protection": {
-        "buy_protection_days": 0,
-        "sell_cooldown_days": 0,
-        "max_holding_days": 0,
-        "locks": []
-      }
-    },
-    "stop_take_policy": {
-      "stop_loss": null,
-      "take_profit": null
-    },
-    "out_of_pool_policy": "hold"
-  },
-  "signalSymbol": "000300.SH",
-  "sourceCode": "strategy(\"fixture_hold_without_stops_backtest\") {\n  mode(\"rotation\")\n  market(\"CN_A\")\n  benchmark(\"000300.SH\")\n  signal(\"000300.SH\")\n  rebalance.every_days(1)\n  universe.include([\"000001.SZ\", \"000002.SZ\"])\n  selection.limit(2)\n  selection.candidate_limit(2)\n  selection.market_cap_band(field=\"close\", lower=0, upper=1000000000000)\n  filter.stock_expr(close > 0)\n  ordering.rank_expr((symbol == \"000001.SZ\" || symbol == \"000002.SZ\") ? (symbol == \"000001.SZ\" ? (0) : (1)) : 2, \"asc\")\n  risk.index_exposure(max(0.0, 1.0000000000 - 0.0000 / max(total_equity, 1.0)))\n  allocation.buy_scale(1.0)\n  stock_pool.config({\"schema_version\":1,\"pool_id\":\"fixture-pool\",\"version_id\":\"fixture-version\",\"members\":[{\"symbol\":\"000001.SZ\",\"requested_order\":0,\"recommendation_reason\":\"\",\"target_weight_bps\":null,\"stop_loss\":null,\"take_profit\":null},{\"symbol\":\"000002.SZ\",\"requested_order\":1,\"recommendation_reason\":\"\",\"target_weight_bps\":null,\"stop_loss\":null,\"take_profit\":null}],\"allocation_policy\":{\"target_holding_count\":2,\"portfolio_policy\":{\"schema_version\":1,\"membership\":\"retain_holdings\",\"rebalance_weights\":false},\"invest_ratio_bps\":10000,\"reserve_cash\":0},\"timing_policy\":{\"schema_version\":1,\"auto_execute\":true,\"freeze_time\":\"00:00\",\"window_start\":\"09:30\",\"window_end\":\"15:00\",\"trigger_mode\":\"scheduled_bar\",\"pricing_mode\":\"first_tick\",\"automatic_trade_protection\":{\"buy_protection_days\":0,\"sell_cooldown_days\":0,\"max_holding_days\":0,\"locks\":[]}},\"stop_take_policy\":{\"stop_loss\":null,\"take_profit\":null},\"out_of_pool_policy\":\"hold\"})\n  risk.reference_price_mode(\"position_average_entry_price\")\n  execution.matching_type(\"current_bar_close\")\n}\n",
-  "mode": "rotation"
-}

crates/fidc-core/tests/stock_pool_execution_contract.rs

@@ -1,632 +0,0 @@
-use chrono::NaiveDate;
-use fidc_core::stock_pool_execution::*;
-use fidc_core::{
-    BacktestConfig, BacktestEngine, BenchmarkSnapshot, BrokerSimulator, CandidateEligibility,
-    ChinaAShareCostModel, ChinaEquityRuleHooks, DailyFactorSnapshot, DailyMarketSnapshot, DataSet,
-    FidcRiskControlConfig, Instrument, MatchingType, OrderIntent, PlatformExprStrategy,
-    PortfolioState, PriceField, StrategyDecision, platform_expr_config_from_value,
-};
-use rust_decimal::Decimal;
-use std::collections::{BTreeMap, BTreeSet};
-
-fn day(n: u32) -> NaiveDate {
-    NaiveDate::from_ymd_opt(2026, 1, n).unwrap()
-}
-fn code(n: usize) -> String {
-    format!("{n:06}.SZ")
-}
-fn data(low_volume: bool) -> DataSet {
-    data_with_first_volume(if low_volume { 100 } else { 1_000_000 })
-}
-fn data_with_first_volume(first_volume: u64) -> DataSet {
-    data_with_suspension(first_volume, None)
-}
-fn data_with_suspension(first_volume: u64, suspension: Option<NaiveDate>) -> DataSet {
-    data_with_fund_rules(first_volume, suspension, false)
-}
-fn data_with_fund_rules(
-    first_volume: u64,
-    suspension: Option<NaiveDate>,
-    fund_rules: bool,
-) -> DataSet {
-    let mut instruments: Vec<Instrument> = (1..=2)
-        .map(|n| Instrument {
-            symbol: code(n),
-            name: code(n),
-            board: if fund_rules && n == 2 {
-                "ETF".into()
-            } else {
-                "SZ".into()
-            },
-            round_lot: 100,
-            listed_at: Some(day(1)),
-            delisted_at: None,
-            status: "active".into(),
-        })
-        .collect();
-    instruments.push(Instrument {
-        symbol: "000300.SH".into(),
-        name: "fixture reference index".into(),
-        board: "INDEX".into(),
-        round_lot: 1,
-        listed_at: Some(day(1)),
-        delisted_at: None,
-        status: "active".into(),
-    });
-    let mut market = Vec::new();
-    let mut candidates = Vec::new();
-    for date in [day(2), day(5), day(6)] {
-        for n in 1..=2 {
-            let price = if fund_rules && n == 2 {
-                0.934
-            } else if n == 1 && date >= day(5) {
-                20.0
-            } else {
-                10.0
-            };
-            market.push(DailyMarketSnapshot {
-                date,
-                symbol: code(n),
-                timestamp: None,
-                day_open: price,
-                open: price,
-                high: price,
-                low: price,
-                close: price,
-                last_price: price,
-                bid1: price,
-                ask1: price,
-                prev_close: 10.,
-                volume: if n == 1 { first_volume } else { 1_000_000 },
-                minute_volume: 100_000,
-                bid1_volume: 100_000,
-                ask1_volume: 100_000,
-                trading_phase: None,
-                paused: n == 2 && suspension == Some(date),
-                upper_limit: 100.,
-                lower_limit: 0.1,
-                price_tick: if fund_rules && n == 2 { 0.001 } else { 0.01 },
-            });
-            candidates.push(CandidateEligibility {
-                date,
-                symbol: code(n),
-                is_st: false,
-                is_star_st: false,
-                is_new_listing: false,
-                is_paused: n == 2 && suspension == Some(date),
-                allow_buy: true,
-                allow_sell: true,
-                is_kcb: false,
-                is_one_yuan: false,
-                risk_level_code: None,
-            });
-        }
-        let mut reference = market.last().unwrap().clone();
-        reference.symbol = "000300.SH".into();
-        reference.day_open = 100.;
-        reference.open = 100.;
-        reference.high = 100.;
-        reference.low = 100.;
-        reference.close = 100.;
-        reference.last_price = 100.;
-        reference.bid1 = 100.;
-        reference.ask1 = 100.;
-        reference.prev_close = 100.;
-        reference.upper_limit = 1000.;
-        market.push(reference);
-    }
-    let benchmarks = [day(2), day(5), day(6)]
-        .into_iter()
-        .map(|date| BenchmarkSnapshot {
-            date,
-            benchmark: "000300.SH".into(),
-            open: 100.,
-            close: 100.,
-            prev_close: 100.,
-            volume: 1_000_000,
-        })
-        .collect();
-    let factors = [day(2), day(5), day(6)]
-        .into_iter()
-        .flat_map(|date| {
-            (1..=2).map(move |n| DailyFactorSnapshot {
-                date,
-                symbol: code(n),
-                market_cap_bn: 10.,
-                free_float_cap_bn: 10.,
-                pe_ttm: 10.,
-                turnover_ratio: None,
-                effective_turnover_ratio: None,
-                adjustment_factor_backward1: Some(1.),
-                extra_factors: Default::default(),
-            })
-        })
-        .collect();
-    DataSet::from_components(instruments, market, factors, candidates, benchmarks).unwrap()
-}
-fn broker(volume: bool) -> BrokerSimulator<ChinaAShareCostModel, ChinaEquityRuleHooks> {
-    let mut risk = FidcRiskControlConfig::default();
-    risk.trading_constraints.commission_rate = 0.;
-    risk.trading_constraints.minimum_commission = 0.;
-    risk.trading_constraints.transfer_fee_rate = 0.;
-    risk.trading_constraints.stamp_tax_rate_before_change = 0.;
-    risk.trading_constraints.stamp_tax_rate_after_change = 0.;
-    risk.trading_constraints.volume_limit_enabled = volume;
-    risk.trading_constraints.volume_percent = 0.25;
-    risk.trading_constraints.liquidity_limit_enabled = false;
-    BrokerSimulator::new(
-        ChinaAShareCostModel::from_trading_constraints(risk.trading_constraints),
-        ChinaEquityRuleHooks,
-    )
-    .with_matching_type(MatchingType::NextBarOpen)
-    .with_risk_config(risk)
-}
-fn contract(signal: NaiveDate, target: usize, preserve: bool) -> FrozenStockPoolIntent {
-    let symbols = vec![code(1), code(2)];
-    FrozenStockPoolIntent {
-        pool_id: "fixture-pool".into(),
-        signal_date: signal,
-        frozen_equity: Decimal::from(30000),
-        selection: StockPoolSelection {
-            trade_date: signal,
-            requested_symbols: symbols.clone(),
-            normal_trading_symbols: symbols.clone(),
-            risk_eligible_symbols: symbols,
-            final_symbols: vec![code(target)],
-            exclusion_reasons: BTreeMap::new(),
-            inherited_from_generation: None,
-            explicit_empty: false,
-            generation: Some(format!("g-{signal}")),
-        },
-        members: (1..=2)
-            .map(|n| StockPoolMemberSpec {
-                symbol: code(n),
-                requested_order: n as i32,
-                recommendation_reason: String::new(),
-                target_weight_bps: None,
-                stop_loss: None,
-                take_profit: None,
-            })
-            .collect(),
-        rule: StockPoolExecutionRule {
-            pricing_mode: POOL_PRICE_FIRST_TICK.into(),
-            ..Default::default()
-        },
-        constraints: StockPoolDecisionConstraints {
-            target_holding_count: Some(1),
-            portfolio_policy: Some(StockPoolPortfolioPolicy {
-                schema_version: 1,
-                membership: MembershipPolicy::FollowCandidates,
-                rebalance_weights: !preserve,
-            }),
-            ..Default::default()
-        },
-        invest_ratio_bps: 10000,
-        reserve_cash: Decimal::ZERO,
-        out_of_pool_policy: "hold".into(),
-        generation: format!("g-{signal}"),
-    }
-}
-fn decision(contract: FrozenStockPoolIntent) -> StrategyDecision {
-    StrategyDecision {
-        order_intents: vec![OrderIntent::StockPool {
-            contract: Box::new(contract),
-        }],
-        ..Default::default()
-    }
-}
-
-#[test]
-fn paused_execution_day_keeps_the_prior_slot_and_never_submits_an_exit() {
-    let data = data_with_suspension(1_000_000, Some(day(6)));
-    let broker = broker(false);
-    let mut account = PortfolioState::new(30_000.);
-    let first = broker
-        .execute_with_event_dates(
-            day(5),
-            day(2),
-            day(2),
-            &mut account,
-            &data,
-            &decision(contract(day(2), 2, false)),
-        )
-        .unwrap();
-    assert_eq!(first.fill_events.len(), 1);
-    let quantity = account.position(&code(2)).unwrap().quantity;
-    let mut replacement = contract(day(5), 1, false);
-    replacement
-        .members
-        .retain(|member| member.symbol != code(2));
-    replacement
-        .selection
-        .requested_symbols
-        .retain(|symbol| symbol != &code(2));
-    replacement.out_of_pool_policy = "reduce_to_zero_when_sellable".into();
-    let paused = broker
-        .execute_with_event_dates(
-            day(6),
-            day(5),
-            day(5),
-            &mut account,
-            &data,
-            &decision(replacement),
-        )
-        .unwrap();
-    assert!(paused.fill_events.is_empty(), "{paused:?}");
-    assert_eq!(account.position(&code(2)).unwrap().quantity, quantity);
-    assert!(
-        paused
-            .diagnostics
-            .iter()
-            .any(|line| line.contains("MARKET_SUSPENDED"))
-    );
-}
-
-#[test]
-fn mixed_fund_and_stock_round_trip_uses_declared_ticks_and_asset_specific_fees() {
-    let data = data_with_fund_rules(1_000_000, None, true);
-    let mut costs = ChinaAShareCostModel::default();
-    costs.set_transfer_fee_rate(0.00001);
-    let broker = BrokerSimulator::new(costs, ChinaEquityRuleHooks)
-        .with_matching_type(MatchingType::NextBarOpen);
-    let mut account = PortfolioState::new(30_000.);
-    let mut entry = contract(day(2), 1, false);
-    entry.selection.final_symbols = vec![code(1), code(2)];
-    entry.constraints.target_holding_count = Some(2);
-    entry.rule.buy_offset_bps = 1;
-    entry.rule.sell_offset_bps = -1;
-    let buys = broker
-        .execute_with_event_dates(
-            day(5),
-            day(2),
-            day(2),
-            &mut account,
-            &data,
-            &decision(entry.clone()),
-        )
-        .unwrap();
-    assert_eq!(buys.fill_events.len(), 2, "{buys:?}");
-    let fund = buys
-        .fill_events
-        .iter()
-        .find(|fill| fill.symbol == code(2))
-        .unwrap();
-    assert_eq!(fund.quantity, 16000);
-    assert_eq!(fund.price, 0.934);
-    assert_eq!(fund.stamp_tax, 0.);
-    assert_eq!(fund.transfer_fee, 0.);
-    let stock = buys
-        .fill_events
-        .iter()
-        .find(|fill| fill.symbol == code(1))
-        .unwrap();
-    assert_eq!(stock.quantity, 700);
-    assert_eq!(stock.transfer_fee, 0.14);
-    entry.signal_date = day(5);
-    entry.selection.trade_date = day(5);
-    entry.generation = "exit".into();
-    entry.invest_ratio_bps = 0;
-    let sells = broker
-        .execute_with_event_dates(
-            day(6),
-            day(5),
-            day(5),
-            &mut account,
-            &data,
-            &decision(entry),
-        )
-        .unwrap();
-    assert_eq!(sells.fill_events.len(), 2, "{sells:?}");
-    let fund = sells
-        .fill_events
-        .iter()
-        .find(|fill| fill.symbol == code(2))
-        .unwrap();
-    assert_eq!(fund.stamp_tax, 0.);
-    assert_eq!(fund.transfer_fee, 0.);
-    let stock = sells
-        .fill_events
-        .iter()
-        .find(|fill| fill.symbol == code(1))
-        .unwrap();
-    assert_eq!(stock.stamp_tax, 7.);
-    assert_eq!(stock.transfer_fee, 0.14);
-    assert!(
-        (account.cash() - 29972.72).abs() < 0.000001,
-        "cash={}",
-        account.cash()
-    );
-    assert!(
-        account
-            .positions()
-            .values()
-            .all(|position| position.quantity == 0)
-    );
-}
-
-#[test]
-fn new_daily_target_sells_old_member_then_buys_using_frozen_equity() {
-    let data = data(false);
-    let broker = broker(false);
-    let mut account = PortfolioState::new(20000.);
-    account.position_mut(&code(1)).buy(day(2), 1000, 10.);
-    let report = broker
-        .execute_with_event_dates(
-            day(5),
-            day(2),
-            day(2),
-            &mut account,
-            &data,
-            &decision(contract(day(2), 2, false)),
-        )
-        .unwrap();
-    assert_eq!(report.fill_events.len(), 2, "{report:?}");
-    assert!(account.position(&code(1)).is_none_or(|p| p.quantity == 0));
-    assert_eq!(account.position(&code(2)).unwrap().quantity, 3000);
-    assert!(
-        (account.cash() - 10000.).abs() < 1e-8,
-        "next-open equity must not replace the frozen 30000 budget"
-    );
-    let unique = report
-        .fill_events
-        .iter()
-        .map(|fill| (fill.symbol.clone(), format!("{:?}", fill.side)))
-        .collect::<BTreeSet<_>>();
-    assert_eq!(unique.len(), 2);
-    let next = broker
-        .execute_with_event_dates(
-            day(6),
-            day(5),
-            day(5),
-            &mut account,
-            &data,
-            &decision(contract(day(5), 2, true)),
-        )
-        .unwrap();
-    assert!(
-        next.fill_events.is_empty(),
-        "preserved shares must not be rebalanced: {next:?}"
-    );
-}
-
-#[test]
-fn partial_sell_does_not_release_a_slot_or_authorize_replacement() {
-    let data = data(true);
-    let broker = broker(true).with_matching_type(MatchingType::CurrentBarClose);
-    let mut account = PortfolioState::new(20000.);
-    account.position_mut(&code(1)).buy(day(2), 1000, 10.);
-    let report = broker
-        .execute_with_event_dates(
-            day(5),
-            day(2),
-            day(2),
-            &mut account,
-            &data,
-            &decision(contract(day(2), 2, false)),
-        )
-        .unwrap();
-    assert!(account.position(&code(2)).is_none());
-    assert_eq!(account.position(&code(1)).unwrap().quantity, 975);
-    assert!(
-        report
-            .diagnostics
-            .iter()
-            .any(|text| text.contains("DEFERRED_POSITION_SLOTS"))
-    );
-}
-
-#[test]
-fn actual_fill_protection_is_evaluated_on_execution_date() {
-    let data = data(false);
-    let broker = broker(false);
-    let mut account = PortfolioState::new(20000.);
-    account.position_mut(&code(1)).buy(day(2), 1000, 10.);
-    let mut intent = contract(day(2), 2, false);
-    intent.rule.automatic_trade_protection.buy_protection_days = 3;
-    let report = broker
-        .execute_with_event_dates(
-            day(5),
-            day(2),
-            day(2),
-            &mut account,
-            &data,
-            &decision(intent),
-        )
-        .unwrap();
-    assert!(report.fill_events.is_empty(), "{report:?}");
-    assert_eq!(account.position(&code(1)).unwrap().quantity, 1000);
-}
-
-#[test]
-fn parsed_pool_program_executes_daily_membership_changes_without_legacy_translation() {
-    let intent = contract(day(2), 1, false);
-    for quote_condition in ["", "price<5"] {
-        let program = StockPoolProgram {
-            schema_version: 1,
-            pool_id: "pool-fixture".into(),
-            version_id: "version-fixture".into(),
-            members: intent.members.clone(),
-            allocation_policy: serde_json::json!({"target_holding_count":1,"invest_ratio_bps":10000,"portfolio_policy":{"schema_version":1,"membership":"follow_candidates","rebalance_weights":false}}),
-            // Disabled natural trading must not disable an explicitly requested historical backtest.
-            timing_policy: serde_json::json!({"auto_execute":false,"pricing_mode":"first_tick","buy_condition":quote_condition}),
-            stop_take_policy: serde_json::json!({"stop_loss":null,"take_profit":0}),
-            out_of_pool_policy: "hold".into(),
-        };
-        let mut config=platform_expr_config_from_value("pool-fixture",&code(1),&serde_json::json!({
-   "stockPool":program,"signalSymbol":code(1),"benchmark":{"instrumentId":"000300.SH"},"universe":{"include":[code(1),code(2)]}
-  })).unwrap();
-        config.market_cap_field = "close".into();
-        config.market_cap_lower_expr = "0".into();
-        config.market_cap_upper_expr = "1000000000000".into();
-        config.stock_filter_expr = "true".into();
-        config.selection_limit_expr = "1".into();
-        config.selection_candidate_limit_expr = "2".into();
-        config.rank_expr = format!(
-            "decision_date == \"2026-01-02\" ? (symbol == \"{}\" ? 0 : 1) : (symbol == \"{}\" ? 0 : 1)",
-            code(1),
-            code(2)
-        );
-        config.matching_type = MatchingType::CurrentBarClose;
-        let result = BacktestEngine::new(
-            data(false),
-            PlatformExprStrategy::new(config),
-            broker(false).with_matching_type(MatchingType::CurrentBarClose),
-            BacktestConfig {
-                initial_cash: 30000.,
-                benchmark_code: "000300.SH".into(),
-                start_date: Some(day(2)),
-                end_date: Some(day(6)),
-                decision_lag_trading_days: 0,
-                execution_price_field: PriceField::Close,
-            },
-        )
-        .run()
-        .unwrap();
-        if quote_condition.is_empty() {
-            assert_eq!(
-                result.fills.len(),
-                3,
-                "fills={:#?}, decisions={:#?}, days={:#?}",
-                result.fills,
-                result.risk_decisions,
-                result
-                    .equity_curve
-                    .iter()
-                    .map(|point| (&point.date, &point.diagnostics))
-                    .collect::<Vec<_>>()
-            );
-            assert_eq!(result.fills[0].symbol, code(1));
-            assert_eq!(result.fills[1].symbol, code(1));
-            assert_eq!(result.fills[2].symbol, code(2));
-            assert_eq!(result.fills[2].quantity, 6000);
-        } else {
-            assert!(
-                result.fills.is_empty(),
-                "configured quote condition must reach the actual executor"
-            );
-        }
-    }
-}
-
-#[test]
-fn frontend_compiled_unset_stops_only_builds_positions_and_keeps_holding() {
-    // Generated by OmniQuant's actual handoff and compiler, not a hand-written
-    // replacement runtimeExpressions contract. It used to inject 0.93/1.07.
-    let spec: serde_json::Value = serde_json::from_str(include_str!(
-        "fixtures/stock_pool_disabled_stops_compiled.json"
-    ))
-    .unwrap();
-    let config =
-        platform_expr_config_from_value("fixture_hold_without_stops", "000300.SH", &spec).unwrap();
-    assert!(config.stop_loss_expr.is_empty());
-    assert!(config.take_profit_expr.is_empty());
-    let result = BacktestEngine::new(
-        data(false),
-        PlatformExprStrategy::new(config),
-        broker(false).with_matching_type(MatchingType::CurrentBarClose),
-        BacktestConfig {
-            initial_cash: 30000.,
-            benchmark_code: "000300.SH".into(),
-            start_date: Some(day(2)),
-            end_date: Some(day(6)),
-            decision_lag_trading_days: 0,
-            execution_price_field: PriceField::Close,
-        },
-    )
-    .run()
-    .unwrap();
-    assert_eq!(
-        result.fills.len(),
-        2,
-        "stock one doubles in price, but disabled stops and weight rebalancing must not sell it: {:?}",
-        result.fills
-    );
-    assert!(
-        result
-            .fills
-            .iter()
-            .all(|fill| fill.side == fidc_core::OrderSide::Buy)
-    );
-    assert_eq!(result.equity_curve.len(), 3);
-}
-
-#[test]
-fn partial_backtest_fills_do_not_turn_into_completed_preserved_holdings() {
-    let data = data_with_first_volume(2000);
-    let broker = broker(true).with_matching_type(MatchingType::CurrentBarClose);
-    let mut account = PortfolioState::new(30000.);
-    let first = broker
-        .execute_with_event_dates(
-            day(2),
-            day(2),
-            day(2),
-            &mut account,
-            &data,
-            &decision(contract(day(2), 1, true)),
-        )
-        .unwrap();
-    let partial = account
-        .position(&code(1))
-        .map(|position| position.quantity)
-        .unwrap_or(0);
-    assert!(partial > 0 && partial < 3000, "{first:?}");
-    let second = broker
-        .execute_with_event_dates(
-            day(5),
-            day(5),
-            day(5),
-            &mut account,
-            &data,
-            &decision(contract(day(5), 1, true)),
-        )
-        .unwrap();
-    assert!(
-        account.position(&code(1)).unwrap().quantity > partial,
-        "partial entry must continue on the next valid execution: {second:?}"
-    );
-}
-
-#[test]
-fn next_day_outside_policy_executes_after_the_first_exclusion_signal() {
-    let data = data(false);
-    let broker = broker(false).with_matching_type(MatchingType::CurrentBarClose);
-    let mut account = PortfolioState::new(20000.);
-    account.position_mut(&code(1)).buy(day(1), 1000, 10.);
-    let outside = |signal| {
-        let mut value = contract(signal, 2, true);
-        value.members.retain(|member| member.symbol == code(2));
-        value.selection.requested_symbols = vec![code(2)];
-        value.selection.normal_trading_symbols = vec![code(2)];
-        value.selection.risk_eligible_symbols = vec![code(2)];
-        value.out_of_pool_policy = "reduce_next_trading_day".into();
-        value
-    };
-    let first = broker
-        .execute_with_event_dates(
-            day(2),
-            day(2),
-            day(2),
-            &mut account,
-            &data,
-            &decision(outside(day(2))),
-        )
-        .unwrap();
-    assert!(first.fill_events.is_empty(), "{first:?}");
-    let next = broker
-        .execute_with_event_dates(
-            day(5),
-            day(5),
-            day(5),
-            &mut account,
-            &data,
-            &decision(outside(day(5))),
-        )
-        .unwrap();
-    assert!(
-        account
-            .position(&code(1))
-            .is_none_or(|position| position.quantity == 0),
-        "{next:?}"
-    );
-    assert_eq!(account.position(&code(2)).unwrap().quantity, 3000);
-}

crates/fidc-core/tests/stock_pool_execution_state.rs

@@ -1,280 +0,0 @@
-use chrono::NaiveDate;
-use fidc_core::stock_pool_execution::*;
-use fidc_core::stock_pool_state::StockPoolExecutionState;
-use rust_decimal::Decimal;
-use serde_json::json;
-use std::collections::BTreeMap;
-
-fn day(value: u32) -> NaiveDate {
-    NaiveDate::from_ymd_opt(2026, 9, value).unwrap()
-}
-fn member() -> StockPoolMemberSpec {
-    StockPoolMemberSpec {
-        symbol: "000001.SZ".into(),
-        requested_order: 0,
-        recommendation_reason: String::new(),
-        target_weight_bps: None,
-        stop_loss: None,
-        take_profit: None,
-    }
-}
-fn held(quantity: i64, closable: i64) -> Position {
-    Position {
-        symbol: "000001.SZ".into(),
-        quantity: quantity.into(),
-        closable_quantity: closable.into(),
-        average_cost: 10.into(),
-    }
-}
-fn quote() -> MarketSnapshot {
-    MarketSnapshot {
-        symbol: "000001.SZ".into(),
-        last_price: 10.into(),
-        prev_close: Some(10.into()),
-        volume: Some(1000000.into()),
-        turnover: Some(10000000.into()),
-        bid_price_1: Some(10.into()),
-        ask_price_1: Some(10.into()),
-        is_kcb: Some(false),
-        instrument_rules: None,
-        buy_sizing_price: None,
-        sell_sizing_price: None,
-    }
-}
-fn plan(
-    state: &StockPoolExecutionState,
-    at: NaiveDate,
-    members: &[StockPoolMemberSpec],
-    positions: &[Position],
-    cash: i64,
-    outside: &str,
-) -> StockPoolPlan {
-    plan_at_price(state, at, members, positions, cash, outside, 10)
-}
-fn plan_at_price(
-    state: &StockPoolExecutionState,
-    at: NaiveDate,
-    members: &[StockPoolMemberSpec],
-    positions: &[Position],
-    cash: i64,
-    outside: &str,
-    price: i64,
-) -> StockPoolPlan {
-    let symbols = members
-        .iter()
-        .map(|member| member.symbol.clone())
-        .collect::<Vec<_>>();
-    let selection = StockPoolSelection {
-        trade_date: at,
-        requested_symbols: symbols.clone(),
-        normal_trading_symbols: symbols.clone(),
-        risk_eligible_symbols: symbols.clone(),
-        final_symbols: symbols,
-        exclusion_reasons: BTreeMap::new(),
-        inherited_from_generation: None,
-        explicit_empty: false,
-        generation: Some("same-goal".into()),
-    };
-    let mut constraints = stock_pool_constraints_from_configuration(
-        &json!({"top_n_rebalance_policy":"preserve_existing"}),
-        &json!({}),
-    )
-    .unwrap();
-    constraints.pending_entry_symbols = state.pending_symbols();
-    constraints.next_day_outside_exit_symbols = state.next_day_exit_symbols(at);
-    let mut market = quote();
-    market.last_price = price.into();
-    market.bid_price_1 = Some(price.into());
-    market.ask_price_1 = Some(price.into());
-    build_stock_pool_target_plan_with_constraints(
-        &selection,
-        members,
-        &StockPoolExecutionRule::default(),
-        &AccountSnapshot {
-            total_equity: 10000.into(),
-            cash: cash.into(),
-            frozen_cash: Decimal::ZERO,
-        },
-        positions,
-        &[market],
-        10000,
-        Decimal::ZERO,
-        outside,
-        "preserve_existing",
-        &constraints,
-        "same-goal",
-        Decimal::ZERO,
-        Decimal::ZERO,
-        Decimal::ZERO,
-    )
-    .unwrap()
-}
-
-#[test]
-fn fully_filled_entry_is_not_reopened_when_price_falls_before_next_observation() {
-    let members = vec![member()];
-    let calendar = vec![day(11), day(14)];
-    let initial = StockPoolExecutionState::default()
-        .observe(day(11), day(11), &calendar, &members, &[]).unwrap();
-    let first_plan = plan(&initial, day(11), &members, &[], 10000, "hold");
-    let state = initial.record_plan(day(11), "first-entry", &first_plan).unwrap();
-    assert_eq!(state.entries["000001.SZ"].completion_quantity, Some(1000.into()));
-    let state: StockPoolExecutionState = serde_json::from_slice(&serde_json::to_vec(&state).unwrap()).unwrap();
-    let observed = state.observe(day(14), day(14), &calendar, &members, &[held(1000, 1000)]).unwrap();
-    assert!(!observed.pending_symbols().contains("000001.SZ"));
-    let next = plan_at_price(&observed, day(14), &members, &[held(1000, 1000)], 1000, "hold", 8);
-    assert_eq!(next.rows[0].target_quantity, 1000.into());
-    assert_eq!(next.rows[0].delta_quantity, Decimal::ZERO);
-    assert_eq!(next.rows[0].status, "PRESERVED_EXISTING_POSITION");
-}
-
-#[test]
-fn cash_clipped_or_rejected_entry_does_not_claim_full_completion() {
-    let members = vec![member()];
-    let calendar = vec![day(11), day(14)];
-    let initial = StockPoolExecutionState::default()
-        .observe(day(11), day(11), &calendar, &members, &[]).unwrap();
-    let first_plan = plan(&initial, day(11), &members, &[], 5000, "hold");
-    assert_eq!(first_plan.rows[0].status, "REDUCE_TO_ALLOWED_QUANTITY");
-    let state = initial.record_plan(day(11), "limited-entry", &first_plan).unwrap();
-    assert_eq!(state.entries["000001.SZ"].completion_quantity, None);
-    for quantity in [0, 500] {
-        let positions = if quantity == 0 { vec![] } else { vec![held(quantity, quantity)] };
-        let observed = state.observe(day(14), day(14), &calendar, &members, &positions).unwrap();
-        assert!(observed.pending_symbols().contains("000001.SZ"));
-    }
-}
-
-#[test]
-fn legacy_state_without_quantity_keeps_its_serialized_identity() {
-    let original = json!({
-        "schema_version":1,"last_execution_date":"2026-09-11",
-        "entries":{"000001.SZ":{"pending":true,"observed_holding":false,
-        "first_decision_date":"2026-09-11","latest_generation":"legacy",
-        "latest_target_value":"10000"}},"last_target_weights":{},"removed_since":{}
-    });
-    let state: StockPoolExecutionState = serde_json::from_value(original.clone()).unwrap();
-    state.validate().unwrap();
-    assert_eq!(serde_json::to_value(state).unwrap(), original);
-}
-
-#[test]
-fn partial_entry_continues_after_restart_then_completed_holdings_are_preserved() {
-    let members = vec![member()];
-    let calendar = vec![day(11), day(14)];
-    let first = StockPoolExecutionState::default()
-        .observe(day(11), day(11), &calendar, &members, &[])
-        .unwrap();
-    let initial = plan(&first, day(11), &members, &[], 10000, "hold");
-    assert_eq!(initial.rows[0].target_quantity, 1000.into());
-    let pending = first.record_plan(day(11), "same-goal", &initial).unwrap();
-    assert!(pending.entries["000001.SZ"].pending);
-    assert!(!pending.entries["000001.SZ"].observed_holding);
-    let persisted = serde_json::to_vec(&pending).unwrap();
-    let restored: StockPoolExecutionState = serde_json::from_slice(&persisted).unwrap();
-    let partial = restored
-        .observe(day(11), day(11), &calendar, &members, &[held(500, 0)])
-        .unwrap();
-    let retry = plan(&partial, day(11), &members, &[held(500, 0)], 5000, "hold");
-    assert_eq!(retry.rows[0].delta_quantity, 500.into(), "{retry:?}");
-    let pending = partial.record_plan(day(11), "same-goal", &retry).unwrap();
-    assert!(pending.entries["000001.SZ"].pending);
-    let filled = pending
-        .observe(day(14), day(14), &calendar, &members, &[held(1000, 1000)])
-        .unwrap();
-    let satisfied = plan(&filled, day(14), &members, &[held(1000, 1000)], 0, "hold");
-    assert_eq!(satisfied.rows[0].status, "PRESERVED_EXISTING_POSITION");
-    let completed = filled.record_plan(day(14), "new-day", &satisfied).unwrap();
-    assert!(!completed.entries["000001.SZ"].pending);
-    assert_eq!(
-        plan(
-            &completed,
-            day(14),
-            &members,
-            &[held(1000, 1000)],
-            0,
-            "hold"
-        )
-        .rows[0]
-            .status,
-        "PRESERVED_EXISTING_POSITION"
-    );
-}
-
-#[test]
-fn removal_anchor_is_not_reset_by_rechecks_weekends_or_t_plus_one() {
-    let calendar = vec![day(11), day(14), day(15)];
-    let positions = vec![held(1000, 1000)];
-    let removed = StockPoolExecutionState::default()
-        .observe(day(11), day(11), &calendar, &[], &positions)
-        .unwrap();
-    assert_eq!(removed.removed_since["000001.SZ"], day(11));
-    assert_eq!(
-        plan(
-            &removed,
-            day(11),
-            &[],
-            &positions,
-            0,
-            "reduce_next_trading_day"
-        )
-        .rows[0]
-            .status,
-        "DEFERRED_T_PLUS_ONE"
-    );
-    assert!(
-        removed
-            .observe(day(12), day(12), &calendar, &[], &positions)
-            .is_err()
-    );
-    let restored: StockPoolExecutionState =
-        serde_json::from_str(&serde_json::to_string(&removed).unwrap()).unwrap();
-    let monday = restored
-        .observe(day(14), day(14), &calendar, &[], &[held(1000, 0)])
-        .unwrap();
-    assert_eq!(monday.removed_since["000001.SZ"], day(11));
-    assert_eq!(
-        plan(
-            &monday,
-            day(14),
-            &[],
-            &[held(1000, 0)],
-            0,
-            "reduce_next_trading_day"
-        )
-        .rows[0]
-            .delta_quantity,
-        Decimal::ZERO
-    );
-    let next = monday
-        .observe(day(15), day(15), &calendar, &[], &positions)
-        .unwrap();
-    let exit = plan(
-        &next,
-        day(15),
-        &[],
-        &positions,
-        0,
-        "reduce_next_trading_day",
-    );
-    assert_eq!(exit.rows[0].target_quantity, Decimal::ZERO);
-    assert_eq!(exit.rows[0].side, Some(OrderSide::Sell));
-    let returned = next
-        .observe(day(15), day(15), &calendar, &[member()], &positions)
-        .unwrap();
-    assert!(returned.removed_since.is_empty());
-}
-
-#[test]
-fn cloned_preview_does_not_start_a_timer_and_next_open_uses_signal_removal_date() {
-    let state = StockPoolExecutionState::default();
-    let calendar = vec![day(11), day(14)];
-    let preview = state
-        .observe(day(11), day(14), &calendar, &[], &[held(1000, 1000)])
-        .unwrap();
-    assert!(state.removed_since.is_empty());
-    assert!(preview.next_day_exit_symbols(day(14)).contains("000001.SZ"));
-    let mut invalid = preview;
-    invalid.schema_version = 0;
-    assert!(invalid.validate().is_err());
-}

crates/fidc-signal-client/Cargo.toml

@@ -1,10 +0,0 @@
-[package]
-name = "fidc-signal-client"
-version.workspace = true
-edition.workspace = true
-license.workspace = true
-
-[dependencies]
-fidc-core = { path = "../fidc-core" }
-reqwest.workspace = true
-serde_json.workspace = true

crates/fidc-signal-client/src/lib.rs

@@ -1,43 +0,0 @@
-//! Shared signal transport for FIDC backtest and trading services.
-
-use std::sync::Arc;
-use fidc_core::signal_contract::{SignalBookReference,ValidatedSignalBook,cached_signal_book,register_signal_book};
-use reqwest::Client;
-use serde_json::{Value,json};
-
-#[derive(Clone,Copy)]
-pub enum Purpose { Backtest, Online }
-
-pub async fn load(client:&Client, source_url:&str, token:&str, reference:&SignalBookReference, purpose:Purpose)
-    -> Result<Arc<ValidatedSignalBook>,String>
-{
-    reference.validate()?;
-    if token.len()<32 {return Err("signal_service_auth_not_configured".into());}
-    let purpose_name=match purpose {Purpose::Backtest=>"backtest",Purpose::Online=>"online"};
-    let payload=json!({"reference":reference,"purpose":purpose_name});
-    let root=format!("{}/api/strategy-signals/internal",source_url.trim_end_matches('/'));
-    // Registration/purpose validation always precedes a process-cache hit.
-    let response=client.post(format!("{root}/validate"))
-        .header("X-FIDC-Lifecycle-Token",token).json(&payload).send().await
-        .map_err(|_|"signal_validation_service_unavailable")?;
-    if !response.status().is_success() {return Err(format!("signal_validation_rejected_http_{}",response.status()));}
-    let validation:Value=response.json().await.map_err(|_|"signal_validation_response_invalid")?;
-    if validation.get("ok")!=Some(&Value::Bool(true)) || validation.get("reference")!=Some(&json!(reference)) {
-        return Err("signal_validation_identity_mismatch".into());
-    }
-    let book=if let Some(book)=cached_signal_book(reference)? {book} else {
-        let mut response=client.post(format!("{root}/book"))
-            .header("X-FIDC-Lifecycle-Token",token).json(&payload).send().await
-            .map_err(|_|"signal_book_service_unavailable")?;
-        if !response.status().is_success() {return Err(format!("signal_book_rejected_http_{}",response.status()));}
-        if response.content_length().is_some_and(|bytes|bytes>64*1024*1024) {return Err("signal_book_transport_size_exceeded".into());}
-        let mut bytes=Vec::new();
-        while let Some(chunk)=response.chunk().await.map_err(|_|"signal_book_transport_incomplete")? {
-            if bytes.len().saturating_add(chunk.len())>64*1024*1024 {return Err("signal_book_transport_size_exceeded".into());}
-            bytes.extend_from_slice(&chunk);
-        }
-        register_signal_book(reference,&bytes)?
-    };
-    if matches!(purpose,Purpose::Online) {book.require_observed()?;}
-    Ok(book)
-}

docs/automatic-trade-protection-20260911.md

@@ -1,25 +0,0 @@
-# 策略级自动交易保护
-
-## 统一合同
-
-`runtimeExpressions.trading.automaticTradeProtection` 是每个股票/ETF策略自己的不可变配置。股票池、表达式轮动和显式订单复用 `holding_policy` 内核，不新增全局共享配置，也不修改未配置的历史策略。
-
-```json
-{"buy_protection_days":3,"sell_cooldown_days":3,"max_holding_days":90,"locks":[{"symbol":"000001.SZ","start_date":"2026-09-11","end_date":"2026-09-16"}]}
-```
-
-- 周期为空、null或0关闭，必须为0—3650整数；锁定支持同股多个区间，起止日包含当日，截止null持续有效。
-- 买入保护禁止自动减仓/清仓及止盈止损；卖出冷却禁止自动增加仓位。只有实际成交计时，部分成交延长对应最后成交日；未成交、拒绝、撤单不启动。
-- 成交日及后续N个完整正式交易日均受保护。例如周五成交、N=3，保护到下周三结束，周四恢复；不按72小时或自然日替代。
-- 最长持有从连续持仓第一次实际买入开始，跨正式交易日计数；加仓、部分卖出和有证据的证券转换不重置，完全卖出再买入开启新周期。锁定和买入保护优先于最长持有退出。
-- 日期锁定禁止自动买卖，已接受的挂单不自动撤销；手工路径只绕过自动策略保护，不绕过账户授权、T+1、券商和风控。
-- 保留的真实持仓继续占用资金与席位，不把未完成卖出当现金。最长持有退出先形成唯一最终目标，不能叠加一笔策略部分卖出和一笔框架全量卖出。
-- 在线上下文重建必须注入已经校验的真实成交/持仓快照，不能把重建日或旧行情日当建仓日。期货或股票期货混合账户未纳入本合同，显式拒绝。
-
-## 根因补充修复
-
-组合 `decision_date == "2026-09-11" && symbol == "000001.SZ"` 会落到字符串表达式路径。旧代码遗漏日期等内建标识符的保留登记，又按“额外因子”注入NaN，覆盖同名真实日期，造成选股错误。现登记全部已注入内建字段，并禁止额外因子覆盖已存在的作用域变量。单独数字VM日期测试不足以发现该问题，新增日期+证券混合选择回归。
-
-## 验证与边界
-
-原生完整回测测试验证：显式策略真实模拟成交日启动3日保护/禁买、日期锁定零委托、最长持有让位于保护、锁定持仓占据资金与席位、解锁后才按候选顺序买入；序列化和别名归一不改max_holding_days字段，冲突策略拒绝。现有534核心用例通过（6个既有忽略项）。这些是隔离内核测试，不是GT实际成交验收。

docs/daily-pattern-signals.md

@@ -1,24 +0,0 @@
-# 完成日线形态与次日信号
-
-`fidc_daily_ohlcv_pattern_v1` 由 `fidc-core::daily_patterns` 单一计算核实现。Source Lake 只读取、核验及传输真实 OHLCV；研究服务和策略表达式不分别维护数值算法。
-
-四种量价条件为趋势强势、前高突破、放量上涨、缩量突破；额外提供独立的均线下方、放量下跌卖出条件。前三者名称不暗示当日金叉或价格突破等未实际检验的事实。
-
-## 应用阶段
-
-- `filter.stock_expr(pattern_signal("<模板 JSON>"))`：选择候选，再按既有顺序和 Top N 取目标。
-- `filter.buy_expr(pattern_signal("<模板 JSON>"))`：只限制正向仓位增量，不移除目标、不反向清仓，正常减仓不受影响。
-- `risk.stop_loss(pattern_signal("<独立卖出模板 JSON>"))`：独立退出条件，不使用买入条件的反值。
-- `pattern_score` 只可用于已通过形态条件的对象；没有放量参照或合法排除对象不伪造零分。
-
-参数是 JSON 字符串，例如 `pattern_signal("{\"template\":\"ma_below\",\"parameters\":{\"ma_window\":20}}")`。
-
-新规则必须显式 `execution.matching_type("next_bar_open")`。信号日 D 的完整日线不能用于 D 日盘前或盘中；历史回放按 D 决策、下一真实交易日执行，实时上下文使用已完成 D 日窗口。实际委托仍需要执行日行情、资金、可卖数量、交易许可和风控。不得用研究结果开启交易路由。
-
-## 数据与预热
-
-所有价格统一用真实 backward1 因子，成交量不复权。缺失、非有限值、无效 OHLC、重复、未来行、未声明停牌状态均拒绝。仅按明确上市日期证明的上市前窗口或正式停牌记录可以返回结构化排除；不补价、不跳过日期压缩窗口。有效价格但缺复权因子即使停牌也报错。回测和运行态须从表达式提取真实窗口需求，冻结完整日历预热。
-
-研究选择的范围及日期、上市/停牌排除证据、源查询和哈希需保留。固定候选的后续规则回测不等于历史全市场动态选股。CAPM 全区间拟合属于解释性诊断；要成为次日条件，必须另行使用截至 D 日的滚动估计并验证样本外表现，不得回填到拟合区间内。
-
-旧任务默认撮合、历史筛选记录和策略源码不变；用户显式创建新规则后才采用此合同。

docs/execution-leg-price-risk-20260911.md

@@ -1,54 +0,0 @@
-# 逐成交腿价格风控验收
-
-## 修复范围
-
-Engine `7e0877b5860d8724da1c4507a1d1ba393b3497f5`，Trading `1f7bc074024191cfaa5975546f22c2c2c733602a`，均以 tag `v2026.9.11.2` 发布177。
-
-- 回测在每条实际报价进入撮合前检查原始参考价，滑点和限价处理后再次检查最终价。买入一元股、买入涨停、卖出跌停以及无效价格均按本腿价格处理，不能只依赖最初下单的日线标记或价格。
-- Paper和Live的订单前检查与Paper撮合共用`MarketSnapshot::execution_reference_price`：普通买入用卖一、卖出用买一；未提供该侧价格时保留既有最新价合同，显式0或负数不当缺失处理、不回退。
-- 选股仍独立使用其日线最新价与显式规则，不被买卖盘差异改写。盘后固定价仍使用原正式收盘价合同。
-- Paper已接受/部分成交订单在新报价到达时重新检查。后续被风控拒绝不删除或回滚此前真实模拟成交，不重复扣资金或手续费。
-- 实盘这里只验证发单前路径；券商实际成交事实必须原样保存，不能声称本地检查能保证委托进入券商后市场不再变化。本轮未提交证券订单。
-
-## 测试
-
-- 原始报价0.9、正向滑点20%后为1.08，仍不得利用滑点绕过一元股规则。
-- 先出现0.9、后出现1.2的报价，只允许在后一个实际时点成交；不回写到前一时点。
-- 限价滑点将最终执行价变为0.9时仍拒绝；显式关闭一元股买入规则后放行；卖出不继承买入一元股规则。
-- 最后价10而卖一11触及涨停：买入拒绝。最后价11而卖一10.5：执行检查不按旧最后价误拒；显式选股涨停规则仍可按最后价拒绝。
-- 最后价10而买一9触及跌停：卖出拒绝。最后价9而买一9.5：执行检查不按旧最后价误拒。
-- 原挂单/部分成交后，最后价1.1但卖一0.9：余单拒绝，既有成交数和现金保持不变。
-
-177测试：Engine 667通过/8忽略，Trading工作区548通过/10忽略，Runner370通过/3忽略，API99通过/1忽略。新场景使用隔离合成账户/报价，未以此冒充原始市场样本。
-
-## 真实分钟回放
-
-- 同一冻结请求、信号及bundle，2025-01-03至2025-01-06，分钟13:07，初始10,000,000，滑点0.002，佣金万三/最低5，分钟25%量约束不改。
-- 原基准 `btr_1789074235759_2081201_1`。
-- 新运行 `btr_1789093974375_2601124_0`。
-- 均21成交、11个最终持仓，最终资产9,968,551.588547；订单、成交、账户、权益、持仓和风险审计六项canonical完全一致。
-- 总SHA `a1aa004f544b34eae0ade41e849a0fd067e39600d1c4ad1a127f5a3d6a79be11`。
-- 服务端3.490秒，客户端提交/读取/轮询16.927秒。未采集客户端各子段，不能把差值归因到某个具体服务，也不与原报告“提交后轮询耗时”混比。缓存条件的短样本不能外推冷态或多年性能。
-
-## 发布与状态
-
-通过官方Backtest和Trading installer构建和发布，没有调用Source/因子重启入口。Backtest service源码仍`75202cc3b876daf99d0d2dffb988ca456c34aabf`并重新链接上述engine。运行二进制SHA与清单一致。
-
-本轮发布前10:27已观测到3Paper/0Live，重复读取确认；这不同于上一轮的3Paper/1Live，不是本次发布删除。本轮没有新建、恢复或删除实例。发布后仍3Paper/0Live，完整配置/状态摘要与本轮发布前相同。
-
-Source主PID2267019和因子主PID2178403、NRestarts不变。发布后样本Paper9行、Live11行无WARN/ERROR，Runtime0行不能视为实际执行成功；行情`/readyz`仍503，THS -4302配额问题未恢复。
-
-## 未完成
-
-next-open全天量容量和动态滑点使用全天high/low/volume的问题没有被本次修复覆盖，仍按P0时点问题处理。新的执行观察规格位于`/Users/boris/WorkSpace/docs/fidc/execution-observation-prd-20260911.md`，只是后续实现规格，不是已部署能力。禁止静默改用昨量、自动关闭风控、修改旧结果或把后续一分钟量回填到开盘。
-
-自然Paper/Live还需要合格模型、正式审批和真实可用行情；不开放2026封存，不替研究模型审批。当前实盘列表为空，不自行补建。
-
-## 证据
-
-`/srv/fidc/canonical/run/research/execution-leg-risk-20260911/`：
-
-- `engine-focused.log`、`engine-full.log`、`trading-full.log`、`backtest-full.log`。
-- `minute-replay/request.json`、`submission.json`、`result.json`、`comparison.json`。
-- `deploy-before.json`、`deploy-after.json`、`running-binary-verification.json`、`post-deploy-log-audit.json`。
-- 官方部署日志、研究审计脚本与执行观察设计稿。不改旧证据目录和WFT V18制品。

docs/execution-price-account-audit-20260911.md

@@ -1,87 +0,0 @@
-# 执行价风控与共享信号账户隔离验收
-
-## 结论
-
-本次修复已通过测试并发布 177。只证明一元股请求阶段价格修复、同一共享信号的账户隔离和既有真实样本结果不变；完整生产闭环尚未完成。next-open 全天容量、动态滑点的日内可见性及逐成交腿风控仍是未关闭项，不能称为全部成交无未来信息。
-
-## 修复
-
-- `risk_control.rs` 的 Buy 一元股规则改用本次 `check_price`，不再读取日线 `is_one_yuan` 或当天更早的 `day_open`。无效价格拒绝，其他缺失风险事实仍拒绝；显式 Selection 规则保留。
-- Trading 共用 `risk.rs` 的 Paper/Live 订单前检查使用新鲜 `last_price`，不再被日线标记或开盘价覆盖。选股阶段的开关和日线标记单独处理。
-- 缺执行价格继续输出具体 `missing_execution_price field=open`，保留 `historical_price_fallback=false`；停牌等权威状态仍优先，不因新通用校验丢失根因。
-- 没有修改共享信号内容、模型、账号权限、运行配置、Source Lake、研究 checkpoint 或既有回测数据。
-
-## 账户隔离组合
-
-隔离共享核心测试使用同一份经过原生校验的 `fidc.signal-book/v2`，信号只表达保留 50% 持仓。当前价 10、止损 10%、止盈 20%；每个账户独立计算实际订单。
-
-| 原数量 | 买入价 | 买入费用总额 | 预期剩余 | 结果 |
-| ---: | ---: | ---: | ---: | --- |
-| 1,000 | 8.00 | 0 | 0 | 止盈优先于半仓目标 |
-| 1,000 | 10.00 | 0 | 500 | 按本账户数量减半 |
-| 3,000 | 10.00 | 0 | 1,500 | 不共用其他账户数量 |
-| 1,000 | 12.00 | 0 | 0 | 止损 |
-| 1,000 | 11.11 | 0 | 500 | 尚未跨过止损阈值 |
-| 1,000 | 11.11 | 2.00 | 0 | 含费用成本跨过止损阈值 |
-
-六种账户卖出后，当天再消费同一买入目标均不得买回；独立未卖出账户可正常买入。同一信号版本不变，策略规划不预先修改持仓。这些是隔离合成账户测试，不是券商委托/成交证据。
-
-## 回归与真实回放
-
-- Engine：656 通过，8 个专用测试忽略。
-- Trading 工作区：537 通过，9 个专用测试忽略。
-- Backtest Runner：370 通过、3 忽略；API：99 通过、1 忽略。
-- 一元股专项覆盖真实执行价为 0.9/1.0/1.2、旧标记与新价格相反、缺失其他风险事实、NaN/无效价及开关独立性。
-
-实际 HTTP 回测使用原始冻结请求、信号和 bundle，未复制结果：
-
-- 原基准：`btr_req_260d0f3179d40fda5c918d48eba0a239bd335406c82a1cbe`。
-- 新运行：`btr_1789091571964_2429476_0`。
-- 区间：2025-02-05 至 2025-02-10；初始资金 10,000,000；目标 10 仓；next-open；滑点 0.002；佣金万三、最低 5。
-- 两次均 28 成交，最终资产 10,089,448.918844，收益 0.89448918844%。
-- 订单、成交、账户事件、权益、持仓、风险审计六项摘要相同。
-- Canonical SHA256：`befa50b3ec5b94adafede459903db7e2542797cf0eefe2de32900afc83ca1481`。
-- 服务端 3.954 秒，客户端含轮询 6.072 秒。此短区间已有缓存样本不能代表全市场冷态或多年性能。
-
-## 发布
-
-- Engine `d3c36e947894fd220b62ecd6fbfe02473f70bd2c`，tag `v2026.9.11`。
-- Trading `dfcec36bd1c0f92e73cd30073540eb39dbd02835`，tag `v2026.9.11`。
-- Backtest service `75202cc3b876daf99d0d2dffb988ca456c34aabf`，重新链接上述引擎。
-- 只使用官方 installer，以 Boris 构建和运行。发布后 Backtest/Runtime/Paper/Live 的进程和 HTTP `/healthz` 正常，运行二进制核对独立清单，不仅检查源码 HEAD。实时行情 `/readyz` 仍为 503，原因如下，不能宣称自然交易正常。
-- 原 3 Paper / 1 Live 配置和状态摘要前后相同；本次投影 Paper 为 `52a909117fe8f01ae35a327bd86310e2583d291609bba6596dc0f49a2b10559c`，Live 为 `aaec1e9dbc984012e9fe677e54db1efb860edd59d5840d1dc87c4b230b26bac6`。仅与本次相同投影的发布前数据对比，不与此前其他字段投影混比。
-- Source PID 2267019、因子主进程 PID 2178403、NRestarts 均不变。本轮未调用 Source/因子重启入口；不能由主 PID 不变推断全部因子子任务已经验收。
-
-## 未关闭问题
-
-### 实时行情配额
-
-发布后文件日志审查发现 THS `-4302`：本周行情用量超过 1.5 亿。受保护的行情源目录只返回 `ths_realtime`，enabled=true、ready=false；没有已配置可用的授权备用源。行情 `/readyz` 返回503、snapshot_count=0，实盘日志反复记录实际执行日2026-09-11请求150证券、收到0新鲜行情，因此 next-open 规划失败。
-
-所查尾部8,000行日志中，配额告警最早已出现在01:30:12 UTC（上海09:30），早于本轮09:58的Trading发布。不能把该故障归因于本次一元股代码或用重启解决。不得拿昨日收盘、Source历史数据或手工报价代替实时价格；恢复账户配额或配置正式授权的可用行情源后，才能继续自然交易验收。
-
-Paper的3条WARN为启动重建的PG读取，分别约1.015/1.122/1.460秒；本轮未见ERROR，但这只是采样范围，不能称全部日志无异常。证据：`realtime-quota-timeline.json`、`realtime-provider-readiness.json`、`post-deploy-file-log-audit.json`。Runtime无新采样日志不等于实际调度通过。
-
-### 执行容量与校准
-
-独立依赖探针确认：保持 next-open 订单和开盘价不变，仅修改执行日后来形成的全天量，成交量从 100 变为 1,000；仅修改全天 high/low，动态滑点成交价从 10.305 变为 11.000。探针是合成输入，不冒充市场证据。
-
-详见 `/Users/boris/WorkSpace/docs/fidc/execution-time-capacity-coordination-20260911.md`。下一步须分离实测执行时点容量和声明的容量估计、冻结校准数据时钟、覆盖挂单逐成交腿；不能偷偷改为昨日成交量、关闭限制或使用未来一分钟量。V18 研究只允许新不可变后继评估，不能改现有结果。
-
-自然 Paper 观察与正式 Live 仍需真实合格版本和正式审批。当前研究控制模型仅 23 个验证日，2026 留出期继续封存；不得为演示闭环降低门槛、伪造 observed、代替审批或手工发证券订单。
-
-### 并发代码合并
-
-报告推送时远端新增 `33924b1/f2e228e` 的策略自动交易保护。已保留并合并至main `f7d16fb`，177源码同步，组合引擎回归666通过、8忽略。该合并后的新保护尚未由本任务部署，线上仍使用本报告列出的d3c36e9/dfcec36清单；不能把源码同步当作发布或把对方功能归为本次已完成的自然交易验收。
-
-随后 Trading main 新增 `4ff7ee9aeefa2e1013098212dc75b4969499a1a6`，本机与177均已正常快进同步，合并组合工作区545通过、10忽略。此为并发功能合并后的源码测试，同样不改变本次发布清单；不重复部署另一个任务尚在验收的完整交易保护功能。
-
-## 证据
-
-177 根目录：`/srv/fidc/canonical/run/research/execution-risk-signal-audit-20260911/`。
-
-- `engine-full-tests-v2.log`、`trading-full-tests.log`、`backtest-full-tests.log`。
-- `deploy-before.json`、`deploy-after.json`、`running-binary-verification.json`。
-- `same-signal-backtest/request.json`、`submission.json`、`result.json`、`comparison.json`。
-- `execution-time-dependency-probe.json` SHA256：`feeb69275b8ad537f16e4c119cc7e59dd3a15773334fb591e27d7afdf34311d3`。
-- 官方部署日志与独立探针源码保存在相同证据根，不写入交易数据库或修改原始行情。

docs/expression-missing-values-20260909.md

@@ -1,63 +0,0 @@
-# 表达式缺失值与执行参数验收
-
-## 根因
-
-原数值执行器把 NaN 比较结果直接变成 false，外层 NOT 因而可能变成 true。
-`min(NaN, value)` 还会返回另一个有效值，使缺失因子参与筛选。下单标量继续经过
-`max`、`clamp` 或整数转换时，也可能把无效输入变成零仓位或零数量。
-
-## 执行合同
-
-数值 VM 使用带类型的 Missing 值，数值缺失及非有限运算结果不再提前变为布尔 false。
-
-| 表达式 | 结果 |
-| --- | --- |
-| NOT unknown | unknown |
-| false AND unknown | false |
-| true AND unknown | unknown |
-| true OR unknown | true |
-| false OR unknown | unknown |
-
-最终布尔筛选只接受 true；显式 `if`/`iff` 与 CASE WHEN 一样，只在条件确认为 true 时取真分支。
-显式 `nz` 保留策略自己声明的缺失值替代含义，框架不会自行填零。
-短路仍不读取未使用分支。非法 clamp 范围返回错误，不允许使进程 panic。
-
-Rhai 的逻辑运算不能承载可空布尔，因此动态脚本遇到未知数值比较时明确报错，不能
-返回错误的命中；缺失 map 属性同样报错。已关闭会绕过自定义比较保护的 Fast Operators。
-有限浮点比较仍使用现有 epsilon 口径，混合整数/浮点比较也受保护。
-[Rhai 运算符文档](https://rhai.rs/book/rust/operators.html)说明了该分派边界。
-
-下单数量、目标仓位、投入比例和筛选边界必须返回有限数值，否则记录
-`missing_numeric_result`，包含表达式、证券、决策日和执行日。只有排名评估保留
-独立的缺失值诊断路径；没有把数据源的缺行改写为价格或交易事实。
-
-## 代码与测试
-
-- `fda2e70`：VM 三值逻辑及动态数值保护。
-- `ea58ab2`：显式关闭 Rhai 快运算符，补齐缺失 map 保护。
-- `e3f1028`：执行标量必须有限，排名与执行参数分离。
-- 177 引擎：585 项通过、8 项跳过。
-- Runner：360 项通过、3 项跳过。
-- 交易工作区链接 e3f1028：510 项通过、8 项跳过。
-
-首次回归曾发现 Rhai 快路径仍绕过保护，修复后重新完整测试，未将失败候选部署。
-
-## 真实回放
-
-使用已保存的原始 strategy spec、初始资金、日期、基准、频率及全部执行配置，
-通过独立 runner 真正重新执行。固定为服务实际使用的16个逻辑CPU、Rayon8线程、Tokio16线程。
-
-- 五年日线：2021-08-23 至 2026-08-28，1,000万元，25,408笔成交。
-- 分钟样本：2025-01-02 至 2025-11-17，100万元，156笔成交。
-- 10次回放的 canonical 与 result-store 均等于各自同 frozen bundle 基准。
-- 包含 e3f1028 的最终回放为 `five-year-strict-1`、`minute-strict-1`。
-
-完整证据：`/Users/boris/WorkSpace/fidc-backtest-service/docs/evidence/numeric-condition-replay-20260909.json`。
-日线源行6,918,227；分钟样本仅636行，不能用其亚秒耗时宣传全部分钟策略的性能。
-
-## 边界
-
-该候选尚未部署到常驻回测或交易服务。此验证证明两种已有策略在有效冻结数据下结果不变，
-不证明所有策略、所有原始财务公告/vintage、全部缺失数据原因或真实券商交易均已验收。
-Rhai 未提供与数值 VM 完全相同的 nullable 表达式能力，目前选择明确拒绝，不能称为所有
-动态语言表达式都已支持三值逻辑。完整 typed Base Panel 与对象分配优化仍待完成。

docs/framework-execution-comparison-20260911.md

@@ -1,73 +0,0 @@
-# FIDC执行合同与开源框架审查
-
-状态：源码审查和部分通用修复已完成。尚未完成多策略长区间A/B；不能据此宣称某个框架性能最优或FIDC生产闭环已通过。
-
-## 固定版本
-
-源码保存在`/Volumes/SystemSSD/WorkSpace/fidc-reference-frameworks`，未执行第三方项目的策略或交易程序。
-
-| 框架 | 审查版本 | 主要参考位置 |
-|---|---|---|
-| NautilusTrader | 6f48cd8e713b72b878626e9a9757c6e4a026b708 | [报价类型](/Volumes/SystemSSD/WorkSpace/fidc-reference-frameworks/nautilus_trader/crates/model/src/data/quote.rs:51)、[归并](/Volumes/SystemSSD/WorkSpace/fidc-reference-frameworks/nautilus_trader/crates/backtest/src/node.rs:442) |
-| LEAN | 8ee075a39918f2df6fe9e0a5944e366fb60d10dc | [股票撮合](/Volumes/SystemSSD/WorkSpace/fidc-reference-frameworks/Lean/Common/Orders/Fills/EquityFillModel.cs:482) |
-| Zipline Reloaded | 943010b9da848e317fc520de87edade2b884d329 | [滑点与容量](/Volumes/SystemSSD/WorkSpace/fidc-reference-frameworks/zipline-reloaded/src/zipline/finance/slippage.py:464) |
-| Backtrader | b853d7c90b6721476eb5a5ea3135224e33db1f14 | [Broker](/Volumes/SystemSSD/WorkSpace/fidc-reference-frameworks/backtrader/backtrader/brokers/bbroker.py:228) |
-
-## 可采用的设计
-
-### 事件与时钟
-
-Nautilus把Quote、Trade、Bar区分为不同类型，保存事件与接收/初始化时钟；数据归并按`ts_init`排序，分块保留同一时间戳的完整组。这适合FIDC后续有界分钟流：Source声明观测类型、覆盖区间和可见时间，执行端持有独立账户状态，而非共享一个同时装着日终与盘中字段的可变字典。
-
-FIDC本轮实际发现：以09:32:58行情给09:33订单定价时，成交时间也写成09:32:58。已修为实际成交不得早于订单执行时钟；价格仍引用原行情，容量扣减也继续绑定原行情，不能通过换一个订单时钟重新获得额度。
-
-### 开盘和陈旧行情
-
-LEAN的MarketOnOpenFill单独处理正式开盘成交标志、bar开始/结束时间和订单时间；不是任意取一个日线字段即可成交。但其默认模型也有整体成交和数据回退假设，不能直接当作真实市场流动性保证。
-
-FIDC已统一预估与撮合的盘中价格选择。己方价、对手价和最近成交价各用自己的字段；缺失/无效时不改用另一种价，也不越过最新坏行情寻找更旧的可用价格。
-
-### 成交量与滑点
-
-Zipline按股票和bar累计已使用量，历史冲击窗口排除当前未完成交易日。FIDC应复用不可变历史校准，但每个账户自己的成交消耗必须独立；不能按订单次数重复分配同一个bar的额度。它在历史不足时的回退不是FIDC的默认准入策略。
-
-FIDC新增`ParticipationRate`：按冻结JSON小数语义精确向下取整，避免浮点乘法和窄整数转换误差。例如58%乘50股为29，不应因二进制误差成为28；巨大市场量也不能在转u32时截断成另一个额度。比例解析在配置阶段完成，不放入逐成交腿热循环。
-
-Backtrader把volume filler、滑点开关、cheat-on-open/close等模型选择显式区分。值得采用的是明确暴露假设；不照搬不带成交量限制的默认值，也不为了收益对齐开启能改变可见时间的行为。
-
-## 已落地通用修复
-
-- 精确参与率计算用于Broker和策略预估，同一观测的已消耗量跨订单共享、跨账户隔离。
-- 实际执行时钟与参考行情时钟分开，修复成交早于下单的问题。
-- 缺失的执行价不由其他价格或更旧行情代替；删除重复价格选择及不可达深度分支。
-- Runner拒绝空身份、错日期、晚于请求时钟的行情、非有限价格、缺失或非整数数量。
-- 多查询引用同一观测只有完全一致才合并；同一目标查询的源重复行和跨查询冲突均报错，不采用第一条。
-- 目录缓存使用Linux变更通知，不能只凭mtime/目录大小判断没有新文件；通知不可用时重新扫描。事件溢出、目录替换、重命名、删除均失效重建。
-
-这些改变不按策略ID、固定选股条件或10:17/10:18等时间分支。
-
-## 仍未关闭的问题
-
-1. **日线全天量仍进入早晨数量计算**：Broker和projection两条路径都需接入容量模式。`VolumeCapacityMode`及`SessionCapacityAudit`目前只是已测试基础类型，未完成配置、撮合、日终结果和页面的完整接线。不得称P0已修。
-2. **Source可能掩盖缺失**：当前目标分钟序列会先剔除无效close，再寻找旧的有效值；部分缺失volume/amount置0；备用Arrow包装器还会用请求时钟替代缺失行情时间。必须清理这些行为，并按数据/市场缺席合同分类。
-3. **TWAP早期配额可能依赖未来可成交记录数**：当前实现使用筛选后的`eligible_quotes.len()`分配数量。应按冻结时间表切片，后续缺量只能影响后续执行，不改早期分配。
-4. **集合竞价**：实时数据与日线/分钟模型必须区分委托进入竞价、等待撮合和实际成交，不能用竞价中间的零量判定股票停牌，不能提前使用最终清算价。
-5. **数据种类/单位**：源观测类型与价格模型能力要明确；分钟OHLC不能冒充真实L1深度。盘口单位、名义bar区间和可见时间仍须逐源校验。
-
-## 下一阶段实施合同
-
-- 普通风险开关和参与率仍是同一个策略三端共享配置。历史回测的容量假设单独冻结，不能用研究审核模式绕过Paper/Live临单风控。
-- 有真实可见观测时使用`execution_observation`；`completed_bar`须验证bar结束和可见时间，不靠日线日期猜15:00。
-- 只有日线总量而没有开盘容量时，严格模式须在提交预检失败；用户可明确选择`session_capacity_audit`做研究。日终只判定容量验收，不回写早晨的数量、现金、持仓或净值。
-- 不能自动关闭参与率限制，也不能悄悄替换为昨日量。
-- Source、Runner、Engine、研究handoff、Strategy AI和UI成套发布；持有冻结合同的旧任务不改写。当前研究维护方尚未授权共享服务切换。
-
-## 验证与基准
-
-Engine当前680项通过、8忽略；Runner375项通过，真实Source的8个JSON/Arrow行情点通过严格解析。小样本中的14:59零量在serving Parquet中确实存在，15:00有成交；这是源事实核对，不是完整集合竞价逻辑验收。历史股票收盘竞价时段应按适用规则处理，不能将后来的规则回填到旧日期。[深交所2023年交易机制说明](https://investor.szse.cn/institute/rules/t20230629_601434.html)
-
-上交所2026版规则于2026-07-06生效，且通知明确存在暂缓实施条文。后续交易时段/容量合同必须同时核对规则版本和实施范围。[上交所发布通知](https://www.sse.com.cn/lawandrules/sselawsrules2025/stocks/exchange/c/c_20260424_10816482.shtml)
-
-下一组A/B应覆盖动态Top-N日线、静态组合、逐分钟策略、TWAP/VWAP及共享模型信号，分别检查同条件重复、时间变更、参数变更、短区间和五年区间。先关闭时点错误，再测准备/引擎/持久化/端到端耗时、峰值RSS、缓存代际与逐笔差异。不得用微型元数据读取速度外推完整回测性能。
-
-本轮证据根：`/srv/fidc/canonical/run/research/historical-slippage-20260911/`。服务均未由本任务重启，没有提交回测任务或证券订单。

docs/lifecycle-price-evidence-20260910.md

@@ -1,15 +0,0 @@
-# 生命周期、价格缺失与历史状态
-
-证券有效区间为 `[listed_at, delisted_at)`。无明确摘牌日期的最新 terminal 标签不能反向污染历史；已知未来摘牌日不阻断此前的正常交易。退市整理期不是已摘牌。
-
-执行价加载前分别核验证券身份、正式上市/摘牌边界。合法上市前、摘牌后不查询和补价，记录结构化原因；同一日已有正执行价与生命周期边界冲突时报错。未知身份/代码映射、上市后的分钟缺口、候选事实缺失继续失败，不因 missing candidate 而跳过校验。持仓仅在当日正式暂停交易事实成立时允许按既定估值合同沿用历史价格；普通行情缺口不再无条件沿用旧价。
-
-整个明确证券范围尚未上市时保留官方日历内现金净值点，不缩短回测范围，不伪造成交或 OHLCV。基准只在首个基线点归一，后续无交易日不反复重置。
-
-513 项核心测试通过，6 项原有测试忽略。新增验证包含沪深北股票和 ETF 上市前、实际摘牌日、未知证券身份、候选缺失、正式停牌和普通价格缺口、全池上市前现金期间。对单个正式分区的数据缺口仍需数据源修复，不从这些测试外推全市场完整性。
-
-## 真实边界回放补充
-
-177 回测 `btr_1789041425783_797911_1`：920038.BJ，2026-08-04 至 08-07。真实上市日08-05，原结果只保留08-05至08-07三个净值点。原因是准备面同时加载基准000300.SH，基准不是交易候选但参与了“全部证券生命周期外”的判定。现在只排除已声明且没有交易候选记录的基准，不按代码或名称猜测指数，也不把真实候选排除；补充真实准备结构的回归后，4日现金区间完整保留。
-
-该草稿沿用源池 `rejectBjseSelection=false`、`rejectBjseBuy=true`，所以选中北交所但不下单符合其买入政策；原规划阶段没有记录拒绝原因则是审计缺项。新增 `scope=buy, stage=buy_planning` 审计，不伪造订单ID，不把买入否决改写成选股排除。测试验证禁止时无订单且有bjse原因，放开买入政策时正常生成意图。最新核心514项通过、6项原有忽略。

docs/stock-pool-screen-execution-20260911.md

@@ -1,10 +0,0 @@
-# 股票池候选顺序合同
-
-新请求可显式设置 `runtimeExpressions.selection.preserveCandidateOrder=true`，同一 `candidateSymbolsByDate` 同时冻结成员和顺序。原有未设置该标志的策略保留成员过滤后自行排名的语义，不改写历史回测。
-
-- 顺序在解析时保留，重复证券仍报错；空日期保持空，不继承旧候选。
-- 不再走市值快排或套用旧 rank 方向。选股风控和股票条件仍在 Top N 前执行，被排除后从后续已冻结候选补位。
-- 该标志必须绑定非空的日期映射，不允许空映射放开全市场。
-- 股票池完成日线筛选的新前端请求采用 next_bar_open，日线信号日与真实执行日分离。
-
-本轮共享内核全量回归 668 项通过（8 项显式忽略），新增顺序/旧排名方向/选股排除补位验证。该记录不是实盘成交验收，也不代表手选与自动候选混合来源完整实现。