fix(stock-pool): keep full stops stronger than simultaneous reductions

crates/fidc-core/src/stock_pool_execution.rs

@@ -669,6 +669,13 @@ pub fn build_stock_pool_target_plan_with_fee_model(
             }
         }
     }
+    // Validate source targets before a stronger stop/expiry can replace them.
+    // Otherwise an invalid ratio could be hidden by target consolidation.
+    for (symbol, target) in &constraints.position_target_bps {
+        if *target >= 10_000 {
+            return Err(format!("factor position target for {symbol} must be below 10000 bps"));
+        }
+    }
     let mut effective_position_targets = constraints.position_target_bps.clone();
     for (symbol, permission) in &constraints.automatic_permissions {
         if permission.max_holding_exit {
@@ -863,13 +870,27 @@ pub fn build_stock_pool_target_plan_with_fee_model(
             .then(|| symbol.clone())
         })
         .collect::<BTreeSet<_>>();
+    // A full stop is stricter than a simultaneous relative reduction. Merge
+    // the target before selecting its single owner, never emit a second exit.
+    for symbol in &global_stop_hits {
+        if let Some(target) = effective_position_targets.get_mut(symbol) {
+            *target = 0;
+        }
+    }
     let mut quote_sell_exits = BTreeSet::new();
     let mut sell_condition_denials = BTreeSet::new();
     if rule.sell_trigger_mode == POOL_SELL_CONDITION {
+        // Ordinary sell predicates only depend on positions participating in
+        // that stage. Independent stops/expiry and protected holdings were
+        // already decided above; unrelated quote fields must not block them.
         let held = current
             .iter()
             .filter(|(symbol, row)| {
-                row.0 > Decimal::ZERO && !constraints.frozen_positions.contains_key(*symbol)
+                row.0 > Decimal::ZERO
+                    && !protected_positions.contains(*symbol)
+                    && !global_stop_hits.contains(*symbol)
+                    && !constraints.automatic_permissions.get(*symbol)
+                        .is_some_and(|permission| permission.max_holding_exit)
             })
             .map(|(symbol, _)| symbol.clone())
             .collect::<Vec<_>>();
@@ -880,14 +901,6 @@ pub fn build_stock_pool_target_plan_with_fee_model(
             &quote_map,
         )?;
         for symbol in held {
-            if global_stop_hits.contains(&symbol)
-                || constraints
-                    .automatic_permissions
-                    .get(&symbol)
-                    .is_some_and(|permission| permission.max_holding_exit)
-            {
-                continue;
-            }
             let permitted = qualified.get(&symbol) == Some(&true)
                 && (!rule.secondary_sell_condition
                     || constraints.position_target_bps.contains_key(&symbol));
@@ -1031,7 +1044,12 @@ pub fn build_stock_pool_target_plan_with_fee_model(
     }
     let mut planning_symbols = active_symbols;
     for symbol in &original_final_symbols {
-        if rebuy_exclusions.contains(symbol) && !planning_symbols.contains(symbol) {
+        // An explicit quote/expiry position action owns its single target row.
+        // Keep it excluded from entry sizing without adding a second stop row.
+        if rebuy_exclusions.contains(symbol)
+            && !factor_position_target_bps.contains_key(symbol)
+            && !planning_symbols.contains(symbol)
+        {
             planning_symbols.push(symbol.clone());
         }
     }
@@ -1323,11 +1341,6 @@ pub fn build_stock_pool_target_plan_with_fee_model(
     }
 
     for (symbol, target_bps) in factor_position_target_bps {
-        if *target_bps >= 10_000 {
-            return Err(format!(
-                "factor position target for {symbol} must be below 10000 bps"
-            ));
-        }
         if !member_map.contains_key(symbol) && !current.contains_key(symbol) {
             return Err(format!(
                 "factor position-action symbol {symbol} is outside candidates and managed holdings"
@@ -1414,6 +1427,8 @@ pub fn build_stock_pool_target_plan_with_fee_model(
                         "达到最长持有期，按配置退出"
                     } else if quote_sell_exits.contains(symbol) {
                         "卖出行情条件命中"
+                    } else if stop_take_exits.contains(symbol) {
+                        "止损/止盈触发，覆盖较弱的减仓目标"
                     } else if *target_bps == 0 {
                         "生产因子退出条件命中"
                     } else {
@@ -1688,6 +1703,14 @@ pub fn build_stock_pool_target_plan_with_fee_model(
             }
         }
     }
+    // Verify disjoint planning ownership before an index cap can address rows
+    // by symbol. Never deduplicate emitted intentions or count proceeds twice.
+    let mut owners = BTreeSet::new();
+    for row in &rows {
+        if !owners.insert(row.symbol.as_str()) {
+            return Err(format!("stock_pool_target_owner_conflict:{}", row.symbol));
+        }
+    }
     if market_timing.is_some() {
         let caps = index_cap::remaining_index_targets(
             &current,

crates/fidc-core/src/stock_pool_execution_tests.rs

@@ -509,6 +509,16 @@ fn condition_plan(
     quotes: &[MarketSnapshot],
     constraints: &StockPoolDecisionConstraints,
 ) -> StockPoolPlan {
+    condition_plan_result(selection, rule, positions, quotes, constraints).unwrap()
+}
+
+fn condition_plan_result(
+    selection: &StockPoolSelection,
+    rule: &StockPoolExecutionRule,
+    positions: &[Position],
+    quotes: &[MarketSnapshot],
+    constraints: &StockPoolDecisionConstraints,
+) -> Result<StockPoolPlan, String> {
     let held_value = positions
         .iter()
         .map(|position| {
@@ -541,7 +551,6 @@ fn condition_plan(
         Decimal::ZERO,
         Decimal::ZERO,
     )
-    .unwrap()
 }
 
 #[test]
@@ -704,6 +713,163 @@ fn native_sell_and_quote_conditions_are_and_but_stop_and_protection_remain_indep
     );
 }
 
+#[test]
+fn independent_stop_does_not_require_unused_ordinary_sell_quote_facts() {
+    let mut market = quotes(1);
+    market[0].last_price = 9.into();
+    market[0].volume = None;
+    let rule = normalize_stock_pool_execution_rule(
+        Some(&json!({"sell_trigger_mode":"condition","sell_condition":"volume>1000"})),
+        false,
+        false,
+    ).unwrap();
+    let constraints = StockPoolDecisionConstraints {
+        default_stop_loss: Some(Decimal::new(5, 2)),
+        ..Default::default()
+    };
+    let plan = condition_plan(&selection(1, 1), &rule, &[position(1)], &market, &constraints);
+    let exit = plan.rows.iter().find(|row| row.symbol == symbol(1)).unwrap();
+    assert_eq!(exit.side, Some(OrderSide::Sell), "{plan:?}");
+    assert_eq!(exit.target_quantity, Decimal::ZERO, "{plan:?}");
+}
+
+#[test]
+fn ordinary_sell_scope_excludes_independent_exits_and_protected_positions() {
+    for scope in [QuoteConditionScope::PerSymbol, QuoteConditionScope::AllTargets, QuoteConditionScope::AnyTarget] {
+        for cause in ["stop_loss", "take_profit", "maximum_holding_exit", "automatic_trade_locked", "buy_fill_protection"] {
+            let mut market = quotes(2);
+            market[0].volume = None;
+            let mut constraints = StockPoolDecisionConstraints::default();
+            match cause {
+                "stop_loss" => { market[0].last_price = 9.into(); constraints.default_stop_loss = Some(Decimal::new(5, 2)); },
+                "take_profit" => { market[0].last_price = 12.into(); constraints.default_take_profit = Some(Decimal::new(10, 2)); },
+                "maximum_holding_exit" => { constraints.automatic_permissions.insert(symbol(1), crate::holding_policy::AutomaticTradePermission { max_holding_exit: true, ..Default::default() }); },
+                _ => { constraints.automatic_permissions.insert(symbol(1), crate::holding_policy::AutomaticTradePermission { sell_denial: Some(cause), buy_denial: Some(cause), ..Default::default() }); },
+            }
+            let rule = normalize_stock_pool_execution_rule(
+                Some(&json!({"sell_trigger_mode":"condition","sell_condition":"volume>1000","sell_condition_scope":scope})),
+                false, false,
+            ).unwrap();
+            let plan = condition_plan(&selection(2, 2), &rule, &[position(1), position(2)], &market, &constraints);
+            let protected = plan.rows.iter().find(|row| row.symbol == symbol(1)).unwrap();
+            let normal = plan.rows.iter().find(|row| row.symbol == symbol(2)).unwrap();
+            assert_eq!(normal.side, Some(OrderSide::Sell), "{scope:?}/{cause}: {plan:?}");
+            if cause == "automatic_trade_locked" || cause == "buy_fill_protection" {
+                assert_eq!(protected.side, None, "{scope:?}/{cause}: {plan:?}");
+                assert_eq!(protected.target_quantity, 1000.into(), "{scope:?}/{cause}: {plan:?}");
+                assert_eq!(protected.status, "AUTOMATIC_TRADE_PROTECTED", "{scope:?}/{cause}: {plan:?}");
+            } else {
+                assert_eq!(protected.side, Some(OrderSide::Sell), "{scope:?}/{cause}: {plan:?}");
+                assert_eq!(protected.target_quantity, Decimal::ZERO, "{scope:?}/{cause}: {plan:?}");
+            }
+        }
+    }
+}
+
+#[test]
+fn independent_exit_quote_priority_does_not_bypass_t_plus_one_or_price_validation() {
+    let rule = normalize_stock_pool_execution_rule(Some(&json!({"sell_trigger_mode":"condition","sell_condition":"volume>1000"})), false, false).unwrap();
+    let mut market = quotes(1);
+    market[0].last_price = 9.into(); market[0].volume = None;
+    let constraints = StockPoolDecisionConstraints { default_stop_loss: Some(Decimal::new(5,2)), ..Default::default() };
+    for closable in [0, 400, 1000] {
+        let mut held = position(1); held.closable_quantity = Decimal::from(closable);
+        let plan = condition_plan(&selection(1,1), &rule, &[held], &market, &constraints);
+        let row = plan.rows.iter().find(|row|row.symbol==symbol(1)).unwrap();
+        assert_eq!(row.delta_quantity, -Decimal::from(closable), "{plan:?}");
+        assert_eq!(row.target_quantity, Decimal::from(1000-closable), "{plan:?}");
+    }
+    market[0].last_price = Decimal::ZERO;
+    assert!(condition_plan_result(&selection(1,1), &rule, &[position(1)], &market, &constraints).unwrap_err().contains("execution quote is invalid"));
+}
+
+#[test]
+fn full_stop_overrides_a_simultaneous_factor_reduction_without_a_second_target() {
+    let mut selected = selection(2, 1);
+    selected.final_symbols = vec![symbol(2)];
+    let mut market = quotes(2);
+    market[0].last_price = 9.into();
+    let constraints = StockPoolDecisionConstraints {
+        default_stop_loss: Some(Decimal::new(5, 2)),
+        position_target_bps: BTreeMap::from([(symbol(1), 5000)]),
+        ..Default::default()
+    };
+    let plan = condition_plan(&selected, &StockPoolExecutionRule::default(), &[position(1)], &market, &constraints);
+    let rows = plan.rows.iter().filter(|row|row.symbol==symbol(1)).collect::<Vec<_>>();
+    assert_eq!(rows.len(),1,"{plan:?}");
+    assert_eq!(rows[0].target_quantity,Decimal::ZERO,"a full stop must not be weakened by a 50% reduction: {plan:?}");
+    assert_eq!(rows[0].delta_quantity,Decimal::from(-1000),"{plan:?}");
+}
+
+#[test]
+fn stop_reduction_merge_matrix_preserves_protection_t_plus_one_and_invalid_config_errors() {
+    for take_profit in [false,true] {
+        for reduction in [0,2500,5000,9999] {
+            for closable in [0,400,1000] {
+                for locked in [false,true] {
+                    let mut selected=selection(2,1);selected.final_symbols=vec![symbol(2)];
+                    let mut market=quotes(2);market[0].last_price=if take_profit {12.into()} else {9.into()};market[0].volume=None;
+                    let mut held=position(1);held.closable_quantity=Decimal::from(closable);
+                    let mut constraints=StockPoolDecisionConstraints {position_target_bps:BTreeMap::from([(symbol(1),reduction)]),..Default::default()};
+                    if take_profit {constraints.default_take_profit=Some(Decimal::new(10,2))} else {constraints.default_stop_loss=Some(Decimal::new(5,2))}
+                    if locked {constraints.automatic_permissions.insert(symbol(1),crate::holding_policy::AutomaticTradePermission {sell_denial:Some("automatic_trade_locked"),buy_denial:Some("automatic_trade_locked"),..Default::default()});}
+                    let rule=normalize_stock_pool_execution_rule(Some(&json!({"sell_trigger_mode":"condition","sell_condition":"volume>1000"})),false,true).unwrap();
+                    let plan=condition_plan(&selected,&rule,&[held],&market,&constraints);
+                    let rows=plan.rows.iter().filter(|row|row.symbol==symbol(1)).collect::<Vec<_>>();
+                    assert_eq!(rows.len(),1,"{plan:?}");
+                    let sold=if locked {0} else {closable};
+                    assert_eq!(rows[0].delta_quantity,-Decimal::from(sold),"{plan:?}");
+                    assert_eq!(rows[0].target_quantity,Decimal::from(1000-sold),"{plan:?}");
+                    assert_eq!(plan.estimated_sell_amount,Decimal::from(sold)*market[0].last_price,"{plan:?}");
+                    if locked {assert_eq!(rows[0].status,"AUTOMATIC_TRADE_PROTECTED","{plan:?}")}
+                }
+            }
+        }
+    }
+    let mut invalid=StockPoolDecisionConstraints {default_stop_loss:Some(Decimal::new(5,2)),position_target_bps:BTreeMap::from([(symbol(1),10000)]),..Default::default()};
+    invalid.automatic_permissions.insert(symbol(1),crate::holding_policy::AutomaticTradePermission {max_holding_exit:true,..Default::default()});
+    assert!(condition_plan_result(&selection(1,1),&StockPoolExecutionRule::default(),&[position(1)],&quotes(1),&invalid).unwrap_err().contains("must be below 10000"));
+}
+
+#[test]
+fn ordinary_sell_keeps_required_quote_failures_and_zero_stop_is_not_an_exit() {
+    let rule = normalize_stock_pool_execution_rule(Some(&json!({"sell_trigger_mode":"condition","sell_condition":"volume>1000"})), false, false).unwrap();
+    let mut market = quotes(1); market[0].last_price = 9.into(); market[0].volume = None;
+    for stop in [None, Some(Decimal::ZERO)] {
+        let constraints = StockPoolDecisionConstraints { default_stop_loss: stop, ..Default::default() };
+        assert_eq!(condition_plan_result(&selection(1,1), &rule, &[position(1)], &market, &constraints).unwrap_err(), "condition requires volume");
+    }
+}
+
+#[test]
+fn quote_field_operator_side_and_scope_matrix_matches_the_configured_predicate() {
+    let market = quotes(2);
+    for (field, threshold) in [("price", "10"), ("last", "10"), ("change_pct", "0"), ("volume", "1000000"), ("amount", "10000000"), ("bid1", "10"), ("ask1", "10")] {
+        for (operator, matched) in [(">",false), (">=",true), ("<",false), ("<=",true), ("==",true), ("!=",false)] {
+            for scope in [QuoteConditionScope::PerSymbol, QuoteConditionScope::AllTargets, QuoteConditionScope::AnyTarget] {
+                for side in [OrderSide::Buy, OrderSide::Sell] {
+                    let condition = format!("{field}{operator}{threshold}");
+                    let config = if side == OrderSide::Buy {
+                        json!({"trigger_mode":"condition","buy_condition":condition,"buy_condition_scope":scope})
+                    } else {
+                        json!({"sell_trigger_mode":"condition","sell_condition":condition,"sell_condition_scope":scope})
+                    };
+                    let rule = normalize_stock_pool_execution_rule(Some(&config), false, false).unwrap();
+                    let held = if side == OrderSide::Sell { vec![position(1),position(2)] } else { vec![] };
+                    let plan = condition_plan(&selection(2,2), &rule, &held, &market, &StockPoolDecisionConstraints::default());
+                    assert_eq!(plan.rows.iter().map(|row| &row.symbol).collect::<BTreeSet<_>>().len(), plan.rows.len(), "duplicate target ownership: {plan:?}");
+                    let orders = plan.rows.iter().filter(|row|row.side==Some(side)).count();
+                    assert_eq!(orders, if matched {2} else {0}, "{side:?}/{scope:?}/{condition}: {plan:?}");
+                    if side == OrderSide::Sell && matched {
+                        assert_eq!(plan.estimated_sell_amount, Decimal::from(20000), "{plan:?}");
+                        assert_eq!(plan.estimated_cash_after, Decimal::from(40000), "{plan:?}");
+                    }
+                }
+            }
+        }
+    }
+}
+
 #[test]
 fn partial_sell_cooldown_restricts_increases_without_clearing_the_remainder() {
     let mut constraints = StockPoolDecisionConstraints::default();

crates/fidc-core/tests/stock_pool_execution_contract.rs

@@ -445,6 +445,31 @@ fn actual_fill_protection_is_evaluated_on_execution_date() {
     assert_eq!(account.position(&code(1)).unwrap().quantity, 1000);
 }
 
+#[test]
+fn ordinary_sell_has_one_order_owner_before_broker_execution() {
+    let data = data(false);
+    let broker = broker(false);
+    let mut account = PortfolioState::new(20_000.);
+    account.position_mut(&code(1)).buy(day(2), 1000, 10.);
+    let mut intent = contract(day(2), 1, false);
+    intent.rule.sell_trigger_mode = POOL_SELL_CONDITION.into();
+    intent.rule.sell_condition = "price>0".into();
+    let report = broker.execute_with_event_dates(
+        day(5), day(2), day(2), &mut account, &data, &decision(intent),
+    ).unwrap();
+    let sells=report.fill_events.iter().filter(|row|row.symbol==code(1)).collect::<Vec<_>>();
+    assert_eq!(sells.len(),1,"{report:?}");
+    assert_eq!(sells[0].quantity,1000,"{report:?}");
+    let owners=report.order_events.iter().filter(|row|row.symbol==code(1)).map(|row|row.order_id).collect::<BTreeSet<_>>();
+    assert_eq!(owners.len(),1,"{report:?}");
+    assert_eq!(account.position(&code(1)).map(|row|row.quantity).unwrap_or(0),0);
+    // The replacement may enter only after the single sell has settled.
+    let replacement=report.fill_events.iter().find(|row|row.symbol==code(2)).unwrap();
+    assert_eq!(replacement.quantity,3000,"{report:?}");
+    assert_eq!(report.account_events[0].cash_after,40000.);
+    assert_eq!(report.account_events[1].cash_before,40000.);
+}
+
 #[test]
 fn parsed_pool_program_executes_daily_membership_changes_without_legacy_translation() {
     let intent = contract(day(2), 1, false);