Merge remote-tracking branch 'origin/main'

This reverts commit 4e953b6e98.

crates/fidc-core/src/data.rs

@@ -3,7 +3,7 @@ use std::cmp::Reverse;
 use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet};
 use std::sync::{Arc, OnceLock};
 
-use ahash::AHashMap;
+use ahash::{AHashMap, AHashSet};
 use chrono::{NaiveDate, NaiveDateTime};
 use compact_str::CompactString;
 use rayon::prelude::*;
@@ -1586,48 +1586,15 @@ impl DataSet {
             benchmark_by_date: BTreeMap::new(),
             corporate_actions_by_date: BTreeMap::new(),
         };
-        for mut bundle in bundles {
+        // Indexed collection retains chronological error precedence while each
+        // worker validates and normalizes only its owned day buffers.
+        let prepared = bundles
+            .into_par_iter()
+            .map(normalize_daily_snapshot_bundle)
+            .collect::<Vec<_>>();
+        for bundle in prepared {
+            let bundle = bundle?;
             let date = bundle.date;
-            if bundle.benchmark.date != date {
-                return Err(DataSetError::InvalidDailyBundleComponentDate {
-                    kind: "benchmark",
-                    bundle_date: date,
-                    row_date: bundle.benchmark.date,
-                    symbol: bundle.benchmark.benchmark.clone(),
-                });
-            }
-            validate_daily_bundle_component_dates(
-                &bundle.market,
-                date,
-                "market",
-                |row| row.date,
-                |row| row.symbol.as_str(),
-            )?;
-            validate_daily_bundle_component_dates(
-                &bundle.factors,
-                date,
-                "factor",
-                |row| row.date,
-                |row| row.symbol.as_str(),
-            )?;
-            validate_daily_bundle_component_dates(
-                &bundle.candidates,
-                date,
-                "candidate",
-                |row| row.date,
-                |row| row.symbol.as_str(),
-            )?;
-            validate_daily_bundle_component_dates(
-                &bundle.corporate_actions,
-                date,
-                "corporate_action",
-                |row| row.date,
-                |row| row.symbol.as_str(),
-            )?;
-            sort_rows_by_symbol_if_needed(&mut bundle.market, |row| row.symbol.as_str());
-            bundle.factors = normalize_factor_snapshots(bundle.factors)?;
-            sort_rows_by_symbol_if_needed(&mut bundle.factors, |row| row.symbol.as_str());
-            sort_rows_by_symbol_if_needed(&mut bundle.candidates, |row| row.symbol.as_str());
             if !bundle.market.is_empty() {
                 grouped.market_by_date.insert(date, bundle.market);
             }
@@ -4423,9 +4390,9 @@ fn normalize_factor_snapshots(
                 });
             }
             let already_normalized = snapshot.extra_factors.iter().all(|(field, value)| {
-                let trimmed = field.as_ref().trim().trim_matches('"').trim_matches('\'');
+                let trimmed = field.as_str().trim().trim_matches('"').trim_matches('\'');
                 !trimmed.is_empty()
-                    && trimmed == field.as_ref()
+                    && trimmed == field.as_str()
                     && trimmed.bytes().all(|byte| !byte.is_ascii_uppercase())
                     && value.is_finite()
             });
@@ -4436,15 +4403,15 @@ fn normalize_factor_snapshots(
                 .extra_factors
                 .into_iter()
                 .filter_map(|(field, value)| {
-                    let trimmed = field.as_ref().trim().trim_matches('"').trim_matches('\'');
+                    let trimmed = field.as_str().trim().trim_matches('"').trim_matches('\'');
                     if trimmed.is_empty() || !value.is_finite() {
                         None
-                    } else if trimmed == field.as_ref()
+                    } else if trimmed == field.as_str()
                         && trimmed.bytes().all(|byte| !byte.is_ascii_uppercase())
                     {
                         Some((field, value))
                     } else {
-                        Some((Cow::Owned(trimmed.to_ascii_lowercase()), value))
+                        Some((CompactString::from(trimmed.to_ascii_lowercase()), value))
                     }
                 })
                 .collect();
@@ -4472,6 +4439,38 @@ fn normalize_history_frequency(frequency: &str) -> Option<String> {
     }
 }
 
+fn normalize_daily_snapshot_bundle(
+    mut bundle: DailySnapshotBundle,
+) -> Result<DailySnapshotBundle, DataSetError> {
+    let date = bundle.date;
+    if bundle.benchmark.date != date {
+        return Err(DataSetError::InvalidDailyBundleComponentDate {
+            kind: "benchmark",
+            bundle_date: date,
+            row_date: bundle.benchmark.date,
+            symbol: bundle.benchmark.benchmark.clone(),
+        });
+    }
+    validate_daily_bundle_component_dates(
+        &bundle.market, date, "market", |row| row.date, |row| row.symbol.as_str(),
+    )?;
+    validate_daily_bundle_component_dates(
+        &bundle.factors, date, "factor", |row| row.date, |row| row.symbol.as_str(),
+    )?;
+    validate_daily_bundle_component_dates(
+        &bundle.candidates, date, "candidate", |row| row.date, |row| row.symbol.as_str(),
+    )?;
+    validate_daily_bundle_component_dates(
+        &bundle.corporate_actions, date, "corporate_action", |row| row.date,
+        |row| row.symbol.as_str(),
+    )?;
+    sort_rows_by_symbol_if_needed(&mut bundle.market, |row| row.symbol.as_str());
+    bundle.factors = normalize_factor_snapshots(bundle.factors)?;
+    sort_rows_by_symbol_if_needed(&mut bundle.factors, |row| row.symbol.as_str());
+    sort_rows_by_symbol_if_needed(&mut bundle.candidates, |row| row.symbol.as_str());
+    Ok(bundle)
+}
+
 fn validate_daily_bundle_component_dates<T, D, S>(
     rows: &[T],
     bundle_date: NaiveDate,
@@ -4532,7 +4531,7 @@ fn build_symbol_id_index(
     factor_by_date: &BTreeMap<NaiveDate, Vec<DailyFactorSnapshot>>,
     candidate_by_date: &BTreeMap<NaiveDate, Vec<CandidateEligibility>>,
 ) -> AHashMap<String, u32> {
-    let mut symbols = instruments.keys().cloned().collect::<HashSet<_>>();
+    let mut symbols = instruments.keys().cloned().collect::<AHashSet<_>>();
     for rows in market_by_date.values() {
         for row in rows {
             if !symbols.contains(row.symbol.as_str()) {
@@ -4574,10 +4573,11 @@ fn build_group_symbol_ids<T, F>(
     symbol_of: F,
 ) -> BTreeMap<NaiveDate, Vec<u32>>
 where
-    F: Fn(&T) -> &str + Copy,
+    T: Sync,
+    F: Fn(&T) -> &str + Copy + Send + Sync,
 {
     groups
-        .iter()
+        .par_iter()
         .map(|(date, rows)| {
             let symbol_ids = rows
                 .iter()
@@ -4590,6 +4590,8 @@ where
             debug_assert!(symbol_ids.windows(2).all(|window| window[0] < window[1]));
             (*date, symbol_ids)
         })
+        .collect::<Vec<_>>()
+        .into_iter()
         .collect()
 }
 
@@ -4669,7 +4671,7 @@ fn build_factor_market_cap_order(
         .collect()
 }
 
-fn build_dense_row_positions<T>(
+fn build_dense_row_positions<T: Sync>(
     groups: &BTreeMap<NaiveDate, Vec<T>>,
     symbol_ids_by_date: &BTreeMap<NaiveDate, Vec<u32>>,
     symbol_count: usize,
@@ -4680,8 +4682,11 @@ fn build_dense_row_positions<T>(
         return None;
     }
 
-    let mut positions_by_date = BTreeMap::new();
+    // Each task owns one bounded day index. No partial index is published if
-    for (date, rows) in groups {
+    // any day has a missing, duplicate, or misaligned symbol identifier.
+    groups
+        .par_iter()
+        .map(|(date, rows)| {
             let symbol_ids = symbol_ids_by_date.get(date)?;
             if rows.len() != symbol_ids.len() {
                 return None;
@@ -4694,9 +4699,10 @@ fn build_dense_row_positions<T>(
                 }
                 *position = u32::try_from(row_index).ok()?;
             }
-        positions_by_date.insert(*date, positions);
+            Some((*date, positions))
-    }
+        })
-    Some(positions_by_date)
+        .collect::<Option<Vec<_>>>()
+        .map(|days| days.into_iter().collect())
 }
 
 fn build_calendar_series_end_positions(
@@ -5542,6 +5548,122 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn parallel_daily_bundle_validation_keeps_earliest_error_and_component_order() {
+        let bundles = || (2..30).rev().map(|day| {
+            let date = NaiveDate::from_ymd_opt(2025, 1, day).unwrap();
+            let mut benchmark = benchmark_row("2025-01-01", 20.0);
+            benchmark.date = date;
+            DailySnapshotBundle {
+                date, benchmark,
+                market: vec![market_row("2025-01-01", 10.0, 100)],
+                factors: Vec::new(), candidates: Vec::new(), corporate_actions: Vec::new(),
+            }
+        }).collect::<Vec<_>>();
+        for threads in [1, 2, 8] {
+            let pool = rayon::ThreadPoolBuilder::new().num_threads(threads).build().unwrap();
+            for _ in 0..4 {
+                let result = pool.install(|| DataSet::from_daily_bundles_with_execution_quotes(
+                    Vec::new(), bundles(), Vec::new(),
+                ));
+                assert!(matches!(result, Err(DataSetError::InvalidDailyBundleComponentDate {
+                    kind: "market", bundle_date, ..
+                }) if bundle_date == NaiveDate::from_ymd_opt(2025, 1, 2).unwrap()));
+            }
+            let mut values = bundles();
+            values.last_mut().unwrap().benchmark.date = NaiveDate::from_ymd_opt(2025, 1, 1).unwrap();
+            let result = pool.install(|| DataSet::from_daily_bundles_with_execution_quotes(
+                Vec::new(), values, Vec::new(),
+            ));
+            assert!(matches!(result, Err(DataSetError::InvalidDailyBundleComponentDate {
+                kind: "benchmark", bundle_date, ..
+            }) if bundle_date == NaiveDate::from_ymd_opt(2025, 1, 2).unwrap()));
+        }
+    }
+
+    #[test]
+    fn parallel_daily_symbol_indices_match_scalar_for_sparse_and_empty_days() {
+        let symbols = ["000001.SZ", "159915.SZ", "600000.SH", "932000.CSI", "custom-long-instrument"];
+        let index = symbols.iter().enumerate()
+            .map(|(id, symbol)| (symbol.to_string(), id as u32))
+            .collect::<AHashMap<_, _>>();
+        let groups = (1..29).map(|day| {
+            let date = NaiveDate::from_ymd_opt(2025, 1, day).unwrap();
+            let rows = symbols.iter().enumerate()
+                .filter(|(id, _)| day % 7 != 0 && (*id + day as usize) % 3 != 0)
+                .map(|(_, symbol)| symbol.to_string()).collect::<Vec<_>>();
+            (date, rows)
+        }).collect::<BTreeMap<_, _>>();
+        let expected_ids = groups.iter().map(|(date, rows)| {
+            (*date, rows.iter().map(|symbol| index[symbol]).collect::<Vec<_>>())
+        }).collect::<BTreeMap<_, _>>();
+        let expected_positions = expected_ids.iter().map(|(date, ids)| {
+            let mut positions = vec![super::MISSING_ROW_POSITION; symbols.len()];
+            for (row, id) in ids.iter().enumerate() { positions[*id as usize] = row as u32; }
+            (*date, positions)
+        }).collect::<BTreeMap<_, _>>();
+        for threads in [1, 2, 8] {
+            rayon::ThreadPoolBuilder::new().num_threads(threads).build().unwrap().install(|| {
+                let ids = super::build_group_symbol_ids(&groups, &index, String::as_str);
+                assert_eq!(ids, expected_ids);
+                assert_eq!(super::build_dense_row_positions(&groups, &ids, symbols.len()), Some(expected_positions.clone()));
+            });
+        }
+    }
+
+    #[test]
+    fn parallel_dense_index_rejects_invalid_days_without_publishing_partial_index() {
+        let day1 = NaiveDate::from_ymd_opt(2025, 1, 2).unwrap();
+        let day2 = NaiveDate::from_ymd_opt(2025, 1, 3).unwrap();
+        let groups = BTreeMap::from([(day1, vec![0, 1]), (day2, vec![0, 1])]);
+        let valid = BTreeMap::from([(day1, vec![0, 2]), (day2, vec![1, 2])]);
+        for threads in [1, 2, 8] {
+            rayon::ThreadPoolBuilder::new().num_threads(threads).build().unwrap().install(|| {
+                for invalid in [vec![], vec![1], vec![1, 1], vec![1, 3], vec![1, u32::MAX]] {
+                    let mut ids = valid.clone();
+                    ids.insert(day2, invalid);
+                    assert!(super::build_dense_row_positions(&groups, &ids, 3).is_none());
+                }
+                let mut missing = valid.clone();
+                missing.remove(&day2);
+                assert!(super::build_dense_row_positions(&groups, &missing, 3).is_none());
+                assert!(super::build_dense_row_positions(&groups, &valid, usize::MAX).is_none());
+                assert!(super::build_dense_row_positions(&groups, &valid, super::MAX_DENSE_ROW_INDEX_BYTES).is_none());
+            });
+        }
+    }
+
+    #[test]
+    fn symbol_id_union_preserves_lexical_order_and_all_component_sources() {
+        let date = NaiveDate::from_ymd_opt(2025, 1, 2).unwrap();
+        let instrument = Instrument {
+            symbol: "932000.CSI".into(), name: "index".into(), board: "CSI".into(),
+            round_lot: 100, listed_at: None, delisted_at: None, status: "active".into(),
+        };
+        let mut market = market_row("2025-01-02", -0.0, 0);
+        market.symbol = "custom-long-instrument".into();
+        let factor = DailyFactorSnapshot {
+            date, symbol: "159915.SZ".into(), market_cap_bn: 0.0, free_float_cap_bn: 0.0,
+            pe_ttm: 0.0, turnover_ratio: None, effective_turnover_ratio: None,
+            adjustment_factor_backward1: None, extra_factors: NumericFactorMap::new(),
+        };
+        let candidate = CandidateEligibility {
+            date, symbol: "000001.SZ".into(), is_st: true, is_star_st: true,
+            is_new_listing: false, is_paused: true, allow_buy: false, allow_sell: false,
+            is_kcb: false, is_one_yuan: false, risk_level_code: Some("test".into()),
+        };
+        let ids = super::build_symbol_id_index(
+            &HashMap::from([(instrument.symbol.clone(), instrument)]),
+            &BTreeMap::from([(date, vec![market.clone(), market])]),
+            &BTreeMap::from([(date, vec![factor])]),
+            &BTreeMap::from([(date, vec![candidate])]),
+        );
+        assert_eq!(ids, AHashMap::from_iter([
+            ("000001.SZ".to_string(), 0), ("159915.SZ".to_string(), 1),
+            ("932000.CSI".to_string(), 2), ("custom-long-instrument".to_string(), 3),
+        ]));
+    }
+
     #[test]
     fn direct_symbol_id_snapshot_lookups_preserve_alignment_for_sparse_rows() {
         let date = NaiveDate::parse_from_str("2025-01-02", "%Y-%m-%d").unwrap();
@@ -6348,10 +6470,8 @@ mod tests {
             extra_factors: From::from([(Cow::Borrowed("amount"), 10.0)]),
         }])
         .expect("normalize clean factor snapshot");
-        assert!(matches!(
+        assert_eq!(clean[0].extra_factors.keys().next().map(CompactString::as_str), Some("amount"));
-            clean[0].extra_factors.keys().next(),
+        assert!(!clean[0].extra_factors.keys().next().unwrap().is_heap_allocated());
-            Some(Cow::Borrowed("amount"))
-        ));
 
         let dirty = normalize_factor_snapshots(vec![DailyFactorSnapshot {
             date,

crates/fidc-core/src/lib.rs

@@ -26,6 +26,7 @@ pub mod platform_runtime_schema;
 pub mod platform_strategy_spec;
 pub mod portfolio;
 pub mod portfolio_loss;
+pub mod position_exposure;
 pub mod risk_control;
 pub mod rules;
 pub mod scheduler;

crates/fidc-core/src/numeric_factors.rs

@@ -3,6 +3,7 @@ use std::collections::BTreeMap;
 use std::fmt;
 use std::ops::Index;
 
+use compact_str::CompactString;
 use serde::de::{MapAccess, Visitor};
 use serde::ser::SerializeMap;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
@@ -10,7 +11,14 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 /// Sorted numeric fields stored contiguously, without a tree node per snapshot.
 #[derive(Clone, Default, PartialEq)]
 pub struct NumericFactorMap {
-    entries: Vec<(Cow<'static, str>, f64)>,
+    entries: Vec<(CompactString, f64)>,
+}
+
+fn compact_key(key: Cow<'static, str>) -> CompactString {
+    match key {
+        Cow::Borrowed(value) => CompactString::const_new(value),
+        Cow::Owned(value) => CompactString::from(value),
+    }
 }
 
 impl NumericFactorMap {
@@ -32,14 +40,14 @@ impl NumericFactorMap {
 
     pub fn get(&self, key: &str) -> Option<&f64> {
         self.entries
-            .binary_search_by(|(name, _)| name.as_ref().cmp(key))
+            .binary_search_by(|(name, _)| name.as_str().cmp(key))
             .ok()
             .map(|index| &self.entries[index].1)
     }
 
     pub fn get_mut(&mut self, key: &str) -> Option<&mut f64> {
         self.entries
-            .binary_search_by(|(name, _)| name.as_ref().cmp(key))
+            .binary_search_by(|(name, _)| name.as_str().cmp(key))
             .ok()
             .map(|index| &mut self.entries[index].1)
     }
@@ -49,17 +57,21 @@ impl NumericFactorMap {
     }
 
     pub fn insert(&mut self, key: Cow<'static, str>, value: f64) -> Option<f64> {
+        self.insert_compact(compact_key(key), value)
+    }
+
+    pub fn insert_compact(&mut self, key: CompactString, value: f64) -> Option<f64> {
         if self
             .entries
             .last()
-            .is_none_or(|(last, _)| last.as_ref() < key.as_ref())
+            .is_none_or(|(last, _)| last.as_str() < key.as_str())
         {
             self.entries.push((key, value));
             return None;
         }
         match self
             .entries
-            .binary_search_by(|(name, _)| name.as_ref().cmp(key.as_ref()))
+            .binary_search_by(|(name, _)| name.as_str().cmp(key.as_str()))
         {
             Ok(index) => Some(std::mem::replace(&mut self.entries[index].1, value)),
             Err(index) => {
@@ -71,19 +83,19 @@ impl NumericFactorMap {
 
     pub fn remove(&mut self, key: &str) -> Option<f64> {
         self.entries
-            .binary_search_by(|(name, _)| name.as_ref().cmp(key))
+            .binary_search_by(|(name, _)| name.as_str().cmp(key))
             .ok()
             .map(|index| self.entries.remove(index).1)
     }
 
-    pub fn retain(&mut self, mut keep: impl FnMut(&Cow<'static, str>, &mut f64) -> bool) {
+    pub fn retain(&mut self, mut keep: impl FnMut(&CompactString, &mut f64) -> bool) {
         self.entries.retain_mut(|(key, value)| keep(key, value));
     }
 
     pub fn iter(&self) -> Iter<'_> {
         Iter(self.entries.iter())
     }
-    pub fn keys(&self) -> impl DoubleEndedIterator<Item = &Cow<'static, str>> + ExactSizeIterator {
+    pub fn keys(&self) -> impl DoubleEndedIterator<Item = &CompactString> + ExactSizeIterator {
         self.entries.iter().map(|(key, _)| key)
     }
     pub fn values(&self) -> impl DoubleEndedIterator<Item = &f64> + ExactSizeIterator {
@@ -104,9 +116,9 @@ impl Index<&str> for NumericFactorMap {
     }
 }
 
-pub struct Iter<'a>(std::slice::Iter<'a, (Cow<'static, str>, f64)>);
+pub struct Iter<'a>(std::slice::Iter<'a, (CompactString, f64)>);
 impl<'a> Iterator for Iter<'a> {
-    type Item = (&'a Cow<'static, str>, &'a f64);
+    type Item = (&'a CompactString, &'a f64);
     fn next(&mut self) -> Option<Self::Item> {
         self.0.next().map(|(k, v)| (k, v))
     }
@@ -121,14 +133,14 @@ impl DoubleEndedIterator for Iter<'_> {
 }
 impl ExactSizeIterator for Iter<'_> {}
 impl<'a> IntoIterator for &'a NumericFactorMap {
-    type Item = (&'a Cow<'static, str>, &'a f64);
+    type Item = (&'a CompactString, &'a f64);
     type IntoIter = Iter<'a>;
     fn into_iter(self) -> Self::IntoIter {
         self.iter()
     }
 }
 impl IntoIterator for NumericFactorMap {
-    type Item = (Cow<'static, str>, f64);
+    type Item = (CompactString, f64);
     type IntoIter = std::vec::IntoIter<Self::Item>;
     fn into_iter(self) -> Self::IntoIter {
         self.entries.into_iter()
@@ -137,6 +149,11 @@ impl IntoIterator for NumericFactorMap {
 
 impl FromIterator<(Cow<'static, str>, f64)> for NumericFactorMap {
     fn from_iter<T: IntoIterator<Item = (Cow<'static, str>, f64)>>(iter: T) -> Self {
+        iter.into_iter().map(|(key, value)| (compact_key(key), value)).collect()
+    }
+}
+impl FromIterator<(CompactString, f64)> for NumericFactorMap {
+    fn from_iter<T: IntoIterator<Item = (CompactString, f64)>>(iter: T) -> Self {
         let mut entries: Vec<_> = iter.into_iter().collect();
         // Stable sorting preserves last-value-wins for repeated input keys.
         if !entries.windows(2).all(|pair| pair[0].0 <= pair[1].0) {
@@ -155,6 +172,11 @@ impl FromIterator<(Cow<'static, str>, f64)> for NumericFactorMap {
 }
 impl Extend<(Cow<'static, str>, f64)> for NumericFactorMap {
     fn extend<T: IntoIterator<Item = (Cow<'static, str>, f64)>>(&mut self, iter: T) {
+        self.extend(iter.into_iter().map(|(key, value)| (compact_key(key), value)));
+    }
+}
+impl Extend<(CompactString, f64)> for NumericFactorMap {
+    fn extend<T: IntoIterator<Item = (CompactString, f64)>>(&mut self, iter: T) {
         let mut incoming: Self = iter.into_iter().collect();
         if incoming.is_empty() {
             return;
@@ -194,9 +216,7 @@ impl<const N: usize> From<[(Cow<'static, str>, f64); N]> for NumericFactorMap {
 }
 impl From<BTreeMap<Cow<'static, str>, f64>> for NumericFactorMap {
     fn from(entries: BTreeMap<Cow<'static, str>, f64>) -> Self {
-        Self {
+        entries.into_iter().collect()
-            entries: entries.into_iter().collect(),
-        }
     }
 }
 
@@ -219,8 +239,8 @@ impl<'de> Deserialize<'de> for NumericFactorMap {
             }
             fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
                 let mut entries = Vec::new();
-                while let Some((key, value)) = map.next_entry::<String, f64>()? {
+                while let Some((key, value)) = map.next_entry::<CompactString, f64>()? {
-                    entries.push((Cow::Owned(key), value));
+                    entries.push((key, value));
                 }
                 Ok(entries.into_iter().collect())
             }
@@ -233,6 +253,34 @@ impl<'de> Deserialize<'de> for NumericFactorMap {
 mod tests {
     use super::*;
 
+    #[test]
+    fn compact_keys_inline_dynamic_names_and_keep_long_static_storage() {
+        const LONG: &str = "a_long_static_factor_identifier_that_must_remain_borrowed";
+        let map = NumericFactorMap::from([
+            (Cow::Owned("dynamic_factor_20".to_owned()), -0.0),
+            (Cow::Borrowed(LONG), 1.0),
+        ]);
+        let cloned = map.clone();
+        let short = cloned.keys().find(|key| key.as_str() == "dynamic_factor_20").unwrap();
+        assert!(!short.is_heap_allocated());
+        let long = cloned.keys().find(|key| key.as_str() == LONG).unwrap();
+        assert_eq!(long.as_static_str(), Some(LONG));
+        assert_eq!(cloned["dynamic_factor_20"].to_bits(), (-0.0_f64).to_bits());
+        assert_eq!(std::mem::size_of::<(CompactString, f64)>(), std::mem::size_of::<(Cow<'static, str>, f64)>());
+    }
+
+    #[test]
+    fn long_dynamic_unicode_and_short_keys_keep_the_same_json_map() {
+        let entries = ["", "a", "a_field_longer_than_the_inline_string_capacity", "价格因子", "ths_up_days_stock"]
+            .into_iter().enumerate().map(|(index, key)| (Cow::Owned(key.to_string()), index as f64 + 0.25))
+            .collect::<BTreeMap<_, _>>();
+        let map = NumericFactorMap::from(entries.clone());
+        assert_eq!(serde_json::to_string(&map).unwrap(), serde_json::to_string(&entries).unwrap());
+        let decoded: NumericFactorMap = serde_json::from_str(&serde_json::to_string(&map).unwrap()).unwrap();
+        assert_eq!(decoded, map);
+        assert!(!decoded.keys().find(|key| key.as_str() == "ths_up_days_stock").unwrap().is_heap_allocated());
+    }
+
     #[test]
     fn updates_order_removal_and_values_match_tree_map() {
         let mut flat = NumericFactorMap::new();
@@ -249,14 +297,14 @@ mod tests {
             }
         }
         assert_eq!(
-            flat.iter().collect::<Vec<_>>(),
+            flat.iter().map(|(key, value)| (key.as_str(), value)).collect::<Vec<_>>(),
-            tree.iter().collect::<Vec<_>>()
+            tree.iter().map(|(key, value)| (key.as_ref(), value)).collect::<Vec<_>>()
         );
         flat.retain(|_, value| *value > 100.0);
         tree.retain(|_, value| *value > 100.0);
         assert_eq!(
-            flat.iter().collect::<Vec<_>>(),
+            flat.iter().map(|(key, value)| (key.as_str(), value)).collect::<Vec<_>>(),
-            tree.iter().collect::<Vec<_>>()
+            tree.iter().map(|(key, value)| (key.as_ref(), value)).collect::<Vec<_>>()
         );
         assert_eq!(
             std::mem::size_of::<NumericFactorMap>(),
@@ -275,8 +323,8 @@ mod tests {
         let flat: NumericFactorMap = input.clone().into_iter().collect();
         let tree: BTreeMap<_, _> = input.into_iter().collect();
         assert_eq!(
-            flat.iter().collect::<Vec<_>>(),
+            flat.iter().map(|(key, value)| (key.as_str(), value)).collect::<Vec<_>>(),
-            tree.iter().collect::<Vec<_>>()
+            tree.iter().map(|(key, value)| (key.as_ref(), value)).collect::<Vec<_>>()
         );
         assert_eq!(flat["z"], 4.0);
     }
@@ -327,13 +375,14 @@ mod tests {
         flat.extend(incoming.clone());
         tree.extend(incoming);
         assert_eq!(
-            flat.iter().collect::<Vec<_>>(),
+            flat.iter().map(|(key, value)| (key.as_str(), value)).collect::<Vec<_>>(),
-            tree.iter().collect::<Vec<_>>()
+            tree.iter().map(|(key, value)| (key.as_ref(), value)).collect::<Vec<_>>()
         );
-        assert!(matches!(flat.keys().last(), Some(Cow::Borrowed("shared"))));
+        assert_eq!(flat.keys().last().map(CompactString::as_str), Some("shared"));
+        assert!(!flat.keys().last().unwrap().is_heap_allocated());
         flat.extend([(Cow::Borrowed("zz"), f64::NAN)]);
         assert!(flat["zz"].is_nan());
-        flat.extend(std::iter::empty());
+        flat.extend(std::iter::empty::<(CompactString, f64)>());
         assert_eq!(flat.len(), tree.len() + 1);
     }
 }

crates/fidc-core/src/platform_expr_strategy.rs

@@ -27,6 +27,7 @@ use crate::numeric_expr_vm::{
     self, EvalError as NumericVmEvalError, Program as NumericVmProgram,
     Scratch as NumericVmScratch, Value as NumericVmValue, ValueType as NumericVmValueType,
 };
+use crate::numeric_factors::NumericFactorMap;
 use crate::portfolio::PortfolioState;
 use crate::holding_policy::{AutomaticTradeProtection, AutomaticTradePermission, HoldingLifecycleEvidence};
 
@@ -651,6 +652,7 @@ pub struct PlatformExprStrategyConfig {
     pub buy_scale_expr: String,
     pub exposure_expr: String,
     pub position_exposure_schedule: BTreeMap<NaiveDate, f64>,
+    pub position_exposure_timeline: crate::position_exposure::PositionExposureTimeline,
     pub portfolio_drawdown_control: Option<PlatformPortfolioDrawdownControlConfig>,
     pub portfolio_loss_control: Option<PortfolioLossConfig>,
     pub stop_loss_expr: String,
@@ -740,6 +742,7 @@ impl PlatformExprStrategyConfig {
             buy_scale_expr: "1.0".to_string(),
             exposure_expr: "1.0".to_string(),
             position_exposure_schedule: BTreeMap::new(),
+            position_exposure_timeline: crate::position_exposure::PositionExposureTimeline::default(),
             portfolio_drawdown_control: None,
             portfolio_loss_control: None,
             stop_loss_expr: String::new(),
@@ -845,6 +848,7 @@ fn band_low(index_close) {
     }
 }
 
+#[cfg(test)]
 fn scheduled_position_exposure(
     schedule: &BTreeMap<NaiveDate, f64>,
     decision_date: NaiveDate,
@@ -1010,7 +1014,7 @@ struct StockExpressionState {
     stock_volume_ma60: f64,
     stock_volume_ma100: f64,
     current_series_end: Option<usize>,
-    extra_factors: BTreeMap<String, f64>,
+    extra_factors: NumericFactorMap,
     extra_text_factors: BTreeMap<String, String>,
 }
 
@@ -1042,7 +1046,6 @@ impl<'a> StockStateSnapshotSource<'a> for IndexedStockStateSnapshotSource<'a> {
         }
         self.data
             .market_by_symbol_id(self.factor_date, symbol_id)
-            .or_else(|| self.execution_market(symbol_id))
     }
 
     fn factor(&self, symbol_id: u32) -> Option<&'a DailyFactorSnapshot> {
@@ -1071,7 +1074,6 @@ impl<'a> StockStateSnapshotSource<'a> for ViewStockStateSnapshotSource<'a, '_> {
         }
         self.factor
             .market(symbol_id)
-            .or_else(|| self.execution_market(symbol_id))
     }
 
     fn factor(&self, symbol_id: u32) -> Option<&'a DailyFactorSnapshot> {
@@ -4390,11 +4392,14 @@ impl PlatformExprStrategy {
                     .factor_snapshot_rows_on(date)
                     .iter()
                     .flat_map(|row| {
-                        row.extra_factors.keys().map(|key| key.to_string()).chain(
+                        row.extra_factors.keys().map(|key| key.as_ref()).chain(
                             row.adjustment_factor_backward1
-                                .map(|_| BACKWARD_ADJUSTMENT_FACTOR_FIELD.to_string()),
+                                .map(|_| BACKWARD_ADJUSTMENT_FACTOR_FIELD),
                         )
                     })
+                    .collect::<BTreeSet<_>>()
+                    .into_iter()
+                    .map(str::to_owned)
                     .collect()
             } else {
                 BTreeSet::new()
@@ -4403,7 +4408,10 @@ impl PlatformExprStrategy {
                 ctx.data
                     .factor_text_rows_on(date)
                     .iter()
-                    .map(|row| row.field.clone())
+                    .map(|row| row.field.as_str())
+                    .collect::<BTreeSet<_>>()
+                    .into_iter()
+                    .map(str::to_owned)
                     .collect()
             } else {
                 BTreeSet::new()
@@ -4736,7 +4744,6 @@ impl PlatformExprStrategy {
                 symbol: symbol.to_string(),
             })
         })?;
-        let feature_market = source.feature_market(symbol_id).unwrap_or(market);
         let factor = source.factor(symbol_id).ok_or_else(|| {
             BacktestError::Data(crate::data::DataSetError::MissingSnapshot {
                 kind: "factor",
@@ -4744,6 +4751,13 @@ impl PlatformExprStrategy {
                 symbol: symbol.to_string(),
             })
         })?;
+        let feature_market = source.feature_market(symbol_id).ok_or_else(|| {
+            BacktestError::Data(crate::data::DataSetError::MissingSnapshot {
+                kind: "feature_market",
+                date: factor_date,
+                symbol: symbol.to_string(),
+            })
+        })?;
         let intraday_same_day_factor = self.uses_intraday_execution_quotes()
             && factor_date == date
             && !ctx.is_lagged_execution();
@@ -4894,12 +4908,12 @@ impl PlatformExprStrategy {
                 .iter()
                 .filter(|(field, _)| {
                     self.stock_extra_factor_map_required
-                        || self.stock_extra_factor_identifiers.contains(field.as_ref())
+                        || self.stock_extra_factor_identifiers.contains(field.as_str())
                 })
-                .map(|(field, value)| (field.to_string(), *value))
+                .map(|(field, value)| (field.clone(), *value))
                 .collect()
         } else {
-            BTreeMap::new()
+            NumericFactorMap::new()
         };
         if !self.config.completed_session_factor_fields.is_empty() {
             let visible_date = completed_session_factor_date(
@@ -4914,7 +4928,7 @@ impl PlatformExprStrategy {
                         .and_then(|row| row.extra_factors.get(field.as_str()))
                         .copied()
                         .unwrap_or(f64::NAN);
-                    extra_factors.insert(field.clone(), value);
+                    extra_factors.insert(field.clone().into(), value);
                 }
             }
         }
@@ -4925,7 +4939,7 @@ impl PlatformExprStrategy {
                     .contains(BACKWARD_ADJUSTMENT_FACTOR_FIELD))
             && let Some(value) = factor.adjustment_factor_backward1
         {
-            extra_factors.insert(BACKWARD_ADJUSTMENT_FACTOR_FIELD.to_string(), value);
+            extra_factors.insert(BACKWARD_ADJUSTMENT_FACTOR_FIELD.into(), value);
         }
 
         let state = StockExpressionState {
@@ -5642,7 +5656,7 @@ impl PlatformExprStrategy {
                     Dynamic::from(stock.stock_volume_ma100),
                 );
                 for (key, value) in &stock.extra_factors {
-                    factors.insert(key.clone().into(), Dynamic::from(*value));
+                    factors.insert(key.as_str().into(), Dynamic::from(*value));
                 }
                 for (key, value) in &stock.extra_text_factors {
                     factors.insert(key.clone().into(), Dynamic::from(value.clone()));
@@ -8640,9 +8654,9 @@ impl PlatformExprStrategy {
         let strategy_exposure = self
             .eval_float(ctx, &self.config.exposure_expr, day, None, None)?
             .clamp(0.0, 1.0);
-        let risk_on_exposure = scheduled_position_exposure(
+        let risk_on_exposure = self.config.position_exposure_timeline.exposure_at(
-            &self.config.position_exposure_schedule,
+            portfolio_loss_decision_at(ctx), ctx.execution_date, &self.config.position_exposure_schedule,
-            ctx.execution_date,
+            strategy_exposure,
         )
         .unwrap_or(strategy_exposure)
         .clamp(0.0, 1.0);
@@ -9970,6 +9984,12 @@ impl PlatformExprStrategy {
                 }
             }
         }
+        if let Some(bps)=self.config.position_exposure_timeline.scale_at(portfolio_loss_decision_at(ctx)) {
+            let before=intents.len();
+            intents=intents.into_iter().map(|intent|crate::position_exposure::scale_explicit_intent(intent,bps,ctx.open_orders))
+                .collect::<Result<Vec<_>,_>>().map_err(BacktestError::Execution)?.into_iter().flatten().collect();
+            diagnostics.push(format!("position_override_scale requested_bps={bps} original_intents={before} emitted_intents={}",intents.len()));
+        }
         Ok((intents, diagnostics))
     }
 
@@ -14546,6 +14566,7 @@ mod tests {
     use std::sync::Arc;
 
     use chrono::{NaiveDate, NaiveTime};
+    use rhai::{Dynamic, Map};
 
     use super::{
         CompiledRuntimeHelperArgs, PlatformAccountActionKind, PlatformExplicitActionStage,
@@ -17542,6 +17563,18 @@ mod tests {
             .stock_state_with_factor_date(&ctx, date, date, present_symbol)
             .expect("factor map stock state");
         assert!(map_stock.extra_factors.contains_key("unused_factor"));
+        let mut numeric_state = (*map_stock).clone();
+        numeric_state.extra_factors.insert("negative_zero".into(), -0.0);
+        numeric_state.extra_factors.insert("undefined_value".into(), f64::NAN);
+        let copied_state = numeric_state.clone();
+        assert_eq!(copied_state.extra_factors["negative_zero"].to_bits(), (-0.0_f64).to_bits());
+        assert!(copied_state.extra_factors["undefined_value"].is_nan());
+        let exposed = copied_state.extra_factors.iter()
+            .map(|(key, value)| (key.as_str().into(), Dynamic::from(*value)))
+            .collect::<Map>();
+        assert_eq!(exposed["negative_zero"].as_float().unwrap().to_bits(), (-0.0_f64).to_bits());
+        assert!(exposed["undefined_value"].as_float().unwrap().is_nan());
+        assert!(!exposed.contains_key("missing_factor"));
         let map_day = map_strategy
             .day_state(&ctx, date)
             .expect("factor map day state");
@@ -21231,6 +21264,37 @@ mod tests {
         assert_eq!(stock.market_cap, 8.0);
         assert_eq!(stock.market_cap_bn, 8.0);
         assert!(stock.touched_upper_limit);
+
+        let missing_feature_day = DataSet::from_components(
+            vec![data.instrument(symbol).unwrap().clone()],
+            data.market_snapshot_rows_on(date).to_vec(),
+            data.factor_snapshot_rows_on(factor_date).iter()
+                .chain(data.factor_snapshot_rows_on(date)).cloned().collect(),
+            data.candidate_snapshot_rows_on(date).to_vec(),
+            vec![data.benchmark(date).unwrap().clone()],
+        ).unwrap();
+        let gap_ctx = StrategyContext {data: &missing_feature_day, decision_date: factor_date, ..ctx};
+        let mut gap_config = PlatformExprStrategyConfig::generic();
+        gap_config.matching_type = MatchingType::NextBarOpen;
+        gap_config.stock_filter_expr = "close > 10.0".into();
+        let gap_strategy = PlatformExprStrategy::new(gap_config);
+        let indexed = gap_strategy.stock_state_with_factor_date(&gap_ctx, date, factor_date, symbol);
+        assert!(matches!(&indexed, Err(crate::BacktestError::Data(crate::data::DataSetError::MissingSnapshot {
+            kind: "feature_market", date: missing_date, symbol: missing_symbol,
+        })) if *missing_date == factor_date && missing_symbol == symbol),
+            "missing decision-date OHLCV must not become execution-date values: {indexed:?}");
+        let execution_view = missing_feature_day.daily_snapshot_view(date);
+        let feature_view = missing_feature_day.daily_snapshot_view(factor_date);
+        let viewed = gap_strategy.uncached_selection_stock_state_from_views_by_symbol_id(
+            &gap_ctx, date, factor_date, missing_feature_day.symbol_id(symbol).unwrap(), symbol,
+            &execution_view, &feature_view,
+        );
+        assert!(matches!(&viewed, Err(crate::BacktestError::Data(crate::data::DataSetError::MissingSnapshot {
+            kind: "feature_market", date: missing_date, ..
+        })) if *missing_date == factor_date), "daily views must preserve the same missing-date boundary: {viewed:?}");
+        assert!(gap_strategy.stock_state_cache.borrow().is_empty());
+        let same_day = gap_strategy.stock_state_with_factor_date(&gap_ctx, date, date, symbol).unwrap();
+        assert_eq!(same_day.close, 20.0);
     }
 
     #[test]
@@ -24872,6 +24936,8 @@ mod tests {
             ],
             vec![
                 market(factor_date, signal, 10.0, 11.0, 9.0),
+                market(factor_date, limit_symbol, 1.80, 1.98, 1.62),
+                market(factor_date, fallback_symbol, 4.20, 4.62, 3.78),
                 market(decision_date, signal, 10.0, 11.0, 9.0),
                 market(execution_date, signal, 10.0, 11.0, 9.0),
                 market(decision_date, limit_symbol, 2.20, 2.42, 1.98),
@@ -25056,6 +25122,8 @@ mod tests {
             .stock_state_with_factor_date(&ctx, decision_date, factor_date, limit_symbol)
             .expect("previous factor-day state");
         assert_eq!(prior_factor_state.amount, 20_000_000.0);
+        assert_eq!(prior_factor_state.close, 1.80);
+        assert_eq!(decision_day_state.close, 2.20);
 
         let decision = strategy.on_day(&ctx).expect("platform decision");
 

crates/fidc-core/src/platform_stock_pool.rs

@@ -204,12 +204,10 @@ impl PlatformExprStrategy {
         let (base_ratio, reserve_cash) =
             pool::stock_pool_funding_from_configuration(&program.allocation_policy)
                 .map_err(BacktestError::Execution)?;
-        let ratio = self
+        let ratio = self.config.position_exposure_timeline
-            .config
+            .exposure_at(portfolio_loss_decision_at(ctx), ctx.execution_date, &self.config.position_exposure_schedule,
-            .position_exposure_schedule
+                f64::from(base_ratio)/10000.)
-            .range(..=ctx.decision_date)
+            .map(|value| (value * 10000.).round() as i64)
-            .next_back()
-            .map(|(_, value)| (*value * 10000.).round() as i64)
             .unwrap_or(i64::from(base_ratio));
         let invest_ratio_bps = i32::try_from(ratio)
             .ok()

crates/fidc-core/src/platform_strategy_spec.rs

@@ -949,6 +949,8 @@ pub struct StrategyExpressionRiskConfig {
     pub exposure_expr: Option<String>,
     #[serde(default, alias = "position_exposure_schedule")]
     pub position_exposure_schedule: Vec<StrategyPositionExposureSchedulePoint>,
+    #[serde(default, alias = "position_exposure_events")]
+    pub position_exposure_events: Vec<crate::position_exposure::PositionExposureEvent>,
     #[serde(default)]
     pub portfolio_drawdown_control: Option<StrategyPortfolioDrawdownControlConfig>,
     #[serde(default)]
@@ -2228,6 +2230,7 @@ pub fn platform_expr_config_from_spec(
                     expr.clone()
                 };
             }
+            cfg.position_exposure_timeline = crate::position_exposure::PositionExposureTimeline::from_events(&risk.position_exposure_events)?;
             for point in &risk.position_exposure_schedule {
                 let effective_date = NaiveDate::parse_from_str(
                     point.effective_date.trim(),

crates/fidc-core/src/position_exposure.rs

@@ -0,0 +1,428 @@
+//! Dated manual adjustments are ordered facts; restoring is not a 100% target.
+use chrono::{DateTime, NaiveDate, Utc};
+use serde::{Deserialize, Serialize};
+use std::collections::{BTreeMap, BTreeSet};
+
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(tag = "action", rename_all = "snake_case", deny_unknown_fields)]
+pub enum PositionExposureAction {
+    Scale {
+        #[serde(rename = "requestedBps", alias = "requested_bps")]
+        requested_bps: i32,
+    },
+    Set {
+        #[serde(rename = "targetExposureBps", alias = "target_exposure_bps")]
+        target_exposure_bps: i32,
+    },
+    Restore,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PositionExposureEvent {
+    #[serde(alias = "event_id")]
+    pub event_id: String,
+    pub sequence: u64,
+    #[serde(alias = "effective_at")]
+    pub effective_at: DateTime<Utc>,
+    #[serde(flatten)]
+    pub action: PositionExposureAction,
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct PositionExposureTimeline {
+    events: BTreeMap<(DateTime<Utc>, u64), PositionExposureAction>,
+}
+
+impl PositionExposureTimeline {
+    pub fn from_events(events: &[PositionExposureEvent]) -> Result<Self, String> {
+        let mut result = Self::default();
+        let mut ids = BTreeSet::new();
+        let mut sequences = BTreeSet::new();
+        for event in events {
+            if event.event_id.trim().is_empty() || !ids.insert(event.event_id.as_str()) {
+                return Err("position exposure event id is missing or duplicated".into());
+            }
+            if event.sequence == 0 || !sequences.insert(event.sequence) {
+                return Err("position exposure event sequence must be positive and unique".into());
+            }
+            if let PositionExposureAction::Scale { requested_bps } = event.action
+                && !(0..=10000).contains(&requested_bps)
+            {
+                return Err("position exposure scale must be between 0 and 10000 bps".into());
+            }
+            if let PositionExposureAction::Set {
+                target_exposure_bps,
+            } = event.action
+                && !(0..=10_000).contains(&target_exposure_bps)
+            {
+                return Err("position exposure target must be between 0 and 10000 bps".into());
+            }
+            result
+                .events
+                .insert((event.effective_at, event.sequence), event.action.clone());
+        }
+        Ok(result)
+    }
+
+    /// Legacy day-level contracts remain day-level; never invent intraday times.
+    pub fn exposure_at(
+        &self,
+        at: DateTime<Utc>,
+        execution_date: NaiveDate,
+        legacy: &BTreeMap<NaiveDate, f64>,
+        strategy_exposure: f64,
+    ) -> Option<f64> {
+        match self
+            .events
+            .range(..=(at, u64::MAX))
+            .next_back()
+            .map(|(_, action)| action)
+        {
+            Some(PositionExposureAction::Scale { requested_bps }) => {
+                Some(strategy_exposure * f64::from(*requested_bps) / 10000.)
+            }
+            Some(PositionExposureAction::Set {
+                target_exposure_bps,
+            }) => Some(f64::from(*target_exposure_bps) / 10_000.),
+            Some(PositionExposureAction::Restore) => None,
+            None => legacy
+                .range(..=execution_date)
+                .next_back()
+                .map(|(_, value)| *value),
+        }
+    }
+
+    pub fn scale_at(&self, at: DateTime<Utc>) -> Option<i32> {
+        match self
+            .events
+            .range(..=(at, u64::MAX))
+            .next_back()
+            .map(|(_, action)| action)
+        {
+            Some(PositionExposureAction::Scale { requested_bps }) => Some(*requested_bps),
+            _ => None,
+        }
+    }
+}
+
+/// Scale new buys and desired targets without weakening sell/reduction or
+/// cancellation instructions. Prices, subscriptions and cash flows are intact.
+pub fn scale_explicit_intent(
+    mut intent: crate::OrderIntent,
+    bps: i32,
+    open_orders: &[crate::OpenOrderView],
+) -> Result<Option<crate::OrderIntent>, String> {
+    use crate::OrderIntent as I;
+    if !(0..=10000).contains(&bps) {
+        return Err("position scale out of range".into());
+    }
+    if bps == 10000 {
+        return Ok(Some(intent));
+    }
+    if let I::WithTimeInForce {
+        intent: inner,
+        time_in_force,
+    } = intent
+    {
+        return Ok(
+            scale_explicit_intent(*inner, bps, open_orders)?.map(|intent| I::WithTimeInForce {
+                intent: Box::new(intent),
+                time_in_force,
+            }),
+        );
+    }
+    let integer = |value: i32| ((i64::from(value) * i64::from(bps)) / 10000) as i32;
+    let amount = |value: f64, target: bool| -> Result<f64, String> {
+        if !value.is_finite() || (target && value < 0.) {
+            return Err("position override received an invalid original amount".into());
+        }
+        Ok(if value > 0. {
+            value * f64::from(bps) / 10000.
+        } else {
+            value
+        })
+    };
+    match &mut intent {
+        I::Shares { quantity, .. }
+        | I::LimitShares { quantity, .. }
+        | I::Lots { lots: quantity, .. }
+        | I::LimitLots { lots: quantity, .. } => {
+            if *quantity > 0 {
+                *quantity = integer(*quantity);
+                if *quantity == 0 {
+                    return Ok(None);
+                }
+            }
+        }
+        I::TargetShares {
+            target_quantity, ..
+        }
+        | I::LimitTargetShares {
+            target_quantity, ..
+        } => {
+            if *target_quantity < 0 {
+                return Err("position override received a negative target quantity".into());
+            }
+            *target_quantity = integer(*target_quantity);
+        }
+        I::Value { value, .. }
+        | I::LimitValue { value, .. }
+        | I::AlgoValue { value, .. }
+        | I::Percent { percent: value, .. }
+        | I::LimitPercent { percent: value, .. }
+        | I::AlgoPercent { percent: value, .. } => {
+            *value = amount(*value, false)?;
+            if *value == 0. {
+                return Ok(None);
+            }
+        }
+        I::TargetValue { target_value, .. }
+        | I::LimitTargetValue { target_value, .. }
+        | I::TimedTargetValue { target_value, .. }
+        | I::TargetPercent {
+            target_percent: target_value,
+            ..
+        }
+        | I::LimitTargetPercent {
+            target_percent: target_value,
+            ..
+        } => {
+            *target_value = amount(*target_value, true)?;
+        }
+        I::TargetPortfolioSmart { target_weights, .. } => {
+            for value in target_weights.values_mut() {
+                *value = amount(*value, true)?;
+            }
+        }
+        I::ModifyOrder {
+            order_id,
+            new_total_quantity: Some(quantity),
+            ..
+        } => {
+            let order = open_orders
+                .iter()
+                .find(|order| order.order_id == *order_id)
+                .ok_or("position override cannot resolve the order being modified")?;
+            if order.side == crate::OrderSide::Buy && *quantity > order.requested_quantity {
+                let extra = u64::from(*quantity - order.requested_quantity) * bps as u64 / 10000;
+                *quantity = order.requested_quantity + extra as u32;
+            }
+        }
+        I::Futures { .. } | I::StockPool { .. } => {
+            return Err("manual equity scaling cannot transform this intent kind".into());
+        }
+        I::ModifyOrder { .. }
+        | I::CancelOrder { .. }
+        | I::CancelSymbol { .. }
+        | I::CancelAll { .. }
+        | I::UpdateUniverse { .. }
+        | I::Subscribe { .. }
+        | I::Unsubscribe { .. }
+        | I::DepositWithdraw { .. }
+        | I::FinanceRepay { .. }
+        | I::SetManagementFeeRate { .. } => {}
+        I::WithTimeInForce { .. } => unreachable!("wrapper handled first"),
+    }
+    Ok(Some(intent))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn scalar_preserves_strategy_risk_off_and_restore_keeps_original_exposure() {
+        let at = DateTime::parse_from_rfc3339("2026-01-05T09:30:00+08:00")
+            .unwrap()
+            .with_timezone(&Utc);
+        let event = PositionExposureEvent {
+            event_id: "scale".into(),
+            sequence: 1,
+            effective_at: at,
+            action: PositionExposureAction::Scale {
+                requested_bps: 5000,
+            },
+        };
+        let timeline = PositionExposureTimeline::from_events(&[event.clone()]).unwrap();
+        assert_eq!(
+            timeline.exposure_at(at, at.date_naive(), &BTreeMap::new(), 0.),
+            Some(0.)
+        );
+        assert_eq!(
+            timeline.exposure_at(at, at.date_naive(), &BTreeMap::new(), 0.2),
+            Some(0.1)
+        );
+        let restored = PositionExposureEvent {
+            event_id: "restore".into(),
+            sequence: 2,
+            effective_at: at,
+            action: PositionExposureAction::Restore,
+        };
+        let timeline = PositionExposureTimeline::from_events(&[event, restored]).unwrap();
+        assert_eq!(
+            timeline
+                .exposure_at(
+                    at,
+                    at.date_naive(),
+                    &BTreeMap::from([(at.date_naive(), 1.)]),
+                    0.2
+                )
+                .unwrap_or(0.2),
+            0.2
+        );
+    }
+
+    #[test]
+    fn explicit_equity_targets_and_buys_scale_but_sales_cashflows_and_prices_do_not() {
+        use crate::OrderIntent as I;
+        let symbol = "000001.SZ".to_string();
+        let reason = "fixture".to_string();
+        for bps in [0, 3000, 5000, 10000] {
+            let ratio = f64::from(bps) / 10000.;
+            let buy = I::LimitShares {
+                symbol: symbol.clone(),
+                quantity: 1000,
+                limit_price: 12.345,
+                reason: reason.clone(),
+            };
+            let scaled = scale_explicit_intent(buy, bps, &[]).unwrap();
+            if bps == 0 {
+                assert!(scaled.is_none())
+            } else if let Some(I::LimitShares {
+                quantity,
+                limit_price,
+                ..
+            }) = scaled
+            {
+                assert_eq!(quantity, (1000. * ratio) as i32);
+                assert_eq!(limit_price, 12.345);
+            } else {
+                panic!("wrong intent")
+            }
+            let sell = I::Shares {
+                symbol: symbol.clone(),
+                quantity: -1000,
+                reason: reason.clone(),
+            };
+            assert!(matches!(
+                scale_explicit_intent(sell, bps, &[]).unwrap(),
+                Some(I::Shares {
+                    quantity: -1000,
+                    ..
+                })
+            ));
+            let clear = I::TargetShares {
+                symbol: symbol.clone(),
+                target_quantity: 0,
+                reason: reason.clone(),
+            };
+            assert!(matches!(
+                scale_explicit_intent(clear, bps, &[]).unwrap(),
+                Some(I::TargetShares {
+                    target_quantity: 0,
+                    ..
+                })
+            ));
+            let target = I::TargetPercent {
+                symbol: symbol.clone(),
+                target_percent: 0.2,
+                reason: reason.clone(),
+            };
+            if let Some(I::TargetPercent { target_percent, .. }) =
+                scale_explicit_intent(target, bps, &[]).unwrap()
+            {
+                assert!((target_percent - 0.2 * ratio).abs() < 1e-12)
+            } else {
+                panic!("wrong target")
+            }
+            let deposit = I::DepositWithdraw {
+                amount: 123.456,
+                receiving_days: 2,
+                reason: reason.clone(),
+            };
+            assert!(matches!(
+                scale_explicit_intent(deposit, bps, &[]).unwrap(),
+                Some(I::DepositWithdraw {
+                    amount: 123.456,
+                    receiving_days: 2,
+                    ..
+                })
+            ));
+        }
+        assert!(
+            scale_explicit_intent(
+                I::TargetValue {
+                    symbol,
+                    target_value: f64::NAN,
+                    reason
+                },
+                0,
+                &[]
+            )
+            .is_err()
+        );
+    }
+
+    #[test]
+    fn same_day_adjustments_restore_and_future_events_keep_their_own_times() {
+        let events: Vec<PositionExposureEvent> = serde_json::from_value(json!([
+            {"eventId":"first","sequence":1,"effectiveAt":"2026-09-10T10:00:00+08:00","action":"set","targetExposureBps":0},
+            {"eventId":"second","sequence":2,"effectiveAt":"2026-09-10T13:00:00+08:00","action":"set","targetExposureBps":5000},
+            {"eventId":"restore","sequence":3,"effectiveAt":"2026-09-10T14:00:00+08:00","action":"restore"},
+            {"eventId":"future","sequence":4,"effectiveAt":"2026-09-11T10:00:00+08:00","action":"set","targetExposureBps":1000}
+        ])).unwrap();
+        let timeline = PositionExposureTimeline::from_events(&events).unwrap();
+        let date = NaiveDate::from_ymd_opt(2026, 9, 10).unwrap();
+        let legacy = BTreeMap::from([(date.pred_opt().unwrap(), 0.8)]);
+        for (time, expected) in [
+            ("09:30:00", Some(0.8)),
+            ("10:00:00", Some(0.)),
+            ("12:59:59", Some(0.)),
+            ("13:00:00", Some(0.5)),
+            ("14:00:00", None),
+            ("15:00:00", None),
+        ] {
+            let at = DateTime::parse_from_rfc3339(&format!("2026-09-10T{time}+08:00"))
+                .unwrap()
+                .with_timezone(&Utc);
+            assert_eq!(
+                timeline.exposure_at(at, date, &legacy, 0.2),
+                expected,
+                "{time}"
+            );
+        }
+        let next_open = DateTime::parse_from_rfc3339("2026-09-11T09:30:00+08:00")
+            .unwrap()
+            .with_timezone(&Utc);
+        assert_eq!(
+            timeline.exposure_at(next_open, date.succ_opt().unwrap(), &legacy, 0.2),
+            None
+        );
+    }
+
+    #[test]
+    fn rejects_unknown_actions_duplicate_identity_and_invalid_bps() {
+        let valid = json!({"eventId":"one","sequence":1,"effectiveAt":"2026-09-10T09:30:00+08:00","action":"set","targetExposureBps":5000});
+        for (key, value) in [
+            ("action", json!("other")),
+            ("effectiveAt", json!("2026-09-10 09:30:00")),
+            ("targetExposureBps", json!(null)),
+        ] {
+            let mut invalid = valid.clone();
+            invalid[key] = value;
+            assert!(serde_json::from_value::<PositionExposureEvent>(invalid).is_err());
+        }
+        let event: PositionExposureEvent = serde_json::from_value(valid).unwrap();
+        assert!(PositionExposureTimeline::from_events(&[event.clone(), event.clone()]).is_err());
+        let mut invalid = event.clone();
+        invalid.action = PositionExposureAction::Set {
+            target_exposure_bps: 10001,
+        };
+        assert!(PositionExposureTimeline::from_events(&[invalid]).is_err());
+        let mut duplicate = event.clone();
+        duplicate.event_id = "two".into();
+        assert!(PositionExposureTimeline::from_events(&[event, duplicate]).is_err());
+    }
+}

crates/fidc-core/tests/stock_pool_execution_contract.rs

@@ -628,6 +628,37 @@ fn parsed_pool_program_executes_daily_membership_changes_without_legacy_translat
     }
 }
 
+#[test]
+fn pool_position_adjustments_use_execution_clock_and_restore_original_twenty_percent() {
+    for timed in [false,true] {
+        let program=StockPoolProgram { schema_version:1,pool_id:"position-clock".into(),version_id:"v1".into(),
+            members:contract(day(2),1,false).members,exit_signals:vec![],
+            allocation_policy:serde_json::json!({"target_holding_count":1,"invest_ratio_bps":2000,"portfolio_policy":{"schema_version":1,"membership":"follow_candidates","rebalance_weights":true}}),
+            timing_policy:serde_json::json!({"auto_execute":true,"pricing_mode":"first_tick"}),stop_take_policy:serde_json::json!({}),out_of_pool_policy:"hold".into() };
+        let risk=if timed {serde_json::json!({"positionExposureEvents":[
+            {"eventId":"zero","sequence":1,"effectiveAt":"2026-01-05T09:30:00+08:00","action":"set","targetExposureBps":0},
+            {"eventId":"restore","sequence":2,"effectiveAt":"2026-01-06T09:30:00+08:00","action":"restore"}
+        ]})}else{serde_json::json!({"positionExposureSchedule":[{"effectiveDate":"2026-01-05","targetExposureBps":1000}]})};
+        let mut config=platform_expr_config_from_value("position-clock",&code(1),&serde_json::json!({
+            "stockPool":program,"signalSymbol":code(1),"benchmark":{"instrumentId":"000300.SH"},"universe":{"include":[code(1),code(2)]},
+            "runtimeExpressions":{"risk":risk}
+        })).unwrap();
+        config.market_cap_field="close".into();config.market_cap_lower_expr="0".into();config.market_cap_upper_expr="1.0e12".into();
+        config.stock_filter_expr="true".into();config.selection_limit_expr="1".into();config.selection_candidate_limit_expr="2".into();config.rank_expr="0".into();
+        config.matching_type=MatchingType::NextBarOpen;
+        let result=BacktestEngine::new(data(false),PlatformExprStrategy::new(config),broker(false),BacktestConfig {
+            // The raw engine retains its first signal day as a cash baseline;
+            // Jan 2's signal executes Jan 5, across the fixture weekend.
+            initial_cash:30000.,benchmark_code:"000300.SH".into(),start_date:Some(day(2)),end_date:Some(day(6)),
+            decision_lag_trading_days:1,execution_price_field:PriceField::Open,
+        }).run().unwrap();
+        assert_eq!(result.fills.len(),1,"timed={timed}, fills={:?}",result.fills);
+        assert_eq!(result.fills[0].symbol,code(1));
+        assert_eq!(result.fills[0].quantity,if timed {300}else{100});
+        assert_eq!(result.fills[0].date,if timed {day(6)}else{day(5)});
+    }
+}
+
 #[test]
 fn parsed_typed_exit_program_keeps_ordinary_gates_and_independent_risk_targets_separate() {
     for (ordinary, risk, quote, sold) in [

docs/expression-context-performance-20260913.md

@@ -0,0 +1,109 @@
+# 表达式上下文性能验收
+
+## 范围
+
+本轮优化 FIDC 引擎的逐股票表达式上下文，不修改策略、因子值、窗口、时间可见性、
+选股/订单规则、费用、成交价、风控或公司行为。Source 保持 `d5b682c6d097`，
+研究和信号保持暂停。其他用户任务只读观察，不更改其进程、亲和性或配置。
+
+已完成编译、回归、正式回放与177发布验收，不能据此关闭整个目标。
+
+## 重复开销
+
+1. DataSet 已采用 `NumericFactorMap`，但 `StockExpressionState` 仍把数值因子
+   重建为 `BTreeMap<String, f64>`，增加树节点和字符串分配。
+2. 每日可用因子名集合先为每个证券复制名称，再由集合丢弃重复名称。
+
+候选在表达式上下文延续紧凑数值存储。每日名称仍按当日真实字段生成完整集合，
+仅改为先对借用名称去重，再为唯一名称分配字符串；文本因子同理。
+没有用全局/未来日期目录替代当日字段，没有缓存选股结果或账户状态。
+Rhai `factors[...]`、缺失、NaN、负零、别名、覆盖顺序与已完成交易日可见性保持原行为。
+
+## CPU 计时
+
+Runner 新增以下运行计时，HTTP benchmark 同样保留：
+
+- `engineTaskWallSeconds`：实际引擎同步任务的墙钟耗时，包含其同步数据读取等待。
+- `engineThreadCpuSeconds`：Linux `CLOCK_THREAD_CPUTIME_ID` 实测的引擎调用线程CPU时间。
+  不包含其他并行线程、I/O等待或未被调度的时间；不可当作整个进程总CPU时间。
+  读取不可用、跨线程或时钟异常保持null，不填0。
+- `engineTaskCount`：实际执行引擎的次数，包含原有修复循环的重放。
+
+这些是 `engineSeconds` 的子指标，禁止再次加到总耗时。正常耗时与诊断运行分开保存。
+计时不改写历史制品，旧记录缺少该指标时保持未知。
+
+## 验收设置
+
+- 固定引擎基线 `fe7243b`；候选为177的 `07b7b18`，对应本地 `df1862e`。
+- 两边使用同一计时版service `a9df11a`；`b5d22ff`仅补充benchmark字段读取。
+- 2021-08-23至2025-11-17、初始1000万、原冻结runtime与策略，1025个执行交易日。
+- 保留原 `session_capacity_audit`，不能当作实际开盘流动性验证。
+- 官方benchmark入口、Boris执行、同CPU资源与Source版本、新进程、相同数据缓存副本、
+  新结果目录，不复用回测结果。
+- 引擎780项、runner408项、API113项、脚本10项通过；9/8/3项手动或外部环境用例分别忽略。
+- 专项延伸验证紧凑因子的克隆、Rhai映射暴露、缺失、NaN及负零；CPU计时验证睡眠和跨线程边界。
+
+证据根：`/srv/fidc/canonical/run/research/engine-context-20260913`。
+
+## 独立进程对照
+
+| 次序 | 样本 | 完整墙钟 | Source校验 | 数据准备 | 引擎墙钟 | 引擎线程CPU |
+|---|---|---:|---:|---:|---:|---:|
+| 1 | control-1 | 31.234s | 11.202s | 8.393s | 10.461s | 10.458s |
+| 2 | candidate-1 | 17.002s | 0.004s | 8.404s | 7.406s | 7.404s |
+| 3 | candidate-2 | 18.203s | 0.003s | 8.371s | 7.411s | 7.408s |
+| 4 | control-2 | 22.983s | 0.004s | 8.323s | 13.401s | 13.398s |
+| 5 | control-3 | 30.714s | 0.005s | 15.318s | 13.999s | 13.990s |
+| 6 | candidate-3 | 25.336s | 0.005s | 13.524s | 10.471s | 10.468s |
+
+首个基线的Source校验等待原样保留，不事后改称预热，不把11.202秒归因于引擎改动。
+后段样本出现主机负载/缓存竞争变化，数据准备也变慢，不能直接用全组平均墙钟夸大提速。
+相邻低负载对照的引擎线程CPU为10.458至7.404秒，后段为13.990至10.468秒。
+CPU计时与任务墙钟非常接近，证明样本主要在执行CPU工作，而不是等待HTTP；
+这不代表没有SMT、内存带宽或其他用户CPU竞争。
+
+六次均为21,393笔成交，账户、权益、委托、成交、持仓和风控canonical及结果制品完全一致。
+每份63个数据缓存文件经完整SHA核对相同，没有复制或读取旧回测结果。
+
+## HTTP 对照
+
+| 状态 | 版本 | 运行ID | 总耗时 | 引擎耗时 |
+|---|---|---|---:|---:|
+| 清DataSet，磁盘/Source保持 | 原版 | btr_1789232559582_3166774_4 | 21.987s | 11.328s |
+| 清DataSet，磁盘/Source保持 | 原版 | btr_1789232585690_3166774_5 | 21.684s | 11.259s |
+| 复用DataSet | 原版 | btr_1789232669598_3166774_6 | 11.820s | 11.031s |
+| 复用DataSet | 原版 | btr_1789232684861_3166774_7 | 11.857s | 11.067s |
+| 清DataSet，磁盘/Source保持 | 新版 | btr_1789232818009_3320588_0 | 17.296s | 7.537s |
+| 清DataSet，磁盘/Source保持 | 新版 | btr_1789232839269_3320588_1 | 17.413s | 7.627s |
+| 复用DataSet | 新版 | btr_1789232898983_3320588_2 | 8.549s | 7.738s |
+| 复用DataSet | 新版 | btr_1789232910904_3320588_3 | 8.586s | 7.784s |
+
+同状态HTTP均值：重建DataSet从21.836至17.355秒，减少约20.5%；
+复用DataSet从11.839至8.568秒，减少约27.6%。两种状态分开比较，
+没有把8.568秒当作Source冷启动成绩。与上一轮不同时间的15/17秒样本不作直接百分比对比。
+
+原版API没有线程CPU字段，保持null；新版本每次实际执行引擎一次，
+两次重建的线程CPU为7.535/7.624秒。没有用新版本计时回填旧记录。
+八次HTTP和六次独立回放的canonical及结果制品SHA全部相同，终态审计clean。
+
+## 发布状态
+
+177通过官方安装器发布 engine `07b7b181b60138c6ef1c965543c0e3192ac65903`、
+service `b5d22ffab16f851eced3028e12fa02627ee4c399`。
+运行身份 `fdd8652a47a5935be4d891beb3b8b0f3e19a468be166a902a2a97b85a9c9e01e`。
+
+- API SHA：`bf22f58946c3fa495161eb381a400d4e28d7c8d327ee46f5645d83a8308117cf`。
+- Runner SHA：`7b3849cd8af33d650db242add80c49cfdd32e8cc8686a614da7b3b4016ce2a60`。
+- 生产在用构建根：`/srv/fidc/canonical/build/engine-context-candidate-20260913`，禁止清理。
+- 原生因子能力目录发布前后字节相同，SHA为
+  `cec37331a476bc39bdea32c308581b8ac2f86d005d8dd4cc7ba228c5d9dc9a2e`。
+- API PID3320588，Boris、active、NRestarts=0；Source仍为PID1700096/d5，研究未恢复。
+
+[完整结构化验收证据](evidence/expression-context-performance-20260913.json)，
+SHA256 `f526950e018354c1305922beebf4063ae3823004f8c5ab20510a452f98b7b7ea`。
+
+## 边界
+
+本轮真实长区间案例含一个原生扩展因子，动态映射、缺失及多字段语义另由引擎回归覆盖；
+不宣称所有策略都具有相同比例提速。Source冷路径仍受独立冻结约束，
+信号闭环和全部策略/分钟区间/财务PIT不在本轮通过范围内。

docs/feature-date-market-integrity-20260913.md

@@ -0,0 +1,75 @@
+# 特征日行情缺口与跨日回退
+
+## 问题
+
+审查发现股票表达式上下文的三个位置把缺少的特征日行情回退到执行/当前市场日：
+两个 `StockStateSnapshotSource::feature_market` 实现，以及最终构建器的 `unwrap_or(market)`。
+当 `factor_date` 早于 `date` 时，这会把后来日期的OHLCV用于原本指定的历史特征日。
+这是错误日期代用，并具有前视风险；不据此推断所有历史回测都已触发此路径。
+
+真实代码的合成缺口回归已复现：2025-04-03因子快照存在但行情缺失，
+2025-04-07行情存在，旧版返回close=20.0、volume=45600、open=19.0，
+而非报告4月3日行情缺失。此回归使用合成数据验证代码路径，不是行情数据造假或真实市场收益样本。
+
+## 修改
+
+- 两个行情读取入口只返回指定特征日期的快照，删除向执行日的回退。
+- 构建器缺少快照时返回 `MissingSnapshot { kind: "feature_market", date: factor_date, symbol }`。
+- 保持原市场、候选和因子缺失错误优先级；失败状态不写入股票上下文缓存。
+- 同日上下文继续使用同日快照；正常跨日上下文仍将历史OHLCV与执行报价分开。
+- 不调整价格、因子、窗口、风险、手续费、滑点、成交量或原始数据，不引入替代缓存。
+
+新增回归覆盖索引读取、每日视图读取、错误缓存边界和同日合法输入。
+原next-open涨跌停测试只有前一日因子、没有对应行情，原先隐式依赖了该回退。
+已补充两只证券各自明确的历史行情，并断言历史价1.80与决策日价2.20分开；
+不放宽时点规则，也不改真实数据。
+
+## 当前状态
+
+177的红色回归已确认为行为失败；最初缺少错误枚举限定名的编译失败另存，不作为复现证据。
+修复后完整引擎783项、runner410项、API113项通过，分别9/8/3项既有外部或手动测试忽略。
+已通过官方入口发布到回测服务；Paper/Live/Strategy Runtime没有在本轮重建或重启，
+不能将共享源码修复等同于全部消费者已经部署。
+
+## 真实回放
+
+固定原策略、2021-08-23至2025-11-17、初始1000万及原冻结bundle。
+保留历史`session_capacity_audit`，不能当作开盘容量验收。
+全部运行重新执行引擎，Source/磁盘数据缓存保持，不缓存回测结果。
+
+| 状态 | 版本 | 运行ID | 总耗时 | 数据准备 | 引擎 |
+|---|---|---|---:|---:|---:|
+| 清DataSet内存 | 原版 | btr_1789251904666_3596554_4 | 17.689s | 8.664s | 8.141s |
+| 清DataSet内存 | 原版 | btr_1789251925997_3596554_5 | 17.082s | 8.333s | 7.947s |
+| 清DataSet内存 | 修复版 | btr_1789252042334_3735010_0 | 15.668s | 7.247s | 7.608s |
+| 清DataSet内存 | 修复版 | btr_1789252061568_3735010_1 | 15.717s | 6.949s | 7.985s |
+| DataSet复用 | 修复版 | btr_1789252206579_3735010_2 | 8.790s | 0.006s | 7.988s |
+| DataSet复用 | 修复版 | btr_1789252217644_3735010_3 | 9.892s | 0.006s | 7.880s |
+
+六次均21,393笔成交，账户、权益、委托、成交、持仓、风控canonical及完整制品SHA一致，
+终态clean，每次引擎执行次数为1。真实完整数据没有触发新增缺失错误。
+最后一次包含1.233秒Source合同验证，不能把DataSet复用等同于Source无等待。
+本轮未观察到该样本的性能回退，但这是正确性修复；主机负载及数据读取也有波动，
+不将17秒至15秒归因于普遍算法提速，更不外推所有策略。
+
+canonical：`3f089cbcc5412e07bbe2308d0dd60ac561a119f0a2228010fc3323714fde8ca7`。
+结果制品：`1905f0c8a887215279342b26d5769a6cbe40058971eef15adf86ef2eaa02aeb9`。
+
+## 发布证据
+
+177 engine `e3b39295787c4fd896753d633e457deddf9f1232`，service `106a89d8bb74af494cdf84d9d3af5ec4bcb249cd`。
+
+- API：`86f0a0385410db8ab308edf892f4ad6376c0a706c0ebbac0f397a23539d782c0`。
+- Runner：`aebdd37ad30ee73f11a9ffd206ad8c978ced19a257cb51849881b0e5bdce36ee`。
+- 运行身份：`d196bd4740b1b506c42515a689ae155a21e37b8092956b99a298b8d7934e53c7`。
+- 在用构建根：`/srv/fidc/canonical/build/feature-date-candidate-20260913`，禁止清理。
+- PID3735010、Boris、active、NRestarts=0；收据时cgroup约7.91GiB，峰值约9.29GiB。
+- 原生目录字节SHA仍为`cec37331a476bc39bdea32c308581b8ac2f86d005d8dd4cc7ba228c5d9dc9a2e`。
+- Source保持d5/PID1700096，研究和信号未恢复，没有向券商提交订单。
+
+证据根 `/srv/fidc/canonical/run/research/feature-date-integrity-20260913`。
+[结构化证据](evidence/feature-date-market-integrity-20260913.json)，
+SHA256 `56e70172916c45060106aca3eb006984735a3f85e6b13d2c325c409e83b8962b`。
+更多策略、真实缺口数据审计、Paper/Live消费者发布及完整财务PIT仍未完成。
+Source目录缓存的隔离后继验证单独见Alpha Factory的`docs/native-condition-transport-20260913.md`，
+不能把本轮回测发布当作Source冻结解除。

docs/position-exposure-events-20260913.md

@@ -0,0 +1,13 @@
+# 仓位事件执行合同
+
+2026-09-13。`runtimeExpressions.risk.positionExposureEvents` 使用带eventId、严格唯一sequence、UTC有效时点的事件；必须明确指定set、scale或restore。缺失动作、重复身份、非法比例和无时区日期均拒绝。
+
+- scale用于人工比例乘数：普通轮动仍先计算策略自身仓位，0%指数择时不会被人工100%覆盖。显式权益买入和目标类委托，以及SignalBook产生的意图，同样按比例处理；不修改原SignalBook。
+- 卖出/减仓增量、零目标清仓、取消、订阅、现金流和价格不被缩量。对已有买单增加数量只缩放增加部分；无法确定被改单身份时拒绝。期货等未定义类型不静默转换。
+- set用于股票池投入比例等明确绝对目标；restore恢复原策略/池规则，不转换成100%。旧日期级positionExposureSchedule保留原粒度，新的恢复事件不再回落到旧人工值。
+- 比例按实际执行时点读取；股票池不再用信号日读取覆盖值。原引擎首信号日现金基线和next-open调度合同不改变。
+- 不改变OHLCV、费用、价格精度、证券生命周期或成交量容量合同。
+
+验证覆盖同日多次调整、未来事件隔离、0/30/50/100%、20%原策略恢复、显式委托与现金流、以及原始引擎跨周末的股票池回放：1月2日信号在1月5日执行，1月5日覆盖在该日生效，1月6日恢复20%而不是100%。测试行情明确是隔离夹具，不代表真实历史或券商成交验收。
+
+交易侧用不可变操作审计提供事件，保留运行任务/账户绑定和原始请求。此模块不自己下单或创建新的回测，不读取用户资金账户。未完成的独立人工调仓命令与逐笔人工交易影子回放仍需另行验收，不能据时间线通过声明所有调仓路径完成。