接入独立手工仓位时间线并保留原策略配置

crates/fidc-core/src/position_exposure.rs

@@ -25,13 +25,19 @@ pub struct PositionExposureEvent {
     pub sequence: u64,
     #[serde(alias = "effective_at")]
     pub effective_at: DateTime<Utc>,
+    #[serde(
+        default,
+        skip_serializing_if = "Option::is_none",
+        alias = "allocation_weights_bps"
+    )]
+    pub allocation_weights_bps: Option<BTreeMap<String, i32>>,
     #[serde(flatten)]
     pub action: PositionExposureAction,
 }
 
 #[derive(Debug, Clone, Default)]
 pub struct PositionExposureTimeline {
-    events: BTreeMap<(DateTime<Utc>, u64), PositionExposureAction>,
+    events: BTreeMap<(DateTime<Utc>, u64), (PositionExposureAction, Option<BTreeMap<String, i32>>)>,
 }
 
 impl PositionExposureTimeline {
@@ -58,9 +64,24 @@ impl PositionExposureTimeline {
             {
                 return Err("position exposure target must be between 0 and 10000 bps".into());
             }
-            result
-                .events
-                .insert((event.effective_at, event.sequence), event.action.clone());
+            if let Some(weights) = &event.allocation_weights_bps {
+                let target = match event.action {
+                    PositionExposureAction::Set {
+                        target_exposure_bps,
+                    } => target_exposure_bps,
+                    PositionExposureAction::Scale { requested_bps } => requested_bps,
+                    PositionExposureAction::Restore => {
+                        return Err(
+                            "restoring strategy allocation cannot carry manual weights".into()
+                        );
+                    }
+                };
+                validate_allocation_weights(weights, target)?;
+            }
+            result.events.insert(
+                (event.effective_at, event.sequence),
+                (event.action.clone(), event.allocation_weights_bps.clone()),
+            );
         }
         Ok(result)
     }
@@ -77,7 +98,7 @@ impl PositionExposureTimeline {
             .events
             .range(..=(at, u64::MAX))
             .next_back()
-            .map(|(_, action)| action)
+            .map(|(_, (action, _))| action)
         {
             Some(PositionExposureAction::Scale { requested_bps }) => {
                 Some(strategy_exposure * f64::from(*requested_bps) / 10000.)
@@ -98,12 +119,47 @@ impl PositionExposureTimeline {
             .events
             .range(..=(at, u64::MAX))
             .next_back()
-            .map(|(_, action)| action)
+            .map(|(_, (action, _))| action)
         {
             Some(PositionExposureAction::Scale { requested_bps }) => Some(*requested_bps),
             _ => None,
         }
     }
+
+    pub fn allocation_weights_at(&self, at: DateTime<Utc>) -> Option<&BTreeMap<String, i32>> {
+        self.events
+            .range(..=(at, u64::MAX))
+            .next_back()
+            .and_then(|(_, (_, weights))| weights.as_ref())
+    }
+}
+
+pub fn validate_allocation_weights(
+    weights: &BTreeMap<String, i32>,
+    exposure_bps: i32,
+) -> Result<(), String> {
+    if !(0..=10000).contains(&exposure_bps) || weights.len() > 10000 {
+        return Err("invalid allocation exposure or weight count".into());
+    }
+    for (symbol, weight) in weights {
+        if !(0..=10000).contains(weight)
+            || !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(
+                "allocation weights require canonical stock/ETF symbols and 0..10000 bps".into(),
+            );
+        }
+    }
+    if (weights.is_empty() && exposure_bps != 0)
+        || (!weights.is_empty() && weights.values().sum::<i32>() != 10000)
+    {
+        return Err("manual allocation weights must total 10000 bps; only a zero exposure may have no weights".into());
+    }
+    Ok(())
 }
 
 /// Scale new buys and desired targets without weakening sell/reduction or
@@ -241,6 +297,7 @@ mod tests {
             event_id: "scale".into(),
             sequence: 1,
             effective_at: at,
+            allocation_weights_bps: None,
             action: PositionExposureAction::Scale {
                 requested_bps: 5000,
             },
@@ -258,6 +315,7 @@ mod tests {
             event_id: "restore".into(),
             sequence: 2,
             effective_at: at,
+            allocation_weights_bps: None,
             action: PositionExposureAction::Restore,
         };
         let timeline = PositionExposureTimeline::from_events(&[event, restored]).unwrap();
@@ -274,6 +332,56 @@ mod tests {
         );
     }
 
+    #[test]
+    fn allocation_is_dated_and_any_later_scalar_or_restore_clears_it() {
+        let at = DateTime::parse_from_rfc3339("2026-09-14T10:00:00+08:00")
+            .unwrap()
+            .with_timezone(&Utc);
+        let weights = BTreeMap::from([("000001.SZ".into(), 3000), ("510300.SH".into(), 7000)]);
+        let event = PositionExposureEvent {
+            event_id: "allocation".into(),
+            sequence: 1,
+            effective_at: at,
+            action: PositionExposureAction::Set {
+                target_exposure_bps: 8000,
+            },
+            allocation_weights_bps: Some(weights.clone()),
+        };
+        let timeline = PositionExposureTimeline::from_events(&[event.clone()]).unwrap();
+        assert!(
+            timeline
+                .allocation_weights_at(at - chrono::Duration::seconds(1))
+                .is_none()
+        );
+        assert_eq!(timeline.allocation_weights_at(at), Some(&weights));
+        for action in [
+            PositionExposureAction::Set {
+                target_exposure_bps: 5000,
+            },
+            PositionExposureAction::Restore,
+        ] {
+            let next = PositionExposureEvent {
+                event_id: "new".into(),
+                sequence: 2,
+                effective_at: at + chrono::Duration::seconds(1),
+                action,
+                allocation_weights_bps: None,
+            };
+            assert!(
+                PositionExposureTimeline::from_events(&[event.clone(), next])
+                    .unwrap()
+                    .allocation_weights_at(at + chrono::Duration::seconds(1))
+                    .is_none()
+            );
+        }
+        assert!(
+            validate_allocation_weights(&BTreeMap::from([("000001.SZ".into(), 9000)]), 5000)
+                .is_err()
+        );
+        assert!(validate_allocation_weights(&BTreeMap::new(), 1).is_err());
+        assert!(validate_allocation_weights(&BTreeMap::new(), 0).is_ok());
+    }
+
     #[test]
     fn explicit_equity_targets_and_buys_scale_but_sales_cashflows_and_prices_do_not() {
         use crate::OrderIntent as I;