记录独立公司行为估值合同及核心完整回归

crates/fidc-core/src/broker.rs

@@ -1191,7 +1191,7 @@ where
         let target_value_side = |symbol: &str, target_value: f64| {
             let current_qty = portfolio
                 .position(symbol)
-                .map(|position| position.quantity)
+                .map(|position| position.economic_quantity())
                 .unwrap_or(0);
             let current_value = data
                 .market(date, symbol)
@@ -1234,7 +1234,7 @@ where
             } => {
                 let current_qty = portfolio
                     .position(symbol)
-                    .map(|position| position.quantity as i64)
+                    .map(|position| position.economic_quantity() as i64)
                     .unwrap_or(0);
                 Some(if i64::from(*target_quantity).max(0) < current_qty {
                     OrderSide::Sell
@@ -1392,7 +1392,7 @@ where
         let held_symbols = portfolio
             .positions()
             .iter()
-            .filter(|(_, position)| position.quantity > 0)
+            .filter(|(_, position)| position.economic_quantity() > 0)
             .map(|(symbol, _)| symbol.clone())
             .collect::<BTreeSet<_>>();
         let mut exit_symbols = BTreeSet::new();
@@ -1428,7 +1428,7 @@ where
         portfolio
             .positions()
             .values()
-            .filter(|position| position.quantity > 0)
+            .filter(|position| position.economic_quantity() > 0)
             .count()
     }
 
@@ -3897,7 +3897,7 @@ where
             )?;
             let current_qty = portfolio
                 .position(symbol)
-                .map(|position| position.quantity)
+                .map(|position| position.economic_quantity())
                 .unwrap_or(0);
             let target_value = (equity * weight).max(0.0);
             let current_value = price * current_qty as f64;
@@ -3934,7 +3934,7 @@ where
         for symbol in symbols {
             let current_qty = portfolio
                 .position(&symbol)
-                .map(|pos| pos.quantity)
+                .map(|pos| pos.economic_quantity())
                 .unwrap_or(0);
             let desired_qty = *desired_targets.get(&symbol).unwrap_or(&0);
             let price = self.rebalance_valuation_price_with_overrides(
@@ -5610,7 +5610,7 @@ where
     ) -> Result<(), BacktestError> {
         let current_qty = portfolio
             .position(symbol)
-            .map(|pos| pos.quantity)
+            .map(|pos| pos.economic_quantity())
             .unwrap_or(0);
 
         if target_value <= f64::EPSILON {
@@ -5710,7 +5710,7 @@ where
     ) -> Result<(), BacktestError> {
         let current_qty = portfolio
             .position(symbol)
-            .map(|pos| pos.quantity)
+            .map(|pos| pos.economic_quantity())
             .unwrap_or(0);
         if target_value <= f64::EPSILON && current_qty == 0 {
             return Ok(());
@@ -5797,7 +5797,7 @@ where
     ) -> Result<(), BacktestError> {
         let current_qty = portfolio
             .position(symbol)
-            .map(|pos| pos.quantity)
+            .map(|pos| pos.economic_quantity())
             .unwrap_or(0);
         let target_qty = target_quantity.max(0) as u32;
         let minimum_order_quantity = self.minimum_order_quantity(data, symbol);
@@ -5960,7 +5960,7 @@ where
     ) -> Result<(), BacktestError> {
         let current_qty = portfolio
             .position(symbol)
-            .map(|pos| pos.quantity)
+            .map(|pos| pos.economic_quantity())
             .unwrap_or(0);
         let target_qty = target_quantity.max(0) as u32;
         let minimum_order_quantity = self.minimum_order_quantity(data, symbol);
@@ -6690,7 +6690,7 @@ where
         let remainder_policy = self.effective_remainder_policy(date, allow_pending_limit);
         if portfolio
             .position(symbol)
-            .is_none_or(|position| position.quantity == 0)
+            .is_none_or(|position| position.economic_quantity() == 0)
             && self
                 .runtime_target_position_limit
                 .get()
@@ -6836,7 +6836,7 @@ where
 
         let current_position_quantity = portfolio
             .position(symbol)
-            .map(|position| position.quantity)
+            .map(|position| position.economic_quantity())
             .unwrap_or(0)
             .saturating_add(self.reserved_open_buy_quantity(symbol, Some(order_id)));
         let size_check_price = limit_price.unwrap_or_else(|| {
@@ -7452,10 +7452,10 @@ where
                         PriceField::Last => "last",
                     },
                 })?;
-            market_value += price * position.quantity as f64;
+            market_value += price * position.economic_quantity() as f64;
         }
 
-        Ok(portfolio.cash() + market_value)
+        Ok(portfolio.cash() + market_value + portfolio.cash_receivable_value() - portfolio.cash_liabilities())
     }
 
     fn round_lot(&self, data: &DataSet, symbol: &str) -> u32 {
@@ -7619,9 +7619,9 @@ where
                         field: self.rebalance_valuation_price_field_name(),
                     })?
             };
-            market_value += price * position.quantity as f64;
+            market_value += price * position.economic_quantity() as f64;
         }
-        Ok(portfolio.cash() + market_value)
+        Ok(portfolio.cash() + market_value + portfolio.cash_receivable_value() - portfolio.cash_liabilities())
     }
 
     fn required_custom_order_price(
@@ -10740,6 +10740,59 @@ mod tests {
         assert_eq!(portfolio.position("000001.SZ").unwrap().quantity, 1_000);
     }
 
+    #[test]
+    fn pending_registered_shares_do_not_trigger_duplicate_target_buys() {
+        let date = chrono::NaiveDate::from_ymd_opt(2025, 1, 2).unwrap();
+        let broker = BrokerSimulator::new_with_execution_price(
+            ChinaAShareCostModel::default(), ChinaEquityRuleHooks, PriceField::Open,
+        ).with_matching_type(MatchingType::NextBarOpen)
+            .with_volume_limit(false).with_liquidity_limit(false).with_inactive_limit(false);
+        let mut snapshot = limit_test_snapshot();
+        snapshot.date = date;
+        snapshot.prev_close = 10.0;
+        snapshot.open = 10.0;
+        snapshot.close = 10.0;
+        let data = DataSet::from_components_with_actions_and_quotes(
+            vec![limit_test_instrument()], vec![snapshot], Vec::new(),
+            vec![limit_test_candidate(true, true)], vec![limit_test_benchmark()],
+            Vec::new(), Vec::new(),
+        ).unwrap();
+        let mut portfolio = PortfolioState::new(20_000.0);
+        portfolio.position_mut("000001.SZ").buy(date.pred_opt().unwrap(), 1_000, 15.0);
+        portfolio.apply_cash_delta(-15_000.0).unwrap();
+        portfolio.record_closing_holdings(date.pred_opt().unwrap()).unwrap();
+        portfolio.register_share_entitlement(&crate::CorporateAction {
+            date, symbol: "000001.SZ".into(), record_date: date.pred_opt(),
+            share_effective_date: date.succ_opt(), share_rounding_rule: None,
+            ex_reference_price: Some(10.0),
+            payable_date: None, share_cash: 0.0, share_bonus: 0.5, share_gift: 0.0,
+            issue_quantity: 0.0, issue_price: 0.0, reform: false, adjust_factor: None,
+            successor_symbol: None, successor_ratio: None, successor_cash: None,
+        }).unwrap();
+        let mut report = BrokerExecutionReport::default();
+        broker.process_target_value(date, &mut portfolio, &data, "000001.SZ", 15_000.0,
+            "registered shares already meet target value", &mut BTreeMap::new(),
+            &mut IntradayExecutionLedger::default(), &mut None, &mut BTreeMap::new(), &mut report).unwrap();
+        broker.process_timed_target_value(date, &mut portfolio, &data, "000001.SZ", 15_000.0,
+            AlgoOrderStyle::Twap, None, None, "registered shares already meet timed target",
+            &mut BTreeMap::new(), &mut IntradayExecutionLedger::default(), &mut None,
+            &mut BTreeMap::new(), &mut report).unwrap();
+        broker.process_target_shares(date, &mut portfolio, &data, "000001.SZ", 1_500,
+            "registered shares already meet quantity target", &mut BTreeMap::new(),
+            &mut IntradayExecutionLedger::default(), &mut None, &mut BTreeMap::new(), &mut report).unwrap();
+        assert!(report.order_events.is_empty());
+        assert!(report.fill_events.is_empty());
+        assert_eq!(portfolio.cash(), 5_000.0);
+        let position = portfolio.position("000001.SZ").unwrap();
+        assert_eq!(position.quantity, 1_000);
+        assert_eq!(position.share_receivable_quantity(), 500);
+        assert_eq!(position.sellable_qty(date), 1_000);
+        let mut pending_only = portfolio.clone();
+        pending_only.position_mut("000001.SZ").sell(1_000, 10.0).unwrap();
+        assert_eq!(pending_only.position("000001.SZ").unwrap().quantity, 0);
+        assert_eq!(BrokerSimulator::<ChinaAShareCostModel, ChinaEquityRuleHooks>::positive_position_count(&pending_only), 1);
+    }
+
     #[test]
     fn target_value_delta_below_order_step_is_audited_without_creating_zero_quantity_order() {
         let date = chrono::NaiveDate::from_ymd_opt(2025, 1, 2).expect("valid date");

crates/fidc-core/src/broker_stock_pool.rs

@@ -787,12 +787,10 @@ impl<C: CostModel, R: EquityRuleHooks> BrokerSimulator<C, R> {
             if let Some(denial) = denial {
                 report.diagnostics.push(format!("etf_daily_open_fallback:protected symbol={} date={date} reason={denial}", target.symbol));
                 etf_activity(&mut report,date,&target.symbol,target.side,format!("ETF 顺延目标受持有保护限制：{denial}；未提交委托。"));
-                self.deferred_etf_targets.borrow_mut().defer_to_next_session(target, date, &dates);
                 continue;
             }
             if target.side == pool::OrderSide::Buy && before_quantity == 0 && Self::positive_position_count(portfolio) >= target.max_positions {
                 report.diagnostics.push(format!("etf_daily_open_fallback:blocked symbol={} reason=occupied_position_slots", target.symbol));
-                self.deferred_etf_targets.borrow_mut().defer_to_next_session(target, date, &dates);
                 continue;
             }
             let value = target.target_value.to_f64().ok_or_else(|| BacktestError::Execution("etf_daily_open_fallback: target value out of range".into()))?;

crates/fidc-core/src/corporate_book.rs

@@ -15,6 +15,21 @@ pub(crate) fn validate_action<'a>(
             action.symbol, action.date
         )
     })?;
+    if action.ex_reference_price.is_some() {
+        action.required_ex_reference_price()?;
+    }
+    if action.share_cash != 0.0 {
+        action.required_cash_payment_date()?;
+        action.required_record_date()?;
+        if action.share_cash < 0.0 { return Err("corporate_action_negative_cash_dividend".into()); }
+    }
+    if action.share_bonus < 0.0 || action.share_gift < 0.0 {
+        return Err("corporate_action_negative_share_distribution".into());
+    }
+    if action.share_bonus != 0.0 || action.share_gift != 0.0 {
+        action.required_record_date()?;
+        action.required_share_effective_date()?;
+    }
     if let Some((successor, _, _)) = terms {
         for (symbol, role) in [(&*action.symbol, "source"), (successor, "successor")] {
             if data.instrument(symbol).is_none() {
@@ -38,14 +53,38 @@ pub(crate) fn apply(
     cash_dividend_adjusts_cost_basis: bool,
 ) -> Result<BrokerExecutionReport, BacktestError> {
     let actions = data.corporate_actions_on(date);
+    let mut reference_prices = std::collections::BTreeMap::new();
     for action in actions {
         validate_action(action, data).map_err(BacktestError::Execution)?;
+        if let Some(reference) = action.ex_reference_price {
+            if reference_prices.insert(&action.symbol, reference.to_bits())
+                .is_some_and(|previous| previous != reference.to_bits()) {
+                return Err(BacktestError::Execution("corporate_action_conflicting_ex_reference_price".into()));
+            }
+        }
+        if cash_dividends_enabled && action.share_cash != 0.0 {
+            portfolio.registered_quantity(action.required_record_date().map_err(BacktestError::Execution)?, &action.symbol)
+                .map_err(BacktestError::Execution)?;
+        }
+        if action.share_bonus != 0.0 || action.share_gift != 0.0 {
+            portfolio.registered_quantity(action.required_record_date().map_err(BacktestError::Execution)?, &action.symbol)
+                .map_err(BacktestError::Execution)?;
+        }
+        if action.has_successor_conversion() && (
+            action.share_bonus != 0.0 || action.share_gift != 0.0
+            || portfolio.position(&action.symbol).is_some_and(|position| position.share_receivable_quantity() > 0)) {
+            return Err(BacktestError::Execution("corporate_action_pending_share_successor_terms_required".into()));
+        }
     }
     if !actions.iter().any(|action| {
         action.has_effect()
             && portfolio
                 .position(&action.symbol)
-                .is_some_and(|position| position.quantity > 0)
+                .is_some_and(|position| position.economic_quantity() > 0)
+            || (cash_dividends_enabled && action.share_cash != 0.0
+                && portfolio.registered_quantity(action.record_date.expect("validated record date"), &action.symbol).expect("validated closing fact") > 0)
+            || ((action.share_bonus != 0.0 || action.share_gift != 0.0)
+                && portfolio.registered_quantity(action.record_date.expect("validated record date"), &action.symbol).expect("validated closing fact") > 0)
     }) {
         return Ok(BrokerExecutionReport::default());
     }
@@ -80,38 +119,28 @@ fn apply_inner(
         if !action.has_effect() {
             continue;
         }
-        let Some(existing_position) = portfolio.position(&action.symbol) else {
-            continue;
-        };
-        if existing_position.quantity == 0 {
-            continue;
+        if action.share_cash != 0.0 || action.share_bonus != 0.0 || action.share_gift != 0.0 {
+            portfolio.apply_ex_reference_mark(action).map_err(BacktestError::Execution)?;
         }
-
-        if cash_dividends_enabled && action.share_cash.abs() > f64::EPSILON {
+        if cash_dividends_enabled && action.share_cash != 0.0 {
+            let record_date = action.required_record_date().map_err(BacktestError::Execution)?;
+            let entitled_quantity = portfolio.registered_quantity(record_date, &action.symbol).map_err(BacktestError::Execution)?;
             let cash_before = portfolio.cash();
-            let (cash_delta, quantity_after, average_cost) = {
-                let position = portfolio
-                    .position_mut_if_exists(&action.symbol)
-                    .expect("position exists for dividend action");
-                let cash_delta = if cash_dividend_adjusts_cost_basis {
-                    position.apply_cash_dividend(action.share_cash)
-                } else {
-                    position.apply_cash_dividend_preserve_cost_basis(action.share_cash)
-                };
-                (cash_delta, position.quantity, position.average_cost)
-            };
+            let (cash_delta, realized_income) = portfolio.apply_registered_cash_dividend(&action.symbol,
+                record_date, action.share_cash, cash_dividend_adjusts_cost_basis).map_err(BacktestError::Execution)?;
+            let (quantity_after, average_cost) = portfolio.position(&action.symbol).map_or((0,0.0), |p| (p.quantity,p.average_cost));
             if cash_delta.abs() > f64::EPSILON {
-                let payable_date = action.payable_date.unwrap_or(date);
+                let payable_date = action.required_cash_payment_date().map_err(BacktestError::Execution)?;
                 portfolio.add_cash_receivable(CashReceivable {
                     symbol: action.symbol.clone(),
                     ex_date: date,
                     payable_date,
                     amount: cash_delta,
-                    reason: format!("cash_dividend {:.6}", action.share_cash),
+                    reason: format!("cash_dividend {:.6} record_date={} entitled_quantity={}", action.share_cash, record_date, entitled_quantity),
                 });
                 let note = format!(
-                    "cash_dividend_receivable {} share_cash={:.6} quantity={} payable_date={} cash={:.2}",
-                    action.symbol, action.share_cash, quantity_after, payable_date, cash_delta
+                    "cash_dividend_receivable {} share_cash={:.6} record_date={} entitled_quantity={} quantity={} payable_date={} cash={:.2}",
+                    action.symbol, action.share_cash, record_date, entitled_quantity, quantity_after, payable_date, cash_delta
                 );
                 notes.push(note.clone());
                 report.account_events.push(AccountEvent {
@@ -127,52 +156,23 @@ fn apply_inner(
                     delta_quantity: 0,
                     quantity_after,
                     average_cost,
-                    realized_pnl_delta: 0.0,
+                    realized_pnl_delta: realized_income,
                     reason: format!("cash_dividend {:.6}", action.share_cash),
                 });
             }
         }
 
-        let split_ratio = action.split_ratio();
-        if (split_ratio - 1.0).abs() > f64::EPSILON {
-            checked_quantity(
-                &action.symbol,
-                date,
-                portfolio
-                    .position(&action.symbol)
-                    .expect("position exists for split")
-                    .quantity,
-                split_ratio,
-                0,
-            )?;
-            portfolio
-                .adjust_stock_pool_split(&action.symbol, split_ratio)
-                .map_err(BacktestError::Execution)?;
-            let (delta_quantity, quantity_after, average_cost) = {
-                let position = portfolio
-                    .position_mut_if_exists(&action.symbol)
-                    .expect("position exists for split action");
-                let delta_quantity = position.apply_split_ratio(split_ratio);
-                (delta_quantity, position.quantity, position.average_cost)
-            };
-            if delta_quantity != 0 {
-                let note = format!(
-                    "stock_split {} ratio={:.6} delta_qty={}",
-                    action.symbol, split_ratio, delta_quantity
-                );
-                notes.push(note);
-                report.position_events.push(PositionEvent {
-                    date,
-                    symbol: action.symbol.clone(),
-                    delta_quantity,
-                    quantity_after,
-                    average_cost,
-                    realized_pnl_delta: 0.0,
-                    reason: format!("stock_split {:.6}", split_ratio),
-                });
+        if action.share_bonus != 0.0 || action.share_gift != 0.0 {
+            let record = action.required_record_date().map_err(BacktestError::Execution)?;
+            let quantity = portfolio.register_share_entitlement(action).map_err(BacktestError::Execution)?;
+            if quantity > 0 {
+                notes.push(format!("share_distribution_receivable {} record_date={} ex_date={} effective_date={} entitled_shares={quantity}",
+                    action.symbol, record, action.date, action.required_share_effective_date().map_err(BacktestError::Execution)?));
             }
         }
 
+        if !portfolio.position(&action.symbol).is_some_and(|position| position.quantity > 0) { continue; }
+
         if let Some((successor_symbol, ratio, cash_per_share)) = action
             .validated_successor_terms()
             .map_err(BacktestError::Execution)?
@@ -240,6 +240,20 @@ fn apply_inner(
     Ok(report)
 }
 
+pub(crate) fn settle_shares(date: NaiveDate, portfolio: &mut PortfolioState, notes: &mut Vec<String>)
+    -> Result<BrokerExecutionReport, BacktestError> {
+    let delivered = portfolio.deliver_share_receivables(date).map_err(BacktestError::Execution)?;
+    let mut report = BrokerExecutionReport::default();
+    for (symbol, quantity, quantity_after, average_cost) in delivered {
+        let delta_quantity = i32::try_from(quantity).map_err(|_| BacktestError::Execution("delivered share report quantity overflow".into()))?;
+        let reason = "registered_share_distribution_delivered".to_string();
+        notes.push(format!("share_receivable_delivered {symbol} date={date} quantity={quantity}"));
+        report.position_events.push(PositionEvent { date, symbol, delta_quantity, quantity_after,
+            average_cost, realized_pnl_delta: 0.0, reason });
+    }
+    Ok(report)
+}
+
 fn checked_quantity(
     symbol: &str,
     date: NaiveDate,
@@ -679,6 +693,10 @@ mod tests {
             date: date(),
             symbol: "000001.SZ".into(),
             payable_date: None,
+            record_date: date().pred_opt(),
+            share_effective_date: None,
+            share_rounding_rule: None,
+            ex_reference_price: None,
             share_cash: 0.,
             share_bonus: 0.,
             share_gift: 0.,
@@ -725,14 +743,408 @@ mod tests {
         let mut book = PortfolioState::new(1000.);
         book.position_mut("000001.SZ")
             .buy(date().pred_opt().unwrap(), 100, 10.);
+        book.record_closing_holdings(date().pred_opt().unwrap()).unwrap();
         book
     }
 
+    fn dividend(payment: Option<NaiveDate>) -> crate::CorporateAction {
+        let mut action = conversion();
+        action.successor_symbol = None;
+        action.successor_ratio = None;
+        action.successor_cash = None;
+        action.share_cash = 0.5;
+        action.ex_reference_price = Some(9.5);
+        action.payable_date = payment;
+        action
+    }
+
+    fn shares(delivery: Option<NaiveDate>) -> crate::CorporateAction {
+        let mut action = conversion();
+        action.successor_symbol = None;
+        action.successor_ratio = None;
+        action.successor_cash = None;
+        action.share_bonus = 0.5;
+        action.ex_reference_price = Some(10.0 / 1.5);
+        action.share_effective_date = delivery;
+        action
+    }
+
+    #[test]
+    fn differential_cash_entitlement_and_reference_price_remain_distinct() {
+        let mut action = dividend(Some(date().succ_opt().unwrap()));
+        // Gross cash and the diluted reference deduction differ. The prior
+        // 20.00 close is a synthetic fixture, not an issuer market observation.
+        action.share_cash = 5.028;
+        action.ex_reference_price = Some(20.0 - 5.0147304);
+        let input = conversion_data(vec![action], false);
+        let mut book = PortfolioState::new(1000.0);
+        book.position_mut("000001.SZ").buy(date().pred_opt().unwrap(), 100, 20.0);
+        book.record_closing_holdings(date().pred_opt().unwrap()).unwrap();
+        book.begin_trading_day_at(date());
+        apply(date(), &input, &mut book, &mut Vec::new(), true, true).unwrap();
+        let position = book.position("000001.SZ").unwrap();
+        assert!((position.last_price - 14.9852696).abs() < 1e-10);
+        assert!((position.average_cost - 14.972).abs() < 1e-10);
+        assert_eq!(book.cash(), 1000.0);
+        assert!((book.cash_receivables()[0].amount - 502.8).abs() < 1e-8);
+        assert!((book.total_equity() - 3001.32696).abs() < 1e-7);
+        assert!((book.daily_pnl() - 1.32696).abs() < 1e-7);
+    }
+
+    #[test]
+    fn same_day_actual_quote_is_not_reduced_by_an_older_lots_entitlement() {
+        let mut action = dividend(Some(date().succ_opt().unwrap()));
+        action.ex_reference_price = None;
+        let input = conversion_data(vec![action], false);
+        let mut book = conversion_book();
+        book.begin_trading_day_at(date());
+        book.position_mut("000001.SZ").buy(date(), 100, 8.8);
+        apply(date(), &input, &mut book, &mut Vec::new(), true, true).unwrap();
+        let position = book.position("000001.SZ").unwrap();
+        assert_eq!(position.last_price, 8.8);
+        assert_eq!(position.quantity, 200);
+        assert_eq!(book.cash_receivables()[0].amount, 50.0);
+    }
+
+    #[test]
+    fn missing_or_invalid_reference_cannot_guess_a_price_or_partly_change_the_ledger() {
+        for reference in [None, Some(0.0), Some(-1.0), Some(f64::NAN), Some(f64::INFINITY)] {
+            let mut action = dividend(Some(date()));
+            action.ex_reference_price = reference;
+            let input = conversion_data(vec![action], false);
+            let mut book = conversion_book();
+            let before = book.financial_replay_identity();
+            let mut notes = vec!["original".to_owned()];
+            assert!(apply(date(), &input, &mut book, &mut notes, true, true).is_err());
+            assert_eq!(book.financial_replay_identity(), before);
+            assert_eq!(notes, ["original"]);
+        }
+    }
+
+    #[test]
+    fn combined_cash_and_later_share_delivery_apply_the_reference_once() {
+        let mut action = shares(Some(date().succ_opt().unwrap()));
+        action.share_cash = 0.5;
+        action.payable_date = Some(date().succ_opt().unwrap());
+        action.ex_reference_price = Some(9.5 / 1.5);
+        let input = conversion_data(vec![action], false);
+        let mut book = conversion_book();
+        book.begin_trading_day_at(date());
+        apply(date(), &input, &mut book, &mut Vec::new(), true, true).unwrap();
+        let position = book.position("000001.SZ").unwrap();
+        assert!((position.last_price - 9.5 / 1.5).abs() < 1e-10);
+        assert_eq!(position.economic_quantity(), 150);
+        assert_eq!(position.sellable_qty(date()), 100);
+        assert_eq!(book.cash_receivables()[0].amount, 50.0);
+        assert!((book.total_equity() - 2000.0).abs() < 1e-8);
+        assert!(book.daily_pnl().abs() < 1e-8);
+    }
+
+    #[test]
+    fn conflicting_same_day_reference_prices_cannot_be_selected_by_row_order() {
+        let first = dividend(Some(date()));
+        let mut second = first.clone();
+        second.share_cash = 0.25;
+        second.ex_reference_price = Some(9.25);
+        for actions in [vec![first.clone(), second.clone()], vec![second, first]] {
+            let input = conversion_data(actions, false);
+            let mut book = conversion_book();
+            let before = book.financial_replay_identity();
+            let mut notes = vec!["original".into()];
+            let error = apply(date(), &input, &mut book, &mut notes, true, true).unwrap_err();
+            assert!(error.to_string().contains("conflicting_ex_reference_price"));
+            assert_eq!(book.financial_replay_identity(), before);
+            assert_eq!(notes, ["original"]);
+        }
+    }
+
+    #[test]
+    fn registered_shares_are_valued_but_not_delivered_or_sellable_before_the_original_date() {
+        let delivery = date().succ_opt().unwrap().succ_opt().unwrap();
+        let input = conversion_data(vec![shares(Some(delivery))], false);
+        let mut account = conversion_book();
+        account.begin_trading_day();
+        let before = account.total_equity();
+        apply(date(), &input, &mut account, &mut Vec::new(), true, true).unwrap();
+        let p = account.position("000001.SZ").unwrap();
+        assert_eq!(p.quantity, 100);
+        assert_eq!(p.economic_quantity(), 150);
+        assert_eq!(p.share_receivable_quantity(), 50);
+        assert_eq!(p.sellable_qty(date()), 100);
+        let mut attempted = account.clone();
+        assert!(attempted.position_mut("000001.SZ").sell(150, 10. / 1.5).is_err());
+        assert_eq!(attempted.position("000001.SZ").unwrap().quantity, 100);
+        assert_eq!(attempted.position("000001.SZ").unwrap().share_receivable_quantity(), 50);
+        assert!((account.total_equity() - before).abs() < 1e-8);
+        assert!(account.daily_pnl().abs() < 1e-8);
+        settle_shares(date().succ_opt().unwrap(), &mut account, &mut Vec::new()).unwrap();
+        assert_eq!(account.position("000001.SZ").unwrap().quantity, 100);
+        let result = settle_shares(delivery, &mut account, &mut Vec::new()).unwrap();
+        let p = account.position("000001.SZ").unwrap();
+        assert_eq!(p.quantity, 150);
+        assert_eq!(p.share_receivable_quantity(), 0);
+        assert_eq!(p.sellable_qty(delivery), 150);
+        assert_eq!(result.position_events[0].delta_quantity, 50);
+        assert!((account.total_equity() - before).abs() < 1e-8);
+        assert!(settle_shares(delivery, &mut account, &mut Vec::new()).unwrap().position_events.is_empty());
+    }
+
+    #[test]
+    fn post_record_purchase_does_not_inherit_registered_shares() {
+        let input = conversion_data(vec![shares(Some(date()))], false);
+        let mut account = conversion_book();
+        account.begin_trading_day();
+        account.position_mut("000001.SZ").buy(date(), 100, 10.);
+        apply(date(), &input, &mut account, &mut Vec::new(), true, true).unwrap();
+        assert_eq!(account.position("000001.SZ").unwrap().share_receivable_quantity(), 50);
+        settle_shares(date(), &mut account, &mut Vec::new()).unwrap();
+        assert_eq!(account.position("000001.SZ").unwrap().quantity, 250);
+        let mut new_holder = PortfolioState::new(1000.);
+        new_holder.record_closing_holdings(date().pred_opt().unwrap()).unwrap();
+        new_holder.position_mut("000001.SZ").buy(date(), 100, 10.);
+        apply(date(), &input, &mut new_holder, &mut Vec::new(), true, true).unwrap();
+        assert_eq!(new_holder.position("000001.SZ").unwrap().share_receivable_quantity(), 0);
+    }
+
+    #[test]
+    fn unresolved_delisting_cannot_zero_a_pending_share_asset() {
+        let input = conversion_data(vec![shares(Some(date().succ_opt().unwrap()))], false);
+        let mut account = conversion_book();
+        account.begin_trading_day();
+        apply(date(), &input, &mut account, &mut Vec::new(), true, true).unwrap();
+        let mut instruments = input.instruments().values().cloned().collect::<Vec<_>>();
+        instruments[0].delisted_at = Some(date());
+        let delisted = DataSet::from_components(instruments, vec![], vec![], vec![], vec![
+            crate::BenchmarkSnapshot { date: date(), benchmark: "000300.SH".into(),
+                open: 100.0, close: 100.0, prev_close: 100.0, volume: 0 },
+        ]).unwrap();
+        let before = account.financial_replay_identity();
+        let equity_before = account.total_equity();
+        let error = account.update_prices(date(), &delisted, crate::PriceField::Close).unwrap_err();
+        assert!(error.to_string().contains("pending_share_delisting_terms"));
+        assert_eq!(account.financial_replay_identity(), before);
+        assert_eq!(account.total_equity(), equity_before);
+        assert_eq!(account.position("000001.SZ").unwrap().share_receivable_quantity(), 50);
+    }
+
+    #[test]
+    fn invalid_delivery_negative_rates_and_unresolved_fractional_claims_are_atomic() {
+        for action in [shares(None), shares(date().pred_opt()), {
+            let mut action = shares(Some(date())); action.share_bonus = -0.5; action
+        }, {
+            let mut action = shares(Some(date())); action.share_bonus = 0.005; action
+        }] {
+            let input = conversion_data(vec![action], false);
+            let mut account = conversion_book();
+            let before = account.financial_replay_identity();
+            let mut notes = vec!["original".into()];
+            assert!(apply(date(), &input, &mut account, &mut notes, true, true).is_err());
+            assert_eq!(before, account.financial_replay_identity());
+            assert_eq!(notes, ["original"]);
+        }
+    }
+
+    #[test]
+    fn successor_conversion_cannot_discard_unresolved_share_entitlements() {
+        for already_pending in [false, true] {
+            let mut account = conversion_book();
+            let action = if already_pending {
+                let input = conversion_data(vec![shares(Some(date().succ_opt().unwrap()))], false);
+                apply(date(), &input, &mut account, &mut Vec::new(), true, true).unwrap();
+                conversion()
+            } else {
+                let mut action = conversion();
+                action.share_bonus = 0.5;
+                action.share_effective_date = Some(date().succ_opt().unwrap());
+                action
+            };
+            let input = conversion_data(vec![action], true);
+            let before = account.financial_replay_identity();
+            let mut notes = vec!["original".into()];
+            let error = apply(date(), &input, &mut account, &mut notes, true, true).unwrap_err();
+            assert!(error.to_string().contains("pending_share_successor_terms_required"));
+            assert_eq!(account.financial_replay_identity(), before);
+            assert_eq!(notes, ["original"]);
+        }
+    }
+
+    #[test]
+    fn missing_or_backward_cash_payment_date_never_updates_the_account() {
+        for payment in [None, date().pred_opt()] {
+            let data = conversion_data(vec![dividend(payment)], false);
+            assert!(data.get_dividend("000001.SZ", date(), date()).is_err());
+            let mut book = conversion_book();
+            let before = book.financial_replay_identity();
+            let mut notes = vec!["prior".to_string()];
+            for cash_enabled in [true, false] {
+                let error = apply(date(), &data, &mut book, &mut notes, cash_enabled, true).unwrap_err();
+                assert!(error.to_string().contains("cash_payment_date"));
+                assert_eq!(book.financial_replay_identity(), before);
+                assert_eq!(notes, ["prior"]);
+            }
+        }
+    }
+
+    #[test]
+    fn tiny_known_cash_rate_is_preserved_and_cannot_waive_payment_or_record_evidence() {
+        let rate = 1e-16;
+        for payment in [None, Some(date())] {
+            let mut action = dividend(payment);
+            action.share_cash = rate;
+            assert!(action.has_effect());
+            let data = conversion_data(vec![action], false);
+            if payment.is_none() {
+                assert!(data.get_dividend("000001.SZ", date(), date()).is_err());
+                let mut book = conversion_book();
+                let before = book.financial_replay_identity();
+                assert!(apply(date(), &data, &mut book, &mut Vec::new(), true, true).is_err());
+                assert_eq!(book.financial_replay_identity(), before);
+            } else {
+                let observed = data.get_dividend("000001.SZ", date(), date()).unwrap();
+                assert_eq!(observed.len(), 1);
+                assert_eq!(observed[0].dividend_cash_before_tax, rate);
+            }
+        }
+    }
+
+    #[test]
+    fn explicitly_delayed_dividend_remains_receivable_until_actual_payment() {
+        let payment = date().succ_opt().unwrap().succ_opt().unwrap();
+        let data = conversion_data(vec![dividend(Some(payment))], false);
+        let records = data.get_dividend("000001.SZ", date(), date()).unwrap();
+        assert_eq!(records[0].payable_date, payment);
+        let mut book = conversion_book();
+        let mut notes = Vec::new();
+        let equity_before = book.total_equity();
+        apply(date(), &data, &mut book, &mut notes, true, true).unwrap();
+        assert_eq!(book.cash(), 1000.);
+        assert_eq!(book.cash_receivables().len(), 1);
+        assert_eq!(book.cash_receivables()[0].amount, 50.);
+        assert_eq!(book.cash_receivable_value(), 50.);
+        assert_eq!(book.total_equity(), equity_before);
+        assert_eq!(book.unit_net_value(), equity_before / book.units());
+        settle_receivables(date().succ_opt().unwrap(), &data, &mut book, &mut notes, false, None).unwrap();
+        assert_eq!(book.cash(), 1000.);
+        assert_eq!(book.cash_receivables().len(), 1);
+        assert_eq!(book.total_equity(), equity_before);
+        settle_receivables(payment, &data, &mut book, &mut notes, false, None).unwrap();
+        assert_eq!(book.cash(), 1050.);
+        assert!(book.cash_receivables().is_empty());
+        assert_eq!(book.cash_receivable_value(), 0.);
+        assert_eq!(book.total_equity(), equity_before);
+    }
+
+    #[test]
+    fn dividend_receivable_survives_a_flat_position_without_becoming_spendable_cash() {
+        let mut account = PortfolioState::new(1000.);
+        account.add_cash_receivable(CashReceivable { symbol: "000001.SZ".into(),
+            ex_date: date(), payable_date: date().succ_opt().unwrap(), amount: 50., reason: "registered dividend".into() });
+        account.prune_flat_positions();
+        assert_eq!(account.market_value(), 0.);
+        assert_eq!(account.cash(), 1000.);
+        assert_eq!(account.total_equity(), 1050.);
+        assert!(account.deposit_withdraw(-1001.).is_err());
+        settle_receivables(date().succ_opt().unwrap(), &data(false), &mut account, &mut Vec::new(), false, None).unwrap();
+        assert_eq!(account.cash(), 1050.);
+        assert_eq!(account.total_equity(), 1050.);
+    }
+
+    #[test]
+    fn missing_record_date_or_unobserved_closing_book_is_atomic() {
+        for missing_date in [true, false] {
+            let mut action = dividend(Some(date()));
+            if missing_date { action.record_date = None; }
+            let data = conversion_data(vec![action], false);
+            let mut book = PortfolioState::new(1000.);
+            book.position_mut("000001.SZ").buy(date().pred_opt().unwrap(), 100, 10.);
+            let before = book.financial_replay_identity();
+            let mut notes = vec!["prior".into()];
+            let error = apply(date(), &data, &mut book, &mut notes, true, true).unwrap_err();
+            assert!(error.to_string().contains(if missing_date { "record_date_missing" } else { "record_holdings_missing" }));
+            assert_eq!(before, book.financial_replay_identity());
+            assert_eq!(notes, ["prior"]);
+        }
+    }
+
+    #[test]
+    fn post_record_buy_cannot_receive_the_earlier_dividend() {
+        let mut book = PortfolioState::new(1000.);
+        book.record_closing_holdings(date().pred_opt().unwrap()).unwrap();
+        book.position_mut("000001.SZ").buy(date(), 100, 10.);
+        let before = book.financial_replay_identity();
+        let data = conversion_data(vec![dividend(Some(date()))], false);
+        apply(date(), &data, &mut book, &mut Vec::new(), true, true).unwrap();
+        assert!(book.cash_receivables().is_empty());
+        assert_eq!(before, book.financial_replay_identity());
+    }
+
+    #[test]
+    fn sale_after_registration_preserves_cash_and_excludes_new_lots_from_cost_adjustment() {
+        let mut book = conversion_book();
+        book.position_mut("000001.SZ").buy(date(), 100, 10.);
+        book.position_mut("000001.SZ").sell(50, 10.).unwrap();
+        let data = conversion_data(vec![dividend(Some(date()))], false);
+        let report = apply(date(), &data, &mut book, &mut Vec::new(), true, true).unwrap();
+        assert_eq!(book.cash_receivables()[0].amount, 50.);
+        let position = book.position("000001.SZ").unwrap();
+        assert_eq!(position.quantity, 150);
+        assert!((position.average_cost - (10. - 25./150.)).abs() < 1e-10);
+        assert_eq!(report.position_events[0].realized_pnl_delta, 25.);
+    }
+
+    #[test]
+    fn entitlement_survives_complete_sale_and_a_successor_unit_conversion() {
+        let data = conversion_data(vec![dividend(Some(date()))], true);
+        let mut sold = conversion_book();
+        sold.position_mut("000001.SZ").sell(100, 10.).unwrap();
+        sold.prune_flat_positions();
+        apply(date(), &data, &mut sold, &mut Vec::new(), true, true).unwrap();
+        assert_eq!(sold.cash_receivables()[0].amount, 50.);
+        assert!(sold.position("000001.SZ").is_none());
+        let mut converted = conversion_book();
+        converted.apply_successor_conversion("000001.SZ", "000002.SZ", 2., 0.).unwrap();
+        apply(date(), &data, &mut converted, &mut Vec::new(), true, true).unwrap();
+        assert_eq!(converted.cash_receivables()[0].amount, 50.);
+        assert!((converted.position("000002.SZ").unwrap().average_cost - 4.75).abs() < 1e-10);
+    }
+
+    #[test]
+    fn closing_register_cannot_be_replaced_by_later_holdings() {
+        let mut book = conversion_book();
+        book.position_mut("000001.SZ").buy(date(), 100, 10.);
+        assert!(book.record_closing_holdings(date().pred_opt().unwrap()).is_err());
+    }
+
+    #[test]
+    fn flat_position_retirement_does_not_change_issued_lot_state_or_next_purchase_origin() {
+        let mut kept = conversion_book();
+        kept.position_mut("000001.SZ").sell(100, 10.).unwrap();
+        let mut retired = kept.clone();
+        retired.prune_flat_positions();
+        assert_eq!(kept.financial_replay_identity(), retired.financial_replay_identity());
+        for book in [&mut kept, &mut retired] { book.position_mut("000001.SZ").buy(date(), 100, 10.); }
+        assert_eq!(kept.financial_replay_identity(), retired.financial_replay_identity());
+    }
+
+    #[test]
+    fn per_share_precision_is_retained_until_the_registered_cash_amount_is_rounded() {
+        let mut book = PortfolioState::new(1000.);
+        book.position_mut("000001.SZ").buy(date().pred_opt().unwrap(), 10000, 10.);
+        book.record_closing_holdings(date().pred_opt().unwrap()).unwrap();
+        let mut action = dividend(Some(date()));
+        action.share_cash = 0.0176387;
+        let data = conversion_data(vec![action], false);
+        apply(date(), &data, &mut book, &mut Vec::new(), true, true).unwrap();
+        assert!((book.cash_receivables()[0].amount - 176.387).abs() < 1e-10);
+    }
+
     #[test]
     fn successor_without_frozen_instrument_metadata_is_not_an_implicit_new_security() {
         let mut action = conversion();
         action.share_cash = 1.;
+        action.payable_date = Some(date());
         action.share_bonus = 1.;
+        action.share_effective_date = Some(date());
         let data = conversion_data(vec![action], false);
         let mut book = conversion_book();
         let before = book.financial_replay_identity();
@@ -795,7 +1207,9 @@ mod tests {
         dividend.successor_ratio = None;
         dividend.successor_cash = None;
         dividend.share_cash = 1.;
+        dividend.payable_date = Some(date());
         dividend.share_bonus = 1.;
+        dividend.share_effective_date = Some(date());
         let mut failure = conversion();
         failure.successor_cash = Some(1e100);
         let data = conversion_data(vec![dividend, failure], true);
@@ -829,6 +1243,11 @@ mod tests {
             let mut action = conversion();
             if split {
                 action.share_bonus = 1e100;
+                action.ex_reference_price = Some(1.0); // Satisfy the independent synthetic reference prerequisite.
+                action.share_effective_date = Some(date());
+                action.successor_symbol = None;
+                action.successor_ratio = None;
+                action.successor_cash = None;
             } else {
                 action.successor_ratio = Some(1e100);
             }

crates/fidc-core/src/data.rs

@@ -11,6 +11,7 @@ use serde::{Deserialize, Serialize};
 use thiserror::Error;
 
 use crate::calendar::TradingCalendar;
+use crate::engine::BacktestError;
 use crate::futures::FuturesTradingParameter;
 use crate::instrument::Instrument;
 use crate::risk_control::{ChinaAShareRiskControl, FidcRiskControlConfig};
@@ -267,6 +268,16 @@ pub struct CorporateAction {
     pub symbol: String,
     #[serde(default, with = "optional_date_format")]
     pub payable_date: Option<NaiveDate>,
+    #[serde(default, with = "optional_date_format")]
+    pub record_date: Option<NaiveDate>,
+    #[serde(default, with = "optional_date_format")]
+    pub share_effective_date: Option<NaiveDate>,
+    #[serde(default)]
+    pub share_rounding_rule: Option<String>,
+    /// Source-verified ex-date reference price, distinct from the shareholder's
+    /// cash entitlement. Missing evidence must never be derived from share_cash.
+    #[serde(default)]
+    pub ex_reference_price: Option<f64>,
     pub share_cash: f64,
     pub share_bonus: f64,
     pub share_gift: f64,
@@ -443,13 +454,45 @@ impl<'a> Iterator for ExecutionQuoteIterator<'a> {
 }
 
 impl CorporateAction {
+    pub(crate) fn required_ex_reference_price(&self) -> Result<f64, String> {
+        self.ex_reference_price.filter(|price| price.is_finite() && *price > 0.0)
+            .ok_or_else(|| format!("corporate_action_ex_reference_price_unverified: symbol={} ex_date={}",
+                self.symbol, self.date))
+    }
+
+    pub(crate) fn required_record_date(&self) -> Result<NaiveDate, String> {
+        let record = self.record_date.ok_or_else(|| format!(
+            "corporate_action_record_date_missing: symbol={} ex_date={}", self.symbol, self.date))?;
+        if record >= self.date { return Err(format!(
+            "corporate_action_record_date_not_before_ex_date: symbol={} record_date={record} ex_date={}", self.symbol, self.date)); }
+        Ok(record)
+    }
+    pub(crate) fn required_cash_payment_date(&self) -> Result<NaiveDate, String> {
+        let payable = self.payable_date.ok_or_else(|| format!(
+            "corporate_action_cash_payment_date_missing: symbol={} ex_date={}", self.symbol, self.date))?;
+        if payable < self.date {
+            return Err(format!("corporate_action_cash_payment_date_precedes_ex_date: symbol={} ex_date={} payable_date={payable}",
+                self.symbol, self.date));
+        }
+        Ok(payable)
+    }
+
+    pub(crate) fn required_share_effective_date(&self) -> Result<NaiveDate, String> {
+        let effective = self.share_effective_date.ok_or_else(|| format!(
+            "corporate_action_share_effective_date_missing: symbol={} ex_date={}", self.symbol, self.date))?;
+        if effective < self.date {
+            return Err(format!("corporate_action_share_effective_date_precedes_ex_date: symbol={} ex_date={} effective_date={effective}", self.symbol, self.date));
+        }
+        Ok(effective)
+    }
+
     pub fn split_ratio(&self) -> f64 {
         1.0 + self.share_bonus.max(0.0) + self.share_gift.max(0.0)
     }
 
     pub fn has_effect(&self) -> bool {
-        self.share_cash.abs() > f64::EPSILON
-            || (self.split_ratio() - 1.0).abs() > f64::EPSILON
+        self.share_cash != 0.0
+            || self.share_bonus != 0.0 || self.share_gift != 0.0
             || self.issue_quantity.abs() > f64::EPSILON
             || self.reform
             || self.has_successor_conversion()
@@ -541,6 +584,8 @@ pub struct DividendRecord {
     pub ex_dividend_date: NaiveDate,
     #[serde(with = "date_format")]
     pub payable_date: NaiveDate,
+    #[serde(with = "date_format")]
+    pub record_date: NaiveDate,
     pub symbol: String,
     pub dividend_cash_before_tax: f64,
     pub round_lot: u32,
@@ -1425,6 +1470,7 @@ pub struct DataSet {
     factor_by_date: Arc<BTreeMap<NaiveDate, Vec<DailyFactorSnapshot>>>,
     factor_symbol_ids_by_date: Arc<BTreeMap<NaiveDate, Vec<u32>>>,
     factor_row_positions_by_date: Arc<Option<DenseRowPositionIndex>>,
+    decision_projection: Option<DecisionFactorProjection>,
     factor_market_cap_order_by_date: Arc<BTreeMap<NaiveDate, Vec<u32>>>,
     factor_text_by_date: Arc<BTreeMap<NaiveDate, Vec<FactorTextValue>>>,
     factor_text_index: Arc<HashMap<(NaiveDate, String, String), FactorTextValue>>,
@@ -1451,6 +1497,13 @@ pub struct DataSet {
     completed_minute_bars: Arc<BTreeMap<(NaiveDate,String),Vec<crate::session_events::MinuteBar>>>,
 }
 
+#[derive(Debug, Clone)]
+struct DecisionFactorProjection {
+    date: NaiveDate,
+    rows: Vec<DailyFactorSnapshot>,
+    symbol_ids: Vec<u32>,
+}
+
 struct DailySymbolRows<'a, T> {
     rows: &'a [T],
     symbol_ids: &'a [u32],
@@ -1928,6 +1981,7 @@ impl DataSet {
             factor_by_date: Arc::new(factor_by_date),
             factor_symbol_ids_by_date: Arc::new(factor_symbol_ids_by_date),
             factor_row_positions_by_date: Arc::new(factor_row_positions_by_date),
+            decision_projection: None,
             factor_market_cap_order_by_date: Arc::new(factor_market_cap_order_by_date),
             factor_text_by_date: Arc::new(factor_text_by_date),
             factor_text_index: Arc::new(factor_text_index),
@@ -2058,6 +2112,7 @@ impl DataSet {
             }
         }
 
+        let projected_factors = self.decision_projection.as_ref().filter(|item| item.date == date);
         DailySnapshotView {
             market: rows_on(
                 date,
@@ -2065,12 +2120,12 @@ impl DataSet {
                 &self.market_symbol_ids_by_date,
                 &self.market_row_positions_by_date,
             ),
-            factors: rows_on(
-                date,
-                &self.factor_by_date,
-                &self.factor_symbol_ids_by_date,
+            factors: projected_factors.map(|item| DailySymbolRows {
+                rows: &item.rows, symbol_ids: &item.symbol_ids, row_positions: None,
+            }).unwrap_or_else(|| rows_on(
+                date, &self.factor_by_date, &self.factor_symbol_ids_by_date,
                 &self.factor_row_positions_by_date,
-            ),
+            )),
             candidates: rows_on(
                 date,
                 &self.candidate_by_date,
@@ -2170,6 +2225,11 @@ impl DataSet {
         date: NaiveDate,
         symbol_id: u32,
     ) -> Option<&DailyFactorSnapshot> {
+        if let Some(item) = self.decision_projection.as_ref().filter(|item| item.date == date)
+            && let Some(row) = find_by_symbol_id(&item.rows, &item.symbol_ids, symbol_id)
+        {
+            return Some(row);
+        }
         let rows = self.factor_by_date.get(&date)?;
         if let Some(index) = dense_row_position(&self.factor_row_positions_by_date, date, symbol_id)
         {
@@ -2178,6 +2238,45 @@ impl DataSet {
         find_by_symbol_id(rows, self.factor_symbol_ids_by_date.get(&date)?, symbol_id)
     }
 
+    pub(crate) fn clear_decision_projection(&mut self) {
+        self.decision_projection = None;
+    }
+
+    pub(crate) fn require_unmaterialized_projection_fields(
+        &self, fields: &BTreeSet<String>,
+    ) -> Result<(), crate::engine::BacktestError> {
+        if self.factor_by_date.values().flatten().any(|row|
+            fields.iter().any(|field| factor_numeric_value(row, field).is_some()))
+        {
+            return Err(crate::engine::BacktestError::Execution(
+                "decision projection fields already exist in static inputs; historical score replay is forbidden".into(),
+            ));
+        }
+        Ok(())
+    }
+
+    pub(crate) fn install_decision_projection(
+        &mut self, date: NaiveDate, projections: &[crate::decision_projection::DecisionProjectionRow],
+    ) -> Result<(), crate::engine::BacktestError> {
+        let mut rows = Vec::with_capacity(projections.len());
+        for projection in projections {
+            let symbol_id = self.symbol_id(&projection.symbol).ok_or_else(||
+                crate::engine::BacktestError::Execution("projection symbol has no frozen base instrument".into()))?;
+            let mut row = self.factor_by_symbol_id(date, symbol_id).cloned().ok_or_else(||
+                crate::engine::BacktestError::Execution("projection symbol has no same-date raw factor observation".into()))?;
+            for (field, value) in &projection.values {
+                row.extra_factors.insert(Cow::Owned(field.clone()), *value);
+            }
+            rows.push((symbol_id, row));
+        }
+        rows.sort_unstable_by_key(|(symbol_id, _)| *symbol_id);
+        let (symbol_ids, rows) = rows.into_iter().unzip();
+        // Only the current selection view is projected. Economic observations,
+        // history, and other backtest clones keep the shared immutable base.
+        self.decision_projection = Some(DecisionFactorProjection { date, rows, symbol_ids });
+        Ok(())
+    }
+
     pub fn candidate(&self, date: NaiveDate, symbol: &str) -> Option<&CandidateEligibility> {
         let symbol_id = self.symbol_id(symbol)?;
         self.candidate_by_symbol_id(date, symbol_id)
@@ -2828,25 +2927,30 @@ impl DataSet {
         symbol: &str,
         start: NaiveDate,
         end: NaiveDate,
-    ) -> Vec<DividendRecord> {
+    ) -> Result<Vec<DividendRecord>, BacktestError> {
         let mut rows = self
             .corporate_actions_by_date
             .range(start..=end)
             .flat_map(|(_, actions)| actions.iter())
-            .filter(|action| action.symbol == symbol && action.share_cash.abs() > f64::EPSILON)
-            .map(|action| DividendRecord {
+            .filter(|action| action.symbol == symbol && action.share_cash != 0.0)
+            .map(|action| {
+                crate::finite_serialization::validate(action).map_err(|error| BacktestError::Execution(format!(
+                    "corporate_action_invalid_number: symbol={} ex_date={} detail={error}", action.symbol, action.date)))?;
+                Ok(DividendRecord {
                 ex_dividend_date: action.date,
-                payable_date: action.payable_date.unwrap_or(action.date),
+                payable_date: action.required_cash_payment_date().map_err(BacktestError::Execution)?,
+                record_date: action.required_record_date().map_err(BacktestError::Execution)?,
                 symbol: action.symbol.clone(),
                 dividend_cash_before_tax: action.share_cash,
                 round_lot: self
                     .instrument(symbol)
                     .map(Instrument::effective_round_lot)
                     .unwrap_or(100),
+                })
             })
-            .collect::<Vec<_>>();
+            .collect::<Result<Vec<_>, BacktestError>>()?;
         rows.sort_by_key(|row| row.ex_dividend_date);
-        rows
+        Ok(rows)
     }
 
     pub fn get_split(&self, symbol: &str, start: NaiveDate, end: NaiveDate) -> Vec<SplitRecord> {
@@ -3334,13 +3438,13 @@ impl DataSet {
     }
 
     pub fn factor_snapshots_on(&self, date: NaiveDate) -> Vec<&DailyFactorSnapshot> {
-        self.factor_by_date
-            .get(&date)
-            .map(|rows| rows.iter().collect())
-            .unwrap_or_default()
+        self.factor_snapshot_rows_on(date).iter().collect()
     }
 
     pub fn factor_snapshot_rows_on(&self, date: NaiveDate) -> &[DailyFactorSnapshot] {
+        if let Some(item) = self.decision_projection.as_ref().filter(|item| item.date == date) {
+            return &item.rows;
+        }
         self.factor_by_date
             .get(&date)
             .map(Vec::as_slice)
@@ -3348,6 +3452,9 @@ impl DataSet {
     }
 
     pub fn factor_symbol_ids_on(&self, date: NaiveDate) -> &[u32] {
+        if let Some(item) = self.decision_projection.as_ref().filter(|item| item.date == date) {
+            return &item.symbol_ids;
+        }
         self.factor_symbol_ids_by_date
             .get(&date)
             .map(Vec::as_slice)
@@ -3411,7 +3518,7 @@ impl DataSet {
             date,
             benchmark,
             market: self.market_by_date.get(&date).cloned().unwrap_or_default(),
-            factors: self.factor_by_date.get(&date).cloned().unwrap_or_default(),
+            factors: self.factor_snapshot_rows_on(date).to_vec(),
             candidates: self
                 .candidate_by_date
                 .get(&date)
@@ -3537,8 +3644,8 @@ impl DataSet {
         }
         let output_field = normalize_field(output_field);
         let mut rows = Vec::new();
-        for (_, snapshots) in self.factor_by_date.range(start..=end) {
-            let Some(snapshot) = snapshots.iter().find(|row| row.symbol == symbol) else {
+        for (date, _) in self.factor_by_date.range(start..=end) {
+            let Some(snapshot) = self.factor(*date, symbol) else {
                 continue;
             };
             for field in fields {
@@ -5450,6 +5557,10 @@ mod tests {
                 date,
                 symbol: symbols[0].to_string(),
                 payable_date: Some(date),
+                record_date: date.pred_opt(),
+                share_effective_date: None,
+                share_rounding_rule: None,
+                ex_reference_price: None,
                 share_cash: 0.1,
                 share_bonus: 0.02,
                 share_gift: 0.03,

crates/fidc-core/src/decision_projection.rs

@@ -0,0 +1,272 @@
+//! Run-local, receipt-bound model projections for a completed decision session.
+
+use std::collections::{BTreeMap, BTreeSet};
+use std::path::{Component, Path};
+
+use chrono::{NaiveDate, NaiveDateTime, NaiveTime};
+use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
+
+use crate::engine::BacktestError;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(deny_unknown_fields)]
+pub struct DecisionProjectionContract {
+    pub contract_sha256: String,
+    pub fields: BTreeSet<String>,
+    pub input_cutoff_time: NaiveTime,
+}
+
+impl DecisionProjectionContract {
+    pub fn validate(&self) -> Result<(), BacktestError> {
+        require_sha256(&self.contract_sha256)?;
+        if self.fields.is_empty() || self.fields.iter().any(|field| !valid_projection_field(field)) {
+            return Err(error("projection fields must be explicit canonical numeric identifiers, not market or typed factors"));
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(deny_unknown_fields)]
+pub struct DecisionProjectionRequest {
+    pub contract_sha256: String,
+    pub decision_date: NaiveDate,
+    pub execution_date: NaiveDate,
+    pub as_of: NaiveDateTime,
+    pub symbols: BTreeSet<String>,
+    pub fields: BTreeSet<String>,
+}
+
+impl DecisionProjectionRequest {
+    pub fn sha256(&self) -> Result<String, BacktestError> {
+        json_sha256(self)
+    }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+pub struct DecisionProjectionRow {
+    pub symbol: String,
+    pub values: BTreeMap<String, f64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(deny_unknown_fields)]
+pub struct DecisionProjectionExclusion {
+    pub symbol: String,
+    pub classification: String,
+    pub reason: String,
+    pub source_sha256: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(deny_unknown_fields)]
+pub struct DecisionProjectionReference {
+    pub path: String,
+    pub sha256: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(deny_unknown_fields)]
+pub struct DecisionProjectionBatch {
+    pub contract_sha256: String,
+    pub decision_date: NaiveDate,
+    pub execution_date: NaiveDate,
+    pub input_available_at: NaiveDateTime,
+    pub rows: Vec<DecisionProjectionRow>,
+    pub exclusions: Vec<DecisionProjectionExclusion>,
+    pub inference_reference: DecisionProjectionReference,
+    pub provider_request_sha256: String,
+    pub provider_response_sha256: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(deny_unknown_fields)]
+pub struct DecisionProjectionReceipt {
+    pub schema_version: String,
+    pub request: DecisionProjectionRequest,
+    pub request_sha256: String,
+    pub input_available_at: NaiveDateTime,
+    pub inference_reference: DecisionProjectionReference,
+    pub provider_request_sha256: String,
+    pub provider_response_sha256: String,
+    pub values_sha256: String,
+    pub row_count: usize,
+    pub excluded_count: usize,
+}
+
+impl DecisionProjectionBatch {
+    pub(crate) fn validate(
+        &self,
+        request: &DecisionProjectionRequest,
+    ) -> Result<DecisionProjectionReceipt, BacktestError> {
+        if self.contract_sha256 != request.contract_sha256
+            || self.decision_date != request.decision_date
+            || self.execution_date != request.execution_date
+            || request.as_of.date() != request.decision_date
+            || request.decision_date >= request.execution_date
+            || self.input_available_at > request.as_of
+        {
+            return Err(error("projection identity or causal availability differs from the decision request"));
+        }
+        require_sha256(&self.inference_reference.sha256)?;
+        require_sha256(&self.provider_request_sha256)?;
+        require_sha256(&self.provider_response_sha256)?;
+        let path = Path::new(&self.inference_reference.path);
+        if !path.is_absolute() || path.components().any(|part| matches!(part, Component::ParentDir)) {
+            return Err(error("projection inference receipt requires an absolute immutable artifact reference"));
+        }
+        if request.symbols.is_empty() || request.fields.is_empty() {
+            return Err(error("projection request population and fields must be explicit"));
+        }
+        let mut covered = BTreeSet::new();
+        for row in &self.rows {
+            if !request.symbols.contains(&row.symbol) || !covered.insert(row.symbol.clone()) {
+                return Err(error("projection returned an unexpected or duplicate symbol"));
+            }
+            if row.values.keys().collect::<BTreeSet<_>>() != request.fields.iter().collect()
+                || row.values.values().any(|value| !value.is_finite())
+            {
+                return Err(error("projection numeric field coverage is incomplete or non-finite"));
+            }
+        }
+        for exclusion in &self.exclusions {
+            if !request.symbols.contains(&exclusion.symbol) || !covered.insert(exclusion.symbol.clone()) {
+                return Err(error("projection exclusion overlaps a value or repeats an unexpected symbol"));
+            }
+            if exclusion.classification != "valid_market_absence" || exclusion.reason.trim().is_empty() {
+                return Err(error("projection missing data is unclassified; no order skip is permitted"));
+            }
+            require_sha256(&exclusion.source_sha256)?;
+        }
+        if covered != request.symbols {
+            return Err(error("projection did not explain every requested symbol"));
+        }
+        // Digest the actual normalized values consumed by this engine, not a
+        // provider's summary flag. Stable ordering preserves same-input replay.
+        let rows = self.rows.iter().map(|row| (&row.symbol, &row.values)).collect::<BTreeMap<_, _>>();
+        let exclusions = self.exclusions.iter().map(|item| (&item.symbol, item)).collect::<BTreeMap<_, _>>();
+        Ok(DecisionProjectionReceipt {
+            schema_version: "fidc.decision-projection-receipt/v1".into(),
+            request: request.clone(),
+            request_sha256: request.sha256()?,
+            input_available_at: self.input_available_at,
+            inference_reference: self.inference_reference.clone(),
+            provider_request_sha256: self.provider_request_sha256.clone(),
+            provider_response_sha256: self.provider_response_sha256.clone(),
+            values_sha256: json_sha256(&(rows, exclusions))?,
+            row_count: self.rows.len(),
+            excluded_count: self.exclusions.len(),
+        })
+    }
+}
+
+fn valid_projection_field(field: &str) -> bool {
+    let mut bytes = field.bytes();
+    let identifier = bytes.next().is_some_and(|c| c.is_ascii_lowercase() || c == b'_')
+        && bytes.all(|c| c.is_ascii_lowercase() || c.is_ascii_digit() || c == b'_');
+    identifier && !matches!(field,
+        "market_cap" | "market_cap_bn" | "free_float_cap" | "free_float_cap_bn"
+        | "pe" | "pe_ttm" | "turnover_ratio" | "effective_turnover_ratio"
+        | "adjustment_factor_backward1" | "open" | "day_open" | "close"
+        | "high" | "low" | "last" | "last_price" | "volume" | "amount"
+        | "prev_close" | "bid1" | "ask1" | "upper_limit" | "lower_limit")
+}
+
+fn require_sha256(value: &str) -> Result<(), BacktestError> {
+    if value.len() != 64 || !value.bytes().all(|c| c.is_ascii_digit() || (b'a'..=b'f').contains(&c)) {
+        return Err(error("projection requires canonical SHA256 identities"));
+    }
+    Ok(())
+}
+
+fn json_sha256(value: &impl Serialize) -> Result<String, BacktestError> {
+    let bytes = serde_json::to_vec(value).map_err(|_| error("projection receipt could not be serialized"))?;
+    Ok(format!("{:x}", Sha256::digest(bytes)))
+}
+
+fn error(message: &str) -> BacktestError {
+    BacktestError::Execution(message.into())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn request() -> DecisionProjectionRequest {
+        let decision_date = NaiveDate::from_ymd_opt(2025, 1, 2).unwrap();
+        DecisionProjectionRequest {
+            contract_sha256: "1".repeat(64), decision_date,
+            execution_date: NaiveDate::from_ymd_opt(2025, 1, 3).unwrap(),
+            as_of: decision_date.and_hms_opt(16, 0, 0).unwrap(),
+            symbols: BTreeSet::from(["000001.SZ".into(), "000002.SZ".into()]),
+            fields: BTreeSet::from(["model_score_a".into()]),
+        }
+    }
+
+    fn batch() -> DecisionProjectionBatch {
+        let request = request();
+        DecisionProjectionBatch {
+            contract_sha256: request.contract_sha256,
+            decision_date: request.decision_date, execution_date: request.execution_date,
+            input_available_at: request.as_of,
+            rows: vec![DecisionProjectionRow { symbol: "000001.SZ".into(), values: BTreeMap::from([("model_score_a".into(), 0.5)]) }],
+            exclusions: vec![DecisionProjectionExclusion { symbol: "000002.SZ".into(), classification: "valid_market_absence".into(), reason: "dated suspension evidence".into(), source_sha256: "2".repeat(64) }],
+            inference_reference: DecisionProjectionReference { path: "/private/inference.json".into(), sha256: "3".repeat(64) },
+            provider_request_sha256: "4".repeat(64), provider_response_sha256: "5".repeat(64),
+        }
+    }
+
+    #[test]
+    fn exact_projection_coverage_and_classified_absence_are_receipted() {
+        let receipt = batch().validate(&request()).unwrap();
+        assert_eq!((receipt.row_count, receipt.excluded_count), (1, 1));
+        assert_eq!(receipt.request_sha256, request().sha256().unwrap());
+        let mut changed = batch(); changed.rows[0].values.insert("model_score_a".into(), 0.6);
+        assert_ne!(changed.validate(&request()).unwrap().values_sha256, receipt.values_sha256);
+    }
+
+    #[test]
+    fn projection_contract_does_not_shadow_core_market_or_typed_fields() {
+        for field in ["", "Score", "model-score", "close", "market_cap_bn", "adjustment_factor_backward1"] {
+            let contract = DecisionProjectionContract { contract_sha256: "1".repeat(64), fields: BTreeSet::from([field.into()]), input_cutoff_time: NaiveTime::from_hms_opt(16, 0, 0).unwrap() };
+            assert!(contract.validate().is_err(), "{field}");
+        }
+    }
+
+    #[test]
+    fn projection_rejects_incomplete_duplicate_extra_and_overlapping_population() {
+        let mut examples = vec![];
+        let mut item = batch(); item.exclusions.clear(); examples.push(item);
+        let mut item = batch(); item.rows.push(item.rows[0].clone()); examples.push(item);
+        let mut item = batch(); item.rows[0].symbol = "999999.SZ".into(); examples.push(item);
+        let mut item = batch(); item.exclusions[0].symbol = item.rows[0].symbol.clone(); examples.push(item);
+        for item in examples { assert!(item.validate(&request()).is_err()); }
+    }
+
+    #[test]
+    fn projection_rejects_nonfinite_wrong_fields_and_unproven_absence() {
+        let mut examples = vec![];
+        for value in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
+            let mut item = batch(); item.rows[0].values.insert("model_score_a".into(), value); examples.push(item);
+        }
+        let mut item = batch(); item.rows[0].values.clear(); examples.push(item);
+        let mut item = batch(); item.rows[0].values.insert("extra".into(), 1.0); examples.push(item);
+        let mut item = batch(); item.exclusions[0].classification = "unknown".into(); examples.push(item);
+        let mut item = batch(); item.exclusions[0].reason.clear(); examples.push(item);
+        let mut item = batch(); item.exclusions[0].source_sha256.clear(); examples.push(item);
+        for item in examples { assert!(item.validate(&request()).is_err()); }
+    }
+
+    #[test]
+    fn projection_rejects_future_drift_or_unbound_receipts() {
+        let mut examples = vec![];
+        let mut item = batch(); item.input_available_at += chrono::Duration::seconds(1); examples.push(item);
+        let mut item = batch(); item.decision_date = item.execution_date; examples.push(item);
+        let mut item = batch(); item.contract_sha256 = "0".repeat(64); examples.push(item);
+        let mut item = batch(); item.inference_reference.path = "/private/../inference.json".into(); examples.push(item);
+        let mut item = batch(); item.provider_response_sha256 = "A".repeat(64); examples.push(item);
+        for item in examples { assert!(item.validate(&request()).is_err()); }
+    }
+}

crates/fidc-core/src/engine.rs

@@ -7,6 +7,10 @@ use thiserror::Error;
 use crate::broker::{BrokerExecutionReport, BrokerSimulator, MatchingType};
 use crate::cost::CostModel;
 use crate::data::{BenchmarkSnapshot, DataSet, DataSetError, IntradayExecutionQuote, PriceField};
+use crate::decision_projection::{
+    DecisionProjectionBatch, DecisionProjectionContract, DecisionProjectionReceipt,
+    DecisionProjectionRequest,
+};
 use crate::event_bus::{BacktestProcessMod, BacktestProcessModLoader, ProcessEventBus};
 use crate::events::{
     AccountEvent, FillEvent, OrderEvent, OrderSide, OrderStatus, PositionEvent, ProcessEvent,
@@ -137,6 +141,7 @@ pub struct BacktestResult {
     pub daily_holdings: Vec<HoldingSummary>,
     pub metrics: BacktestMetrics,
     pub terminal_audit: BacktestTerminalAudit,
+    pub decision_projection_receipts: Vec<DecisionProjectionReceipt>,
 }
 
 #[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
@@ -234,6 +239,12 @@ type ExecutionQuoteLoader = Box<
     dyn FnMut(ExecutionQuoteRequest) -> Result<Vec<IntradayExecutionQuote>, BacktestError> + Send,
 >;
 
+struct DecisionProjectionLoader {
+    contract: DecisionProjectionContract,
+    load: Box<dyn FnMut(DecisionProjectionRequest) -> Result<DecisionProjectionBatch, BacktestError> + Send>,
+    requested_dates: BTreeSet<NaiveDate>,
+}
+
 #[derive(Debug, Clone, Serialize)]
 pub struct AnalyzerTradeRow {
     #[serde(with = "date_format")]
@@ -303,6 +314,8 @@ pub struct AnalyzerReport {
     pub benchmark_series: Vec<BenchmarkSnapshot>,
     pub metrics: BacktestMetrics,
     pub terminal_audit: BacktestTerminalAudit,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub decision_projection_receipts: Vec<DecisionProjectionReceipt>,
 }
 
 impl BacktestResult {
@@ -347,6 +360,7 @@ impl BacktestResult {
             benchmark_series: self.benchmark_series.clone(),
             metrics: self.metrics.clone(),
             terminal_audit: self.terminal_audit.clone(),
+            decision_projection_receipts: self.decision_projection_receipts.clone(),
         }
     }
 
@@ -486,6 +500,7 @@ pub struct BacktestEngine<S, C, R> {
     futures_cost_model: FuturesTransactionCostModel,
     futures_validation_config: FuturesValidationConfig,
     execution_quote_loader: Option<ExecutionQuoteLoader>,
+    decision_projection_loader: Option<DecisionProjectionLoader>,
     execution_quote_request_cache:
         BTreeSet<(NaiveDate, String, Option<NaiveTime>, Option<NaiveTime>)>,
     execution_absence_notes: BTreeMap<NaiveDate, Vec<String>>,
@@ -598,11 +613,12 @@ pub fn backtest_execution_dates_with_rules(
 
 impl<S, C, R> BacktestEngine<S, C, R> {
     pub fn new(
-        data: DataSet,
+        mut data: DataSet,
         strategy: S,
         broker: BrokerSimulator<C, R>,
         config: BacktestConfig,
     ) -> Self {
+        data.clear_decision_projection();
         Self {
             data,
             strategy,
@@ -623,6 +639,7 @@ impl<S, C, R> BacktestEngine<S, C, R> {
             futures_cost_model: FuturesTransactionCostModel::default(),
             futures_validation_config: FuturesValidationConfig::default(),
             execution_quote_loader: None,
+            decision_projection_loader: None,
             execution_quote_request_cache: BTreeSet::new(),
             execution_absence_notes: BTreeMap::new(),
             execution_lifecycle_reported: BTreeSet::new(),
@@ -664,7 +681,8 @@ impl<S, C, R> BacktestEngine<S, C, R> {
         self
     }
 
-    pub fn into_data(self) -> DataSet {
+    pub fn into_data(mut self) -> DataSet {
+        self.data.clear_decision_projection();
         self.data
     }
 
@@ -678,6 +696,89 @@ impl<S, C, R> BacktestEngine<S, C, R> {
         self
     }
 
+    pub fn with_decision_projection_loader<F>(
+        mut self, contract: DecisionProjectionContract, loader: F,
+    ) -> Result<Self, BacktestError>
+    where
+        F: FnMut(DecisionProjectionRequest) -> Result<DecisionProjectionBatch, BacktestError> + Send + 'static,
+    {
+        contract.validate()?;
+        if self.config.decision_lag_trading_days == 0 || self.decision_projection_loader.is_some() {
+            return Err(BacktestError::Execution(
+                "decision projection requires a single loader and a completed prior trading session".into(),
+            ));
+        }
+        self.data.require_unmaterialized_projection_fields(&contract.fields)?;
+        self.decision_projection_loader = Some(DecisionProjectionLoader {
+            contract, load: Box::new(loader), requested_dates: BTreeSet::new(),
+        });
+        Ok(self)
+    }
+
+    fn prepare_decision_projection(
+        &mut self, execution_date: NaiveDate, decision_date: NaiveDate,
+    ) -> Result<Option<DecisionProjectionReceipt>, BacktestError> {
+        let Some(loader) = &mut self.decision_projection_loader else { return Ok(None); };
+        if !loader.requested_dates.insert(execution_date) {
+            return Err(BacktestError::Execution("projection request was already dispatched by this engine; verify its durable receipt before recovery".into()));
+        }
+        let symbols = self.data.candidate_snapshot_rows_on(decision_date).iter()
+            .map(|row| row.symbol.to_string()).collect::<BTreeSet<_>>();
+        if symbols.is_empty() || symbols.iter().any(|symbol| self.data.factor(decision_date, symbol).is_none()) {
+            return Err(BacktestError::Execution("decision projection requires complete same-date candidate and raw factor observations".into()));
+        }
+        let request = DecisionProjectionRequest {
+            contract_sha256: loader.contract.contract_sha256.clone(),
+            decision_date, execution_date,
+            as_of: decision_date.and_time(loader.contract.input_cutoff_time),
+            symbols, fields: loader.contract.fields.clone(),
+        };
+        let batch = (loader.load)(request.clone())?;
+        let receipt = batch.validate(&request)?;
+        self.data.install_decision_projection(decision_date, &batch.rows)?;
+        Ok(Some(receipt))
+    }
+
+    fn validate_decision_projection_calendar(&self) -> Result<(), BacktestError> {
+        let Some(loader) = &self.decision_projection_loader else { return Ok(()); };
+        if !loader.requested_dates.is_empty() {
+            return Err(BacktestError::Execution("a projection-enabled engine cannot replay its dispatched run in place".into()));
+        }
+        let dates = self.data.calendar().days();
+        for (index, execution_date) in dates.iter().copied().enumerate() {
+            if self.config.start_date.is_some_and(|start| execution_date < start)
+                || self.config.end_date.is_some_and(|end| execution_date > end) { continue; }
+            let Some(decision_index) = index.checked_sub(self.config.decision_lag_trading_days) else {
+                if self.config.start_date.is_some() {
+                    return Err(BacktestError::Execution("projection run is missing the completed signal session before its requested start".into()));
+                }
+                continue;
+            };
+            let decision_date = dates[decision_index];
+            if self.data.market_snapshot_rows_on(execution_date).is_empty()
+                || self.data.factor_snapshot_rows_on(decision_date).is_empty()
+                || self.data.candidate_snapshot_rows_on(decision_date).is_empty()
+            {
+                return Err(BacktestError::Execution(format!(
+                    "projection calendar has unresolved market/candidate/factor data for decision {decision_date} / execution {execution_date}; no session may be silently dropped"
+                )));
+            }
+        }
+        Ok(())
+    }
+
+    fn decision_projection_execution_schedule(&self) -> Vec<(NaiveDate, Option<(usize, NaiveDate)>)> {
+        let dates = self.data.calendar().days();
+        dates.iter().copied().enumerate()
+            .filter(|(_, date)| self.config.start_date.is_none_or(|start| *date >= start))
+            .filter(|(_, date)| self.config.end_date.is_none_or(|end| *date <= end))
+            .enumerate().map(|(execution_index, (calendar_index, execution_date))| {
+                let signal = calendar_index.checked_sub(self.config.decision_lag_trading_days)
+                    .map(|signal_index| (execution_index, dates[signal_index]));
+                (execution_date, signal)
+            }).collect()
+    }
+
     pub fn with_dividend_reinvestment(mut self, enabled: bool) -> Self {
         self.dividend_reinvestment = enabled;
         self
@@ -3026,6 +3127,7 @@ where
     where
         F: FnMut(&BacktestDayProgress) -> Result<(), BacktestError>,
     {
+        self.validate_decision_projection_calendar()?;
         let mut portfolio = PortfolioState::new(self.config.initial_cash);
         let mut manual_cursor = self.manual_execution_source.as_ref().map(|source|
             crate::manual_execution::ManualReplayCursor::from_shared(source.clone())).transpose().map_err(BacktestError::Execution)?;
@@ -3033,17 +3135,22 @@ where
         self.subscriptions = self.strategy.initial_subscriptions();
         let scheduler_calendar = self.data.calendar().clone();
         let scheduler = Scheduler::new(&scheduler_calendar);
-        let execution_schedule = backtest_execution_schedule_with_rules(
+        let execution_schedule = if self.decision_projection_loader.is_some() {
+            self.decision_projection_execution_schedule()
+        } else { backtest_execution_schedule_with_rules(
             &self.data,
             self.config.start_date,
             self.config.end_date,
             self.config.decision_lag_trading_days,
             &self.strategy.schedule_rules(),
-        );
+        ) };
         let execution_dates = execution_schedule
             .iter()
             .map(|(execution_date, _)| *execution_date)
             .collect::<Vec<_>>();
+        if let Some(first) = execution_dates.first() {
+            portfolio.record_empty_simulation_origin(*first).map_err(BacktestError::Execution)?;
+        }
         self.manual_corporate_replay = if manual_has_fills
             && execution_dates
                 .iter()
@@ -3112,12 +3219,20 @@ where
             daily_holdings: Vec::new(),
             metrics: BacktestMetrics::default(),
             terminal_audit: BacktestTerminalAudit::default(),
+            decision_projection_receipts: Vec::new(),
         };
         let mut stock_equity_by_date = BTreeMap::<NaiveDate, f64>::new();
         let mut previous_external_cash_flow_total = portfolio.external_cash_flow_total();
         let mut cumulative_corporate_allocation_count = 0;
 
         for (execution_idx, execution_date) in execution_dates.iter().copied().enumerate() {
+            let decision_slot = execution_schedule.get(execution_idx).and_then(|(_, slot)| *slot);
+            self.data.clear_decision_projection();
+            if let Some((_, decision_date)) = decision_slot
+                && let Some(receipt) = self.prepare_decision_projection(execution_date, decision_date)?
+            {
+                result.decision_projection_receipts.push(receipt);
+            }
             let day_order_start = result.order_events.len();
             let day_fill_start = result.fills.len();
             let day_manual_start = result.manual_executions.len();
@@ -3129,7 +3244,7 @@ where
             self.observe_manual_until(&mut manual_cursor, execution_date.and_hms_opt(0, 0, 0).unwrap(),
                 &mut portfolio, &mut result, &mut between_session_events, None)?;
             self.retain_process_events(&mut result.process_events, &mut between_session_events);
-            portfolio.begin_trading_day();
+            portfolio.begin_trading_day_at(execution_date);
             if let Some(account) = self.futures_account.as_mut() {
                 account.begin_trading_day();
             }
@@ -3155,6 +3270,9 @@ where
                 execution_date,
                 execution_date,
             );
+            let share_delivery_report = crate::corporate_book::settle_shares(
+                execution_date, &mut portfolio, &mut corporate_action_notes)?;
+            self.extend_result(&mut result, share_delivery_report, execution_date, execution_date);
             let receivable_report = self.settle_cash_receivables(
                 execution_date,
                 &mut portfolio,
@@ -3187,9 +3305,6 @@ where
                 execution_date,
                 execution_date,
             );
-            let decision_slot = execution_schedule
-                .get(execution_idx)
-                .and_then(|(_, decision_slot)| *decision_slot);
             let Some((decision_index, decision_date)) = decision_slot else {
                 let mut process_events = Vec::new();
                 let mut report = self.execute_deferred_session_without_signal(
@@ -4502,6 +4617,7 @@ where
                     self.broker.same_day_buy_close_mark_at_fill())?;
             }
             let daily_fill_count = result.fills.len() - day_fill_start + result.manual_executions.len() - day_manual_start;
+            portfolio.record_closing_holdings(execution_date).map_err(BacktestError::Execution)?;
             for audit in self.broker.audit_completed_session_capacity(execution_date, &self.data)? {
                 result.capacity_audit.observe(&audit);
                 // Keep every audit in the durable event store, independent of
@@ -7192,6 +7308,165 @@ mod tests {
         }
     }
 
+    fn projection_contract() -> crate::DecisionProjectionContract {
+        crate::DecisionProjectionContract {
+            contract_sha256: "a".repeat(64), fields: BTreeSet::from(["model_score_a".into()]),
+            input_cutoff_time: NaiveTime::from_hms_opt(16, 0, 0).unwrap(),
+        }
+    }
+
+    fn projection_batch(request: &crate::DecisionProjectionRequest, score: f64) -> crate::DecisionProjectionBatch {
+        crate::DecisionProjectionBatch {
+            contract_sha256: request.contract_sha256.clone(), decision_date: request.decision_date,
+            execution_date: request.execution_date, input_available_at: request.as_of,
+            rows: request.symbols.iter().map(|symbol| crate::DecisionProjectionRow {
+                symbol: symbol.clone(), values: BTreeMap::from([("model_score_a".into(), score)]),
+            }).collect(), exclusions: vec![],
+            inference_reference: crate::DecisionProjectionReference {
+                path: format!("/private/inference-{}.json", request.execution_date), sha256: "b".repeat(64),
+            }, provider_request_sha256: "c".repeat(64), provider_response_sha256: "d".repeat(64),
+        }
+    }
+
+    struct ProjectionProbe { seen: Arc<Mutex<Vec<(NaiveDate, f64)>>> }
+
+    impl Strategy for ProjectionProbe {
+        fn name(&self) -> &str { "decision-projection-probe" }
+
+        fn before_trading(&mut self, ctx: &StrategyContext<'_>) -> Result<(), crate::BacktestError> {
+            assert!(ctx.data.factor_numeric_value(ctx.decision_date, SYMBOL, "model_score_a").is_some());
+            assert!(ctx.data.factor_numeric_value(ctx.execution_date, SYMBOL, "model_score_a").is_none());
+            Ok(())
+        }
+
+        fn on_day(&mut self, ctx: &StrategyContext<'_>) -> Result<StrategyDecision, crate::BacktestError> {
+            let score = ctx.data.factor_numeric_value(ctx.decision_date, SYMBOL, "model_score_a")
+                .ok_or_else(|| crate::BacktestError::Execution("missing current projection".into()))?;
+            self.seen.lock().unwrap().push((ctx.decision_date, score));
+            let symbol_id = ctx.data.symbol_id(SYMBOL).unwrap();
+            assert_eq!(ctx.data.daily_snapshot_view(ctx.decision_date).factor(symbol_id)
+                .unwrap().extra_factors.get("model_score_a").copied(), Some(score));
+            assert_eq!(ctx.data.factor_snapshot_rows_on(ctx.decision_date)[0].extra_factors.get("model_score_a").copied(), Some(score));
+            assert_eq!(ctx.data.get_factor(SYMBOL, ctx.decision_date, ctx.decision_date, "model_score_a")[0].value, score);
+            Ok(StrategyDecision { order_intents: if score > 0.0 { vec![OrderIntent::Shares {
+                symbol: SYMBOL.into(), quantity: 100, reason: "current causal model score".into(),
+            }] } else { vec![] }, ..Default::default() })
+        }
+    }
+
+    fn projection_probe_engine(data: DataSet, seen: Arc<Mutex<Vec<(NaiveDate, f64)>>>)
+        -> BacktestEngine<ProjectionProbe, ChinaAShareCostModel, ChinaEquityRuleHooks>
+    {
+        let broker = BrokerSimulator::new_with_execution_price(ChinaAShareCostModel::default(), ChinaEquityRuleHooks, PriceField::Open)
+            .with_matching_type(MatchingType::NextBarOpen).with_volume_limit(false).with_liquidity_limit(false);
+        BacktestEngine::new(data, ProjectionProbe { seen }, broker, BacktestConfig {
+            initial_cash: 10000.0, benchmark_code: "000852.SH".into(), start_date: None, end_date: None,
+            decision_lag_trading_days: 1, execution_price_field: PriceField::Open,
+        })
+    }
+
+    #[test]
+    fn decision_projection_is_called_before_callbacks_and_is_not_shared_or_carried_forward() {
+        let dates = [d(2025, 1, 2), d(2025, 1, 3), d(2025, 1, 6)];
+        let data = dataset_from_market_and_candidates(dates.iter().map(|date| market(*date, 10.0, 10.0)).collect(), dates.iter().map(|date| candidate(*date)).collect());
+        let base = data.clone();
+        let seen = Arc::new(Mutex::new(vec![]));
+        let requested = Arc::new(Mutex::new(vec![]));
+        let recorded = requested.clone();
+        let mut engine = projection_probe_engine(data, seen.clone()).with_decision_projection_loader(projection_contract(), move |request| {
+            recorded.lock().unwrap().push(request.clone());
+            Ok(projection_batch(&request, if request.decision_date == dates[0] { 0.5 } else { -0.5 }))
+        }).unwrap();
+        let result = engine.run().unwrap();
+        assert_eq!(*seen.lock().unwrap(), vec![(dates[0], 0.5), (dates[1], -0.5)]);
+        assert_eq!(requested.lock().unwrap().len(), 2);
+        assert_eq!(result.decision_projection_receipts.len(), 2);
+        assert_eq!(result.fills.len(), 1);
+        assert_eq!(result.fills[0].date, dates[1]);
+        for date in dates { assert_eq!(base.factor_numeric_value(date, SYMBOL, "model_score_a"), None); }
+        let run_data = engine.into_data();
+        assert_eq!(run_data.factor_numeric_value(dates[0], SYMBOL, "model_score_a"), None);
+        assert_eq!(run_data.factor_numeric_value(dates[1], SYMBOL, "model_score_a"), None);
+        let clean = projection_probe_engine(run_data.clone(), Arc::new(Mutex::new(vec![]))).into_data();
+        assert_eq!(clean.factor_numeric_value(dates[1], SYMBOL, "model_score_a"), None);
+    }
+
+    #[test]
+    fn decision_projection_failure_never_reaches_strategy_and_does_not_blindly_retry() {
+        let seen = Arc::new(Mutex::new(vec![]));
+        let attempts = Arc::new(Mutex::new(0));
+        let counted = attempts.clone();
+        let mut engine = projection_probe_engine(dataset(), seen.clone()).with_decision_projection_loader(projection_contract(), move |_| {
+            *counted.lock().unwrap() += 1;
+            Err(crate::BacktestError::Execution("provider outcome unknown; inspect its receipt".into()))
+        }).unwrap();
+        assert!(engine.run().unwrap_err().to_string().contains("provider outcome unknown"));
+        assert!(seen.lock().unwrap().is_empty());
+        assert!(engine.run().unwrap_err().to_string().contains("cannot replay"));
+        assert_eq!(*attempts.lock().unwrap(), 1);
+    }
+
+    #[test]
+    fn decision_projection_requested_first_session_uses_visible_preperiod_inputs() {
+        let first = d(2025, 1, 3);
+        let seen = Arc::new(Mutex::new(vec![]));
+        let mut engine = projection_probe_engine(dataset(), seen.clone());
+        engine.config.start_date = Some(first);
+        engine.config.end_date = Some(first);
+        let mut engine = engine.with_decision_projection_loader(projection_contract(), move |request| {
+            assert_eq!(request.execution_date, first);
+            assert_eq!(request.decision_date, d(2025, 1, 2));
+            Ok(projection_batch(&request, 0.5))
+        }).unwrap();
+        let result = engine.run().unwrap();
+        assert_eq!(result.decision_projection_receipts.len(), 1);
+        assert_eq!(result.fills[0].date, first);
+        assert_eq!(*seen.lock().unwrap(), vec![(d(2025, 1, 2), 0.5)]);
+    }
+
+    #[test]
+    fn decision_projection_does_not_silently_shift_a_start_without_prior_inputs() {
+        let mut engine = projection_probe_engine(dataset(), Arc::new(Mutex::new(vec![])));
+        engine.config.start_date = Some(d(2025, 1, 2));
+        let mut engine = engine.with_decision_projection_loader(projection_contract(), |_| panic!("missing warmup must be classified before dispatch")).unwrap();
+        assert!(engine.run().unwrap_err().to_string().contains("before its requested start"));
+    }
+
+    #[test]
+    fn decision_projection_rejects_future_response_before_any_strategy_callback() {
+        let seen = Arc::new(Mutex::new(vec![]));
+        let mut engine = projection_probe_engine(dataset(), seen.clone()).with_decision_projection_loader(projection_contract(), move |request| {
+            let mut batch = projection_batch(&request, 1.0);
+            batch.input_available_at += chrono::Duration::seconds(1);
+            Ok(batch)
+        }).unwrap();
+        assert!(engine.run().unwrap_err().to_string().contains("causal availability"));
+        assert!(seen.lock().unwrap().is_empty());
+    }
+
+    #[test]
+    fn decision_projection_rejects_missing_calendar_inputs_instead_of_dropping_a_session() {
+        let dates = [d(2025, 1, 2), d(2025, 1, 3), d(2025, 1, 6)];
+        let data = DataSet::from_components(vec![default_instrument()], dates.iter().map(|date| market(*date, 10.0, 10.0)).collect(),
+            vec![factor(dates[0])], dates.iter().map(|date| candidate(*date)).collect(), dates.iter().map(|date| benchmark(*date)).collect()).unwrap();
+        let mut engine = projection_probe_engine(data, Arc::new(Mutex::new(vec![]))).with_decision_projection_loader(projection_contract(), move |_| panic!("unresolved data must fail before dispatch")).unwrap();
+        assert!(engine.run().unwrap_err().to_string().contains("no session may be silently dropped"));
+    }
+
+    #[test]
+    fn decision_projection_refuses_static_scores_and_same_session_inputs() {
+        let first = d(2025, 1, 2); let second = d(2025, 1, 3);
+        let mut factors = vec![factor(first), factor(second)];
+        factors[1].extra_factors.insert(std::borrow::Cow::Borrowed("model_score_a"), 0.5);
+        let data = DataSet::from_components(vec![default_instrument()], vec![market(first, 10.0, 10.0), market(second, 10.0, 10.0)], factors,
+            vec![candidate(first), candidate(second)], vec![benchmark(first), benchmark(second)]).unwrap();
+        let result = projection_probe_engine(data, Arc::new(Mutex::new(vec![]))).with_decision_projection_loader(projection_contract(), |_| unreachable!());
+        assert!(matches!(result, Err(error) if error.to_string().contains("historical score replay")));
+        let mut engine = projection_probe_engine(dataset(), Arc::new(Mutex::new(vec![])));
+        engine.config.decision_lag_trading_days = 0;
+        assert!(engine.with_decision_projection_loader(projection_contract(), |_| unreachable!()).is_err());
+    }
+
     fn dataset_with(
         first_market: DailyMarketSnapshot,
         second_market: DailyMarketSnapshot,

crates/fidc-core/src/etf_execution.rs

@@ -81,15 +81,6 @@ impl DeferredEtfTargets {
             *existing = row;
         } else { self.rows.push(row); }
     }
-    /// Keep a due target when execution was intentionally deferred by a
-    /// transient portfolio condition (for example an occupied slot or a
-    /// holding-protection window).  The next official session is the only
-    /// valid retry clock; a natural-day retry would create a second decision
-    /// for the same market session.
-    pub fn defer_to_next_session(&mut self, mut row: DeferredEtfTarget, date: NaiveDate, dates: &[NaiveDate]) {
-        row.execute_on = dates.iter().copied().find(|candidate| *candidate > date);
-        self.upsert(row);
-    }
     pub fn take_due(&mut self, date: NaiveDate) -> Vec<DeferredEtfTarget> {
         let mut due = Vec::new();
         self.rows.retain(|row| {
@@ -135,20 +126,4 @@ mod tests {
         assert!(queue.take_due(NaiveDate::from_ymd_opt(2026,2,1).unwrap()).is_empty());
         assert_eq!(queue.len(),1);
     }
-
-    #[test]
-    fn deferred_target_moves_to_next_official_session_instead_of_being_lost() {
-        let mut queue=DeferredEtfTargets::default();
-        queue.replace_generation("pool","v1");
-        queue.upsert(target("510300.SH",crate::stock_pool_execution::OrderSide::Buy,"v1"));
-        let date=NaiveDate::from_ymd_opt(2026,1,5).unwrap();
-        let due=queue.take_due(date);
-        assert_eq!(due.len(),1);
-        queue.defer_to_next_session(due.into_iter().next().unwrap(),date,&[
-            NaiveDate::from_ymd_opt(2026,1,5).unwrap(),
-            NaiveDate::from_ymd_opt(2026,1,6).unwrap(),
-        ]);
-        assert!(queue.take_due(date).is_empty());
-        assert_eq!(queue.take_due(NaiveDate::from_ymd_opt(2026,1,6).unwrap()).len(),1);
-    }
 }

crates/fidc-core/src/lib.rs

@@ -3,6 +3,7 @@ pub mod calendar;
 pub mod cost;
 mod corporate_book;
 pub mod data;
+pub mod decision_projection;
 mod numeric_factors;
 pub mod daily_patterns;
 pub mod pattern_context;
@@ -60,6 +61,11 @@ pub use data::{
     IntradayMarketSnapshotOverlay, IntradayOrderBookDepthLevel, NumericFactorMap, PriceBar,
     PriceField, SecuritiesMarginRecord, SplitRecord, YieldCurvePoint,
 };
+pub use decision_projection::{
+    DecisionProjectionBatch, DecisionProjectionContract, DecisionProjectionExclusion,
+    DecisionProjectionReceipt, DecisionProjectionReference, DecisionProjectionRequest,
+    DecisionProjectionRow,
+};
 pub use engine::{
     AnalyzerMonthlyReturnRow, AnalyzerPositionRow, AnalyzerReport, AnalyzerRiskSummary,
     AnalyzerTradeRow, BacktestConfig, BacktestDayProgress, BacktestEngine, BacktestError,

crates/fidc-core/src/manual_corporate_replay.rs

@@ -174,12 +174,16 @@ impl ManualCorporateReplay {
         let expected = current.financial_replay_identity();
         let reference_identity = reference.financial_replay_identity();
         if reference_identity != expected {
+            let differing = expected.as_object().into_iter().flat_map(|value| value.keys())
+                .chain(reference_identity.as_object().into_iter().flat_map(|value| value.keys()))
+                .collect::<BTreeSet<_>>().into_iter().filter(|key| expected.get(*key)!=reference_identity.get(*key))
+                .cloned().collect::<Vec<_>>().join(",");
             return Err(format!(
-                "manual corporate ledger coverage mismatch: symbol={} observed_at={} expected={} replayed={}",
+                "manual corporate ledger coverage mismatch: symbol={} observed_at={} expected={} replayed={} differing_fields={}",
                 observation.order.symbol,
                 observation.fill.observed_at,
                 digest(&expected)?,
-                digest(&reference_identity)?
+                digest(&reference_identity)?, differing
             ));
         }
         let replayed = self.replay(
@@ -350,12 +354,13 @@ impl ManualCorporateReplay {
         }
         events.sort_by_key(|(clock, priority, sequence, _)| (*clock, *priority, *sequence));
         let mut book = PortfolioState::from_fixed_initial_cash(initial_cash);
+        book.record_empty_simulation_origin(self.first_date)?;
         for (clock, _, _, event) in events {
             if clock > at {
                 return Err("manual corporate replay contains a future financial fact".into());
             }
             match event {
-                Event::Session => book.begin_trading_day(),
+                Event::Session => book.begin_trading_day_at(clock.date()),
                 Event::Cash(effect) => {
                     book.apply_cash_delta_fixed(effect.amount)?;
                     if book.cash_fixed() < FixedMoney::ZERO {
@@ -376,6 +381,8 @@ impl ManualCorporateReplay {
                     .map_err(|error| error.to_string())?;
                 }
                 Event::Settle(date) => {
+                    crate::corporate_book::settle_shares(date, &mut book, &mut Vec::new())
+                        .map_err(|error| error.to_string())?;
                     crate::corporate_book::settle_receivables(date, data, &mut book, &mut Vec::new(), self.reinvest, Some(runtime_input))
                         .map_err(|error| error.to_string())?;
                 }
@@ -411,6 +418,9 @@ impl ManualCorporateReplay {
                         self.same_day_mark_at_fill,
                     )
                     .map_err(|error| error.to_string())?;
+                    if date < at.date() || at.time() == chrono::NaiveTime::from_hms_nano_opt(23,59,59,999_999_999).unwrap() {
+                        book.record_closing_holdings(date)?;
+                    }
                 }
             }
             if book.cash_fixed() < FixedMoney::ZERO {

crates/fidc-core/src/platform_expr_strategy.rs

@@ -7564,7 +7564,7 @@ impl PlatformExprStrategy {
                 let start = self.helper_start_date(ctx, day.date, lookback);
                 let total = ctx
                     .data
-                    .get_dividend(&symbol, start, day.date)
+                    .get_dividend(&symbol, start, day.date)?
                     .iter()
                     .map(|row| row.dividend_cash_before_tax)
                     .sum::<f64>();
@@ -26574,6 +26574,10 @@ mod tests {
                 date,
                 symbol: "000001.SZ".to_string(),
                 payable_date: Some(date),
+                record_date: date.pred_opt(),
+                share_effective_date: Some(date),
+                share_rounding_rule: None,
+                ex_reference_price: None,
                 share_cash: 0.2,
                 share_bonus: 0.1,
                 share_gift: 0.0,

crates/fidc-core/src/platform_stock_pool.rs

@@ -126,7 +126,7 @@ impl PlatformExprStrategy {
             .portfolio
             .positions()
             .values()
-            .filter(|p| p.quantity > 0)
+            .filter(|p| p.economic_quantity() > 0)
             .map(|p| p.symbol.clone())
             .collect::<BTreeSet<_>>();
         if !self.config.buy_filter_expr.trim().is_empty() {

crates/fidc-core/src/portfolio.rs

@@ -2,6 +2,8 @@ use chrono::NaiveDate;
 use indexmap::IndexMap;
 use serde::{Deserialize, Serialize};
 use std::collections::{BTreeMap, BTreeSet};
+use std::sync::Arc;
+use rust_decimal::{Decimal, RoundingStrategy, prelude::ToPrimitive};
 
 use crate::data::{DataSet, DataSetError, PriceField};
 use crate::fixed_point::{FixedMoney, MONEY_SCALE};
@@ -47,6 +49,31 @@ fn allocate_fixed_value(
     Ok(FixedMoney::from_raw(rounded))
 }
 
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize)]
+struct LotOrigin {
+    symbol: String,
+    acquired_date: NaiveDate,
+    sequence: u64,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
+struct RegisteredLot {
+    origin: LotOrigin,
+    quantity: u32,
+    remaining_purchase_units: Decimal,
+}
+
+type ClosingHoldings = BTreeMap<String, Vec<RegisteredLot>>;
+
+#[derive(Debug, Clone, Serialize)]
+pub struct ShareReceivable {
+    pub ex_date: NaiveDate,
+    pub record_date: NaiveDate,
+    pub effective_date: NaiveDate,
+    pub quantity: u32,
+    pub holding_origin_date: NaiveDate,
+}
+
 #[derive(Debug, Clone)]
 pub struct PositionLot {
     pub acquired_date: NaiveDate,
@@ -54,6 +81,8 @@ pub struct PositionLot {
     // Total values keep partial-lot allocation exact without a rounded per-share mirror.
     entry_value: FixedMoney,
     cost_basis: FixedMoney,
+    origin: LotOrigin,
+    remaining_purchase_units: Decimal,
 }
 
 #[derive(Debug, Clone)]
@@ -67,12 +96,15 @@ pub struct Position {
     // ALV-compatible moving average including buy costs; partial sells do not rebase it.
     pub average_cost: f64,
     pub last_price: f64,
+    last_market_mark_date: Option<NaiveDate>,
+    current_session_date: Option<NaiveDate>,
     realized_pnl: FixedMoney,
     realized_entry_pnl: FixedMoney,
     pub trading_pnl: f64,
     pub position_pnl: f64,
     dividend_receivable: FixedMoney,
     day_start_quantity: u32,
+    day_start_economic_quantity: u32,
     day_start_price: f64,
     day_split_ratio: f64,
     day_dividend_cash: FixedMoney,
@@ -83,6 +115,9 @@ pub struct Position {
     day_buy_value: FixedMoney,
     day_sell_value: FixedMoney,
     lots: Vec<PositionLot>,
+    next_lot_sequence: u64,
+    share_receivables: Vec<ShareReceivable>,
+    day_share_accretion: FixedMoney,
 }
 
 impl Position {
@@ -95,12 +130,15 @@ impl Position {
             average_price: 0.0,
             average_cost: 0.0,
             last_price: 0.0,
+            last_market_mark_date: None,
+            current_session_date: None,
             realized_pnl: FixedMoney::ZERO,
             realized_entry_pnl: FixedMoney::ZERO,
             trading_pnl: 0.0,
             position_pnl: 0.0,
             dividend_receivable: FixedMoney::ZERO,
             day_start_quantity: 0,
+            day_start_economic_quantity: 0,
             day_start_price: 0.0,
             day_split_ratio: 1.0,
             day_dividend_cash: FixedMoney::ZERO,
@@ -111,11 +149,54 @@ impl Position {
             day_buy_value: FixedMoney::ZERO,
             day_sell_value: FixedMoney::ZERO,
             lots: Vec::new(),
+            next_lot_sequence: 0,
+            share_receivables: Vec::new(),
+            day_share_accretion: FixedMoney::ZERO,
         }
     }
 
     pub fn is_flat(&self) -> bool {
-        self.quantity == 0
+        self.quantity == 0 && self.share_receivables.is_empty()
+    }
+
+    pub fn share_receivable_quantity(&self) -> u32 {
+        self.share_receivables.iter().try_fold(0u32, |total, claim| total.checked_add(claim.quantity))
+            .expect("share receivable quantity overflow")
+    }
+
+    pub fn economic_quantity(&self) -> u32 {
+        self.quantity.checked_add(self.share_receivable_quantity()).expect("economic holding quantity overflow")
+    }
+
+    pub fn share_receivable_value(&self) -> f64 {
+        f64::from(self.share_receivable_quantity()) * self.last_price
+    }
+
+    pub fn share_receivables(&self) -> &[ShareReceivable] { &self.share_receivables }
+
+    fn deliver_registered_shares(&mut self, date: NaiveDate) -> Result<u32, String> {
+        let mut pending = Vec::new();
+        let mut delivered = 0u32;
+        for claim in self.share_receivables.drain(..) {
+            if claim.effective_date > date { pending.push(claim); continue; }
+            delivered = delivered.checked_add(claim.quantity).ok_or("delivered share quantity overflow")?;
+            self.lots.push(PositionLot {
+                acquired_date: claim.holding_origin_date, quantity: claim.quantity,
+                entry_value: FixedMoney::ZERO, cost_basis: FixedMoney::ZERO,
+                origin: LotOrigin { symbol: self.symbol.clone(), acquired_date: claim.holding_origin_date, sequence: self.next_lot_sequence },
+                remaining_purchase_units: Decimal::from(claim.quantity),
+            });
+            self.next_lot_sequence = self.next_lot_sequence.checked_add(1).ok_or("delivered share lot sequence overflow")?;
+        }
+        self.quantity = self.quantity.checked_add(delivered).ok_or("delivered holding quantity overflow")?;
+        self.share_receivables = pending;
+        if delivered > 0 {
+            self.opened_date = self.lots.iter().map(|lot| lot.acquired_date).min();
+            self.average_price = self.average_entry_price().unwrap_or(0.0);
+            self.recalculate_average_cost();
+            self.refresh_day_pnl();
+        }
+        Ok(delivered)
     }
 
     pub fn opened_date(&self) -> Option<NaiveDate> {
@@ -167,9 +248,13 @@ impl Position {
             quantity,
             entry_value: gross_amount,
             cost_basis: gross_amount,
+            origin: LotOrigin { symbol: self.symbol.clone(), acquired_date: date, sequence: self.next_lot_sequence },
+            remaining_purchase_units: Decimal::from(quantity),
         });
+        self.next_lot_sequence = self.next_lot_sequence.checked_add(1).expect("position lot sequence overflow");
         self.quantity += quantity;
         self.last_price = normalized_mark_price(mark_price, execution_price);
+        self.last_market_mark_date = Some(date);
         self.day_trade_quantity_delta += quantity as i32;
         self.day_buy_quantity += quantity;
         self.day_buy_value = self
@@ -286,6 +371,10 @@ impl Position {
                 .entry_value
                 .checked_sub(lot_entry)
                 .ok_or_else(|| "fixed-point lot entry underflow".to_string())?;
+            first_lot.remaining_purchase_units = first_lot.remaining_purchase_units
+                .checked_mul(Decimal::from(lot_quantity_before - lot_sell))
+                .and_then(|value| value.checked_div(Decimal::from(lot_quantity_before)))
+                .ok_or("registered lot ownership allocation overflow")?;
             remaining_proceeds = remaining_proceeds
                 .checked_sub(lot_proceeds)
                 .ok_or_else(|| "fixed-point sell proceeds underflow".to_string())?;
@@ -299,6 +388,7 @@ impl Position {
 
         self.quantity -= quantity;
         self.last_price = normalized_mark_price(mark_price, execution_price);
+        self.last_market_mark_date = self.current_session_date;
         self.realized_pnl = self
             .realized_pnl
             .checked_add(realized)
@@ -444,6 +534,8 @@ impl Position {
 
     pub fn begin_trading_day(&mut self) {
         self.day_start_quantity = self.quantity;
+        self.day_start_economic_quantity = self.economic_quantity();
+        self.day_share_accretion = FixedMoney::ZERO;
         self.day_start_price = self.last_price;
         self.day_split_ratio = 1.0;
         self.day_dividend_cash = FixedMoney::ZERO;
@@ -610,6 +702,8 @@ impl Position {
                 quantity: round_half_up_u32(lot.quantity as f64 * ratio),
                 entry_value: lot.entry_value,
                 cost_basis: lot.cost_basis,
+                origin: lot.origin.clone(),
+                remaining_purchase_units: lot.remaining_purchase_units,
             })
             .collect::<Vec<_>>();
 
@@ -645,19 +739,19 @@ impl Position {
     }
 
     fn refresh_day_pnl(&mut self) {
-        let adjusted_old_quantity = self.day_start_quantity as f64 * self.day_split_ratio;
-        self.position_pnl = if self.day_start_quantity == 0 || self.day_start_price <= 0.0 {
-            0.0
+        let adjusted_old_quantity = self.day_start_economic_quantity as f64 * self.day_split_ratio;
+        let marked = if self.day_start_economic_quantity == 0 || self.day_start_price <= 0.0 {
+            FixedMoney::ZERO
         } else {
             fixed_money_or_panic(
                 adjusted_old_quantity
                     * (self.last_price - (self.day_start_price / self.day_split_ratio)),
                 "position daily mark PnL",
             )
-            .checked_add(self.day_dividend_cash)
-            .expect("fixed-point position daily PnL overflow")
-            .to_f64()
         };
+        self.position_pnl = marked.checked_add(self.day_dividend_cash)
+            .and_then(|value| value.checked_add(self.day_share_accretion))
+            .expect("fixed-point position daily PnL overflow").to_f64();
         let buy_mark = if self.day_buy_quantity == 0 {
             FixedMoney::ZERO
         } else {
@@ -713,6 +807,12 @@ pub struct PortfolioState {
     // Kept after a position becomes flat so an active date lock is not lost.
     corporate_predecessors: BTreeMap<String, BTreeSet<String>>,
     stock_pool_states: std::collections::BTreeMap<String,crate::stock_pool_state::StockPoolExecutionState>,
+    // Immutable closing facts are shared by transactional checkpoints.
+    // Capturing all actual holdings avoids consulting future corporate events.
+    closing_holdings: Arc<BTreeMap<NaiveDate, ClosingHoldings>>,
+    empty_simulation_origin: Option<NaiveDate>,
+    retired_lot_sequences: BTreeMap<String, u64>,
+    current_session_date: Option<NaiveDate>,
 }
 
 pub(crate) struct PortfolioCheckpoint {
@@ -755,6 +855,220 @@ pub(crate) struct SuccessorConversionOutcome {
 }
 
 impl PortfolioState {
+    pub(crate) fn record_empty_simulation_origin(&mut self, date: NaiveDate) -> Result<(), String> {
+        if self.positions.values().any(|position| position.quantity != 0) || !self.closing_holdings.is_empty() {
+            return Err("empty simulation origin conflicts with observed holdings".into());
+        }
+        self.empty_simulation_origin = Some(date);
+        Ok(())
+    }
+
+    pub(crate) fn record_closing_holdings(&mut self, date: NaiveDate) -> Result<(), String> {
+        let mut origins = BTreeSet::new();
+        let mut closing = BTreeMap::new();
+        for (symbol, position) in &self.positions {
+            if position.quantity == 0 { continue; }
+            let mut lots = Vec::new();
+            let mut quantity = 0u32;
+            for lot in &position.lots {
+                if lot.remaining_purchase_units <= Decimal::ZERO || !origins.insert(lot.origin.clone()) {
+                    return Err("closing registered lot lineage is invalid or duplicated".into());
+                }
+                quantity = quantity.checked_add(lot.quantity).ok_or("closing quantity overflow")?;
+                lots.push(RegisteredLot { origin: lot.origin.clone(), quantity: lot.quantity,
+                    remaining_purchase_units: lot.remaining_purchase_units });
+            }
+            if quantity != position.quantity { return Err("closing registered quantity differs from actual lots".into()); }
+            closing.insert(symbol.clone(), lots);
+        }
+        if let Some(existing) = self.closing_holdings.get(&date) {
+            if existing != &closing { return Err("already closed registered holdings changed".into()); }
+            return Ok(());
+        }
+        Arc::make_mut(&mut self.closing_holdings).insert(date, closing);
+        Ok(())
+    }
+
+    fn registered_lots(&self, date: NaiveDate, symbol: &str) -> Result<Vec<RegisteredLot>, String> {
+        if let Some(closing) = self.closing_holdings.get(&date) {
+            return Ok(closing.get(symbol).cloned().unwrap_or_default());
+        }
+        // A newly-created all-cash simulation owns no shares before its origin.
+        // Imported accounts never receive this declaration automatically.
+        if self.empty_simulation_origin.is_some_and(|origin| date < origin) { return Ok(Vec::new()); }
+        Err(format!("corporate_action_record_holdings_missing: symbol={symbol} record_date={date}"))
+    }
+
+    pub(crate) fn registered_quantity(&self, date: NaiveDate, symbol: &str) -> Result<u32, String> {
+        self.registered_lots(date, symbol)?.iter().try_fold(0u32, |total, lot|
+            total.checked_add(lot.quantity).ok_or_else(|| "registered entitlement quantity overflow".into()))
+    }
+
+    pub(crate) fn apply_ex_reference_mark(&mut self, action: &crate::CorporateAction) -> Result<(), String> {
+        let Some(position) = self.positions.get_mut(&action.symbol) else { return Ok(()); };
+        if position.economic_quantity() == 0 { return Ok(()); }
+        if position.last_market_mark_date.is_some_and(|day| day > action.date) {
+            return Err("corporate_action_market_mark_after_ex_date".into());
+        }
+        if position.last_market_mark_date == Some(action.date)
+            && (!position.last_price.is_finite() || position.last_price <= 0.0) {
+            return Err("corporate_action_same_day_market_mark_invalid".into());
+        }
+        // An actual same-day quote already reflects the corporate action.
+        // Prior marks need the independent, verified reference price; lot cash
+        // allocations and gross entitlements do not determine a market price.
+        if position.last_market_mark_date != Some(action.date) {
+            position.last_price = action.required_ex_reference_price()?;
+            position.last_market_mark_date = Some(action.date);
+            position.refresh_day_pnl();
+        }
+        Ok(())
+    }
+
+    pub(crate) fn register_share_entitlement(&mut self, action: &crate::CorporateAction) -> Result<u32, String> {
+        let record_date = action.required_record_date()?;
+        let effective_date = action.required_share_effective_date()?;
+        let rate = Decimal::from_str_exact(&(action.share_bonus + action.share_gift).to_string())
+            .map_err(|_| "corporate_action_quantity_overflow: share rate exceeds exact arithmetic domain")?;
+        if rate <= Decimal::ZERO { return Err("corporate_action_share_rate_not_positive".into()); }
+        let registered = self.registered_lots(record_date, &action.symbol)?;
+        if action.share_rounding_rule.as_deref().is_some_and(|rule| rule != "aggregate_half_up") {
+            return Err("corporate_action_share_rounding_rule_unsupported".into());
+        }
+        let ideal = registered.iter().try_fold(Decimal::ZERO, |total, lot| {
+            Decimal::from(lot.quantity).checked_mul(rate).and_then(|quantity| total.checked_add(quantity))
+                .ok_or("corporate_action_quantity_overflow: registered entitlement")
+        })?;
+        let settled = if ideal.fract() == Decimal::ZERO { ideal }
+            else if action.share_rounding_rule.as_deref() == Some("aggregate_half_up") {
+                ideal.round_dp_with_strategy(0, RoundingStrategy::MidpointAwayFromZero)
+            } else { return Err("corporate_action_fractional_share_settlement_evidence_required".into()); };
+        let total = settled.to_u32().ok_or("corporate_action_quantity_overflow: registered entitlement")?;
+        let mut allocated = Vec::new();
+        let mut floor_total = 0u32;
+        for (index, lot) in registered.iter().enumerate() {
+            let value = Decimal::from(lot.quantity).checked_mul(rate).ok_or("registered share entitlement overflow")?;
+            let floor = value.trunc().to_u32().ok_or("registered share entitlement overflow")?;
+            floor_total = floor_total.checked_add(floor).ok_or("registered share entitlement overflow")?;
+            allocated.push((index, floor, value.fract()));
+        }
+        let remainder = total.checked_sub(floor_total).ok_or("registered share allocation exceeds total")? as usize;
+        if remainder > allocated.len() { return Err("registered share allocation remainder invalid".into()); }
+        allocated.sort_by(|a,b| b.2.cmp(&a.2).then_with(|| a.0.cmp(&b.0)));
+        for (_, quantity, _) in allocated.iter_mut().take(remainder) { *quantity += 1; }
+        allocated.sort_by_key(|entry| entry.0);
+        let mut claims = Vec::new();
+        for ((index, quantity, _), lot) in allocated.into_iter().zip(registered) {
+            let _ = index;
+            if quantity == 0 { continue; }
+            claims.push(ShareReceivable { ex_date: action.date, record_date, effective_date,
+                quantity, holding_origin_date: lot.origin.acquired_date });
+        }
+        if total == 0 { return Ok(0); }
+        if total > i32::MAX as u32 { return Err("registered share report quantity overflow".into()); }
+        let position = self.position_mut(&action.symbol);
+        if position.share_receivables.iter().any(|claim| claim.ex_date == action.date && claim.record_date == record_date) {
+            return Err("corporate_action_share_entitlement_already_registered".into());
+        }
+        let economic_before = position.economic_quantity();
+        position.economic_quantity().checked_add(total).ok_or("economic share quantity overflow")?;
+        let ratio = action.split_ratio();
+        if position.last_market_mark_date.is_some_and(|day| day > action.date) {
+            return Err("corporate_action_market_mark_after_ex_date".into());
+        }
+        if position.last_market_mark_date != Some(action.date) {
+            position.last_price = action.required_ex_reference_price()?;
+            position.last_market_mark_date = Some(action.date);
+        }
+        if !position.last_price.is_finite() || position.last_price <= 0.0 {
+            return Err("corporate_action_share_accounting_reference_missing".into());
+        }
+        if position.day_start_economic_quantity > 0 && economic_before > 0 {
+            position.day_split_ratio *= f64::from(economic_before + total) / f64::from(economic_before);
+        } else {
+            let amount = fixed_money(f64::from(total) * position.last_price, "share entitlement accrual")?;
+            position.day_share_accretion = position.day_share_accretion.checked_add(amount).ok_or("share accrual overflow")?;
+        }
+        position.share_receivables.extend(claims);
+        position.refresh_day_pnl();
+        self.adjust_stock_pool_split(&action.symbol, ratio)?;
+        Ok(total)
+    }
+
+    pub(crate) fn deliver_share_receivables(&mut self, date: NaiveDate) -> Result<Vec<(String,u32,u32,f64)>, String> {
+        let mut next = self.clone();
+        let mut delivered = Vec::new();
+        for (symbol, position) in &mut next.positions {
+            let quantity = position.deliver_registered_shares(date)?;
+            if quantity > i32::MAX as u32 { return Err("corporate_action_quantity_overflow: delivered share report".into()); }
+            if quantity > 0 { delivered.push((symbol.clone(),quantity,position.quantity,position.average_cost)); }
+        }
+        *self = next;
+        Ok(delivered)
+    }
+
+    pub(crate) fn apply_registered_cash_dividend(&mut self, symbol: &str, record_date: NaiveDate,
+        per_share: f64, adjust_cost: bool) -> Result<(f64, f64), String> {
+        if !per_share.is_finite() || per_share < 0.0 { return Err("invalid registered cash dividend".into()); }
+        let registered = self.registered_lots(record_date, symbol)?;
+        let mut terms = BTreeMap::new();
+        let mut total = FixedMoney::ZERO;
+        for lot in registered {
+            // Round the actual entitlement, preserving sub-money-unit rates.
+            let cash = fixed_money(per_share * f64::from(lot.quantity), "registered cash dividend")?;
+            total = total.checked_add(cash).ok_or("registered cash dividend overflow")?;
+            if terms.insert(lot.origin, (cash, lot.remaining_purchase_units)).is_some() {
+                return Err("duplicate registered lot entitlement".into());
+            }
+        }
+        // Ownership units survive splits/conversions and decrease only on sale.
+        // New purchases therefore cannot inherit an earlier lot's entitlement.
+        let mut remaining = BTreeMap::<LotOrigin, Decimal>::new();
+        for position in self.positions.values() {
+            for lot in &position.lots {
+                if let Some((_, recorded_units)) = terms.get(&lot.origin) {
+                    let units = remaining.entry(lot.origin.clone()).or_default();
+                    *units = units.checked_add(lot.remaining_purchase_units).ok_or("registered ownership overflow")?;
+                    if *units > *recorded_units { return Err("registered remaining ownership exceeds its closing fact".into()); }
+                }
+            }
+        }
+        let mut adjusted = FixedMoney::ZERO;
+        for position in self.positions.values_mut() {
+            let mut position_delta = FixedMoney::ZERO;
+            for lot in &mut position.lots {
+                if let Some((cash, units)) = terms.get(&lot.origin) {
+                    let fraction = lot.remaining_purchase_units.checked_div(*units).ok_or("registered ownership ratio invalid")?;
+                    let raw = Decimal::try_from_i128_with_scale(cash.raw(), 0).map_err(|_| "registered amount overflow")?
+                        .checked_mul(fraction).ok_or("registered amount allocation overflow")?
+                        .round_dp_with_strategy(0, RoundingStrategy::MidpointAwayFromZero).to_i128().ok_or("registered amount conversion overflow")?;
+                    let amount = FixedMoney::from_raw(raw);
+                    lot.entry_value = lot.entry_value.checked_sub(amount).ok_or("registered entry adjustment overflow")?;
+                    if adjust_cost { lot.cost_basis = lot.cost_basis.checked_sub(amount).ok_or("registered cost adjustment overflow")?; }
+                    position_delta = position_delta.checked_add(amount).ok_or("registered position amount overflow")?;
+                }
+            }
+            if position_delta != FixedMoney::ZERO {
+                let per_current_share = position_delta.to_f64() / f64::from(position.quantity);
+                position.average_price -= per_current_share;
+                if adjust_cost { position.average_cost -= per_current_share; }
+                position.day_dividend_cash = position.day_dividend_cash.checked_add(position_delta).ok_or("registered day income overflow")?;
+                position.refresh_day_pnl();
+            }
+            adjusted = adjusted.checked_add(position_delta).ok_or("registered aggregate adjustment overflow")?;
+        }
+        let disposed_income = total.checked_sub(adjusted).filter(|value| *value >= FixedMoney::ZERO)
+            .ok_or("registered allocation exceeds the actual entitlement")?;
+        if disposed_income != FixedMoney::ZERO {
+            let position = self.position_mut(symbol);
+            if adjust_cost { position.realized_pnl = position.realized_pnl.checked_add(disposed_income).ok_or("registered realized income overflow")?; }
+            position.realized_entry_pnl = position.realized_entry_pnl.checked_add(disposed_income).ok_or("registered entry income overflow")?;
+            position.day_dividend_cash = position.day_dividend_cash.checked_add(disposed_income).ok_or("registered disposed income overflow")?;
+            position.refresh_day_pnl();
+        }
+        Ok((total.to_f64(), if adjust_cost { disposed_income.to_f64() } else { 0.0 }))
+    }
+
     /// Ordinary single-security orders need not duplicate every other lot.
     /// Complex portfolio intents request the complete checkpoint instead.
     pub(crate) fn checkpoint(&self, symbols: Option<&BTreeSet<String>>) -> PortfolioCheckpoint {
@@ -773,6 +1087,10 @@ impl PortfolioState {
                 cash_receivables: self.cash_receivables.clone(), pending_cash_flows: self.pending_cash_flows.clone(),
                 day_sold_symbols: self.day_sold_symbols.clone(), corporate_predecessors: self.corporate_predecessors.clone(),
                 stock_pool_states: self.stock_pool_states.clone(),
+                closing_holdings: self.closing_holdings.clone(),
+                empty_simulation_origin: self.empty_simulation_origin,
+                retired_lot_sequences: self.retired_lot_sequences.clone(),
+                current_session_date: self.current_session_date,
             },
             position_order: Some(self.positions.keys().cloned().collect()),
         }
@@ -799,6 +1117,10 @@ impl PortfolioState {
             day_sold_symbols: BTreeSet::new(),
             corporate_predecessors: BTreeMap::new(),
             stock_pool_states: std::collections::BTreeMap::new(),
+            closing_holdings: Arc::new(BTreeMap::new()),
+            empty_simulation_origin: None,
+            retired_lot_sequences: BTreeMap::new(),
+            current_session_date: None,
         }
     }
 
@@ -852,12 +1174,14 @@ impl PortfolioState {
     pub(crate) fn cash_fixed(&self) -> FixedMoney { self.cash }
 
     pub(crate) fn financial_replay_identity(&self) -> serde_json::Value {
-        let positions = self.positions.iter().filter(|(_, position)| position.quantity > 0)
+        let positions = self.positions.iter().filter(|(_, position)| !position.is_flat())
             .map(|(symbol, position)| {
                 let mut lots = position.lots.iter().map(|lot| (lot.acquired_date, lot.quantity,
-                    lot.entry_value.to_decimal_string(), lot.cost_basis.to_decimal_string())).collect::<Vec<_>>();
+                    lot.entry_value.to_decimal_string(), lot.cost_basis.to_decimal_string(),
+                    lot.origin.clone(), lot.remaining_purchase_units.to_string())).collect::<Vec<_>>();
                 lots.sort();
                 (symbol.clone(), serde_json::json!({"quantity":position.quantity,"lots":lots,
+                    "shareReceivables":position.share_receivables,
                     "openedDate":position.opened_date,"lastBuyDate":position.last_buy_date}))
             }).collect::<std::collections::BTreeMap<_, _>>();
         let mut receivables = self.cash_receivables.iter().map(|row| (row.symbol.clone(), row.ex_date,
@@ -867,6 +1191,26 @@ impl PortfolioState {
         if !self.corporate_predecessors.is_empty() {
             identity["corporatePredecessors"] = serde_json::json!(self.corporate_predecessors);
         }
+        if !self.closing_holdings.is_empty() {
+            identity["registeredClosingHoldings"] = serde_json::json!(self.closing_holdings.as_ref());
+        }
+        if let Some(origin) = self.empty_simulation_origin {
+            identity["emptySimulationOrigin"] = serde_json::json!(origin);
+        }
+        // A retained flat position and its retired counter encode the same
+        // issued acquisitions. Compare that complete state independently of
+        // when a caller prunes an empty position.
+        let mut issued_sequences = self.retired_lot_sequences.clone();
+        for (symbol, position) in &self.positions {
+            if position.next_lot_sequence > 0 {
+                issued_sequences.entry(symbol.clone()).and_modify(|next| *next=(*next).max(position.next_lot_sequence))
+                    .or_insert(position.next_lot_sequence);
+            }
+        }
+        issued_sequences.retain(|_,next| *next>0);
+        if !issued_sequences.is_empty() {
+            identity["issuedLotSequences"] = serde_json::json!(issued_sequences);
+        }
         identity
     }
 
@@ -881,6 +1225,8 @@ impl PortfolioState {
         for (symbol, position) in &mut replayed.positions {
             if let Some(current) = self.positions.get(symbol).filter(|current| current.quantity > 0) {
                 position.last_price = current.last_price;
+                position.last_market_mark_date = current.last_market_mark_date;
+                position.current_session_date = current.current_session_date;
                 position.refresh_day_pnl();
             }
         }
@@ -891,6 +1237,9 @@ impl PortfolioState {
         // Corrected actual receipts can prove a position was fully sold
         // before conversion. Do not retain a now-disproved financial link.
         self.corporate_predecessors = replayed.corporate_predecessors;
+        self.closing_holdings = replayed.closing_holdings;
+        self.empty_simulation_origin = replayed.empty_simulation_origin;
+        self.retired_lot_sequences = replayed.retired_lot_sequences;
         // Existing issued units, explicit cash-flow/financing facts, and task
         // target state are observed controls, not counterfactual new orders.
         Ok(())
@@ -925,9 +1274,11 @@ impl PortfolioState {
     }
 
     pub fn position_mut(&mut self, symbol: &str) -> &mut Position {
+        let next = self.retired_lot_sequences.get(symbol).copied().unwrap_or(0);
+        let session = self.current_session_date;
         self.positions
             .entry(symbol.to_string())
-            .or_insert_with(|| Position::new(symbol))
+            .or_insert_with(|| { let mut position = Position::new(symbol); position.next_lot_sequence = next; position.current_session_date = session; position })
     }
 
     pub fn apply_cash_delta(&mut self, delta: f64) -> Result<(), String> {
@@ -972,7 +1323,8 @@ impl PortfolioState {
             .positions
             .get(symbol)
             .cloned()
-            .unwrap_or_else(|| Position::new(symbol));
+            .unwrap_or_else(|| { let mut position = Position::new(symbol);
+                position.next_lot_sequence = self.retired_lot_sequences.get(symbol).copied().unwrap_or(0); position });
         let delta = match side {
             OrderSide::Buy => gross.checked_add(fees).and_then(FixedMoney::checked_neg),
             OrderSide::Sell => gross.checked_sub(fees),
@@ -1037,6 +1389,8 @@ impl PortfolioState {
         }
         position.day_trade_cost = next_cost;
         position.refresh_day_pnl();
+        position.current_session_date = Some(trade_date);
+        position.last_market_mark_date = Some(trade_date);
         self.positions.insert(symbol.to_string(), position);
         self.cash = next_cash;
         Ok(delta)
@@ -1044,6 +1398,12 @@ impl PortfolioState {
 
     pub fn prune_flat_positions(&mut self) {
         let mut sold_symbols = Vec::new();
+        for (symbol, position) in &self.positions {
+            if position.is_flat() {
+                self.retired_lot_sequences.entry(symbol.clone()).and_modify(|next| *next=(*next).max(position.next_lot_sequence))
+                    .or_insert(position.next_lot_sequence);
+            }
+        }
         self.positions.retain(|symbol, position| {
             if position.is_flat() {
                 if position.sold_quantity() > 0 {
@@ -1299,6 +1659,16 @@ impl PortfolioState {
         &self.cash_receivables
     }
 
+    pub fn cash_receivable_value(&self) -> f64 {
+        self.cash_receivables.iter().try_fold(FixedMoney::ZERO, |total, receivable| {
+            let amount = fixed_money(receivable.amount, "cash receivable asset")?;
+            if amount < FixedMoney::ZERO {
+                return Err("cash receivable asset cannot be negative".to_string());
+            }
+            total.checked_add(amount).ok_or_else(|| "cash receivable asset overflow".to_string())
+        }).expect("cash receivable asset must be valid fixed-point money").to_f64()
+    }
+
     pub fn begin_trading_day(&mut self) {
         self.day_sold_symbols.clear();
         for position in self.positions.values_mut() {
@@ -1307,6 +1677,12 @@ impl PortfolioState {
         self.refresh_dividend_receivables();
     }
 
+    pub fn begin_trading_day_at(&mut self, date: NaiveDate) {
+        self.begin_trading_day();
+        self.current_session_date = Some(date);
+        for position in self.positions.values_mut() { position.current_session_date = Some(date); }
+    }
+
     pub fn update_prices(
         &mut self,
         date: NaiveDate,
@@ -1323,6 +1699,17 @@ impl PortfolioState {
         field: PriceField,
         same_day_buy_close_mark_at_fill: bool,
     ) -> Result<(), DataSetError> {
+        if let Some(position) = self.positions.values().find(|position| {
+            position.share_receivable_quantity() > 0
+                && data.market(date, &position.symbol).is_none()
+                && data.instrument(&position.symbol).is_some_and(|instrument| {
+                    instrument.is_delisted_on_or_before(date)
+                })
+        }) {
+            return Err(DataSetError::MissingSnapshot {
+                kind: "pending_share_delisting_terms", date, symbol: position.symbol.clone(),
+            });
+        }
         let day_sold_symbols = self.day_sold_symbols.clone();
         for position in self.positions.values_mut() {
             let current_market_missing = data.market(date, &position.symbol).is_none();
@@ -1368,6 +1755,7 @@ impl PortfolioState {
                     symbol: position.symbol.clone(),
                 })?;
             position.last_price = price;
+            position.last_market_mark_date = Some(date);
             position.refresh_day_pnl();
         }
         Ok(())
@@ -1377,6 +1765,10 @@ impl PortfolioState {
         self.positions.values().map(Position::market_value).sum()
     }
 
+    pub fn share_receivable_value(&self) -> f64 {
+        self.positions.values().map(Position::share_receivable_value).sum()
+    }
+
     pub fn transaction_cost(&self) -> f64 {
         self.positions
             .values()
@@ -1403,7 +1795,8 @@ impl PortfolioState {
     }
 
     pub fn total_equity(&self) -> f64 {
-        self.cash.to_f64() + self.market_value() - self.cash_liabilities.to_f64()
+        self.cash.to_f64() + self.market_value() + self.cash_receivable_value() + self.share_receivable_value()
+            - self.cash_liabilities.to_f64()
     }
 
     pub fn total_value(&self) -> f64 {
@@ -1447,7 +1840,7 @@ impl PortfolioState {
         let total_equity = self.total_equity();
         self.positions
             .values()
-            .filter(|position| position.quantity > 0)
+            .filter(|position| !position.is_flat())
             .map(|position| {
                 let market_value = position.market_value();
                 let entry_average_cost = position
@@ -1461,6 +1854,8 @@ impl PortfolioState {
                     date,
                     symbol: position.symbol.clone(),
                     quantity: position.quantity,
+                    share_receivable_quantity: position.share_receivable_quantity(),
+                    share_receivable_value: position.share_receivable_value(),
                     average_cost: entry_average_cost,
                     last_price: position.last_price,
                     market_value,
@@ -1501,6 +1896,8 @@ impl PortfolioState {
         }
         let old_symbol_owned = old_symbol.to_string();
         let old_position = self.positions.shift_remove(old_symbol)?;
+        self.retired_lot_sequences.entry(old_symbol.to_owned()).and_modify(|next| *next=(*next).max(old_position.next_lot_sequence))
+            .or_insert(old_position.next_lot_sequence);
         if old_position.quantity == 0 {
             return None;
         }
@@ -1521,6 +1918,8 @@ impl PortfolioState {
                 quantity: round_half_up_u32(lot.quantity as f64 * ratio),
                 entry_value: lot.entry_value,
                 cost_basis: lot.cost_basis,
+                origin: lot.origin,
+                remaining_purchase_units: lot.remaining_purchase_units,
             })
             .collect::<Vec<_>>();
         let expected_total = round_half_up_u32(old_quantity as f64 * ratio);
@@ -1542,10 +1941,11 @@ impl PortfolioState {
             0.0
         };
 
+        let next_lot_sequence = self.retired_lot_sequences.get(new_symbol).copied().unwrap_or(0);
         let successor = self
             .positions
             .entry(new_symbol.to_string())
-            .or_insert_with(|| Position::new(new_symbol));
+            .or_insert_with(|| { let mut position=Position::new(new_symbol); position.next_lot_sequence=next_lot_sequence; position });
         let successor_quantity_before = successor.quantity;
         successor.opened_date = match (successor.opened_date, old_opened_date) {
             (Some(current), Some(previous)) => Some(current.min(previous)),
@@ -2447,6 +2847,10 @@ pub struct HoldingSummary {
     pub date: NaiveDate,
     pub symbol: String,
     pub quantity: u32,
+    #[serde(default)]
+    pub share_receivable_quantity: u32,
+    #[serde(default)]
+    pub share_receivable_value: f64,
     pub average_cost: f64,
     pub last_price: f64,
     pub market_value: f64,

crates/fidc-core/src/strategy.rs

@@ -705,7 +705,7 @@ impl StrategyContext<'_> {
         self.data.get_price(symbol, start, end, frequency)
     }
 
-    pub fn get_dividend(&self, symbol: &str, start: NaiveDate) -> Vec<DividendRecord> {
+    pub fn get_dividend(&self, symbol: &str, start: NaiveDate) -> Result<Vec<DividendRecord>, BacktestError> {
         let current_data_date = self.current_data_date();
         let end = self
             .data

crates/fidc-core/src/strategy_ai.rs

@@ -362,7 +362,7 @@ pub fn built_in_strategy_manual() -> StrategyAiManual {
             ManualFunction { name: "get_trading_dates/get_previous_trading_date/get_next_trading_date".to_string(), signature: "ctx.get_previous_trading_date(date, n)".to_string(), detail: "交易日历 API。get_trading_dates 返回闭区间交易日；previous/next 返回相对某日向前或向后的第 n 个交易日，当前日自身不计入。".to_string() },
             ManualFunction { name: "is_suspended/is_st_stock".to_string(), signature: "ctx.is_suspended(symbol, count)".to_string(), detail: "读取指定证券截至当前信号日最近 count 个交易日的停牌或 ST 标记，返回 bool 序列，顺序从旧到新；对应平台内核的 is_suspended/is_st_stock 数据能力。执行日停牌或 ST 只能由撮合风控判断，不能在 next_bar_open 的 T 日提前固化。".to_string() },
             ManualFunction { name: "get_price".to_string(), signature: "ctx.get_price(symbol, start_date, end_date, \"1d\" | \"1m\")".to_string(), detail: "按日期区间读取统一 PriceBar 序列。日线返回 open/high/low/close/last/volume/盘口字段；分钟线返回按 timestamp 排序的 last/bid1/ask1/volume_delta/amount_delta 映射，便于服务层转成表格或前端明细。".to_string() },
-            ManualFunction { name: "get_dividend / dividend_cash / has_dividend".to_string(), signature: "dividend_cash(lookback) / has_dividend(lookback)".to_string(), detail: "高级数据 风格分红 API。Rust Context 可用 ctx.get_dividend(symbol, start_date) 读取明细；平台表达式可用 dividend_cash(lookback) 汇总当前股票最近 N 个交易日现金分红，用 has_dividend(lookback) 判断是否发生分红，也支持 dividend_cash(\"600000.SH\", lookback)。".to_string() },
+            ManualFunction { name: "get_dividend / dividend_cash / has_dividend".to_string(), signature: "dividend_cash(lookback) / has_dividend(lookback)".to_string(), detail: "高级数据 风格分红 API。Rust Context 可用 ctx.get_dividend(symbol, start_date)? 读取明细；缺少真实付款日或付款日早于除息日时返回错误，不推定到账日期。平台表达式可用 dividend_cash(lookback) 汇总当前股票最近 N 个交易日现金分红，用 has_dividend(lookback) 判断是否发生分红，也支持 dividend_cash(\"600000.SH\", lookback)。".to_string() },
             ManualFunction { name: "get_split / split_ratio / has_split".to_string(), signature: "split_ratio(lookback) / has_split(lookback)".to_string(), detail: "高级数据 风格拆分/送转 API。Rust Context 可用 ctx.get_split(symbol, start_date) 读取明细；平台表达式可用 split_ratio(lookback) 计算当前股票最近 N 个交易日累计拆分比例，has_split(lookback) 判断是否发生送转。".to_string() },
             ManualFunction { name: "get_factor / factor_value".to_string(), signature: "factor_value(\"field\", lookback=1)".to_string(), detail: "数值因子 API。factor(\"field\") 读取当前股票当日因子；factor_value(\"field\", lookback) 会在最近 N 个交易日内取该字段最新数值，适合读取任意可用指标或自定义数值因子。Rust Context 可用 ctx.get_factor(symbol, start, end, field) 读取完整数值序列。".to_string() },
             ManualFunction { name: "get_factor_text / factor_text".to_string(), signature: "factor_text(\"field\", lookback=1)".to_string(), detail: "字符串因子 API。读取最近 N 个交易日内指定字段的最新字符串值，适合行业名称、概念、标签、风格分类、自定义文本信号等字段。示例：factor_text(\"concept\") == \"ai_chip\" 或 factor(\"industry_name\") == \"电子\"。Rust Context 可用 ctx.get_factor_text(symbol, start, end, field) 读取完整字符串序列。".to_string() },

crates/fidc-core/tests/automatic_trade_protection.rs

@@ -158,6 +158,10 @@ fn observed_manual_trades_then_split_keep_real_fill_protection_and_lock_dates()
         date: d(15),
         symbol: "000001.SZ".into(),
         payable_date: None,
+        record_date: Some(d(14)),
+        share_effective_date: Some(d(15)),
+        share_rounding_rule: None,
+        ex_reference_price: Some(5.0),
         share_cash: 0.,
         share_bonus: 1.,
         share_gift: 0.,

crates/fidc-core/tests/corporate_actions.rs

@@ -267,6 +267,10 @@ fn successor_conversion_depletes_older_source_lots_before_newer_successor_buys()
             date: dates[2],
             symbol: symbols[0].into(),
             payable_date: None,
+            record_date: Some(dates[1]),
+            share_effective_date: None,
+            share_rounding_rule: None,
+            ex_reference_price: None,
             share_cash: 0.,
             share_bonus: 0.,
             share_gift: 0.,
@@ -520,6 +524,10 @@ fn engine_reinvests_dividend_receivable_in_round_lots() {
             date: ex_date,
             symbol: "000001.SZ".to_string(),
             payable_date: Some(payable_date),
+            record_date: Some(buy_date),
+            share_effective_date: None,
+            share_rounding_rule: None,
+            ex_reference_price: Some(8.95),
             share_cash: 1.05,
             share_bonus: 0.0,
             share_gift: 0.0,
@@ -603,6 +611,10 @@ fn engine_settles_same_day_dividend_after_split_for_aiquant_semantics() {
             date: ex_date,
             symbol: "000001.SZ".to_string(),
             payable_date: Some(ex_date),
+            record_date: Some(buy_date),
+            share_effective_date: Some(ex_date),
+            share_rounding_rule: None,
+            ex_reference_price: Some((10.0 - 1.05) / 1.2),
             share_cash: 1.05,
             share_bonus: 0.2,
             share_gift: 0.0,
@@ -658,7 +670,7 @@ fn engine_settles_same_day_dividend_after_split_for_aiquant_semantics() {
         result
             .position_events
             .iter()
-            .any(|event| event.reason == "stock_split 1.200000" && event.quantity_after == 1_200)
+            .any(|event| event.reason == "registered_share_distribution_delivered" && event.quantity_after == 1_200)
     );
     assert!(
         result

crates/fidc-core/tests/delisting.rs

@@ -530,6 +530,10 @@ fn engine_applies_successor_conversion_before_unresolved_delisting_audit() {
             date: date2,
             symbol: "000001.SZ".to_string(),
             payable_date: None,
+            record_date: Some(date1),
+            share_effective_date: None,
+            share_rounding_rule: None,
+            ex_reference_price: None,
             share_cash: 0.0,
             share_bonus: 0.0,
             share_gift: 0.0,

crates/fidc-core/tests/dividend_reinvestment_contract.rs

@@ -92,6 +92,10 @@ fn data() -> DataSet {
             date: day(14),
             symbol: SYMBOL.into(),
             payable_date: Some(day(14)),
+            record_date: Some(day(11)),
+            share_effective_date: None,
+            share_rounding_rule: None,
+            ex_reference_price: Some(8.95),
             share_cash: 1.05,
             share_bonus: 0.,
             share_gift: 0.,

crates/fidc-core/tests/manual_corporate_observation.rs

@@ -120,6 +120,14 @@ fn data_with_successor_metadata(action: Action, include_successor: bool) -> Data
             date: date(14),
             symbol: "000001.SZ".into(),
             payable_date: Some(date(14)),
+            record_date: Some(date(11)),
+            share_effective_date: Some(date(14)),
+            share_rounding_rule: Some("aggregate_half_up".into()),
+            ex_reference_price: match action {
+                Action::Dividend => Some(9.0),
+                Action::Split => Some(5.0),
+                Action::Successor => None,
+            },
             share_cash: if matches!(action, Action::Dividend) {
                 1.
             } else {

docs/cash-receivable-equity-20261005.md

@@ -0,0 +1,25 @@
+# 应收股息资产与支付日净值守恒修复
+
+2026-10-05。发现总权益只计算现金、持仓市值和负债，遗漏已经确认但尚未支付的应收股息。这会在除息后的持仓计价下降时低估资产，再在真正支付时把资产转移误呈现成收益。本次修复账簿计价；没有部署活动运行版本或改写历史研究结果，生产策略仍为 0/10。
+
+## 行为更正
+
+`PortfolioState::total_equity` 现在加入独立应收股息资产。应收金额逐项转换为固定精度货币并检查非负及溢出，既不变成可用现金，也不计入证券市值。真实支付通过既有结算链路将同一资产从应收转为现金，不凭空新增权益；已卖光或被清理的持仓不能让应收资产消失。
+
+具体回归：账户现金 1,000、登记日持有 100 股、价格 10、税前每股股息 0.5。除息后持仓市值 950、应收 50，账户权益仍为 2,000；支付前现金仍为 1,000，支付后现金 1,050、应收零，总权益保持 2,000。没有实际到账前，提现仍受现金余额约束。独立无持仓案例验证应收 50 不因空持仓清理而丢失。
+
+同时移除对原始股息率的 `f64::EPSILON` 过滤。明确的极小非零值仍出现在股息查询中，也必须具备支付日、登记日和实际登记持仓证据；不能因为最终乘积可能按货币精度舍入为零，就在校验前抹掉原始率或绕过门禁。新增 1e-16 原始率的保留及未知支付日拒绝回归。
+
+## 代码、运行与证据
+
+权益计价提交为 `af655de0c169cd92ea8bf9bbc77c34a5c157bdf3`，极小非零率提交为 `d3f49a17ef284dba587607ad0ac160cc394bf677`，已推送既有工作分支。没有重写正式历史输入、模型、评分、旧日志或旧报告。
+
+重构建及测试在 177 的 Boris UID 1003 私有 checkout 中执行，显式使用批准的 `stable-x86_64-unknown-linux-gnu` / Rust 1.98.0、锁文件和离线依赖。编译输出写入已核验可执行的 `/tmp` tmpfs，单元 CPUQuota=400%、MemoryMax=16GiB、MemorySwapMax=0、4 个构建 worker；不使用低于保留线的 SSD 进行批量构建，不改系统工具链。
+
+首次权益计价版本通过 18 项定向测试及全工作区 963 项测试。最终版本 `cargo test --locked --offline -p fidc-core --all-targets` 通过 **964 项测试、9 项既有忽略项**，日志 SHA256 为 `7e25d69e1adec3183394a90a6c3dfab01c56982f9a4aa64afd261af69be72551`。新改动后复核完整核心回归，未跳过失败样本。
+
+验证回执 SHA256 为 `c92576e6ecb36727444baf4f0eeebd5a1d9f401cc60cc88f541482e7c2645640`，PG18 artifact 为 `strategy_research_fcae25fd6b283a74016bd99e`，完整 JSONB 回读通过。回执、PG 原记录、首次及最终测试日志见 `docs/evidence/cash-receivable-equity-20261005/`。真实冻结研究执行器仍为 PID 1396112、InvocationID `0eb28e3a45694a00951aa3aec0e13465`，原数值研究预算未重开。
+
+## 未完成门禁
+
+此次结果证明应收现金计入权益及支付转移的账簿回归，不等同于完整实盘或策略验收。股份应收、登记日送转权益、真实股份交付与可卖日仍需继续实现；Rust 接收端对股份交付日的承接、AiQuant 同条件运行、完整 Source 事件/无事件与修订证据、样本外、容量、模拟盘和人工审批仍未闭环。`production_runtime_deployed=false`、`production_ready=false`、`trading_allowed=false` 保留。

docs/corporate-ex-reference-20261005.md

@@ -0,0 +1,13 @@
+# 公司行为现金应收与估值参考分离
+
+2026-10-05。发行人差异化分红原公告证明，股东税前应收现金与按总股本摊薄的除息扣减额可以不同。原账本用登记 lot 的现金分摊扣减 `last_price`，还会改变已有除息日实际报价及合并后的其他证券价格；股份应收估值也从现金腿推算，缺少独立来源合同。
+
+新增 `CorporateAction.ex_reference_price` 作为独立来源事实。旧日期持仓只按已验证的正有限参考价重标一次，同日实际价格保持原值；非法、未知、未来市场标记及同股同日冲突参考拒绝且整个批次原子不变。分红应收和配置成本调整仍按原登记合资格 lot；现金可用日期、股份实际交付日期、历史持股日期和保护锁沿用各自事实，不从市场价格反推应收现金。缺少参考事实不得使用旧相邻收盘、除息日未来收盘或 gross cash 推造。
+
+业务版本 `31c332895c5e9042df7bd13b124c769e3ef2b98a` 在 177 Boris UID 1003、Rust 1.98.0、CPUQuota 400%、MemoryMax 16G、禁交换和增量编译的 tmpfs 中完成完整 `fidc-core` 回归：**975 通过、9 忽略**。日志 SHA `f2b8aaea6a8d6f6dace79938e1ecebca2866587a8b43b5cbf5a16f90bed2a5e1`，PG18 artifact `strategy_research_6f611c63e74c4b03feadda9e`，完整 JSONB 独立回读通过。新增五组回归覆盖差异化分红、同日实际标记、现金和延迟股份组合、参考未知/非法原子拒绝及同日冲突；数量溢出夹具补齐合成参考前置事实后保留严格溢出拒绝。首次失败结果和日志保留，PG artifact `strategy_research_5152f228b65cada325740594`。
+
+相配 Source 业务版本 `e52ee7e538acf134054e89c17f236f2d2b2d4861` 的 Rows 语义 v12，SHA `b0bccd0865cc879098573b492c5465f84f9bfacaf87556a3c1935bf4090c3aad`；runner 业务版本 `c1e08b1e6567bc0694fa1f3360cd42d682bd3791` 公司行为缓存 v6。旧 v11/v7/v5、原冻结 bundle 和数值模型不重标。Source 450 项与 83 个子测试通过，runner 包 475 项通过、9 忽略。
+
+13 份原公告、51 页全文及原结构化现金/日期核验，物理 PDF SHA、页码与完整血缘保存在 Alpha 仓库 `docs/projection-same-day-dividend-originals-20261005.md` 和对应 evidence。原件核验 SHA `abad2573b85ccba18ac893ae1f8e3db6ff07bef990cc5fac28d28a80707cf5aa`，PG artifact `strategy_research_20499f0567229defd2290f87`。近似除息扣减额另有精度标记，不能成为精确相等或全市场参考价准入证明。
+
+独立运行核验 SHA `d57f23c0970f6ae02de5dda2be1053040c200580c17fe6e7f1d01d478bcdea78`，PG artifact `strategy_research_6447dca5c8fddfd77dc5c399`。五个原运行单元身份和 v11 计划保持不变、两个健康接口 200、获授权 incremental 根零文件。本次仅验证候选源码，未正式发布或部署；全市场 Source 准入、冻结输入、双框架与生产审批未完成，生产策略仍 0/10。

docs/evidence/cash-receivable-equity-20261005/file-shas.json

@@ -0,0 +1,27 @@
+{
+  "full-linux-tests.log": {
+    "original_path": "/data/fidc-cold/autonomous-research/fidc-cash-receivable-validation-20261005-d3f49a1/full-linux-tests.log",
+    "bytes": 98059,
+    "sha256": "7e25d69e1adec3183394a90a6c3dfab01c56982f9a4aa64afd261af69be72551"
+  },
+  "validation-receipt.json": {
+    "original_path": "/data/fidc-cold/autonomous-research/fidc-cash-receivable-validation-20261005-d3f49a1/validation-receipt.json",
+    "bytes": 1728,
+    "sha256": "c92576e6ecb36727444baf4f0eeebd5a1d9f401cc60cc88f541482e7c2645640"
+  },
+  "validation-pg-receipt.json": {
+    "original_path": "/data/fidc-cold/autonomous-research/fidc-cash-receivable-validation-20261005-d3f49a1/validation-pg-receipt.json",
+    "bytes": 2771,
+    "sha256": "eb2e367fc18a43297b70f9bd7967b317463369365291644d1383aaebb012eb7c"
+  },
+  "first-targeted-linux-tests.log": {
+    "original_path": "/data/fidc-cold/autonomous-research/fidc-cash-receivable-validation-20261005-af655de/targeted-linux-tests.log",
+    "bytes": 8284,
+    "sha256": "10e4936faf4ac2955d2e3d9038f5d56c43e7eaccb0b62b6fcaa701bb68a4b1fd"
+  },
+  "first-full-linux-tests.log": {
+    "original_path": "/data/fidc-cold/autonomous-research/fidc-cash-receivable-validation-20261005-af655de/full-linux-tests.log",
+    "bytes": 101035,
+    "sha256": "6e90211e4df5c91d81e55f3de4cbd6ed9b24b20cdf7c4927d7cdcadcdda41467"
+  }
+}

docs/evidence/cash-receivable-equity-20261005/first-targeted-linux-tests.log

@@ -0,0 +1,177 @@
+   Compiling version_check v0.9.5
+   Compiling proc-macro2 v1.0.106
+   Compiling unicode-ident v1.0.24
+   Compiling quote v1.0.45
+   Compiling autocfg v1.5.0
+   Compiling serde_core v1.0.228
+   Compiling libc v0.2.184
+   Compiling cfg-if v1.0.4
+   Compiling crunchy v0.2.4
+   Compiling generic-array v0.14.7
+   Compiling tiny-keccak v2.0.2
+   Compiling crossbeam-utils v0.8.22
+   Compiling num-traits v0.2.19
+   Compiling syn v2.0.117
+   Compiling typenum v1.20.1
+   Compiling serde v1.0.228
+   Compiling portable-atomic v1.13.1
+   Compiling crossbeam-epoch v0.9.20
+   Compiling getrandom v0.2.17
+   Compiling getrandom v0.3.4
+   Compiling once_cell v1.21.4
+   Compiling rustversion v1.0.22
+   Compiling crossbeam-deque v0.8.7
+   Compiling zerocopy v0.8.48
+   Compiling const-random-macro v0.1.16
+   Compiling smartstring v1.0.1
+   Compiling ahash v0.8.12
+   Compiling static_assertions v1.1.0
+   Compiling rayon-core v1.13.0
+   Compiling zmij v1.0.23
+   Compiling const-random v0.1.18
+   Compiling crypto-common v0.1.7
+   Compiling block-buffer v0.10.4
+   Compiling itoa v1.0.18
+   Compiling thiserror v2.0.18
+   Compiling serde_json v1.0.145
+   Compiling rust_decimal v1.39.0
+   Compiling castaway v0.2.4
+   Compiling digest v0.10.7
+   Compiling iana-time-zone v0.1.65
+   Compiling ryu v1.0.23
+   Compiling hashbrown v0.16.1
+   Compiling equivalent v1.0.2
+   Compiling bitflags v2.11.1
+   Compiling smallvec v1.15.1
+   Compiling either v1.17.0
+   Compiling thin-vec v0.2.16
+   Compiling serde_derive v1.0.228
+   Compiling thiserror-impl v2.0.18
+   Compiling rhai_codegen v3.1.0
+   Compiling arrayvec v0.7.8
+   Compiling memchr v2.8.0
+   Compiling ta-lib-dispatch v0.1.2 (https://github.com/TA-Lib/ta-lib.git?rev=dd5a90259a3f9e04e2da9f38bf0719a841b40108#dd5a9025)
+   Compiling cpufeatures v0.2.17
+   Compiling sha2 v0.10.9
+   Compiling rhai v1.23.6
+   Compiling ta-lib v0.8.1 (https://github.com/TA-Lib/ta-lib.git?rev=dd5a90259a3f9e04e2da9f38bf0719a841b40108#dd5a9025)
+   Compiling indexmap v2.11.4
+   Compiling chrono v0.4.44
+   Compiling compact_str v0.10.0
+   Compiling rayon v1.12.0
+   Compiling fidc-core v0.1.0 (/srv/fidc/programs/src/fidc-cash-receivable-validation-20261005-af655de/crates/fidc-core)
+    Finished `test` profile [unoptimized] target(s) in 56.65s
+     Running unittests src/lib.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/fidc_core-dbea4d4f6cb5d2d7)
+
+running 18 tests
+test corporate_book::tests::closing_register_cannot_be_replaced_by_later_holdings ... ok
+test corporate_book::tests::dividend_receivable_survives_a_flat_position_without_becoming_spendable_cash ... ok
+test corporate_book::tests::entitlement_survives_complete_sale_and_a_successor_unit_conversion ... ok
+test corporate_book::tests::explicitly_delayed_dividend_remains_receivable_until_actual_payment ... ok
+test corporate_book::tests::a_late_corporate_batch_failure_keeps_prior_cash_positions_and_notes ... ok
+test corporate_book::tests::corporate_quantity_overflow_fails_without_saturation_or_a_negative_delta ... ok
+test corporate_book::tests::missing_accounting_reference_is_atomic_not_a_silent_cash_only_success ... ok
+test corporate_book::tests::manual_zero_skips_only_unused_allocation_facts_not_invalid_cash_evidence ... ok
+test corporate_book::tests::flat_position_retirement_does_not_change_issued_lot_state_or_next_purchase_origin ... ok
+test corporate_book::tests::per_share_precision_is_retained_until_the_registered_cash_amount_is_rounded ... ok
+test corporate_book::tests::missing_or_backward_cash_payment_date_never_updates_the_account ... ok
+test corporate_book::tests::missing_record_date_or_unobserved_closing_book_is_atomic ... ok
+test corporate_book::tests::post_record_buy_cannot_receive_the_earlier_dividend ... ok
+test corporate_book::tests::terminated_security_keeps_paid_cash_and_is_not_recreated_by_reinvestment ... ok
+test corporate_book::tests::sale_after_registration_preserves_cash_and_excludes_new_lots_from_cost_adjustment ... ok
+test corporate_book::tests::successor_without_frozen_instrument_metadata_is_not_an_implicit_new_security ... ok
+test corporate_book::tests::verified_conversion_preserves_lots_without_creating_orders_or_fills ... ok
+test corporate_book::tests::invalid_successor_terms_cannot_be_replaced_with_one_share_or_zero_cash ... ok
+
+test result: ok. 18 passed; 0 failed; 0 ignored; 0 measured; 764 filtered out; finished in 0.01s
+
+     Running unittests src/bin/dump_platform_runtime_schema.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/dump_platform_runtime_schema-c4b52627aec309c9)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+     Running tests/automatic_trade_protection.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/automatic_trade_protection-e76e4284ad200e69)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 6 filtered out; finished in 0.00s
+
+     Running tests/core_rules.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/core_rules-6365eded07d721e8)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 8 filtered out; finished in 0.00s
+
+     Running tests/corporate_actions.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/corporate_actions-05d8a8628f15e674)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 6 filtered out; finished in 0.00s
+
+     Running tests/decision_quote_preload.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/decision_quote_preload-f63700247a753869)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 6 filtered out; finished in 0.00s
+
+     Running tests/delisting.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/delisting-4a43fc52b1f023c5)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out; finished in 0.00s
+
+     Running tests/dividend_reinvestment_contract.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/dividend_reinvestment_contract-69149bb471610f44)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 8 filtered out; finished in 0.00s
+
+     Running tests/engine_hooks.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/engine_hooks-3b06d8e9ecb68f45)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 30 filtered out; finished in 0.00s
+
+     Running tests/explicit_order_flow.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/explicit_order_flow-fe395fa4711b4010)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 58 filtered out; finished in 0.00s
+
+     Running tests/futures_account.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/futures_account-47b777d1d163df6f)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 12 filtered out; finished in 0.00s
+
+     Running tests/intraday_history_performance.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/intraday_history_performance-7ce6b1e7b0291409)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 3 filtered out; finished in 0.00s
+
+     Running tests/manual_corporate_observation.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/manual_corporate_observation-8dc2a04a201f24a0)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 11 filtered out; finished in 0.00s
+
+     Running tests/stock_pool_execution_contract.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/stock_pool_execution_contract-a11a2ea3e2392446)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 30 filtered out; finished in 0.00s
+
+     Running tests/stock_pool_execution_state.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/stock_pool_execution_state-a8b965ddcfd186e1)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 8 filtered out; finished in 0.00s
+
+     Running tests/strategy_selection.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/strategy_selection-bf5a72b2003c833f)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 2 filtered out; finished in 0.00s
+

docs/evidence/cash-receivable-equity-20261005/validation-pg-receipt.json

@@ -0,0 +1,59 @@
+{
+  "artifact_bytes": 1728,
+  "artifact_id": "strategy_research_fcae25fd6b283a74016bd99e",
+  "artifact_path": "/data/fidc-cold/autonomous-research/fidc-cash-receivable-validation-20261005-d3f49a1/validation-receipt.json",
+  "artifact_sha256": "c92576e6ecb36727444baf4f0eeebd5a1d9f401cc60cc88f541482e7c2645640",
+  "artifact_type": "research_source_scope_probe",
+  "contract_sha256": "39388b1bb63377e170145fcff03cee9bb3996283e5fa7c2c44453bbc82525e36",
+  "created_at": "2026-10-04T19:06:15Z",
+  "created_by": "boris",
+  "department_id": null,
+  "organization_id": "local_org",
+  "persisted_at": "2026-10-04T19:06:15Z",
+  "production_ready": false,
+  "record_json": {
+    "cash_entitlement_asset_included_without_spendable_cash_inference": true,
+    "component": "fidc-backtest-engine",
+    "contract_sha256": "31d7028d123a9abd2004d93534f3d8768704b2904529a3666d6146d67de36018",
+    "engine_commit": "d3f49a17ef284dba587607ad0ac160cc394bf677",
+    "ignored_benchmarks": 9,
+    "log_reference": {
+      "path": "/data/fidc-cold/autonomous-research/fidc-cash-receivable-validation-20261005-d3f49a1/full-linux-tests.log",
+      "sha256": "7e25d69e1adec3183394a90a6c3dfab01c56982f9a4aa64afd261af69be72551"
+    },
+    "numeric_research_budget_reopened": false,
+    "observed_at": "2026-10-04T19:06:11.362993+00:00",
+    "original_numerical_research_executor": {
+      "ActiveState": "active",
+      "InvocationID": "0eb28e3a45694a00951aa3aec0e13465",
+      "MainPID": "1396112"
+    },
+    "owner_uid": 1003,
+    "payment_is_receivable_to_cash_asset_transfer_not_new_income": true,
+    "production_ready": false,
+    "production_runtime_deployed": false,
+    "production_strategy_count": 0,
+    "resource_contract": {
+      "build_jobs": 4,
+      "cpu_percent": 400,
+      "memory_max_bytes": 17179869184,
+      "memory_swap_max_bytes": 0,
+      "rust_toolchain": "stable-x86_64-unknown-linux-gnu",
+      "rustc": "1.98.0",
+      "target_filesystem": "executable_tmpfs",
+      "target_path": "/tmp/fidc-cash-receivable-build-20261005-af655de"
+    },
+    "schema_version": "fidc.linux-cash-receivable-equity-validation/v1",
+    "sharedelivery_ledger_implemented": false,
+    "source_path": "/srv/fidc/programs/src/fidc-cash-receivable-validation-20261005-d3f49a1",
+    "status": "full_engine_regression_passed_not_runtime_or_strategy_acceptance",
+    "tests_passed": 964,
+    "tiny_nonzero_original_rate_preserved_and_dates_still_required": true,
+    "trading_allowed": false
+  },
+  "research_key": "fidc-cash-receivable-equity-validation-20261005-d3f49a1",
+  "schema_table": "strategy_research_artifact",
+  "schema_version": "fidc.linux-cash-receivable-equity-validation/v1",
+  "status": "full_engine_regression_passed_not_runtime_or_strategy_acceptance",
+  "storage": "postgres"
+}

docs/evidence/cash-receivable-equity-20261005/validation-receipt.json

@@ -0,0 +1,40 @@
+{
+  "cash_entitlement_asset_included_without_spendable_cash_inference": true,
+  "component": "fidc-backtest-engine",
+  "contract_sha256": "31d7028d123a9abd2004d93534f3d8768704b2904529a3666d6146d67de36018",
+  "engine_commit": "d3f49a17ef284dba587607ad0ac160cc394bf677",
+  "ignored_benchmarks": 9,
+  "log_reference": {
+    "path": "/data/fidc-cold/autonomous-research/fidc-cash-receivable-validation-20261005-d3f49a1/full-linux-tests.log",
+    "sha256": "7e25d69e1adec3183394a90a6c3dfab01c56982f9a4aa64afd261af69be72551"
+  },
+  "numeric_research_budget_reopened": false,
+  "observed_at": "2026-10-04T19:06:11.362993+00:00",
+  "original_numerical_research_executor": {
+    "ActiveState": "active",
+    "InvocationID": "0eb28e3a45694a00951aa3aec0e13465",
+    "MainPID": "1396112"
+  },
+  "owner_uid": 1003,
+  "payment_is_receivable_to_cash_asset_transfer_not_new_income": true,
+  "production_ready": false,
+  "production_runtime_deployed": false,
+  "production_strategy_count": 0,
+  "resource_contract": {
+    "build_jobs": 4,
+    "cpu_percent": 400,
+    "memory_max_bytes": 17179869184,
+    "memory_swap_max_bytes": 0,
+    "rust_toolchain": "stable-x86_64-unknown-linux-gnu",
+    "rustc": "1.98.0",
+    "target_filesystem": "executable_tmpfs",
+    "target_path": "/tmp/fidc-cash-receivable-build-20261005-af655de"
+  },
+  "schema_version": "fidc.linux-cash-receivable-equity-validation/v1",
+  "sharedelivery_ledger_implemented": false,
+  "source_path": "/srv/fidc/programs/src/fidc-cash-receivable-validation-20261005-d3f49a1",
+  "status": "full_engine_regression_passed_not_runtime_or_strategy_acceptance",
+  "tests_passed": 964,
+  "tiny_nonzero_original_rate_preserved_and_dates_still_required": true,
+  "trading_allowed": false
+}

docs/evidence/registered-share-delivery-20261005/additional-file-shas.json

@@ -0,0 +1,11 @@
+{
+  "files": [
+    {
+      "bytes": 827,
+      "file": "validation-probe-assembly-failure.json",
+      "sha256": "7e648d3fc3d3e77b6ce5c30f1c7dc49035d0a0467e433ea2afd0ed2256fe451f"
+    }
+  ],
+  "original_manifest_sha256": "e26c6bb619b9d0f0183983da3e8c030dfc61e610cf0b3a4c2311d3525cc85355",
+  "schema_version": "fidc.additional-share-delivery-evidence/v1"
+}

docs/evidence/registered-share-delivery-20261005/core-attempt1-failure.log

@@ -0,0 +1,853 @@
+   Compiling fidc-core v0.1.0 (/srv/fidc/programs/src/fidc-share-receivable-validation-20261005-0caac44/crates/fidc-core)
+    Finished `test` profile [unoptimized] target(s) in 41.35s
+     Running unittests src/lib.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/fidc_core-dbea4d4f6cb5d2d7)
+
+running 786 tests
+test broker::tests::aiquant_rules_keep_structured_buy_risk_while_using_aiquant_limit_price ... ok
+test broker::tests::aiquant_sell_rule_still_blocks_real_allow_sell_false ... ok
+test broker::tests::aiquant_sell_rule_uses_intraday_quote_when_daily_snapshot_is_stale_lower_limit ... ok
+test broker::tests::aiquant_target_portfolio_smart_keeps_batch_semantics_after_failed_full_close_sell ... ok
+test broker::tests::aiquant_target_portfolio_smart_rejects_deferred_buy_risk_at_order_stage ... ok
+test broker::stock_pool::successor_protection_tests::deferred_etf_open_rechecks_inherited_locks_and_cooldown_before_any_order ... ok
+test broker::tests::aiquant_target_value_delta_uses_scheduled_mark_price ... ok
+test broker::tests::algorithm_clock::algorithm_expiry_without_a_quote_does_not_reuse_old_liquidity ... ok
+test broker::tests::algorithm_clock::a_clock_slice_does_not_turn_window_twap_into_an_unlimited_instant_order ... ok
+test broker::tests::algorithm_clock::algorithm_sell_honors_t_plus_one_and_keeps_original_quantity_after_partial_fills ... ok
+test broker::tests::algorithm_clock::an_explicit_ioc_or_fok_does_not_become_a_persistent_algorithm ... ok
+test broker::tests::algorithm_clock::control_only_phase_cannot_be_used_to_submit_an_order_or_leave_matching_disabled ... ok
+test broker::tests::algorithm_clock::non_matching_controls_amend_or_cancel_without_filling_a_crossing_quote ... ok
+test broker::tests::algorithm_clock::changing_the_later_daily_close_does_not_resize_an_algorithm_submitted_now ... ok
+test broker::tests::algorithm_clock::global_vwap_matching_keeps_the_same_working_order_between_clock_ticks ... ok
+test broker::tests::algorithm_clock::partial_algorithm_cancel_releases_reservation_and_never_executes_the_remainder ... ok
+test broker::tests::algorithm_clock::separate_buy_cannot_spend_the_working_algorithms_cash_budget ... ok
+test broker::tests::algorithm_clock::two_working_algorithms_reserve_only_real_cash_without_starving_the_first ... ok
+test broker::tests::complete_daily_target_batch_uses_positive_target_count_for_slot_limit ... ok
+test broker::tests::daily_capacity_requires_a_timed_observation_instead_of_falling_back_to_total_volume ... ok
+test broker::tests::algorithm_clock::twap_clock_preserves_quantity_prices_fees_budget_and_parent_order ... ok
+test broker::tests::daily_matching_does_not_require_intraday_quote_quantity ... ok
+test broker::tests::custom_valuation_missing_with_current_market_still_fails_closed ... ok
+test broker::tests::decision_buy_denial_allows_reducing_an_existing_buy ... ok
+test broker::tests::algorithm_clock::vwap_clock_preserves_cash_costs_and_does_not_spend_future_volume ... ok
+test broker::tests::decision_buy_denial_does_not_rewrite_existing_pending_order ... ok
+test broker::tests::decision_buy_denial_blocks_topup_but_allows_sell_and_does_not_leak ... ok
+test broker::tests::daily_session_volume_changes_only_audit_not_opening_fills ... ok
+test broker::tests::decision_buy_denial_rejects_increasing_amendments_without_mutation ... ok
+test broker::tests::each_execution_leg_rechecks_one_yuan_including_slippage_and_limit_price ... ok
+test broker::tests::explicit_quote_price_models_do_not_replace_missing_prices_or_reuse_older_ones ... ok
+test broker::tests::decision_buy_denial_uses_actual_next_open_target_delta ... ok
+test broker::tests::failed_target_exit_blocks_replacement_entry_when_no_position_slot_is_released ... ok
+test broker::tests::gtc_resting_order_keeps_its_session_and_original_dates_across_days ... ok
+test broker::tests::deferred_etf_batch_failure_keeps_both_targets_and_prior_generation_progress ... ok
+test broker::tests::failed_new_batch_does_not_erase_prior_success_or_double_charge_on_retry ... ok
+test broker::tests::historical_slippage_rejects_missing_future_or_invalid_calibration_without_raw_price_fallback ... ok
+test broker::tests::instantaneous_twap_without_limits_does_not_cap_quote_quantity ... ok
+test broker::tests::intraday_execution_rejects_buy_at_upper_limit_price ... ok
+test broker::tests::independent_target_entry_is_not_subject_to_replacement_slot_limit ... ok
+test broker::tests::intraday_execution_rejects_sell_at_lower_limit_price ... ok
+test broker::tests::later_execution_clocks_do_not_replenish_the_same_observed_volume ... ok
+test broker::tests::minute_last_exact_time_does_not_fallback_to_older_liquid_quote ... ok
+test broker::tests::minute_last_execution_uses_latest_quote_before_decision_time ... ok
+test broker::tests::market_share_buy_skips_quantity_that_rounds_below_one_lot ... ok
+test broker::tests::minute_last_prefilter_does_not_use_snapshot_minute_volume ... ok
+test broker::tests::minute_last_quote_quantity_cap_depends_on_liquidity_limit ... ok
+test broker::tests::minute_last_uses_volume_delta_when_level1_depth_missing ... ok
+test broker::tests::minute_last_volume_limit_caps_quote_volume_delta_without_liquidity_limit ... ok
+test broker::tests::minute_last_volume_limit_rejects_sub_lot_quote_volume ... ok
+test broker::tests::minute_last_without_volume_or_liquidity_limit_does_not_cap_quote_quantity ... ok
+test broker::tests::historical_slippage_does_not_read_later_daily_fields_for_open_or_minute_fills ... ok
+test broker::tests::next_open_buy_limit_risk_rejects_open_upper_limit_even_when_close_is_clean ... ok
+test broker::tests::next_open_buy_limit_risk_uses_open_not_close ... ok
+test broker::tests::next_open_buy_risk_rejects_execution_date_delisted_even_without_market_snapshot ... ok
+test broker::tests::next_open_buy_risk_uses_execution_date_not_signal_date ... ok
+test broker::tests::next_open_day_limit_remainder_matches_intraday_with_execution_day_ttl ... ok
+test broker::tests::next_open_sell_limit_risk_rejects_open_lower_limit_even_when_close_is_clean ... ok
+test broker::tests::next_open_buy_risk_rejects_execution_date_st_even_if_signal_date_was_clean ... ok
+test broker::tests::next_open_sell_limit_risk_uses_open_not_close ... ok
+test broker::tests::next_open_sell_risk_rejects_execution_date_lower_limit_even_if_signal_date_was_clean ... ok
+test broker::tests::next_open_sell_risk_uses_execution_date_not_signal_date ... ok
+test broker::tests::next_open_target_portfolio_unpriced_symbol_does_not_abort_batch ... ok
+test broker::tests::next_open_target_value_valuation_uses_execution_open ... ok
+test broker::tests::next_open_target_value_recomputes_quantity_from_execution_open ... ok
+test broker::tests::next_open_unpriced_active_snapshot_rejects_without_historical_fill ... ok
+test broker::tests::open_order_upsert_replaces_in_place_and_preserves_queue_position ... ok
+test broker::tests::next_open_with_observations_uses_opening_volume_not_daily_totals_or_future_quotes ... ok
+test broker::tests::next_open_unpriced_paused_snapshot_prefers_execution_day_pause_risk ... ok
+test broker::tests::post_close_phase_is_derived_from_actual_same_day_submission_time ... ok
+test broker::tests::post_close_order_uses_close_without_slippage_and_waits_until_matching_window ... ok
+test broker::tests::queued_order_retains_the_real_creation_clock_when_retried ... ok
+test broker::tests::session_audit_does_not_infer_an_opening_suspension_from_future_zero_volume ... ok
+test broker::tests::scheduled_target_value_valuation_and_sizing_use_same_intraday_price ... ok
+test broker::tests::session_capacity_audit_never_caps_an_early_odd_lot_sell ... ok
+test broker::tests::public_callback_unwind_does_not_leak_order_context_or_authoritative_prior_state ... ok
+test broker::tests::stock_pool_after_sell_rejects_missing_quote_instead_of_reusing_daily_open ... ok
+test broker::tests::stock_pool_after_sell_uses_fresh_quotes_and_actual_submission_clock ... ok
+test broker::tests::stock_pool_delayed_sell_does_not_start_buys_after_the_configured_window ... ok
+test broker::tests::stock_pool_delayed_take_profit_does_not_rebuy_the_same_generation_exit ... ok
+test broker::tests::stock_pool_new_signal_supersedes_the_unsubmitted_buy_phase ... ok
+test broker::tests::stock_pool_engine_drives_the_pending_buy_without_a_minute_strategy_callback ... ok
+test broker::tests::stock_pool_pending_phase_cannot_cross_the_execution_session ... ok
+test broker::tests::stock_pool_partial_sell_waits_for_the_whole_batch_and_never_reissues_buys ... ok
+test broker::tests::strict_value_buy_budget_includes_commission_at_execution_price ... ok
+test broker::tests::successful_target_exit_releases_position_slot_for_replacement_entry ... ok
+test broker::tests::stock_pool_pending_sell_continues_buy_after_actual_fill_without_strategy_rerun ... ok
+test broker::tests::target_percent_reduction_from_full_to_twenty_percent_sells_eighty_percent ... ok
+test broker::tests::target_portfolio_smart_budgets_each_buy_before_cash_optimization ... ok
+test broker::tests::target_portfolio_smart_custom_valuation_does_not_create_limit_orders ... ok
+test broker::tests::target_portfolio_smart_defers_buy_risk_until_order_validation ... ok
+test broker::tests::target_portfolio_smart_ignores_zero_weight_symbols_without_market_snapshot ... ok
+test broker::tests::target_portfolio_smart_keeps_position_when_sell_snapshot_missing ... ok
+test broker::tests::target_portfolio_smart_open_auction_uses_day_open_for_valuation ... ok
+test broker::tests::target_portfolio_smart_records_buy_rejection_when_target_is_blacklisted ... ok
+test broker::tests::target_portfolio_smart_pre_open_cash_does_not_spend_same_batch_sell_proceeds ... ok
+test broker::tests::target_portfolio_smart_uses_prior_close_only_for_missing_day_valuation ... ok
+test broker::tests::target_value_delta_below_order_step_is_audited_without_creating_zero_quantity_order ... ok
+test broker::tests::target_value_batch_executes_reductions_before_increases_when_sell_cash_is_reusable ... ok
+test broker::tests::target_value_reduction_from_full_to_twenty_percent_sells_eighty_percent ... ok
+test broker::tests::target_value_zero_rejects_sell_when_market_snapshot_missing ... ok
+test broker::tests::target_weight_buy_quantity_respects_per_symbol_budget_after_slippage_and_fees ... ok
+test broker::tests::twap_earlier_fills_do_not_depend_on_later_quote_liquidity_or_count ... ok
+test broker::tests::timed_target_value_zero_sells_full_position_at_requested_time_quote ... ok
+test broker::tests::unchanged_targets_do_not_create_zero_quantity_orders ... ok
+test broker::tests::unwinding_an_unpublished_simulator_transaction_restores_its_state ... ok
+test broker::tests::value_buy_rejects_when_slippage_clamps_execution_price_to_upper_limit ... ok
+test broker::tests::value_buy_process_uses_latest_quote_before_decision_time ... ok
+test corporate_book::tests::closing_register_cannot_be_replaced_by_later_holdings ... ok
+test broker::tests::failed_resting_order_batch_keeps_accepted_orders_and_unpublished_financial_state ... ok
+test corporate_book::tests::a_late_corporate_batch_failure_keeps_prior_cash_positions_and_notes ... ok
+test corporate_book::tests::dividend_receivable_survives_a_flat_position_without_becoming_spendable_cash ... ok
+test corporate_book::tests::corporate_quantity_overflow_fails_without_saturation_or_a_negative_delta ... ok
+test corporate_book::tests::explicitly_delayed_dividend_remains_receivable_until_actual_payment ... ok
+test corporate_book::tests::entitlement_survives_complete_sale_and_a_successor_unit_conversion ... ok
+test corporate_book::tests::flat_position_retirement_does_not_change_issued_lot_state_or_next_purchase_origin ... ok
+test corporate_book::tests::manual_zero_skips_only_unused_allocation_facts_not_invalid_cash_evidence ... ok
+test corporate_book::tests::missing_accounting_reference_is_atomic_not_a_silent_cash_only_success ... ok
+test corporate_book::tests::invalid_delivery_negative_rates_and_unresolved_fractional_claims_are_atomic ... ok
+test corporate_book::tests::missing_or_backward_cash_payment_date_never_updates_the_account ... ok
+test corporate_book::tests::missing_record_date_or_unobserved_closing_book_is_atomic ... ok
+test corporate_book::tests::per_share_precision_is_retained_until_the_registered_cash_amount_is_rounded ... ok
+test corporate_book::tests::post_record_buy_cannot_receive_the_earlier_dividend ... ok
+test corporate_book::tests::post_record_purchase_does_not_inherit_registered_shares ... ok
+test corporate_book::tests::registered_shares_are_valued_but_not_delivered_or_sellable_before_the_original_date ... ok
+test corporate_book::tests::sale_after_registration_preserves_cash_and_excludes_new_lots_from_cost_adjustment ... ok
+test corporate_book::tests::terminated_security_keeps_paid_cash_and_is_not_recreated_by_reinvestment ... ok
+test corporate_book::tests::successor_without_frozen_instrument_metadata_is_not_an_implicit_new_security ... ok
+test corporate_book::tests::verified_conversion_preserves_lots_without_creating_orders_or_fills ... ok
+test corporate_book::tests::tiny_known_cash_rate_is_preserved_and_cannot_waive_payment_or_record_evidence ... ok
+test cost::tests::cost_model_can_use_configurable_stamp_tax_change_date ... ok
+test cost::tests::default_quantizes_fees_to_micro_yuan ... ok
+test cost::tests::fund_fees_use_admitted_instrument_type_and_share_the_order_commission_budget ... ok
+test daily_patterns::tests::daily_patterns_adjusts_all_prices_not_volume ... ok
+test daily_patterns::tests::breakout_retest_needs_a_later_retest_not_the_breakout_candle_itself ... ok
+test corporate_book::tests::invalid_successor_terms_cannot_be_replaced_with_one_share_or_zero_cash ... ok
+test daily_patterns::tests::daily_patterns_flat_decimal_prices_do_not_create_a_sell_signal ... ok
+test daily_patterns::tests::daily_patterns_helper_literal_preserves_parameters ... ok
+test daily_patterns::tests::daily_patterns_rejects_future_and_duplicate_bars ... ok
+test daily_patterns::tests::daily_patterns_all_templates_and_score_absence ... ok
+test daily_patterns::tests::daily_patterns_no_missing_data_fallback ... ok
+test daily_patterns::tests::limit_consolidation_requires_real_limit_and_never_infers_ten_percent ... ok
+test daily_patterns::tests::mean_volume_followup_requires_bullish_breakout_and_shrink ... ok
+test daily_patterns::tests::mean_volume_is_not_prior_max_and_excludes_current_bar ... ok
+test daily_patterns::tests::expression_condition_preserves_native_types_and_rejects_numeric_as_signal ... ok
+test daily_patterns::tests::research_index_and_ranking_context_never_unlock_strategy_mapping ... ok
+test data::series_columns::tests::differing_prices_preserve_zero_nan_payloads_and_prior_rows ... ok
+test data::series_columns::tests::identical_prices_share_only_after_exact_bit_comparison ... ok
+test daily_patterns::tests::research_isolates_missing_listing_day_without_weakening_execution ... ok
+test data::series_columns::tests::optional_values_keep_none_distinct_from_empty_and_repeated_text ... ok
+test data::series_columns::tests::repeated_values_preserve_nonzero_values_and_copy_on_change ... ok
+test daily_patterns::tests::research_numeric_output_keeps_warmup_unknown_without_a_false_signal ... ok
+test data::series_columns::tests::repeated_values_reject_out_of_range_access - should panic ... ok
+test data::tests::adjusted_close_average_normalization_prevents_strict_crossover_drift ... ok
+test data::tests::baseline_selection_uses_dated_lifecycle_not_latest_undated_status ... ok
+test data::tests::benchmark_current_rolling_reuses_symbol_boundary ... ignored, manual release-mode current rolling boundary benchmark
+test data::tests::benchmark_daily_snapshot_view_lookup ... ignored, manual component benchmark
+test data::tests::additional_terminal_calendar_dates_are_isolated_from_shared_market_data ... ok
+test data::tests::benchmark_decision_close_windows_exclude_current_close ... ok
+test data::tests::benchmark_instrument_symbol_id_lookup ... ignored, manual release-mode instrument lookup benchmark
+test data::tests::benchmark_series_boundary_reuses_calendar_index ... ignored, manual release-mode calendar index reuse benchmark
+test data::tests::batched_standard_rolling_means_match_scalar_lookups ... ok
+test data::tests::daily_bundle_constructor_rejects_duplicate_or_mismatched_dates ... ok
+test data::tests::current_close_average_uses_backward_adjustment_factor_and_current_base ... ok
+test data::tests::day_open_moving_average_uses_its_own_historical_column ... ok
+test data::tests::dataset_clone_shares_immutable_base_and_isolates_execution_quotes ... ok
+test data::tests::decision_close_average_ignores_current_day_close ... ok
+test data::tests::decision_market_cap_uses_factor_date_snapshot_without_price_reconstruction ... ok
+test data::tests::decision_volume_average_ignores_paused_zero_volume_days ... ok
+test data::tests::decision_volume_average_uses_previous_completed_days_only ... ok
+test data::tests::daily_bundle_constructor_matches_flat_component_constructor ... ok
+test data::tests::eligible_universe_can_use_configured_risk_policy ... ok
+test data::tests::eligible_universe_does_not_require_candidate_risk_state_when_selection_risk_is_disabled ... ok
+test data::tests::direct_symbol_id_snapshot_lookups_preserve_alignment_for_sparse_rows ... ok
+test data::tests::eligible_universe_uses_decision_market_cap_same_date ... ok
+test data::tests::factor_numeric_value_normalizes_fields_without_changing_aliases ... ok
+test data::tests::factor_snapshot_normalization_moves_clean_maps_and_repairs_dirty_maps ... ok
+test data::tests::factor_snapshot_rejects_legacy_or_invalid_adjustment_storage ... ok
+test data::tests::execution_quotes_use_stable_k_way_merge_and_release_by_date ... ok
+test data::tests::intraday_overlay_fails_closed_when_daily_panel_is_shared ... ok
+test data::tests::future_missing_adjustment_factor_does_not_invalidate_historical_window ... ok
+test data::tests::parallel_dense_index_rejects_invalid_days_without_publishing_partial_index ... ok
+test data::tests::replacing_execution_quotes_preserves_duplicate_timestamp_rows ... ok
+test data::tests::parallel_daily_symbol_indices_match_scalar_for_sparse_and_empty_days ... ok
+test data::tests::series_end_position_index_preserves_decision_and_current_boundaries ... ok
+test data::tests::series_columns_preserve_full_snapshots_and_distinct_price_bits ... ok
+test data::tests::series_overlay_materializes_only_changed_values_and_preserves_history_cutoff ... ok
+test data::tests::shared_execution_quote_release_does_not_clone_the_base_map ... ok
+test data::tests::symbol_id_union_preserves_lexical_order_and_all_component_sources ... ok
+test data::tests::symbol_price_series_test_constructor_sorts_unsorted_rows ... ok
+test data::tests::source_volume_contract_rejects_windows_containing_missing_values ... ok
+test data::tests::unique_dataset_applies_sparse_intraday_overlay_to_daily_and_symbol_views ... ok
+test decision_projection::tests::exact_projection_coverage_and_classified_absence_are_receipted ... ok
+test decision_projection::tests::projection_contract_does_not_shadow_core_market_or_typed_fields ... ok
+test data::tests::volume_rolling_ignores_zero_volume_rows_for_source_and_legacy_data ... ok
+test decision_projection::tests::projection_rejects_future_drift_or_unbound_receipts ... ok
+test decision_projection::tests::projection_rejects_incomplete_duplicate_extra_and_overlapping_population ... ok
+test decision_projection::tests::projection_rejects_nonfinite_wrong_fields_and_unproven_absence ... ok
+test data::tests::parallel_daily_bundle_validation_keeps_earliest_error_and_component_order ... ok
+test engine::tests::backtest_execution_dates_match_sparse_lagged_equity_schedule ... ok
+test engine::tests::after_trading_cancel_is_executed_as_a_control_not_a_next_session_order ... ok
+test engine::tests::compact_progress_keeps_counts_without_event_payload_clones ... ok
+test engine::tests::current_bar_close_uses_decision_day_close_for_fill ... ok
+test engine::tests::decision_projection_does_not_silently_shift_a_start_without_prior_inputs ... ok
+test engine::tests::current_close_order_at_1500_loads_and_uses_post_close_matching_window ... ok
+test engine::tests::decision_projection_failure_never_reaches_strategy_and_does_not_blindly_retry ... ok
+test engine::tests::compact_manual_progress_keeps_exact_applications_and_fallible_delivery_stops_the_run ... ok
+test engine::tests::decision_projection_rejects_future_response_before_any_strategy_callback ... ok
+test engine::tests::decision_projection_is_called_before_callbacks_and_is_not_shared_or_carried_forward ... ok
+test engine::tests::decision_projection_rejects_missing_calendar_inputs_instead_of_dropping_a_session ... ok
+test engine::tests::decision_projection_refuses_static_scores_and_same_session_inputs ... ok
+test engine::tests::decision_projection_requested_first_session_uses_visible_preperiod_inputs ... ok
+test engine::tests::default_close_phase_waits_for_close_and_callbacks_receive_completed_trade_history ... ok
+test engine::tests::early_pre_open_schedules_observe_manual_receipts_in_chronological_order ... ok
+test engine::tests::empty_manual_source_does_not_retime_natural_strategy_execution ... ok
+test engine::tests::join_text_parts_matches_vec_join_contract ... ok
+test engine::tests::final_day_late_intents_are_retained_without_orders_or_fills_past_the_end ... ok
+test engine::tests::full_minute_coverage_rejects_missing_active_bars_but_allows_paused_or_zero_volume ... ok
+test engine::tests::lagged_signal_callbacks_keep_signal_date_but_process_notifications_use_execution_date ... ok
+test engine::tests::late_day_callbacks_read_the_actual_earlier_trade_and_keep_their_current_clock ... ok
+test engine::tests::late_intents_do_not_wait_for_another_selection_snapshot ... ok
+test engine::tests::late_complete_targets_use_latest_target_and_next_day_zero_supersedes_them ... ok
+test engine::tests::late_imperative_orders_execute_once_in_next_session_with_original_dates_and_new_price ... ok
+test engine::tests::late_opening_callback_is_interleaved_with_earlier_quotes_and_manual_observations ... ok
+test engine::tests::lifecycle_quote_filter_skips_only_dated_legal_absence_before_loading ... ok
+test engine::tests::minute_event_clock_uses_timestamp_order_and_coalesces_equal_heads ... ok
+test engine::tests::latest_unsent_complete_portfolio_does_not_union_an_older_pre_market_target ... ok
+test engine::tests::minute_schedules_fire_at_each_declared_time_without_market_rows_at_those_times ... ok
+test engine::tests::next_bar_open_eligible_universe_helper_does_not_block_on_decision_day_risk ... ok
+test engine::tests::minute_observer_never_sees_a_later_fill_from_a_coarse_phase ... ok
+test engine::tests::next_bar_open_executes_last_decision_without_execution_day_factor_snapshot ... ok
+test engine::tests::manual_observations_are_visible_at_their_real_phase_and_each_receipt_sequence ... ok
+test engine::tests::next_bar_open_execution_risk_ignores_decision_day_st_state ... ok
+test engine::tests::next_bar_open_execution_risk_ignores_decision_day_paused_state ... ok
+test engine::tests::next_bar_open_execution_risk_ignores_decision_day_star_st_state ... ok
+test engine::tests::next_bar_open_execution_risk_ignores_decision_day_upper_limit_state ... ok
+test engine::tests::next_bar_open_execution_risk_ignores_later_one_yuan_close ... ok
+test engine::tests::next_bar_open_execution_risk_rejects_execution_day_paused_state ... ok
+test engine::tests::next_bar_open_execution_risk_rejects_execution_day_delisted_state ... ok
+test engine::tests::next_bar_open_execution_risk_rejects_blacklisted_buy_on_execution_day ... ok
+test engine::tests::next_bar_open_execution_risk_rejects_execution_day_st_state ... ok
+test engine::tests::next_bar_open_execution_risk_rejects_execution_day_star_st_state ... ok
+test engine::tests::next_bar_open_execution_risk_rejects_execution_day_upper_limit_buy ... ok
+test engine::tests::next_bar_open_execution_risk_rejects_one_yuan_open_despite_higher_close ... ok
+test engine::tests::next_bar_open_execution_risk_uses_open_not_close_for_upper_limit_buy ... ok
+test engine::tests::next_bar_open_same_day_rebuy_uses_actual_execution_date ... ok
+test engine::tests::next_bar_open_scheduled_signal_uses_decision_date_not_execution_date ... ok
+test engine::tests::next_bar_open_sell_respects_allow_sell_policy_on_execution_day ... ok
+test engine::tests::next_bar_open_sell_risk_rejects_execution_day_lower_limit_state ... ok
+test engine::tests::next_bar_open_sell_risk_ignores_decision_day_paused_and_lower_limit_state ... ok
+test engine::tests::next_bar_open_sell_risk_uses_open_not_close_for_lower_limit_sell ... ok
+test engine::tests::next_bar_open_sell_volume_limit_ignores_decision_day_zero_volume ... ok
+test engine::tests::next_bar_open_session_audit_flags_zero_volume_without_rewriting_fills ... ok
+test engine::tests::next_bar_open_skips_unavailable_lag_day_and_fills_next_open ... ok
+test engine::tests::next_bar_open_target_percent_freezes_decision_day_equity ... ok
+test engine::tests::next_bar_open_strategy_context_data_helpers_use_decision_date ... ok
+test engine::tests::next_bar_open_target_portfolio_smart_sizes_with_execution_day_open ... ok
+test engine::tests::next_open_observation_loads_quotes_even_when_execution_price_is_open ... ok
+test engine::tests::observed_manual_sale_updates_the_shared_same_day_rebuy_rule ... ok
+test engine::tests::opening_schedule_cannot_cross_the_after_trading_phase ... ok
+test engine::tests::opening_and_late_lifecycle_schedules_do_not_read_past_or_future_manual_state ... ok
+test engine::tests::opening_orders_are_submitted_once_at_their_real_clock_even_with_an_earlier_execution_window ... ok
+test engine::tests::physical_on_day_rules_keep_each_actual_submission_time ... ok
+test engine::tests::post_close_phase_callbacks_never_rewind_before_completed_fills ... ok
+test engine::tests::opening_subscription_is_loaded_without_replaying_quotes_before_its_activation ... ok
+test engine::tests::post_close_wait_has_no_position_before_the_first_actual_matching_tick ... ok
+test engine::tests::process_callbacks_observe_the_completed_minute_trade_and_its_clock ... ok
+test engine::tests::pre_trading_orders_wait_for_the_configured_window_and_keep_their_audit ... ok
+test engine::tests::scheduled_event_detail_records_actual_time_only_for_timed_rules ... ok
+test engine::tests::pre_market_cancel_is_observed_before_the_next_open_and_new_signal ... ok
+test engine::tests::unknown_identity_or_missing_candidate_does_not_waive_quote_coverage ... ok
+test engine::tests::wholly_prelisting_universe_retains_cash_days_without_fabricating_prices ... ok
+test etf_execution::tests::latest_generation_overwrites_pending_targets_and_preserves_candidate_order ... ok
+test engine::tests::window_algorithm_cannot_publish_future_fill_quantity_to_earlier_callbacks ... ok
+test etf_execution::tests::no_loaded_next_session_is_not_guessed_from_natural_days ... ok
+test events::tests::accounting_origin_cannot_disguise_an_exchange_order_or_fee ... ok
+test events::tests::fill_execution_timestamp_range_is_explicit_and_backward_compatible ... ok
+test events::tests::order_event_status_quantity_contract_is_explicit ... ok
+test events::tests::process_event_business_lifecycle_filter_keeps_audit_events_only ... ok
+test execution_capacity::tests::completed_volume_cannot_be_used_for_an_earlier_open ... ok
+test execution_capacity::tests::decimal_participation_never_rounds_a_fractional_share_up_or_overflows ... ok
+test execution_capacity::tests::delayed_publication_and_invalid_bounds_are_not_treated_as_zero_volume ... ok
+test execution_capacity::tests::session_audit_changes_verdict_not_executed_quantity ... ok
+test execution_schedule::tests::clock_entitlements_are_exact_and_allow_backlog_without_future_quote_counts ... ok
+test factor_cross_section::tests::neutralization_preserves_input_order ... ok
+test factor_cross_section::tests::ties_keep_equal_rank_and_missing_universe_rejects ... ok
+test factor_cross_section::tests::historical_ranks_keep_ties_and_unknown_full_cross_sections ... ok
+test factor_events::tests::cross_is_event_not_state_and_never_uses_future ... ok
+test factor_events::tests::every_parameter_domain_is_structured_and_matches_native_defaults ... ok
+test factor_events::tests::missing_is_not_zero_and_breakout_excludes_current ... ok
+test factor_events::tests::no_event_has_no_bars_since_and_type_errors_reject ... ok
+test engine::tests::scheduled_day_limit_order_loads_later_quotes_without_strategy_minute_subscription ... ok
+test factor_events::tests::ta_rewarms_after_gap_and_const_zscore_is_unknown ... ok
+test factor_events::tests::ta_sma_real_values_and_parameter_validation ... ok
+test finite_serialization::tests::pending_numbers_cannot_be_silently_serialized_as_optional_nulls ... ok
+test fixed_point::tests::decimal_parser_rounds_only_beyond_money_scale ... ok
+test fixed_point::tests::fixed_budget_comparison_rejects_one_micro_yuan_overrun ... ok
+test fixed_point::tests::fixed_budget_never_exceeds_cash_after_cost ... ok
+test fixed_point::tests::fixed_fifo_pnl_and_external_flow_are_deterministic ... ok
+test fixed_point::tests::runtime_cost_model_matches_fixed_execution_primitive ... ok
+test fixed_point::tests::runtime_split_commission_matches_fixed_execution_primitive ... ok
+test holding_policy::tests::absolute_locks_are_inclusive_and_override_timed_exit_without_changing_other_symbols ... ok
+test holding_policy::tests::manual_origin_only_bypasses_automatic_policy_not_an_order_or_broker_permission ... ok
+test holding_policy::tests::opening_date_follows_fills_not_partial_sales_or_corporate_conversions ... ok
+test holding_policy::tests::three_complete_sessions_protect_through_wednesday_not_72_hours ... ok
+test holding_policy::tests::zero_disabled_and_missing_calendar_or_opened_date_are_not_inferred ... ok
+test instrument::tests::lifecycle_is_dated_and_latest_undated_terminal_status_is_not_historical_evidence ... ok
+test instrument::tests::listing_sector_is_explicit_and_unknown_stays_unknown ... ok
+test instrument::tests::order_quantity_rules_are_case_insensitive_without_allocating_normalized_boards ... ok
+test manual_execution::tests::a_failed_corporate_projection_does_not_change_the_book_or_receipt_cursor ... ok
+test manual_execution::tests::all_required_money_and_binding_fields_reject_missing_or_wrong_values ... ok
+test manual_execution::tests::authoritative_total_fee_does_not_require_inventing_unknown_components ... ok
+test manual_execution::tests::changing_any_external_price_or_identity_invalidates_the_frozen_trace ... ok
+test manual_execution::tests::complete_exact_decimal_evidence_allows_later_observation_and_retains_source_digits ... ok
+test manual_execution::tests::confirmed_manual_fill_changes_cash_and_lots_but_not_external_cash_flow_units ... ok
+test manual_execution::tests::confirmed_no_order_outcome_is_distinct_from_unconfirmed_or_unknown_work ... ok
+test manual_execution::tests::cursor_waits_for_observation_and_never_reapplies_or_rewinds ... ok
+test manual_execution::tests::data_scope_only_contains_actual_filled_securities_and_validates_the_source ... ok
+test manual_execution::tests::failed_multi_receipt_advance_keeps_both_progress_and_portfolio_unchanged ... ok
+test manual_execution::tests::fixed_money_decimal_text_preserves_micro_units_without_float_conversion ... ok
+test factor_events::tests::literal_unknown_fields_reject_and_catalog_is_not_trading_permission ... ok
+test factor_events::tests::parameter_domains_keep_enumeration_labels_without_debug_string_parsing ... ok
+test manual_execution::tests::inconsistent_counts_terminals_audits_and_duplicate_facts_are_rejected ... ok
+test manual_execution::tests::late_buy_fifo_depletion_preserves_costs_and_cannot_unlock_today_lots ... ok
+test manual_execution::tests::late_fee_evidence_keeps_the_original_fill_observation_clock ... ok
+test manual_execution::tests::late_buy_retains_the_earliest_opening_and_latest_buy_dates ... ok
+test manual_execution::tests::manual_fee_total_includes_extra_charges_and_rejects_inconsistent_components ... ok
+test manual_execution::tests::manual_mismatches_are_atomic_and_do_not_borrow_shares_cash_or_override_pending_orders ... ok
+test manual_execution::tests::partial_cancel_is_valid_but_full_fill_cannot_be_reported_as_cancelled ... ok
+test manual_execution::tests::observations_follow_durable_receipt_order_and_not_input_array_order ... ok
+test manual_execution::tests::raw_timezone_and_cutoff_are_required ... ok
+test manual_execution::tests::runtime_position_events_cannot_claim_observations_after_the_source_cutoff ... ok
+test manual_execution::tests::the_next_day_manual_sale_keeps_the_actual_quantity_and_fee_contract ... ok
+test manual_execution::tests::v2_facts_keep_their_encoding_but_cannot_silently_carry_new_runtime_settings ... ok
+test market_event_context::tests::formulas_use_real_limits_and_full_denominators ... ok
+test market_event_context::tests::chunking_and_future_append_preserve_history ... ok
+test manual_execution::tests::source_time_precision_is_not_invented_and_submitted_time_must_fit_the_interval ... ok
+test market_event_context::tests::missing_duplicate_and_unproven_limit_states_fail ... ok
+test market_event_context::tests::missing_industry_does_not_invent_groups_or_disable_independent_market_facts ... ok
+test metrics::risk_adjusted_contract_tests::changing_daily_rates_adjusts_each_return_before_variance_and_downside ... ok
+test metrics::risk_adjusted_contract_tests::incomplete_or_invalid_rates_are_not_zero_rate_observations ... ok
+test metrics::risk_adjusted_contract_tests::zero_deviation_and_single_sample_ratios_remain_undefined ... ok
+test metrics::tests::a_defined_zero_ratio_is_not_missing ... ok
+test metrics::tests::drawdown_includes_initial_nav_without_adding_a_trading_day ... ok
+test metrics::tests::benchmark_cumulative_return_uses_first_day_previous_close ... ok
+test metrics::tests::external_cash_flow_is_excluded_from_return_and_reported_separately ... ok
+test metrics::tests::first_day_loss_is_preserved_in_shared_backtest_metrics ... ok
+test metrics::tests::gains_without_downside_have_no_sortino_or_monthly_sharpe ... ok
+test metrics::tests::no_risk_ratio_is_fabricated_after_nav_has_reached_zero ... ok
+test metrics::tests::risk_adjusted_metrics_use_daily_pit_rates_and_all_period_downside ... ok
+test metrics::tests::signal_baseline_uses_same_close_for_strategy_and_benchmark ... ok
+test numeric_expr_vm::tests::benchmark_numeric_vm_against_rhai ... ignored, manual release-mode performance evidence
+test numeric_expr_vm::tests::floating_comparisons_match_rhai_epsilon_semantics ... ok
+test numeric_expr_vm::tests::evaluates_numeric_boolean_and_if_expressions ... ok
+test metrics::tests::undefined_ratios_remain_null_in_backtest_metrics ... ok
+test numeric_expr_vm::tests::invalid_clamp_returns_error_without_panicking ... ok
+test numeric_expr_vm::tests::nullable_boolean_truth_table_preserves_unknown_under_negation ... ok
+test numeric_expr_vm::tests::nullable_short_circuit_and_explicit_conditional_branches_are_lazy ... ok
+test numeric_expr_vm::tests::missing_numeric_operands_do_not_become_boolean_false_or_zero ... ok
+test numeric_expr_vm::tests::rejects_dynamic_language_features ... ok
+test numeric_expr_vm::tests::scratch_reuses_allocations_across_program_runs ... ok
+test numeric_expr_vm::tests::short_circuit_does_not_resolve_unused_variable ... ok
+test numeric_expr_vm::tests::supports_numeric_builtins_and_local_reuse ... ok
+test numeric_factors::tests::bulk_load_is_sorted_and_keeps_last_value_for_each_field ... ok
+test numeric_factors::tests::clone_does_not_share_mutable_values ... ok
+test numeric_factors::tests::compact_keys_inline_dynamic_names_and_keep_long_static_storage ... ok
+test numeric_factors::tests::exact_reservation_preserves_values_and_avoids_growth_during_known_inserts ... ok
+test numeric_factors::tests::long_dynamic_unicode_and_short_keys_keep_the_same_json_map ... ok
+test numeric_factors::tests::serialization_keeps_the_map_contract_and_precise_numbers ... ok
+test numeric_factors::tests::wide_batch_merge_matches_tree_and_preserves_old_key_ownership ... ok
+test numeric_expr_vm::tests::matches_rhai_for_representative_numeric_boolean_corpus ... ok
+test pattern_context::tests::normalized_rule_does_not_turn_an_omitted_window_into_explicit_null ... ok
+test pattern_context::tests::reference_index_never_defaults_to_performance_benchmark ... ok
+test pattern_context::tests::runtime_contract_rejects_missing_range_and_recursive_ranks ... ok
+test numeric_factors::tests::updates_order_removal_and_values_match_tree_map ... ok
+test pattern_context::tests::dataset_rank_is_full_scope_causal_and_equal_to_pure_cross_section ... ok
+test pattern_context::tests::structured_pool_conditions_are_not_rescanned_inside_serialized_source_code ... ok
+test platform_expr_strategy::tests::allocation_buy_scale_preserves_explicit_overweight_multiplier ... ok
+test platform_expr_strategy::tests::benchmark_compiled_runtime_helper_arguments ... ignored, manual release-mode runtime helper binding benchmark
+test platform_expr_strategy::tests::bjse_symbol_detection_is_case_insensitive_without_normalizing_all_symbols ... ok
+test platform_expr_strategy::tests::available_factor_name_collection_preserves_sparse_and_repeated_fields ... ok
+test platform_expr_strategy::tests::buy_filter_attaches_denials_without_rewriting_selection ... ok
+test platform_expr_strategy::tests::available_factor_name_collection_preserves_wide_dynamic_field_identity ... ok
+test platform_expr_strategy::tests::buy_filter_uses_active_schedule_time_instead_of_first_configured_time ... ok
+test platform_expr_strategy::tests::buy_quote_filter_rejects_missing_intraday_quote_not_daily_close ... ok
+test platform_expr_strategy::tests::completed_session_factor_dates_exclude_intraday_and_preserve_next_open ... ok
+test platform_expr_strategy::tests::completed_session_bound_value_does_not_read_same_day_future_value ... ok
+test platform_expr_strategy::tests::daily_replacement_reference_records_an_explicit_empty_previous_target ... ok
+test platform_expr_strategy::tests::daily_pattern_runtime_uses_the_shared_kernel_and_rejects_early_visibility ... ok
+test platform_expr_strategy::tests::dated_position_exposure_uses_the_latest_effective_point ... ok
+test platform_expr_strategy::tests::current_rolling_helpers_do_not_load_factor_maps_or_decision_rollings ... ok
+test platform_expr_strategy::tests::daily_replacement_reference_uses_previous_target_before_lagged_orders_fill ... ok
+test platform_expr_strategy::tests::expression_plan_only_executes_prelude_when_expression_depends_on_it ... ok
+test platform_expr_strategy::tests::expression_plan_skips_unreferenced_market_scope_maps ... ok
+test platform_expr_strategy::tests::framework_rolling_factor_aliases_resolve_to_raw_market_series ... ok
+test platform_expr_strategy::tests::lagged_rebalance_emits_target_value_even_when_projection_is_unchanged ... ok
+test platform_expr_strategy::tests::factor_position_target_reduces_once_without_daily_rebalance_override ... ok
+test platform_expr_strategy::tests::market_cap_ordered_selection_range_is_inclusive_and_field_specific ... ok
+test platform_expr_strategy::tests::model_target_lifecycle_removes_exits_and_appends_replacements ... ok
+test platform_expr_strategy::tests::numeric_vm_compiles_static_runtime_helper_arguments ... ok
+test platform_expr_strategy::tests::numeric_vm_reuses_compiled_program_across_invocations ... ok
+test platform_expr_strategy::tests::numeric_vm_rewrites_only_valid_iso_date_literals ... ok
+test platform_expr_strategy::tests::numeric_vm_reuses_rolling_helper_program_across_dates ... ok
+test platform_expr_strategy::tests::market_cap_ascending_rank_reuses_only_equivalent_universe_order ... ok
+test platform_expr_strategy::tests::periodic_selected_bjse_buy_rejection_is_audited_without_creating_an_order ... ok
+test platform_expr_strategy::tests::platform_aiquant_blocks_target_increase_when_stop_loss_sell_is_lower_limit_blocked ... ok
+test platform_expr_strategy::tests::platform_aiquant_buy_rejection_keeps_candidate_buy_disabled ... ok
+test platform_expr_strategy::tests::platform_aiquant_buy_rejection_uses_scheduled_price_not_open_limit ... ok
+test platform_expr_strategy::tests::platform_aiquant_daily_top_up_releases_slot_after_take_profit_exit ... ok
+test platform_expr_strategy::tests::platform_aiquant_daily_top_up_releases_second_slot_after_prior_top_up ... ok
+test platform_expr_strategy::tests::platform_aiquant_daily_top_up_uses_remaining_slot_budget ... ok
+test platform_expr_strategy::tests::platform_aiquant_marked_total_uses_intraday_last_not_close ... ok
+test platform_expr_strategy::tests::platform_aiquant_delays_upper_limit_take_profit_to_configured_open_time ... ok
+test platform_expr_strategy::tests::platform_aiquant_marked_total_value_uses_scheduled_quote ... ok
+test platform_expr_strategy::tests::platform_aiquant_minute_last_projection_uses_last_quote_for_buy_budget ... ok
+test platform_expr_strategy::tests::platform_aiquant_marks_highlimit_before_cptrade_time ... ok
+test platform_expr_strategy::tests::platform_aiquant_minute_stop_loss_requires_intraday_quote ... ok
+test platform_expr_strategy::tests::platform_aiquant_next_open_stop_loss_uses_signal_close_not_execution_last_price ... ok
+test platform_expr_strategy::tests::platform_aiquant_missing_risk_state_does_not_force_existing_position_exit ... ok
+test platform_expr_strategy::tests::platform_aiquant_next_open_target_delta_uses_previous_close_and_sizes_at_open ... ok
+test platform_expr_strategy::tests::platform_aiquant_projection_allows_signal_day_market_fallback_for_next_open ... ok
+test platform_expr_strategy::tests::platform_aiquant_projection_does_not_release_sell_slot_without_execution_quote ... ok
+test platform_expr_strategy::tests::platform_aiquant_projection_rejects_missing_symbol_execution_quote ... ok
+test platform_expr_strategy::tests::platform_aiquant_projection_reserves_sell_cost_without_same_callback_proceeds ... ok
+test platform_expr_strategy::tests::platform_aiquant_periodic_rebalance_uses_total_equity_equal_weight_buy_budget ... ok
+test platform_expr_strategy::tests::platform_aiquant_remaining_buy_cash_uses_strategy_visible_price_and_projected_quantity ... ok
+test platform_expr_strategy::tests::platform_aiquant_risk_level_forces_existing_position_exit ... ok
+test platform_expr_strategy::tests::platform_aiquant_scheduled_quote_uses_configured_intraday_time ... ok
+test platform_expr_strategy::tests::platform_aiquant_selection_uses_decision_market_cap ... ok
+test platform_expr_strategy::tests::platform_aiquant_sell_projection_uses_signal_day_market_for_lagged_execution ... ok
+test platform_expr_strategy::tests::platform_aiquant_sells_down_before_actionable_take_profit_exit ... ok
+test platform_expr_strategy::tests::platform_aiquant_stock_expr_uses_scheduled_minute_price_for_limit_check ... ok
+test platform_expr_strategy::tests::platform_aiquant_skips_positive_target_adjust_when_position_will_close ... ok
+test platform_expr_strategy::tests::platform_aiquant_target_adjust_uses_scheduled_quote_for_position_value ... ok
+test platform_expr_strategy::tests::platform_aiquant_target_value_uses_scheduled_mark_for_delta ... ok
+test platform_expr_strategy::tests::platform_aiquant_stop_loss_uses_fee_cost_basis_avg_cost ... ok
+test platform_expr_strategy::tests::platform_aiquant_upper_limit_buy_disabled_does_not_force_exit_existing_position ... ok
+test platform_expr_strategy::tests::platform_aiquant_weak_market_allows_pending_highlimit_target_adjust_after_open ... ok
+test platform_expr_strategy::tests::platform_aiquant_weak_market_marks_upper_limit_but_allows_target_adjust ... ok
+test platform_expr_strategy::tests::platform_aiquant_weak_market_emits_daily_position_target_adjustment ... ok
+test platform_expr_strategy::tests::platform_aiquant_weak_market_threshold_top_up_uses_projected_remaining_budget ... ok
+test platform_expr_strategy::tests::platform_aiquant_weak_market_waits_pending_highlimit_target_adjust ... ok
+test platform_expr_strategy::tests::platform_aiquant_weak_market_threshold_only_sells_overweight_positions ... ok
+test platform_expr_strategy::tests::platform_aiquant_weak_market_retargets_same_ratio_every_day ... ok
+test platform_expr_strategy::tests::platform_buy_rejection_allows_lower_limit_buy_when_ask_is_available ... ok
+test platform_expr_strategy::tests::platform_calendar_day_rebalance_interval_can_be_enabled_explicitly ... ok
+test platform_expr_strategy::tests::platform_current_rolling_uses_decision_date_row_not_prior_factor_row ... ok
+test platform_expr_strategy::tests::platform_daily_top_up_caps_empty_slot_to_equal_weight_target ... ok
+test platform_expr_strategy::tests::platform_can_sell_position_uses_configured_lower_limit_policy ... ok
+test platform_expr_strategy::tests::platform_daily_top_up_counts_submitted_zero_fill_candidate_as_strategy_slot ... ok
+test platform_expr_strategy::tests::platform_daily_top_up_keeps_selection_limited_to_target_count ... ok
+test platform_expr_strategy::tests::platform_daily_top_up_does_not_buy_back_same_day_exit ... ok
+test platform_expr_strategy::tests::platform_daily_top_up_release_slot_flag_matches_aiquant_exit_signal_state ... ok
+test platform_expr_strategy::tests::platform_daily_top_up_releases_unsellable_stop_loss_slot ... ok
+test platform_expr_strategy::tests::platform_daily_top_up_skips_current_stop_loss_symbol_like_aiquant ... ok
+test platform_expr_strategy::tests::platform_daily_top_up_uses_same_day_sell_cash ... ok
+test platform_expr_strategy::tests::platform_day_state_uses_decision_benchmark_close ... ok
+test platform_expr_strategy::tests::platform_delayed_open_day_carried_full_close_releases_second_top_up_slot ... ok
+test platform_expr_strategy::tests::platform_delayed_open_exit_uses_delayed_time_for_slot_projection ... ok
+test platform_expr_strategy::tests::platform_delayed_open_day_take_profit_releases_second_top_up_slot ... ok
+test platform_expr_strategy::tests::platform_expr_code_number_extracts_stock_digits ... ok
+test platform_expr_strategy::tests::platform_delayed_open_partial_exit_releases_top_up_slot ... ok
+test platform_expr_strategy::tests::platform_explicit_actions_keep_every_declared_trade_time ... ok
+test platform_expr_strategy::tests::platform_expr_expands_day_factor_in_prelude ... ok
+test platform_expr_strategy::tests::platform_expr_limit_flags_are_directional ... ok
+test platform_expr_strategy::tests::platform_expr_cost_model_honors_zero_minimum_commission ... ok
+test platform_expr_strategy::tests::platform_expr_normalizes_python_style_integer_division ... ok
+test platform_expr_strategy::tests::platform_expr_normalizes_signal_field_alias_in_prelude ... ok
+test platform_expr_strategy::tests::platform_expr_cost_model_uses_commission_override ... ok
+test platform_expr_strategy::tests::platform_expr_preflight_rejects_malformed_expression_with_field_name ... ok
+test platform_expr_strategy::tests::platform_expr_preflight_accepts_all_configured_expression_categories ... ok
+test platform_expr_strategy::tests::platform_expr_rewrites_nested_ternary ... ok
+test platform_expr_strategy::tests::platform_expr_rewrites_prelude_assignment_ternary ... ok
+test platform_expr_strategy::tests::platform_expr_missing_requested_factor_does_not_default_to_zero ... ok
+test platform_expr_strategy::tests::platform_expr_rewrites_multiple_nested_ternaries_inside_function_calls ... ok
+test platform_expr_strategy::tests::platform_expr_safe_div_supports_two_and_three_arg_forms ... ok
+test platform_expr_strategy::tests::platform_expr_supports_python_style_string_aliases ... ok
+test platform_expr_strategy::tests::platform_expr_tracks_requested_dynamic_factor_identifiers ... ok
+test platform_expr_strategy::tests::platform_full_exposure_carried_full_close_releases_second_top_up_slot ... ok
+test platform_expr_strategy::tests::platform_lagged_exit_does_not_reserve_replacement_slot_before_execution ... ok
+test platform_expr_strategy::tests::platform_full_exposure_partial_stop_loss_releases_second_top_up_slot ... ok
+test platform_expr_strategy::tests::platform_helpers_support_generic_rolling_stats_and_normalized_factors ... ok
+test platform_expr_strategy::tests::platform_marked_total_value_uses_current_day_close ... ok
+test platform_expr_strategy::tests::platform_max_holding_days_counts_decision_trading_days_not_calendar_days ... ok
+test platform_expr_strategy::tests::platform_max_holding_days_exit_preempts_take_profit_exit ... ok
+test platform_expr_strategy::tests::platform_market_cap_field_uses_storage_unit_without_extra_scaling ... ok
+test platform_expr_strategy::tests::platform_minute_last_volume_limit_does_not_require_l1_quantity ... ok
+test platform_expr_strategy::tests::platform_next_open_defers_complete_static_selection_risk_before_universe_output ... ok
+test platform_expr_strategy::tests::platform_next_open_select_symbols_defers_decision_day_limit_state ... ok
+test platform_expr_strategy::tests::platform_next_open_risk_level_exit_ignores_decision_day_sellability ... ok
+test platform_expr_strategy::tests::platform_next_open_projected_execution_price_uses_open_not_close ... ok
+test platform_expr_strategy::tests::platform_next_open_selection_applies_explicit_signal_day_risk_filter ... ok
+test platform_expr_strategy::tests::platform_next_open_selection_ignores_execution_day_limit_state ... ok
+test platform_expr_strategy::tests::platform_next_open_sell_risk_uses_open_not_close_for_lower_limit ... ok
+test platform_expr_strategy::tests::platform_numeric_stop_loss_is_strictly_below_multiplier ... ok
+test platform_expr_strategy::tests::platform_order_value_quantity_includes_buy_commission_budget ... ok
+test platform_expr_strategy::tests::platform_periodic_rebalance_caps_empty_slot_to_equal_weight_target ... ok
+test platform_expr_strategy::tests::platform_periodic_rebalance_skips_unsellable_stop_loss_symbol ... ok
+test platform_expr_strategy::tests::platform_projected_execution_limit_checks_respect_risk_policy ... ok
+test platform_expr_strategy::tests::platform_periodic_rebalance_uses_same_day_sell_cash_for_later_buys ... ok
+test platform_expr_strategy::tests::platform_periodic_rebalance_tops_up_underweight_selected_holding ... ok
+test platform_expr_strategy::tests::platform_rebalance_date_due_does_not_use_the_on_day_default_clock ... ok
+test platform_expr_strategy::tests::platform_projection_does_not_consume_cash_from_unfillable_sell ... ok
+test platform_expr_strategy::tests::platform_rebalance_schedule_matches_monthly_tradingday ... ok
+test platform_expr_strategy::tests::platform_rebalance_schedule_matches_physical_time ... ok
+test platform_expr_strategy::tests::platform_rebalance_schedule_matches_weekly_weekday ... ok
+test platform_expr_strategy::tests::platform_rebalance_keeps_unresolved_delisted_position_without_orders_or_replacement ... ok
+test platform_expr_strategy::tests::platform_projected_market_fill_caps_volume_limit ... ok
+test platform_expr_strategy::tests::platform_selection_and_buy_respect_allow_flags_are_configurable ... ok
+test platform_expr_strategy::tests::platform_selection_does_not_fill_candidates_with_buy_risk_rejections ... ok
+test platform_expr_strategy::tests::platform_selection_expands_pct_change_in_filter_and_rank_expr ... ok
+test platform_expr_strategy::tests::platform_refresh_rate_uses_stateful_trading_day_counter ... ok
+test platform_expr_strategy::tests::platform_selection_missing_candidate_risk_state_does_not_change_default_universe ... ok
+test platform_expr_strategy::tests::platform_selection_kcb_switch_overrides_legacy_universe_exclude ... ok
+test platform_expr_strategy::tests::platform_selection_ranks_with_previous_factor_date ... ok
+test platform_expr_strategy::tests::platform_signal_price_model_lifecycle_survives_unfilled_buy_and_exits ... ok
+test platform_expr_strategy::tests::platform_selection_uses_complete_static_risk_policy_before_universe_output ... ok
+test platform_expr_strategy::tests::platform_skip_window_keeps_pending_highlimit_until_open ... ok
+test platform_expr_strategy::tests::platform_skip_window_runs_delayed_open_exit_before_seasonal_liquidation ... ok
+test broker::tests::simulator_transaction_profile_preserves_successful_output ... ok
+test platform_expr_strategy::tests::platform_stock_expr_exposes_star_st_and_bjse_fields_without_default_selection_risk ... ok
+test platform_expr_strategy::tests::platform_stock_expr_handles_positive_volume_guard ... ok
+test platform_expr_strategy::tests::platform_stock_state_uses_completed_day_high_and_low_for_limit_touch ... ok
+test platform_expr_strategy::tests::platform_stock_expr_rejects_when_volume_ma5_exceeds_market_volume_ma100 ... ok
+test platform_expr_strategy::tests::platform_selection_ranks_by_candidate_market_cap_with_current_precomputed_factors ... ok
+test platform_expr_strategy::tests::platform_stock_state_uses_factor_date_for_selection_market_fields ... ok
+test platform_expr_strategy::tests::platform_stock_state_uses_market_series_when_factor_map_has_no_rolling ... ok
+test platform_expr_strategy::tests::platform_stock_state_uses_framework_rolling_series ... ok
+test platform_expr_strategy::tests::platform_stop_loss_residual_pending_rechecks_signal_next_day ... ok
+test platform_expr_strategy::tests::platform_strategy_baseline_risk_rejects_new_listing_buy_without_selection_replacement ... ok
+test platform_expr_strategy::tests::platform_strategy_can_cancel_latest_open_order_by_runtime_id ... ok
+test platform_expr_strategy::tests::platform_strategy_can_filter_with_string_factors ... ok
+test platform_expr_strategy::tests::platform_strategy_emits_explicit_actions_in_open_auction_stage ... ok
+test platform_expr_strategy::tests::platform_strategy_emits_algo_order_actions ... ok
+test platform_expr_strategy::tests::platform_strategy_emits_explicit_actions_when_rotation_is_disabled ... ok
+test platform_expr_strategy::tests::platform_strategy_emits_target_portfolio_smart_explicit_action ... ok
+test platform_expr_strategy::tests::platform_stop_take_fraction_values_are_return_thresholds ... ok
+test platform_expr_strategy::tests::platform_strategy_emits_target_portfolio_smart_algo_order_style ... ok
+test platform_expr_strategy::tests::platform_strategy_emits_target_shares_explicit_action ... ok
+test platform_expr_strategy::tests::platform_strategy_emits_universe_management_actions ... ok
+test platform_expr_strategy::tests::platform_strategy_exposes_advanced_data_runtime_helpers ... ok
+test platform_expr_strategy::tests::platform_strategy_exposes_open_order_runtime_fields ... ok
+test platform_expr_strategy::tests::platform_strategy_exposes_position_lifecycle_runtime_fields ... ok
+test platform_expr_strategy::tests::platform_strategy_filters_target_portfolio_smart_by_subscription_guard ... ok
+test platform_expr_strategy::tests::platform_strategy_empty_exclude_keeps_buy_risk_without_selection_filtering ... ok
+test platform_expr_strategy::tests::platform_strategy_exposes_process_event_runtime_fields ... ok
+test platform_expr_strategy::tests::platform_strategy_skips_explicit_actions_when_schedule_does_not_match ... ok
+test platform_expr_strategy::tests::platform_strategy_treats_missing_stock_rolling_window_as_filter_reject ... ok
+test platform_expr_strategy::tests::platform_strategy_suppresses_explicit_target_for_blocked_stop_loss_exit ... ok
+test platform_expr_strategy::tests::platform_strategy_uses_decision_date_for_next_bar_open_signals ... ok
+test platform_expr_strategy::tests::platform_take_profit_default_uses_position_cost_basis ... ok
+test platform_expr_strategy::tests::platform_take_profit_sells_position_at_upper_limit ... ok
+test platform_expr_strategy::tests::platform_take_profit_false_does_not_track_upper_limit_pending_sell ... ok
+test platform_expr_strategy::tests::platform_weak_exposure_carried_full_close_keeps_residual_slot ... ok
+test platform_expr_strategy::tests::platform_weak_exposure_partial_stop_loss_keeps_residual_slot ... ok
+test platform_expr_strategy::tests::portfolio_drawdown_control_is_idempotent_and_rearms_after_cooldown ... ok
+test platform_expr_strategy::tests::platform_weak_market_skips_target_adjust_before_actionable_stop_loss ... ok
+test platform_expr_strategy::tests::platform_weak_market_skips_target_increase_before_intraday_stop_loss_sell_blocked ... ok
+test platform_expr_strategy::tests::platform_weak_market_skips_target_increase_before_lower_limit_blocked_stop_loss ... ok
+test platform_expr_strategy::tests::selection_buffer_retains_held_symbols_within_buffer_rank ... ok
+test platform_expr_strategy::tests::selection_quote_plan_filters_daily_part_before_minute_candidates ... ok
+test platform_expr_strategy::tests::selection_quote_plan_keeps_configured_static_selection_risk_for_intraday_fields ... ok
+test platform_expr_strategy::tests::selection_replacement_limit_caps_voluntary_daily_removals ... ok
+test platform_expr_strategy::tests::projected_historical_slippage_does_not_swallow_missing_calibration ... ok
+test platform_expr_strategy::tests::session_event_uses_previous_bar_and_recomputes_at_each_minute_without_becoming_a_quote ... ok
+test platform_expr_strategy::tests::portfolio_loss_observes_finalized_nav_after_fees_and_cash_flows ... ok
+test platform_expr_strategy::tests::stock_pool_exit_weight_redistribution_is_explicit_and_uses_integer_bps ... ok
+test platform_expr_strategy::tests::stock_pool_suspension_keeps_budget_and_exit_redistributes_only_available_weights ... ok
+test platform_expr_strategy::tests::stock_pool_suspension_resolution_never_reads_the_future_execution_day ... ok
+test platform_expr_strategy::tests::signal_date_explicit_actions_are_due_only_on_declared_snapshot_dates ... ok
+test platform_expr_strategy::tests::selection_limit_state_requires_intraday_selection_quotes ... ok
+test platform_expr_strategy::tests::stock_pool_target_lifecycle_keeps_exits_for_next_day_reentry ... ok
+test platform_expr_strategy::tests::stock_state_cache_resets_before_reusing_compact_keys_on_another_date ... ok
+test platform_expr_strategy::tests::strategy_specific_labels_are_not_framework_rolling_factors ... ok
+test platform_expr_strategy::tests::stock_snapshot_fields_are_loaded_only_when_the_strategy_uses_them ... ok
+test platform_expr_strategy::tests::strategy105_numeric_expressions_compile_to_vm ... ok
+test platform_expr_strategy::tests::target_scale_replenishment_preserves_strategy_cash_allocation ... ok
+test platform_expr_strategy::tests::target_portfolio_smart_exposes_decision_and_execution_dates ... ok
+test platform_expr_strategy::tests::target_portfolio_smart_respects_current_date_weight_conditions ... ok
+test platform_expr_strategy::tests::typed_runtime_numbers_preserve_legacy_rhai_formatting ... ok
+test platform_expr_strategy::tests::universe_exclude_matches_explicit_symbols_and_bjse_alias ... ok
+test platform_runtime_schema::tests::runtime_schema_includes_known_identifiers ... ok
+test platform_runtime_schema::tests::runtime_schema_serializes_to_json_object ... ok
+test platform_strategy_spec::tests::accepts_equivalent_risk_policy_alias_values ... ok
+test platform_expr_strategy::tests::timed_rotation_runs_on_its_schedule_instead_of_the_untimed_day_hook ... ok
+test platform_strategy_spec::tests::accepts_scoped_blacklist_context_in_runtime_risk_policy ... ok
+test platform_strategy_spec::tests::canonicalizes_duplicate_execution_aliases_without_changing_strategy_intent ... ok
+test platform_strategy_spec::tests::current_close_respects_explicitly_disabled_liquidity_limit ... ok
+test platform_strategy_spec::tests::engine_config_parses_weak_market_shrink_overweight_threshold ... ok
+test platform_strategy_spec::tests::engine_stock_ma_filter_generates_price_and_volume_expr ... ok
+test platform_strategy_spec::tests::explicit_actions_inherit_top_level_runtime_schedule ... ok
+test platform_strategy_spec::tests::execution_limit_aliases_normalize_to_one_serde_field_without_touching_policy ... ok
+test platform_strategy_spec::tests::explicit_delayed_limit_open_exit_false_overrides_trade_times ... ok
+test platform_strategy_spec::tests::explicit_trading_schedule_overrides_rebalance_trade_times ... ok
+test platform_strategy_spec::tests::frozen_candidate_order_is_explicit_and_preserves_source_positions ... ok
+test platform_strategy_spec::tests::index_throttle_uses_signal_ma_not_performance_benchmark_ma ... ok
+test platform_strategy_spec::tests::native_factor_bindings_declare_completed_session_fields ... ok
+test platform_strategy_spec::tests::multiple_trade_times_do_not_imply_delayed_limit_exit ... ok
+test platform_strategy_spec::tests::normalize_board_does_not_infer_kcb_from_security_code ... ok
+test platform_strategy_spec::tests::numeric_strategy_aliases_accept_exact_zero_but_never_hide_rounding_or_conflicts ... ok
+test platform_strategy_spec::tests::parses_and_rejects_invalid_position_target_rules ... ok
+test platform_strategy_spec::tests::parses_buy_filter_as_a_separate_trading_condition ... ok
+test platform_strategy_spec::tests::parses_daily_schedule_time_for_execution_quotes ... ok
+test platform_strategy_spec::tests::parses_delayed_deposit_receiving_days_expression ... ok
+test platform_strategy_spec::tests::parses_dynamic_model_score_dates_into_platform_config ... ok
+test platform_strategy_spec::tests::parses_execution_cost_overrides_into_platform_config ... ok
+test platform_strategy_spec::tests::parses_execution_slippage_overrides_into_platform_config ... ok
+test platform_strategy_spec::tests::parses_explicit_historical_slippage_into_platform_config ... ok
+test platform_strategy_spec::tests::parses_explicit_delayed_limit_open_exit ... ok
+test platform_strategy_spec::tests::parses_lifecycle_target_portfolio_contract ... ok
+test platform_strategy_spec::tests::parses_generic_futures_actions_and_rejects_incomplete_contracts ... ok
+test platform_strategy_spec::tests::parses_max_holding_days_from_engine_and_runtime_trading ... ok
+test platform_expr_strategy::tests::timed_current_close_stop_loss_reloads_state_after_quote_arrives ... ok
+test platform_strategy_spec::tests::parses_percent_slippage_alias_into_platform_config ... ok
+test platform_strategy_spec::tests::parses_minute_stage_schedule_and_initial_subscriptions ... ok
+test platform_strategy_spec::tests::parses_position_average_entry_stop_take_reference_price_mode ... ok
+test platform_strategy_spec::tests::parses_portfolio_drawdown_control_into_platform_config ... ok
+test platform_strategy_spec::tests::parses_rebalance_cash_mode_and_forces_minute_to_actual_sequence ... ok
+test platform_strategy_spec::tests::parses_risk_policy_into_platform_config ... ok
+test platform_strategy_spec::tests::parses_runtime_expression_spec_into_platform_config ... ok
+test platform_strategy_spec::tests::parses_signal_dates_rebalance_into_platform_config ... ok
+test platform_strategy_spec::tests::parses_signal_day_post_adjusted_stop_take_reference_price_mode ... ok
+test platform_strategy_spec::tests::parses_st_and_star_st_risk_policy_switches_into_platform_config ... ok
+test platform_strategy_spec::tests::parses_typed_time_in_force_for_explicit_orders ... ok
+test platform_strategy_spec::tests::rejects_conflicting_non_policy_strategy_aliases ... ok
+test platform_strategy_spec::tests::rejects_conflicting_risk_policy_alias_values ... ok
+test platform_strategy_spec::tests::rejects_invalid_explicit_volume_percent_in_platform_config ... ok
+test platform_strategy_spec::tests::portfolio_loss_contract_is_explicit_and_validated ... ok
+test platform_strategy_spec::tests::rejects_invalid_portfolio_drawdown_control ... ok
+test platform_strategy_spec::tests::rejects_invalid_or_duplicate_static_universe_symbols ... ok
+test platform_strategy_spec::tests::rejects_removed_compatibility_profile ... ok
+test platform_strategy_spec::tests::rejects_removed_engine_profile_name ... ok
+test platform_strategy_spec::tests::rejects_unknown_stop_take_reference_price_mode ... ok
+test platform_strategy_spec::tests::platform_spec_accepts_only_supported_matching_types ... ok
+test platform_strategy_spec::tests::rejects_non_positive_shared_order_limits ... ok
+test platform_strategy_spec::tests::rejects_unknown_strategy_risk_policy_fields_before_deserialization ... ok
+test platform_strategy_spec::tests::rejects_unknown_time_in_force_in_runtime_contract ... ok
+test platform_strategy_spec::tests::runtime_expression_parser_does_not_inherit_microcap_template_defaults ... ok
+test platform_strategy_spec::tests::retired_or_unknown_slippage_models_do_not_fall_back_to_fixed_or_none ... ok
+test platform_strategy_spec::tests::runtime_expression_parses_dated_position_exposure_schedule ... ok
+test platform_strategy_spec::tests::runtime_expressions_infer_ma_windows_from_literal_strategy_logic ... ok
+test platform_strategy_spec::tests::volume_limit_does_not_enable_quote_quantity_limit_for_minute_last ... ok
+test portfolio::tests::buy_after_partial_sell_continues_moving_average_cost_basis ... ok
+test portfolio::tests::cash_dividend_can_preserve_avg_cost_for_aiquant_rules ... ok
+test portfolio::tests::delayed_withdrawals_are_reserved_and_settled_atomically ... ok
+test portfolio::tests::external_cash_flow_rebases_units_without_changing_nav ... ok
+test portfolio::tests::fifo_fixed_pnl_conserves_value_while_alv_average_cost_stays_stable ... ok
+test portfolio::tests::fixed_lot_allocation_rounds_nearest_and_conserves_total ... ok
+test portfolio::tests::holdings_summary_reports_entry_price_pnl_excluding_buy_commission ... ok
+test portfolio::tests::partial_sell_preserves_remaining_average_cost ... ok
+test portfolio::tests::portfolio_exposes_engine_native_account_metrics ... ok
+test portfolio::tests::portfolio_marks_same_day_buy_at_fill_until_next_trading_day ... ok
+test portfolio::tests::portfolio_missing_market_requires_formal_suspension_before_carrying_price ... ok
+test portfolio::tests::portfolio_tracks_dividend_receivable_and_day_pnl ... ok
+test portfolio::tests::position_tracks_day_lifecycle_fields ... ok
+test portfolio::tests::positions_preserve_insertion_order ... ok
+test portfolio::tests::scoped_checkpoint_restores_order_flat_rows_and_progress_without_copying_untouched_lots ... ok
+test portfolio::tests::strategy_entry_price_excludes_buy_commission_cost_basis ... ok
+test portfolio_loss::tests::cash_sessions_preserve_continuity_without_inventing_returns ... ok
+test platform_strategy_spec::tests::session_rotation_keeps_every_declared_clock_not_only_the_last_one ... ok
+test portfolio_loss::tests::refuses_future_missing_corrected_and_incomplete_accounting ... ok
+test platform_expr_strategy::tests::shared_signal_reduction_and_stops_use_each_accounts_cost_quantity_and_sold_state ... ok
+test portfolio_loss::tests::restored_state_rejects_changed_policy_and_forged_cooldown ... ok
+test position_exposure::tests::allocation_is_dated_and_any_later_scalar_or_restore_clears_it ... ok
+test position_exposure::tests::explicit_equity_targets_and_buys_scale_but_sales_cashflows_and_prices_do_not ... ok
+test position_exposure::tests::rejects_unknown_actions_duplicate_identity_and_invalid_bps ... ok
+test position_exposure::tests::same_day_adjustments_restore_and_future_events_keep_their_own_times ... ok
+test position_exposure::tests::scalar_preserves_strategy_risk_off_and_restore_keeps_original_exposure ... ok
+test risk_control::tests::concrete_kcb_reason_wins_over_generic_missing_risk_state ... ok
+test risk_control::tests::configurable_bjse_filter_can_be_disabled ... ok
+test risk_control::tests::configurable_blacklist_rejects_selection_and_buy ... ok
+test portfolio_loss::tests::restart_is_exact_and_duplicate_decisions_do_not_consume_cooldown ... ok
+test risk_control::tests::configurable_kcb_filter_can_be_disabled ... ok
+test risk_control::tests::configurable_lower_limit_selection_filter_can_be_disabled ... ok
+test risk_control::tests::configurable_upper_limit_buy_filter_can_be_disabled ... ok
+test risk_control::tests::configurable_upper_limit_selection_filter_can_be_disabled ... ok
+test risk_control::tests::delisting_period_status_is_not_terminal_without_delisted_date ... ok
+test risk_control::tests::execution_quote_covers_missing_one_yuan_flag_but_not_other_risk_facts ... ok
+test risk_control::tests::explicit_candidate_inactive_status_is_not_treated_as_missing_risk_state ... ok
+test risk_control::tests::explicit_one_yuan_selection_policy_still_uses_selection_facts ... ok
+test portfolio_loss::tests::nav_serialization_preserves_float_bits ... ok
+test risk_control::tests::fund_identity_excludes_stock_one_yuan_rule_but_not_actual_price_and_pause_checks ... ok
+test risk_control::tests::inactive_selection_checks_preserve_missing_facts_and_execution_rejections ... ok
+test risk_control::tests::kcb_filter_uses_classification_instead_of_security_code ... ok
+test risk_control::tests::missing_risk_state_can_be_relaxed_by_disabling_static_filters ... ok
+test risk_control::tests::missing_risk_state_default_selection_ignores_allow_flags_but_buy_rejects ... ok
+test risk_control::tests::missing_risk_state_rejects_sell_when_sell_risk_facts_are_missing ... ok
+test risk_control::tests::missing_risk_state_respects_field_specific_selection_switches ... ok
+test risk_control::tests::missing_risk_state_respects_field_specific_buy_switches ... ok
+test risk_control::tests::missing_risk_state_selection_audit_keeps_missing_fields_in_reason ... ok
+test risk_control::tests::missing_risk_state_selection_still_respects_configured_static_filters ... ok
+test risk_control::tests::missing_risk_state_sell_can_be_relaxed_by_disabling_sell_static_filters ... ok
+test risk_control::tests::one_yuan_buy_rule_uses_execution_price_not_later_close_or_earlier_open ... ok
+test risk_control::tests::sell_rejection_blocks_execution_price_at_lower_limit ... ok
+test risk_control::tests::sell_rejection_respects_allow_sell_policy_on_execution_day ... ok
+test risk_control::tests::sell_rejects_explicit_candidate_inactive_status_without_instrument_row ... ok
+test risk_control::tests::shared_order_size_limits_apply_to_both_sides_and_buy_position ... ok
+test risk_control::tests::st_and_star_st_filters_are_independent ... ok
+test scheduler::tests::date_due_is_independent_from_the_order_execution_clock ... ok
+test scheduler::tests::scheduler_matches_before_trading_and_minute_level_rules ... ok
+test scheduler::tests::scheduler_matches_daily_weekly_and_monthly_rules ... ok
+test portfolio::tests::cash_ledger_accumulates_micro_yuan_exactly ... ok
+test session_events::tests::gaps_and_stale_last_bars_do_not_become_false_or_repeated_signals ... ok
+test session_events::tests::opening_range_is_unavailable_before_the_range_has_completed ... ok
+test signal_contract::tests::changed_valid_contents_must_not_reuse_a_version_hash ... ok
+test signal_contract::tests::completed_daily_inputs_may_be_published_after_market_close ... ok
+test signal_contract::tests::coverage_and_duplicate_actions_fail_closed ... ok
+test signal_contract::tests::empty_complete_snapshot_clears_only_that_accounts_holdings ... ok
+test signal_contract::tests::historical_reconstruction_is_not_online_publication ... ok
+test signal_contract::tests::next_open_uses_decision_session_and_never_nearest_signal ... ok
+test signal_contract::tests::observed_next_open_never_backdates_a_morning_publication_into_yesterdays_orders ... ok
+test signal_contract::tests::platform_spec_consumes_book_without_running_another_selection ... ok
+test signal_contract::tests::reconstruction_ignores_research_wall_clock_but_never_early_input_availability ... ok
+test signal_contract::tests::reduction_is_resolved_from_each_accounts_actual_position ... ok
+test signal_contract::tests::rejects_future_inputs_and_model_knowledge ... ok
+test session_events::tests::decision_uses_the_previous_completed_label_and_future_prices_do_not_rewrite ... ok
+test signal_contract::tests::rejects_quantities_prices_and_unknown_signal_fields ... ok
+test stock_pool_candidates::tests::list_order_reuses_explicit_prefix_and_appends_new_candidates ... ok
+test stock_pool_candidates::tests::missing_snapshot_duplicate_input_and_empty_filtered_scope_fail ... ok
+test stock_pool_candidates::tests::mixed_sources_preserve_priority_and_both_provenances ... ok
+test stock_pool_candidates::tests::zero_automatic_day_keeps_manual_members_without_inheriting_old_auto_targets ... ok
+test signal_contract::tests::rejects_overallocation_nonfinite_and_ambiguous_actions ... ok
+test stock_pool_execution::frozen::ratio_tests::legacy_paused_and_explicit_partial_budgets_are_not_reinterpreted ... ok
+test stock_pool_execution::frozen::ratio_tests::precise_paused_budget_survives_replacement_and_zero_targets ... ok
+test stock_pool_execution::frozen::ratio_tests::precision_is_checked_before_frozen_budget_is_allocated ... ok
+test stock_pool_execution::tests::confirmed_holdings_not_unsettled_sells_determine_remaining_position_budget ... ok
+test stock_pool_execution::tests::all_membership_and_weight_combinations_use_the_same_target_planner ... ok
+test stock_pool_execution::tests::frozen_valuation_is_dated_and_cannot_turn_an_unknown_gap_into_a_pause ... ok
+test stock_pool_execution::tests::full_stop_overrides_a_simultaneous_factor_reduction_without_a_second_target ... ok
+test stock_pool_execution::tests::independent_exit_quote_priority_does_not_bypass_t_plus_one_or_price_validation ... ok
+test stock_pool_execution::tests::independent_full_exit_has_no_ordinary_quote_dependency_but_partial_risk_does_not_fake_missing_facts ... ok
+test stock_pool_execution::tests::independent_stop_does_not_require_unused_ordinary_sell_quote_facts ... ok
+test stock_pool_execution::tests::index_cap_cannot_sell_a_paused_holding_or_use_its_budget_as_free_cash ... ok
+test stock_pool_execution::tests::index_cap_keeps_non_sellable_quantity_and_defers_the_remaining_risk_target ... ok
+test stock_pool_execution::tests::index_cap_reduces_existing_proportions_without_enabling_weight_rebalancing ... ok
+test stock_pool_execution::tests::index_cap_respects_ordinary_weight_changes_and_stronger_fill_protection ... ok
+test stock_pool_execution::tests::equal_thirty_seats_use_full_precision_at_a_board_lot_boundary ... ok
+test stock_pool_execution::tests::instrument_price_tick_and_quantity_units_are_not_a_two_decimal_stock_assumption ... ok
+test stock_pool_execution::tests::legacy_constraints_do_not_gain_an_empty_precision_field ... ok
+test stock_pool_execution::tests::market_quantity_budget_includes_execution_slippage_and_fees ... ok
+test stock_pool_execution::tests::index_exposure_and_reserved_seats_multiply_without_rounding_the_budget_early ... ok
+test stock_pool_execution::tests::optional_configuration_and_conflicting_aliases_are_explicit ... ok
+test stock_pool_execution::tests::native_sell_and_quote_conditions_are_and_but_stop_and_protection_remain_independent ... ok
+test stock_pool_execution::tests::ordinary_sell_keeps_required_quote_failures_and_zero_stop_is_not_an_exit ... ok
+test stock_pool_execution::tests::partial_sell_cooldown_restricts_increases_without_clearing_the_remainder ... ok
+test stock_pool_execution::tests::ordinary_sell_scope_excludes_independent_exits_and_protected_positions ... ok
+test stock_pool_execution::tests::paused_outside_holding_retains_prior_budget_without_an_execution_quote ... ok
+test stock_pool_execution::tests::quote_condition_number_contract_rejects_invalid_facts_and_fractional_shares ... ok
+test session_events::tests::all_thirteen_events_return_native_boolean_series ... ok
+test stock_pool_execution::tests::paused_held_weight_is_not_replenished_after_another_stock_exits ... ok
+test stock_pool_execution::tests::quote_condition_scopes_are_evaluated_before_target_orders ... ok
+test stock_pool_execution::tests::quote_only_exit_still_works_when_independent_risk_rules_are_configured ... ok
+test stock_pool_execution::tests::retained_holdings_reserve_actual_value_and_zero_funding_still_clears ... ok
+test stock_pool_execution::tests::reserve_slots_keep_requested_and_effective_exposure_distinct ... ok
+test stock_pool_execution::tests::sale_slippage_does_not_prevent_a_marked_value_board_lot_reduction ... ok
+test stock_pool_execution::tests::risk_only_configuration_never_turns_into_an_unconditional_ordinary_exit ... ok
+test stock_pool_execution::tests::sell_cooldown_does_not_turn_disabled_weight_rebalancing_back_on ... ok
+test stock_pool_execution::tests::sell_quote_condition_creates_exit_and_unmet_holding_keeps_its_slot ... ok
+test stock_pool_execution::tests::selection_excluding_paused_stock_keeps_the_same_24_stock_budget_as_broker_execution ... ok
+test stock_pool_execution::tests::stop_reduction_merge_matrix_preserves_protection_t_plus_one_and_invalid_config_errors ... ok
+test stock_pool_index_policy::tests::disabled_is_optional_but_enabled_parameters_are_not_invented ... ok
+test stock_pool_index_policy::tests::missing_or_duplicate_or_future_rows_never_shorten_the_window ... ok
+test stock_pool_index_policy::tests::trend_and_caps_match_the_declared_math_and_keep_zero_meaningful ... ok
+test stock_pool_indicators::tests::kdj_uses_the_same_frozen_native_kernel_as_event_conditions ... ok
+test stock_pool_indicators::tests::missing_inputs_require_source_admission_and_future_inputs_fail ... ok
+test stock_pool_indicators::tests::uses_shared_ma_ema_and_preserves_recursive_prefix_before_output_window ... ok
+test stock_pool_market_cap::tests::interpolates_declared_endpoints_and_clamps_without_business_defaults ... ok
+test stock_pool_market_cap::tests::missing_duplicate_or_mismatched_index_inputs_do_not_shrink_the_calendar ... ok
+test stock_pool_quote_facts::tests::lunch_and_post_close_gaps_follow_the_minute_feed_segments ... ok
+test stock_pool_quote_facts::tests::real_source_session_prefix_matches_observed_checkpoints ... ignored, requires FIDC_SESSION_PREFIX_SOURCE_JSON from the frozen Source minute response
+test stock_pool_quote_facts::tests::sparse_unverified_and_overflowing_quotes_cannot_be_called_session_totals ... ok
+test stock_pool_quote_facts::tests::totals_use_only_the_complete_observed_prefix_and_keep_decimal_amounts ... ok
+test strategy::decision_merge_tests::explicit_empty_complete_target_replaces_old_allocation_but_empty_callback_does_not ... ok
+test strategy::decision_merge_tests::newer_complete_target_replaces_old_symbols_without_discarding_explicit_actions ... ok
+test strategy::tests::omni_microcap_projection_uses_configured_trading_cost ... ok
+test strategy::tests::omni_microcap_selection_uses_configured_risk_policy ... ok
+test strategy::tests::order_time_in_force_parsing_and_order_type_contract_are_explicit ... ok
+test strategy_ai::tests::generation_prompt_uses_explicit_performance_acceptance_contract ... ok
+test strategy_ai::tests::manual_separates_explicit_business_selection_from_framework_risk_policy ... ok
+test strategy_ai::tests::optimization_prompt_uses_explicit_performance_acceptance_contract ... ok
+test universe::tests::selector_applies_configured_selection_risk_on_decision_date ... ok
+test universe::tests::selector_can_defer_configured_selection_risk_without_losing_diagnostics ... ok
+test universe::tests::selector_records_structured_selection_risk_decisions ... ok
+test stock_pool_execution::tests::typed_exit_roles_merge_only_satisfied_ordinary_actions_with_independent_risk ... ok
+test risk_control::tests::selection_check_activation_covers_every_configured_flag_and_blacklist_state ... ok
+test stock_pool_execution::tests::quote_field_operator_side_and_scope_matrix_matches_the_configured_predicate ... ok
+
+test result: ok. 779 passed; 0 failed; 7 ignored; 0 measured; 0 filtered out; finished in 0.54s
+
+     Running unittests src/bin/dump_platform_runtime_schema.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/dump_platform_runtime_schema-c4b52627aec309c9)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+     Running tests/automatic_trade_protection.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/automatic_trade_protection-e76e4284ad200e69)
+
+running 6 tests
+test absolute_lock_blocks_initial_strategy_buy_without_a_rejected_order ... ok
+test framework_protection_uses_fills_and_covers_explicit_strategy_orders ... ok
+test maximum_holding_policy_applies_to_discrete_strategies_and_yields_to_buy_protection ... ok
+test serialized_framework_policy_survives_shared_alias_normalization_and_rejects_conflicts ... ok
+test locked_holding_keeps_its_slot_even_when_cash_can_buy_the_next_candidate ... ok
+test observed_manual_trades_then_split_keep_real_fill_protection_and_lock_dates ... ok
+
+test result: ok. 6 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.03s
+
+     Running tests/core_rules.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/core_rules-6365eded07d721e8)
+
+running 8 tests
+test china_cost_model_applies_minimum_commission_and_stamp_tax ... ok
+test china_cost_model_tracks_minimum_commission_per_order_id ... ok
+test china_cost_model_switches_stamp_tax_rate_after_2023_08_28 ... ok
+test china_rule_hooks_allow_sell_when_last_price_is_above_lower_limit ... ok
+test china_rule_hooks_block_same_day_sell_under_t_plus_one ... ok
+test china_rule_hooks_block_buy_at_limit_up_and_sell_at_limit_down ... ok
+test china_rule_hooks_use_strict_price_limits ... ok
+test configured_cost_model_matches_declared_run_options ... ok
+
+test result: ok. 8 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+     Running tests/corporate_actions.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/corporate_actions-05d8a8628f15e674)
+
+running 6 tests
+test cash_dividend_adjusts_cost_basis_and_returns_cash_delta ... ok
+test stock_split_scales_lots_quantity_and_average_cost ... ok
+test portfolio_settles_cash_receivable_on_payable_date ... ok
+test engine_settles_same_day_dividend_after_split_for_aiquant_semantics ... FAILED
+test engine_reinvests_dividend_receivable_in_round_lots ... ok
+test successor_conversion_depletes_older_source_lots_before_newer_successor_buys ... ok
+
+failures:
+
+---- engine_settles_same_day_dividend_after_split_for_aiquant_semantics stdout ----
+
+thread 'engine_settles_same_day_dividend_after_split_for_aiquant_semantics' (4173472) panicked at crates/fidc-core/tests/corporate_actions.rs:663:5:
+assertion failed: result.position_events.iter().any(|event|
+        event.reason == "stock_split 1.200000" &&
+            event.quantity_after == 1_200)
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+
+
+failures:
+    engine_settles_same_day_dividend_after_split_for_aiquant_semantics
+
+test result: FAILED. 5 passed; 1 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+error: test failed, to rerun pass `-p fidc-core --test corporate_actions`

docs/evidence/registered-share-delivery-20261005/core-initial-targeted-failure.log

@@ -0,0 +1,44 @@
+   Compiling fidc-core v0.1.0 (/srv/fidc/programs/src/fidc-share-receivable-validation-20261005-0bbeed4/crates/fidc-core)
+    Finished `test` profile [unoptimized] target(s) in 45.20s
+     Running unittests src/lib.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/fidc_core-dbea4d4f6cb5d2d7)
+
+running 22 tests
+test corporate_book::tests::closing_register_cannot_be_replaced_by_later_holdings ... ok
+test corporate_book::tests::dividend_receivable_survives_a_flat_position_without_becoming_spendable_cash ... ok
+test corporate_book::tests::entitlement_survives_complete_sale_and_a_successor_unit_conversion ... ok
+test corporate_book::tests::a_late_corporate_batch_failure_keeps_prior_cash_positions_and_notes ... ok
+
+thread 'corporate_book::tests::corporate_quantity_overflow_fails_without_saturation_or_a_negative_delta' (4165594) panicked at crates/fidc-core/src/corporate_book.rs:1098:13:
+assertion failed: error.to_string().contains("corporate_action_quantity_overflow")
+note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
+test corporate_book::tests::explicitly_delayed_dividend_remains_receivable_until_actual_payment ... ok
+test corporate_book::tests::flat_position_retirement_does_not_change_issued_lot_state_or_next_purchase_origin ... ok
+test corporate_book::tests::corporate_quantity_overflow_fails_without_saturation_or_a_negative_delta ... FAILED
+test corporate_book::tests::missing_accounting_reference_is_atomic_not_a_silent_cash_only_success ... ok
+test corporate_book::tests::manual_zero_skips_only_unused_allocation_facts_not_invalid_cash_evidence ... ok
+test corporate_book::tests::invalid_delivery_negative_rates_and_unresolved_fractional_claims_are_atomic ... ok
+test corporate_book::tests::missing_or_backward_cash_payment_date_never_updates_the_account ... ok
+test corporate_book::tests::per_share_precision_is_retained_until_the_registered_cash_amount_is_rounded ... ok
+test corporate_book::tests::missing_record_date_or_unobserved_closing_book_is_atomic ... ok
+test corporate_book::tests::post_record_buy_cannot_receive_the_earlier_dividend ... ok
+test corporate_book::tests::post_record_purchase_does_not_inherit_registered_shares ... ok
+test corporate_book::tests::registered_shares_are_valued_but_not_delivered_or_sellable_before_the_original_date ... ok
+test corporate_book::tests::sale_after_registration_preserves_cash_and_excludes_new_lots_from_cost_adjustment ... ok
+
+thread 'corporate_book::tests::successor_without_frozen_instrument_metadata_is_not_an_implicit_new_security' (4165614) panicked at crates/fidc-core/src/corporate_book.rs:998:9:
+assertion failed: error.to_string().contains("successor_instrument_missing")
+test corporate_book::tests::terminated_security_keeps_paid_cash_and_is_not_recreated_by_reinvestment ... ok
+test corporate_book::tests::successor_without_frozen_instrument_metadata_is_not_an_implicit_new_security ... FAILED
+test corporate_book::tests::verified_conversion_preserves_lots_without_creating_orders_or_fills ... ok
+test corporate_book::tests::tiny_known_cash_rate_is_preserved_and_cannot_waive_payment_or_record_evidence ... ok
+test corporate_book::tests::invalid_successor_terms_cannot_be_replaced_with_one_share_or_zero_cash ... ok
+
+failures:
+
+failures:
+    corporate_book::tests::corporate_quantity_overflow_fails_without_saturation_or_a_negative_delta
+    corporate_book::tests::successor_without_frozen_instrument_metadata_is_not_an_implicit_new_security
+
+test result: FAILED. 20 passed; 2 failed; 0 ignored; 0 measured; 764 filtered out; finished in 0.01s
+
+error: test failed, to rerun pass `-p fidc-core --lib`

docs/evidence/registered-share-delivery-20261005/file-shas.json

@@ -0,0 +1,140 @@
+{
+  "engine_commit": "ce46c13f37f028393e689babbe5c348d482d3a32",
+  "files": [
+    {
+      "bytes": 3625,
+      "file": "core-initial-targeted-failure.log",
+      "sha256": "9684e4e1c10aabe426c15cd408bb61b198ada8eed1258231e4b81fc30716ac49",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-0bbeed4/initial-targeted-linux-tests.log",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 82467,
+      "file": "core-attempt1-failure.log",
+      "sha256": "9535151bd7a29a5f56265ef35dbff89b3e48729688cb34c32aa8a8fc9347e41c",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-0caac44/full-linux-tests-attempt1.log",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 95343,
+      "file": "core-attempt2-failure.log",
+      "sha256": "db18ad5e876ce482dc1f76ac244e170a6095c2ead8a991af5dce45e72af8e9ac",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-4eb4c17/full-linux-tests-attempt2.log",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 98381,
+      "file": "core-attempt3-success.log",
+      "sha256": "66879f838ec21001cb3e6c284f497cfb6a80c2d3a724ee9cb04e09476afc101b",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-05315f0/full-linux-tests-attempt3.log",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 98381,
+      "file": "core-sell-availability-success.log",
+      "sha256": "b565d8b983fb87881974da37ad5bd0721db3f51acda3af0cbe1b62406f18371c",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-a267052/final-full-linux-tests.log",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 98381,
+      "file": "core-successor-guard-success.log",
+      "sha256": "b8f7a20a93335801950e40ce3a7124ae039e84fbb1db7dd821c314d2b05b4447",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-7d7cce8/final-full-linux-tests.log",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 98572,
+      "file": "core-final-full-linux-tests.log",
+      "sha256": "cfd1cb81fde9f34991a54a54e2a734844bd8fab52292e043856b08d30090d19a",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-ce46c13/final-full-linux-tests.log",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 10543,
+      "file": "runner-initial-compile-failure.log",
+      "sha256": "e758be915373f707a460e7d08ab4162f3b80d86b98091c555cb3351c2bb4d7b8",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1fa73bb/full-linux-tests-attempt1.log",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 65133,
+      "file": "runner-attempt2-success.log",
+      "sha256": "d053e4e432cbe0b198f85ceee349b241eac4cf90b8e6a75289c322c59538b2b7",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ffc6e1f/full-linux-tests-attempt2.log",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 65133,
+      "file": "runner-successor-pair-success.log",
+      "sha256": "6f2e8974a90d5cdbce788e2744a1276dff9fe94b79958869cfb0730c096d1a42",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ce46c13/final-full-linux-tests.log",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 7207,
+      "file": "prior-validation-receipt.json",
+      "sha256": "5240dbf5f1d7382531a4c0dce5fcdb722f4d1137a41854269159b61f0236d412",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ce46c13/validation-receipt.json",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 8550,
+      "file": "prior-validation-pg-receipt.json",
+      "sha256": "45b483a748c5354239dd678e66b652f53d9225108f2ab41f152a06250e69bd25",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ce46c13/validation-pg-receipt.json",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 2275,
+      "file": "prior-operational-verification.json",
+      "sha256": "32e634849aecbd2b634c6dcdbad68013f2c5eb603c8d586a43cc4698d8b18a4a",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ce46c13/operational-verification.json",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 762,
+      "file": "receipt-construction-failure.json",
+      "sha256": "e62a4819bd08599a3af797588211c79add8867bb8b3dfb67c28497bfe5780445",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ce46c13/receipt-construction-failure.json",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 65258,
+      "file": "runner-final-full-linux-tests.log",
+      "sha256": "2ba99fb0198a68ff5bc3d6341b1cdeb3da1a4d0ca5496b2faa3e79e3494ae434",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1d4b32e/final-full-linux-tests.log",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 8192,
+      "file": "validation-receipt.json",
+      "sha256": "097101988e5f6875c8933012534cfa1ca72f9e2742c04d002aba7d00a69fc346",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1d4b32e/validation-receipt.json",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 9573,
+      "file": "validation-pg-receipt.json",
+      "sha256": "04207632e68efaea406e1357937a5bb75d23fa0d74e5461ccfa7993b07e302e8",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1d4b32e/validation-pg-receipt.json",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 2275,
+      "file": "operational-verification.json",
+      "sha256": "3ce2ba78ed28f549ddc675429565e578fe61eee1db4374c375e5049761c8fd06",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1d4b32e/operational-verification.json",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 839,
+      "file": "live-test-resource-verification.json",
+      "sha256": "1686248392f29ae93f023ff147fcc0abb06b6b2fb15a9806b5718e320ed75a40",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1d4b32e/live-test-resource-verification.json",
+      "source_uid": 1003
+    }
+  ],
+  "schema_version": "fidc.local-share-delivery-evidence-manifest/v1",
+  "service_commit": "1d4b32e18d3836b5844130ae0c95d90247768882"
+}

docs/evidence/registered-share-delivery-20261005/live-test-resource-verification.json

@@ -0,0 +1,31 @@
+{
+  "contract_sha256": "fed292d158989d58f63b478d266675e294b1f156f20796406615f9fc4eb7b398",
+  "observed_at": "2026-10-04T22:06:48.117070+00:00",
+  "observed_process_owners": [
+    {
+      "pid": 83961,
+      "uid": 1003
+    },
+    {
+      "pid": 84064,
+      "uid": 1003
+    },
+    {
+      "pid": 84092,
+      "uid": 1003
+    }
+  ],
+  "owner_uid": 1003,
+  "production_ready": false,
+  "properties": {
+    "ActiveState": "active",
+    "CPUQuotaPerSecUSec": "4s",
+    "ControlGroup": "/user.slice/user-1003.slice/user@1003.service/app.slice/fidc-share-delivery-quantity-validation-20261005.scope",
+    "MemoryMax": "17179869184",
+    "MemorySwapMax": "0",
+    "TasksMax": "256"
+  },
+  "schema_version": "fidc.live-share-delivery-test-scope/v1",
+  "trading_allowed": false,
+  "unit": "fidc-share-delivery-quantity-validation-20261005.scope"
+}

docs/evidence/registered-share-delivery-20261005/operational-verification.json

@@ -0,0 +1,70 @@
+{
+  "authorized_incremental_cache_root": "/srv/fidc/programs/src/fidc-backtest-service/target/debug/incremental",
+  "contract_sha256": "4696cb0eb31095275a0440c3c25e605502c2b6b6f07acf46032eb552d3547e7e",
+  "health": [
+    {
+      "body_sha256": "3d4310bd55460dc1d83c95d0420b5e2c979a15b90c6d98f4b45378b645f6cd96",
+      "http_status": 200,
+      "port": 18095
+    },
+    {
+      "body_sha256": "897da12d1075bd042696ef9b39e0aec42706985e9880887be0daceeab21afb17",
+      "http_status": 200,
+      "port": 18096
+    }
+  ],
+  "incremental_files_present": 0,
+  "numeric_research_budget_reopened": false,
+  "observed_at": "2026-10-04T22:08:10.206192+00:00",
+  "original_research_plan_sha256": "6aa6932b8b7d4538543e7baf48b1b0ab305e684b36003faeaa7f0f4db4067c0c",
+  "original_research_source_commit": "d847b82de3f62a369291c13160b31fcfc0075b8b",
+  "owner_uid": 1003,
+  "production_ready": false,
+  "production_runtime_deployed": false,
+  "production_strategy_count": 0,
+  "schema_version": "fidc.share-delivery-operational-verification/v1",
+  "ssd_free_bytes": 9045954560,
+  "trading_allowed": false,
+  "units": [
+    {
+      "ActiveState": "active",
+      "InvocationID": "b6bd3c6c3a6d4f729291b969590d66a0",
+      "MainPID": "3571059",
+      "NRestarts": "0",
+      "process_uid": 1003,
+      "unit": "fidc-private-agent-runtime.service"
+    },
+    {
+      "ActiveState": "active",
+      "InvocationID": "851771deedc44b78bea58e18c74f9421",
+      "MainPID": "1073961",
+      "NRestarts": "1",
+      "process_uid": 1003,
+      "unit": "fidc-private-source-lake-worker.service"
+    },
+    {
+      "ActiveState": "active",
+      "InvocationID": "ce19e205006945e888c42ff385f96a50",
+      "MainPID": "2371183",
+      "NRestarts": "0",
+      "process_uid": 1003,
+      "unit": "fidc-private-source-lake.service"
+    },
+    {
+      "ActiveState": "active",
+      "InvocationID": "386b6478a0384505a8c9704e2d2a1478",
+      "MainPID": "3571320",
+      "NRestarts": "0",
+      "process_uid": 1003,
+      "unit": "fidc-private-strategy-ai.service"
+    },
+    {
+      "ActiveState": "active",
+      "InvocationID": "0eb28e3a45694a00951aa3aec0e13465",
+      "MainPID": "1396112",
+      "NRestarts": "0",
+      "process_uid": 1003,
+      "unit": "fidc-projection-research-autopilot.service"
+    }
+  ]
+}

docs/evidence/registered-share-delivery-20261005/prior-operational-verification.json

@@ -0,0 +1,70 @@
+{
+  "authorized_incremental_cache_root": "/srv/fidc/programs/src/fidc-backtest-service/target/debug/incremental",
+  "contract_sha256": "66d0cf1d1a93b7960777c494da152af837f1c86b49bccf5591ba3f295f7383b6",
+  "health": [
+    {
+      "body_sha256": "0dc4f9d9af47e41507d9267ee3e08d4cce2027b0b757f0f87193bf27c73abd91",
+      "http_status": 200,
+      "port": 18095
+    },
+    {
+      "body_sha256": "245cfc3e4dd1b3301167429fa8cdfd53e49f7f6a5d8ad754047a6bc1645f5f93",
+      "http_status": 200,
+      "port": 18096
+    }
+  ],
+  "incremental_files_present": 0,
+  "numeric_research_budget_reopened": false,
+  "observed_at": "2026-10-04T22:02:08.949482+00:00",
+  "original_research_plan_sha256": "6aa6932b8b7d4538543e7baf48b1b0ab305e684b36003faeaa7f0f4db4067c0c",
+  "original_research_source_commit": "d847b82de3f62a369291c13160b31fcfc0075b8b",
+  "owner_uid": 1003,
+  "production_ready": false,
+  "production_runtime_deployed": false,
+  "production_strategy_count": 0,
+  "schema_version": "fidc.share-delivery-operational-verification/v1",
+  "ssd_free_bytes": 9070112768,
+  "trading_allowed": false,
+  "units": [
+    {
+      "ActiveState": "active",
+      "InvocationID": "b6bd3c6c3a6d4f729291b969590d66a0",
+      "MainPID": "3571059",
+      "NRestarts": "0",
+      "process_uid": 1003,
+      "unit": "fidc-private-agent-runtime.service"
+    },
+    {
+      "ActiveState": "active",
+      "InvocationID": "851771deedc44b78bea58e18c74f9421",
+      "MainPID": "1073961",
+      "NRestarts": "1",
+      "process_uid": 1003,
+      "unit": "fidc-private-source-lake-worker.service"
+    },
+    {
+      "ActiveState": "active",
+      "InvocationID": "ce19e205006945e888c42ff385f96a50",
+      "MainPID": "2371183",
+      "NRestarts": "0",
+      "process_uid": 1003,
+      "unit": "fidc-private-source-lake.service"
+    },
+    {
+      "ActiveState": "active",
+      "InvocationID": "386b6478a0384505a8c9704e2d2a1478",
+      "MainPID": "3571320",
+      "NRestarts": "0",
+      "process_uid": 1003,
+      "unit": "fidc-private-strategy-ai.service"
+    },
+    {
+      "ActiveState": "active",
+      "InvocationID": "0eb28e3a45694a00951aa3aec0e13465",
+      "MainPID": "1396112",
+      "NRestarts": "0",
+      "process_uid": 1003,
+      "unit": "fidc-projection-research-autopilot.service"
+    }
+  ]
+}

docs/evidence/registered-share-delivery-20261005/prior-validation-pg-receipt.json

@@ -0,0 +1,192 @@
+{
+  "artifact_bytes": 7207,
+  "artifact_id": "strategy_research_cb32517064d7558f69713001",
+  "artifact_path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ce46c13/validation-receipt.json",
+  "artifact_sha256": "5240dbf5f1d7382531a4c0dce5fcdb722f4d1137a41854269159b61f0236d412",
+  "artifact_type": "research_source_scope_probe",
+  "contract_sha256": "35ecf44697bf2e35967221e9f6dd9b330f3445137a3b00dadd3da59a01db2720",
+  "created_at": "2026-10-04T22:03:46Z",
+  "created_by": "boris",
+  "department_id": null,
+  "organization_id": "local_org",
+  "persisted_at": "2026-10-04T22:03:46Z",
+  "production_ready": false,
+  "record_json": {
+    "all_attempt_log_references": [
+      {
+        "bytes": 3625,
+        "compiler_failure": false,
+        "complete_success": false,
+        "failed": 2,
+        "ignored": 0,
+        "passed": 20,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-0bbeed4/initial-targeted-linux-tests.log",
+        "sha256": "9684e4e1c10aabe426c15cd408bb61b198ada8eed1258231e4b81fc30716ac49"
+      },
+      {
+        "bytes": 82467,
+        "compiler_failure": false,
+        "complete_success": false,
+        "failed": 1,
+        "ignored": 7,
+        "passed": 798,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-0caac44/full-linux-tests-attempt1.log",
+        "sha256": "9535151bd7a29a5f56265ef35dbff89b3e48729688cb34c32aa8a8fc9347e41c"
+      },
+      {
+        "bytes": 95343,
+        "compiler_failure": false,
+        "complete_success": false,
+        "failed": 4,
+        "ignored": 9,
+        "passed": 923,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-4eb4c17/full-linux-tests-attempt2.log",
+        "sha256": "db18ad5e876ce482dc1f76ac244e170a6095c2ead8a991af5dce45e72af8e9ac"
+      },
+      {
+        "bytes": 98381,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 9,
+        "passed": 967,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-05315f0/full-linux-tests-attempt3.log",
+        "sha256": "66879f838ec21001cb3e6c284f497cfb6a80c2d3a724ee9cb04e09476afc101b"
+      },
+      {
+        "bytes": 98381,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 9,
+        "passed": 967,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-a267052/final-full-linux-tests.log",
+        "sha256": "b565d8b983fb87881974da37ad5bd0721db3f51acda3af0cbe1b62406f18371c"
+      },
+      {
+        "bytes": 98381,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 9,
+        "passed": 967,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-7d7cce8/final-full-linux-tests.log",
+        "sha256": "b8f7a20a93335801950e40ce3a7124ae039e84fbb1db7dd821c314d2b05b4447"
+      },
+      {
+        "bytes": 98572,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 9,
+        "passed": 969,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-ce46c13/final-full-linux-tests.log",
+        "sha256": "cfd1cb81fde9f34991a54a54e2a734844bd8fab52292e043856b08d30090d19a"
+      },
+      {
+        "bytes": 10543,
+        "compiler_failure": true,
+        "complete_success": false,
+        "failed": 0,
+        "ignored": 0,
+        "passed": 0,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1fa73bb/full-linux-tests-attempt1.log",
+        "sha256": "e758be915373f707a460e7d08ab4162f3b80d86b98091c555cb3351c2bb4d7b8"
+      },
+      {
+        "bytes": 65133,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 17,
+        "passed": 613,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ffc6e1f/full-linux-tests-attempt2.log",
+        "sha256": "d053e4e432cbe0b198f85ceee349b241eac4cf90b8e6a75289c322c59538b2b7"
+      },
+      {
+        "bytes": 65133,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 17,
+        "passed": 613,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ce46c13/final-full-linux-tests.log",
+        "sha256": "6f2e8974a90d5cdbce788e2744a1276dff9fe94b79958869cfb0730c096d1a42"
+      }
+    ],
+    "contract_sha256": "b4885b28b8076c61977dbe24948d2c0eabc7ac32f6e8ad0591b2011f1b9b2c11",
+    "core_test_result": {
+      "bytes": 98572,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 9,
+      "passed": 969,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-ce46c13/final-full-linux-tests.log",
+      "sha256": "cfd1cb81fde9f34991a54a54e2a734844bd8fab52292e043856b08d30090d19a"
+    },
+    "corporate_action_cache_schema_version": 5,
+    "engine_commit": "ce46c13f37f028393e689babbe5c348d482d3a32",
+    "fractional_quantity_requires_explicit_settlement_rule": true,
+    "full_source_event_and_revision_scope_verified": false,
+    "new_runtime_release_performed": false,
+    "numeric_research_budget_reopened": false,
+    "observed_at": "2026-10-04T22:02:08.963623+00:00",
+    "operational_verification_reference": {
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ce46c13/operational-verification.json",
+      "sha256": "32e634849aecbd2b634c6dcdbad68013f2c5eb603c8d586a43cc4698d8b18a4a"
+    },
+    "owner_uid": 1003,
+    "pending_share_successor_conversion_without_carry_terms_rejected": true,
+    "performance_speedup_claimed": false,
+    "production_ready": false,
+    "production_runtime_deployed": false,
+    "production_strategy_count": 0,
+    "registered_share_entitlements_separate_from_delivered_and_sellable_quantity": true,
+    "resource_contract_requested": {
+      "build_jobs": 4,
+      "core_target_path": "/tmp/fidc-cash-receivable-build-20261005-af655de",
+      "cpu_quota_percent": 400,
+      "incremental": false,
+      "locked": true,
+      "memory_max_bytes": 17179869184,
+      "memory_swap_max_bytes": 0,
+      "offline": true,
+      "resource_properties_after_transient_scope_exit_are_not_live_validation": true,
+      "runner_target_path": "/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb",
+      "rustc": "rustc 1.98.0 (88d9e12ae 2026-08-18)",
+      "target_filesystem": "executable_tmpfs",
+      "tasks_max": 256,
+      "toolchain": "stable-x86_64-unknown-linux-gnu"
+    },
+    "runner_api_test_result": {
+      "bytes": 65133,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 17,
+      "passed": 613,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ce46c13/final-full-linux-tests.log",
+      "sha256": "6f2e8974a90d5cdbce788e2744a1276dff9fe94b79958869cfb0730c096d1a42"
+    },
+    "schema_version": "fidc.linux-registered-share-delivery-validation/v1",
+    "service_commit": "ffc6e1f5b8b1d6c9b342a661c7a25ebfc3d8d4c5",
+    "share_receivable_assets_included_in_equity_and_target_sizing": true,
+    "simulation_rounding_fixture_not_official_settlement_evidence": true,
+    "source_pair_root": "/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-ce46c13",
+    "source_publication_times_admitted_as_PIT": false,
+    "source_rows_semantic_sha256": "eec65df828f97a3e51827cb6b0e9ec2c86079a333481d55ec9eb6ab2845d73c5",
+    "source_rows_semantic_version": "v10",
+    "source_transport_commit": "12eeae5d570004499a30f7faa42c0da93c1578cc",
+    "status": "core_and_runner_api_regressions_passed_not_source_runtime_or_strategy_acceptance",
+    "trading_allowed": false,
+    "two_framework_financial_reconciliation_completed": false,
+    "unknown_delivery_date_not_defaulted_to_ex_date": true,
+    "unknown_distribution_quantities_not_defaulted_to_zero": true
+  },
+  "research_key": "fidc-registered-share-delivery-validation-20261005-ce46c13-ffc6e1f",
+  "schema_table": "strategy_research_artifact",
+  "schema_version": "fidc.linux-registered-share-delivery-validation/v1",
+  "status": "core_and_runner_api_regressions_passed_not_source_runtime_or_strategy_acceptance",
+  "storage": "postgres"
+}

docs/evidence/registered-share-delivery-20261005/prior-validation-receipt.json

@@ -0,0 +1,173 @@
+{
+  "all_attempt_log_references": [
+    {
+      "bytes": 3625,
+      "compiler_failure": false,
+      "complete_success": false,
+      "failed": 2,
+      "ignored": 0,
+      "passed": 20,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-0bbeed4/initial-targeted-linux-tests.log",
+      "sha256": "9684e4e1c10aabe426c15cd408bb61b198ada8eed1258231e4b81fc30716ac49"
+    },
+    {
+      "bytes": 82467,
+      "compiler_failure": false,
+      "complete_success": false,
+      "failed": 1,
+      "ignored": 7,
+      "passed": 798,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-0caac44/full-linux-tests-attempt1.log",
+      "sha256": "9535151bd7a29a5f56265ef35dbff89b3e48729688cb34c32aa8a8fc9347e41c"
+    },
+    {
+      "bytes": 95343,
+      "compiler_failure": false,
+      "complete_success": false,
+      "failed": 4,
+      "ignored": 9,
+      "passed": 923,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-4eb4c17/full-linux-tests-attempt2.log",
+      "sha256": "db18ad5e876ce482dc1f76ac244e170a6095c2ead8a991af5dce45e72af8e9ac"
+    },
+    {
+      "bytes": 98381,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 9,
+      "passed": 967,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-05315f0/full-linux-tests-attempt3.log",
+      "sha256": "66879f838ec21001cb3e6c284f497cfb6a80c2d3a724ee9cb04e09476afc101b"
+    },
+    {
+      "bytes": 98381,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 9,
+      "passed": 967,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-a267052/final-full-linux-tests.log",
+      "sha256": "b565d8b983fb87881974da37ad5bd0721db3f51acda3af0cbe1b62406f18371c"
+    },
+    {
+      "bytes": 98381,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 9,
+      "passed": 967,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-7d7cce8/final-full-linux-tests.log",
+      "sha256": "b8f7a20a93335801950e40ce3a7124ae039e84fbb1db7dd821c314d2b05b4447"
+    },
+    {
+      "bytes": 98572,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 9,
+      "passed": 969,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-ce46c13/final-full-linux-tests.log",
+      "sha256": "cfd1cb81fde9f34991a54a54e2a734844bd8fab52292e043856b08d30090d19a"
+    },
+    {
+      "bytes": 10543,
+      "compiler_failure": true,
+      "complete_success": false,
+      "failed": 0,
+      "ignored": 0,
+      "passed": 0,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1fa73bb/full-linux-tests-attempt1.log",
+      "sha256": "e758be915373f707a460e7d08ab4162f3b80d86b98091c555cb3351c2bb4d7b8"
+    },
+    {
+      "bytes": 65133,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 17,
+      "passed": 613,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ffc6e1f/full-linux-tests-attempt2.log",
+      "sha256": "d053e4e432cbe0b198f85ceee349b241eac4cf90b8e6a75289c322c59538b2b7"
+    },
+    {
+      "bytes": 65133,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 17,
+      "passed": 613,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ce46c13/final-full-linux-tests.log",
+      "sha256": "6f2e8974a90d5cdbce788e2744a1276dff9fe94b79958869cfb0730c096d1a42"
+    }
+  ],
+  "contract_sha256": "b4885b28b8076c61977dbe24948d2c0eabc7ac32f6e8ad0591b2011f1b9b2c11",
+  "core_test_result": {
+    "bytes": 98572,
+    "compiler_failure": false,
+    "complete_success": true,
+    "failed": 0,
+    "ignored": 9,
+    "passed": 969,
+    "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-ce46c13/final-full-linux-tests.log",
+    "sha256": "cfd1cb81fde9f34991a54a54e2a734844bd8fab52292e043856b08d30090d19a"
+  },
+  "corporate_action_cache_schema_version": 5,
+  "engine_commit": "ce46c13f37f028393e689babbe5c348d482d3a32",
+  "fractional_quantity_requires_explicit_settlement_rule": true,
+  "full_source_event_and_revision_scope_verified": false,
+  "new_runtime_release_performed": false,
+  "numeric_research_budget_reopened": false,
+  "observed_at": "2026-10-04T22:02:08.963623+00:00",
+  "operational_verification_reference": {
+    "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ce46c13/operational-verification.json",
+    "sha256": "32e634849aecbd2b634c6dcdbad68013f2c5eb603c8d586a43cc4698d8b18a4a"
+  },
+  "owner_uid": 1003,
+  "pending_share_successor_conversion_without_carry_terms_rejected": true,
+  "performance_speedup_claimed": false,
+  "production_ready": false,
+  "production_runtime_deployed": false,
+  "production_strategy_count": 0,
+  "registered_share_entitlements_separate_from_delivered_and_sellable_quantity": true,
+  "resource_contract_requested": {
+    "build_jobs": 4,
+    "core_target_path": "/tmp/fidc-cash-receivable-build-20261005-af655de",
+    "cpu_quota_percent": 400,
+    "incremental": false,
+    "locked": true,
+    "memory_max_bytes": 17179869184,
+    "memory_swap_max_bytes": 0,
+    "offline": true,
+    "resource_properties_after_transient_scope_exit_are_not_live_validation": true,
+    "runner_target_path": "/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb",
+    "rustc": "rustc 1.98.0 (88d9e12ae 2026-08-18)",
+    "target_filesystem": "executable_tmpfs",
+    "tasks_max": 256,
+    "toolchain": "stable-x86_64-unknown-linux-gnu"
+  },
+  "runner_api_test_result": {
+    "bytes": 65133,
+    "compiler_failure": false,
+    "complete_success": true,
+    "failed": 0,
+    "ignored": 17,
+    "passed": 613,
+    "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ce46c13/final-full-linux-tests.log",
+    "sha256": "6f2e8974a90d5cdbce788e2744a1276dff9fe94b79958869cfb0730c096d1a42"
+  },
+  "schema_version": "fidc.linux-registered-share-delivery-validation/v1",
+  "service_commit": "ffc6e1f5b8b1d6c9b342a661c7a25ebfc3d8d4c5",
+  "share_receivable_assets_included_in_equity_and_target_sizing": true,
+  "simulation_rounding_fixture_not_official_settlement_evidence": true,
+  "source_pair_root": "/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-ce46c13",
+  "source_publication_times_admitted_as_PIT": false,
+  "source_rows_semantic_sha256": "eec65df828f97a3e51827cb6b0e9ec2c86079a333481d55ec9eb6ab2845d73c5",
+  "source_rows_semantic_version": "v10",
+  "source_transport_commit": "12eeae5d570004499a30f7faa42c0da93c1578cc",
+  "status": "core_and_runner_api_regressions_passed_not_source_runtime_or_strategy_acceptance",
+  "trading_allowed": false,
+  "two_framework_financial_reconciliation_completed": false,
+  "unknown_delivery_date_not_defaulted_to_ex_date": true,
+  "unknown_distribution_quantities_not_defaulted_to_zero": true
+}

docs/evidence/registered-share-delivery-20261005/receipt-construction-failure.json

@@ -0,0 +1,17 @@
+{
+  "contract_sha256": "6d6cb3b513abce58634f24ed2cc4d691d3c542d0944b2a3408298772806dca67",
+  "error_type": "TypeError",
+  "failed_before_pg_persist_call": true,
+  "failure_function": "build_record",
+  "missing_required_argument": "organization_id",
+  "observed_at": "2026-10-04T22:03:37.554100+00:00",
+  "owner_uid": 1003,
+  "production_ready": false,
+  "schema_version": "fidc.share-delivery-receipt-construction-failure/v1",
+  "test_results_and_frozen_validation_receipt_preserved": true,
+  "trading_allowed": false,
+  "validation_reference": {
+    "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ce46c13/validation-receipt.json",
+    "sha256": "5240dbf5f1d7382531a4c0dce5fcdb722f4d1137a41854269159b61f0236d412"
+  }
+}

docs/evidence/registered-share-delivery-20261005/runner-attempt2-success.log

@@ -0,0 +1,678 @@
+   Compiling fidc-core v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-ffc6e1f/fidc-backtest-engine/crates/fidc-core)
+   Compiling fidc-common v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-ffc6e1f/fidc-backtest-service/crates/fidc-common)
+   Compiling fidc-signal-client v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-ffc6e1f/fidc-backtest-engine/crates/fidc-signal-client)
+   Compiling fidc-backtest-runner v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-ffc6e1f/fidc-backtest-service/services/backtest_runner)
+   Compiling fidc-backtest-service v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-ffc6e1f/fidc-backtest-service/services/api)
+    Finished `test` profile [unoptimized] target(s) in 40.73s
+     Running unittests src/lib.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/deps/fidc_backtest_runner-f9173de301b7a940)
+
+running 483 tests
+test backtest::columnar_factor_overlay_tests::cache_range_rejects_date_disorder_outside_the_binary_search_slice ... ok
+test backtest::columnar_factor_overlay_tests::cache_range_rejects_symbol_disorder_outside_the_requested_date ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_real_cache_value_equivalence ... ignored, requires a frozen private Boris real-data cache directory on 177
+test backtest::columnar_factor_overlay_tests::columnar_overlay_missing_or_stale_cache_does_not_mutate_base ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_rejects_duplicate_window_boundary ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_rejects_duplicate_order_and_count_mismatches ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_rejects_market_projection_and_invalid_cached_column_type ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_rejects_late_key_mismatch_before_any_base_mutation ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_unknown_keys_are_not_hidden_as_empty_values ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_replaced_file_invalidates_view_without_mutating_pinned_input ... ok
+test backtest::columnar_factor_overlay_tests::row_visitor_preserves_selected_offsets_and_late_validation_errors ... ok
+test backtest::compact_storage_tests::batch_bound_factor_columns_preserve_types_nulls_and_nonfinite_values ... ok
+test backtest::columnar_factor_overlay_tests::valid_cache_reuses_its_key_index_and_failed_indexes_are_not_published ... ok
+test backtest::compact_storage_tests::inline_symbols_and_factor_maps_preserve_binary_and_json_contracts ... ok
+test backtest::day_snapshot_builder::tests::a_failed_builder_cannot_publish_earlier_valid_rows ... ok
+test backtest::day_snapshot_builder::tests::factor_reservation_keeps_missing_and_overwrite_semantics ... ok
+test backtest::day_snapshot_builder::tests::late_source_validation_failure_invalidates_the_streamed_day ... ok
+test backtest::equity_lifecycle_metadata_tests::empty_quotes_require_full_interval_lifecycle_proof_not_a_latest_status ... ok
+test backtest::equity_lifecycle_metadata_tests::lifecycle_cash_days_keep_real_benchmark_without_fabricated_security_rows ... ok
+test backtest::equity_lifecycle_metadata_tests::missing_identity_and_dates_do_not_become_active_securities ... ok
+test backtest::execution_config_tests::capacity_preflight_requires_explicit_daily_assumptions_without_changing_risk_switches ... ok
+test backtest::execution_config_tests::component_execution_quotes_seed_uses_latest_intraday_quote_before_target_time ... ok
+test backtest::execution_config_tests::current_close_respects_explicitly_disabled_liquidity_limit ... ok
+test backtest::execution_config_tests::daily_current_close_preserves_the_strategy_decision_clock ... ok
+test backtest::execution_config_tests::daily_execution_price_request_serializes_date_symbol_filter_scope ... ok
+test backtest::execution_config_tests::daily_execution_projection_keeps_benchmark_narrow_and_trade_risk_complete ... ok
+test backtest::execution_config_tests::data_intraday_snapshot_time_is_strategy_spec_driven ... ok
+test backtest::execution_config_tests::dataset_signature_rejects_source_lake_without_frozen_backtest_bundle ... ok
+test backtest::day_snapshot_builder::tests::arrow_rows_build_the_same_final_snapshots_without_a_row_collection ... ok
+test backtest::execution_config_tests::dataset_signature_scopes_dynamic_model_score_source_rows ... ok
+test backtest::execution_config_tests::default_matching_type_follows_backtest_frequency ... ok
+test backtest::execution_config_tests::dataset_signature_scopes_backtest_data_bundle_source_rows ... ok
+test backtest::execution_config_tests::dynamic_model_score_execution_quotes_are_lazy_by_default ... ok
+test backtest::execution_config_tests::dynamic_model_score_rank_does_not_extract_fixed_signal_symbols ... ok
+test backtest::execution_config_tests::execution_quote_prefilter_keeps_previous_factor_rows_in_current_band ... ok
+test backtest::execution_config_tests::execution_quote_prefilter_prefers_runtime_market_cap_slope ... ok
+test backtest::execution_config_tests::execution_quote_query_times_follow_strategy_trade_times ... ok
+test backtest::execution_config_tests::execution_quote_prefilter_keeps_candidates_beyond_legacy_limit ... ok
+test backtest::execution_config_tests::execution_top_level_fee_overrides_nested_risk_policy_cost ... ok
+test backtest::execution_config_tests::extract_score_context_does_not_extract_fixed_signal_symbols ... ok
+test backtest::execution_config_tests::execution_top_level_volume_percent_overrides_nested_risk_policy ... ok
+test backtest::execution_config_tests::factor_keys_use_compact_storage_without_changing_names ... ok
+test backtest::execution_config_tests::fixed_signal_model_score_scope_does_not_validate_candidate_limit ... ok
+test backtest::execution_config_tests::fixed_signal_symbol_scope_preserves_explicit_empty_targets ... ok
+test backtest::execution_config_tests::minute_session_bounds_extend_only_after_post_close_rule_effective_date ... ok
+test backtest::execution_config_tests::full_minute_event_stream_uses_subscriptions_instead_of_point_snapshot ... ok
+test backtest::execution_config_tests::model_score_source_rows_scope_evidence_verifies_candidate_limit ... ok
+test backtest::execution_config_tests::model_score_source_rows_scope_rejects_unbounded_rows ... ok
+test backtest::execution_config_tests::native_next_open_pool_loads_causal_quotes_without_exposing_them_to_selection ... ok
+test backtest::execution_config_tests::narrow_overlay_projection_does_not_retain_a_wide_value_buffer ... ok
+test backtest::execution_config_tests::owned_date_group_producers_drop_every_input_exactly_once_on_failure ... ok
+test backtest::execution_config_tests::owned_trade_day_preparation_matches_borrowed_rows ... ok
+test backtest::execution_config_tests::parse_matching_type_limits_global_backtest_matching_modes ... ok
+test backtest::execution_config_tests::parse_slippage_model_supports_explicit_historical_model ... ok
+test backtest::execution_config_tests::parse_slippage_model_supports_limit_price ... ok
+test backtest::execution_config_tests::platform_daily_factor_strategy_uses_lazy_execution_quotes_by_default ... ok
+test backtest::execution_config_tests::platform_execution_quote_carry_can_include_recent_candidates ... ok
+test backtest::execution_config_tests::platform_execution_quote_carry_does_not_let_candidates_evict_recent_orders ... ok
+test backtest::execution_config_tests::platform_execution_quote_carry_keeps_today_candidates_without_candidate_carry ... ok
+test backtest::execution_config_tests::platform_execution_quote_carry_prefers_recent_candidates_before_today_candidates ... ok
+test backtest::execution_config_tests::platform_execution_quote_carry_prioritizes_order_symbols ... ok
+test backtest::execution_config_tests::platform_execution_quote_default_carry_keeps_large_recent_candidate_set ... ok
+test backtest::execution_config_tests::parallel_owned_date_groups_keep_exact_rows_and_owned_factor_allocations ... ok
+test backtest::execution_config_tests::platform_execution_route_requires_runtime_contract ... ok
+test backtest::execution_config_tests::platform_strategy_config_rejects_loose_value_budget_without_panicking ... ok
+test backtest::execution_config_tests::platform_runtime_snapshot_preserves_typed_time_in_force ... ok
+test backtest::execution_config_tests::prepare_trade_day_candidate_market_cap_falls_back_to_total_market_cap ... ok
+test backtest::execution_config_tests::platform_strategy_config_uses_same_intraday_time_as_broker ... ok
+test backtest::execution_config_tests::prepare_trade_day_daily_selection_price_uses_close_without_limit_allow_flags ... ok
+test backtest::execution_config_tests::prepare_trade_day_does_not_build_execution_quote_from_daily_fallback ... ok
+test backtest::execution_config_tests::prepare_trade_day_keeps_allow_buy_when_missing_field_is_not_buy_relevant ... ok
+test backtest::execution_config_tests::prepare_trade_day_keeps_daily_volume_when_snapshot_has_intraday_volume ... ok
+test backtest::execution_config_tests::prepare_trade_day_keeps_external_signal_warmup_day ... ok
+test backtest::execution_config_tests::prepare_trade_day_keeps_missing_risk_facts_when_runtime_filters_are_disabled ... ok
+test backtest::execution_config_tests::prepare_trade_day_keeps_st_and_star_st_flags_independent ... ok
+test backtest::execution_config_tests::prepare_trade_day_preserves_missing_daily_volume_contract ... ok
+test backtest::execution_config_tests::prepare_trade_day_preserves_zero_ask_from_intraday_snapshot ... ok
+test backtest::execution_config_tests::raw_yuan_market_cap_normalizes_to_100m_units ... ok
+test backtest::execution_config_tests::prepare_trade_day_records_all_missing_risk_facts_independent_of_policy ... ok
+test backtest::execution_config_tests::resolve_dividend_reinvestment_defaults_false_and_reads_engine_flag ... ok
+test backtest::execution_config_tests::resolve_execution_config_does_not_allow_overspending_value_budget ... ok
+test backtest::execution_config_tests::resolve_execution_config_enables_strict_value_budget_by_default ... ok
+test backtest::execution_config_tests::resolve_execution_config_keeps_explicit_liquidity_quote_limit ... ok
+test backtest::execution_config_tests::resolve_execution_config_distinguishes_timed_daily_current_close ... ok
+test backtest::execution_config_tests::resolve_execution_config_keeps_explicit_same_day_buy_mark_override ... ok
+test backtest::execution_config_tests::resolve_execution_config_keeps_explicit_snapshot_volume_limit ... ok
+test backtest::execution_config_tests::resolve_execution_config_keeps_selection_risk_off_by_default ... ok
+test backtest::execution_config_tests::resolve_execution_config_keeps_volume_limit_for_snapshot_minute_last_by_default ... ok
+test backtest::execution_config_tests::resolve_execution_config_maps_daily_next_open ... ok
+test backtest::execution_config_tests::resolve_execution_config_maps_minute_last_to_minute_price ... ok
+test backtest::execution_config_tests::resolve_execution_config_maps_rebalance_cash_mode_and_forces_minute ... ok
+test backtest::execution_config_tests::resolve_execution_config_preserves_zero_minimum_commission ... ok
+test backtest::execution_config_tests::resolve_execution_config_reads_nested_risk_policy ... ok
+test backtest::execution_config_tests::resolve_execution_config_rejects_delay_slippage_outside_sell_then_buy ... ok
+test backtest::execution_config_tests::resolve_execution_config_rejects_vwap_as_global_matching_type ... ok
+test backtest::execution_config_tests::resolve_execution_config_uses_explicit_market_rules_without_profile ... ok
+test backtest::execution_config_tests::resolve_execution_config_uses_latest_trade_time_as_main_schedule ... ok
+test backtest::execution_config_tests::resolve_execution_config_uses_runtime_schedule_time_for_minute_execution ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_preserves_static_universe_contract ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_preserves_weak_market_threshold ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_reads_delayed_limit_open_exit ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_reads_release_slot_on_exit_signal ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_reads_trading_stage ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_reads_trading_schedule ... ok
+test backtest::execution_config_tests::retired_slippage_and_invalid_coefficients_never_become_no_slippage ... ok
+test backtest::execution_config_tests::risk_policy_alias_normalization_preserves_matching_values ... ok
+test backtest::execution_config_tests::risk_policy_alias_normalization_rejects_conflicting_values ... ok
+test backtest::execution_config_tests::reused_candidate_plan_panel_matches_full_intraday_market_materialization ... ok
+test backtest::execution_config_tests::runtime_selection_intraday_quote_detection_reads_quote_fields_only ... ok
+test backtest::execution_config_tests::sorted_overlay_keeps_unchanged_zero_bits_and_counts_only_changed_rows ... ok
+test backtest::execution_config_tests::sorted_overlay_transfers_owned_factor_storage_without_changing_bits ... ok
+test backtest::execution_config_tests::sorted_source_row_insertion_preserves_existing_duplicate_order ... ok
+test backtest::execution_config_tests::sorted_sparse_overlay_merge_falls_back_for_duplicate_keys ... ok
+test backtest::execution_config_tests::sorted_sparse_overlay_merge_preserves_order_and_unmatched_rows ... ok
+test backtest::execution_config_tests::source_lake_execution_price_requests_keep_compact_schema ... ok
+test backtest::execution_config_tests::source_lake_backtest_bundle_context_requires_complete_metadata ... ok
+test backtest::execution_config_tests::source_lake_market_cap_keeps_current_decision_date_value ... ok
+test backtest::execution_config_tests::source_lake_market_cap_uses_current_decision_date_snapshot ... ok
+test backtest::execution_config_tests::source_lake_model_score_context_allows_plain_rotation_without_model_score ... ok
+test backtest::execution_config_tests::source_lake_model_score_context_accepts_complete_inferred_scope ... ok
+test backtest::execution_config_tests::source_lake_model_score_context_rejects_dynamic_mode_without_source_label_or_scope ... ok
+test backtest::execution_config_tests::source_lake_model_score_context_rejects_partial_scope ... ok
+test backtest::execution_config_tests::source_lake_model_score_context_rejects_sparse_ref_without_scope ... ok
+test backtest::execution_config_tests::source_lake_request_keeps_dynamic_model_score_as_all_market_with_score_context ... ok
+test backtest::execution_config_tests::source_lake_request_keeps_explicit_empty_symbols_empty ... ok
+test backtest::execution_config_tests::source_lake_request_scopes_fixed_signal_symbols_and_keeps_compact_schema ... ok
+test backtest::execution_config_tests::source_lake_source_rows_uses_current_row_decision_safe_prev_factor_mode ... ok
+test backtest::execution_config_tests::source_lake_request_serializes_date_symbol_filter_scope ... ok
+test backtest::execution_config_tests::source_row_adjustment_factor_decode_accepts_positive_finite_values ... ok
+test backtest::execution_config_tests::source_row_adjustment_factor_decode_allows_paused_rows_without_close ... ok
+test backtest::execution_config_tests::source_row_adjustment_factor_decode_rejects_missing_or_invalid_values ... ok
+test backtest::execution_config_tests::source_row_adjustment_factor_decode_rejects_paused_rows_with_close ... ok
+test backtest::execution_config_tests::source_row_cache_and_filter_distinguish_all_from_explicit_empty_symbols ... ok
+test backtest::execution_config_tests::source_row_adjustment_factor_decode_skips_unrequested_projection ... ok
+test backtest::execution_config_tests::source_row_daily_capacity_is_scoped_to_actual_insertion_dates ... ok
+test backtest::execution_config_tests::source_row_grouping_copies_date_keys_only_at_boundaries ... ok
+test backtest::execution_config_tests::source_row_missing_open_does_not_mark_candidate_as_one_yuan ... ok
+test backtest::execution_config_tests::source_row_model_score_context_accepts_extract_only_score_metadata ... ok
+test backtest::execution_config_tests::source_row_model_score_context_can_disable_candidate_limit_inference ... ok
+test backtest::execution_config_tests::source_row_model_score_context_infers_candidate_limit_from_selection_limit ... ok
+test backtest::execution_config_tests::source_row_daily_capacity_keeps_supplemental_inserts_in_place ... ok
+test backtest::execution_config_tests::source_row_model_score_context_merges_bundle_extract_and_scopes_cache ... ok
+test backtest::execution_config_tests::source_row_projection_does_not_require_adjustment_factor_for_volume_only_rolling ... ok
+test backtest::execution_config_tests::source_row_projection_includes_amount_for_stock_amount_expressions ... ok
+test backtest::execution_config_tests::source_row_projection_keeps_select_all_for_generic_empty_factor_refs ... ok
+test backtest::execution_config_tests::source_row_projection_keeps_source_lake_empty_factor_refs_narrow ... ok
+test backtest::execution_config_tests::source_row_projection_keeps_source_lake_without_strategy_spec_narrow ... ok
+test backtest::execution_config_tests::source_row_projection_uses_framework_rolling_inputs ... ok
+test backtest::execution_config_tests::source_row_projection_splits_sparse_model_score_factor_refs ... ok
+test backtest::execution_config_tests::source_row_sort_preserves_published_order_and_stably_repairs_merges ... ok
+test backtest::execution_config_tests::source_row_projection_uses_raw_market_columns_for_framework_rollings ... ok
+test backtest::execution_config_tests::source_rows_query_engine_is_validated_and_scopes_cache_epoch ... ok
+test backtest::execution_config_tests::source_rows_scope_evidence_preserves_unordered_date_counts ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_dates_exclude_warmup_rows ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_keeps_named_score_when_context_uses_default_score ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_merges_only_requested_extra_factors ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_query_windows_are_chunked_by_date_span ... ok
+test backtest::execution_config_tests::source_warmup_uses_required_trading_windows ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_skips_primary_score_columns ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_reuses_source_row_cache_without_http ... ok
+test backtest::execution_config_tests::stock_cost_model_for_execution_uses_explicit_fee_overrides ... ok
+test backtest::execution_config_tests::sparse_overlay_skips_source_lake_when_scoped_date_symbol_filter_is_empty ... ok
+test backtest::execution_config_tests::strategy_execution_top_level_risk_enabled_aliases_are_applied ... ok
+test backtest::execution_config_tests::strategy_risk_policy_accepts_camel_case_fields ... ok
+test backtest::execution_config_tests::supplemental_execution_key_index_only_materializes_requested_symbols ... ok
+test backtest::execution_config_tests::strategy_factory_model_rank_rotation_keeps_explicit_execution_contract ... ok
+test backtest::execution_config_tests::timed_daily_current_close_loads_the_intraday_decision_snapshot ... ok
+test backtest::execution_config_tests::top_level_execution_limits_override_nested_risk_policy_defaults ... ok
+test backtest::execution_config_tests::unique_source_row_trade_dates_preserves_sorted_and_unordered_inputs ... ok
+test backtest::execution_config_tests::unsupported_backtest_frequency_is_rejected ... ok
+test backtest::execution_config_tests::validated_source_limit_prices_allows_explicit_no_limit_stock ... ok
+test backtest::execution_config_tests::validated_source_limit_prices_allows_index_without_limits ... ok
+test backtest::execution_config_tests::validated_source_limit_prices_allows_paused_stock_without_limits ... ok
+test backtest::execution_config_tests::validated_source_limit_prices_rejects_missing_stock_limit ... ok
+test backtest::execution_config_tests::validated_source_limit_prices_trusts_source_limits ... ok
+test backtest::factor_history_calendar_tests::history_uses_actual_sessions_and_rejects_short_or_future_calendars ... ok
+test backtest::factor_history_calendar_tests::index_policy_preloads_its_reference_without_widening_the_candidate_universe ... ok
+test backtest::factor_history_calendar_tests::contextual_pattern_expands_data_scope_but_not_candidate_members ... ok
+test backtest::factor_history_calendar_tests::selection_buy_permission_carries_its_complete_pattern_window ... ok
+test backtest::fund_metadata::tests::day_preparation_distinguishes_etf_optional_risk_from_missing_prices ... ok
+test backtest::fund_metadata::tests::etf_metadata_binds_identity_dates_and_units ... ok
+test backtest::fund_metadata::tests::real_etf_fallback_fills_match_source_opens_dates_and_fee_budgets ... ignored, requires exact frontend-compiled frozen Source Lake ETF replay artifacts
+test backtest::fund_metadata::tests::real_mixed_prices_preserve_holdings_until_explicit_zero_allocation ... ignored, requires FIDC_FUND_REPLAY_PREFIX containing read-only real Source Arrow fixtures
+test backtest::fund_metadata::tests::real_source_arrow_preserves_etf_identity_and_detects_tampering ... ignored, requires FIDC_FUND_METADATA_TEST_ARROW from the read-only real Source probe
+test backtest::fund_metadata::tests::preliminary_candidate_panel_uses_verified_etf_rules_without_inventing_limits ... ok
+test backtest::manual_data_scope::tests::explicit_data_scope_can_expand_without_mutating_the_strategy_or_empty_pool ... ok
+test backtest::manual_data_scope::tests::dataset_cache_tracks_extra_market_demand_not_manual_price_or_execution_identity ... ok
+test backtest::prepared_source_row::tests::all_supported_numeric_types_keep_the_existing_conversion_and_null_policy ... ok
+test backtest::prepared_source_row::tests::arbitrary_slices_and_supplemental_rows_keep_symbol_order ... ok
+test backtest::prepared_source_row::tests::finite_values_keep_exact_float_bits_and_metadata ... ok
+test backtest::prepared_source_row::tests::actual_arrow_day_uses_columnar_rows_and_matches_owned_final_snapshots ... ok
+test backtest::prepared_source_row::tests::invalid_json_is_not_hidden_by_a_consumer_that_needs_no_factors ... ok
+test backtest::prepared_source_row::tests::nonfinite_price_policy_does_not_mutate_original_arrow_values ... ok
+test backtest::prepared_source_row::tests::overlay_cannot_relax_base_adjustment_validation ... ok
+test backtest::prepared_source_row::tests::json_typed_duplicates_and_projected_overlay_preserve_overwrite_order ... ok
+test backtest::risk_free_rate_cache_identity_includes_bundle_and_full_calendar ... ok
+test backtest::prepared_source_row::tests::schema_error_precedence_and_null_keys_are_preserved ... ok
+test backtest::risk_free_rate_cache_round_trips_validated_contract ... ok
+test backtest::saved_risk_cache::tests::saved_reference_cancelled_reader_does_not_leave_a_claim ... ok
+test backtest::saved_risk_cache::tests::saved_reference_identity_includes_endpoint_hash_and_calendar ... ok
+test backtest::saved_risk_reference_requires_original_content_not_only_server_claimed_hash ... ok
+test backtest::source_query_windows::tests::actual_cached_boundaries_are_kept_and_gaps_are_covered ... ok
+test backtest::source_query_windows::tests::all_days_remain_once_and_scope_count_is_bounded ... ok
+test backtest::source_query_windows::tests::discovery_never_crosses_source_keys_schemas_or_file_types ... ok
+test backtest::source_query_windows::tests::overlap_prefers_more_covered_days_then_fewer_windows ... ok
+test backtest::source_query_windows::tests::projection_and_symbol_scope_have_distinct_boundary_keys ... ok
+test backtest::source_query_windows::tests::uncached_gaps_keep_the_existing_calendar_anchor ... ok
+test backtest::source_row_key_index::tests::indexed_date_ranges_cover_days_split_across_batches ... ok
+test backtest::saved_risk_cache::tests::saved_reference_coalesces_only_validated_original_contracts ... ok
+test backtest::source_row_key_index::tests::normalized_keys_cannot_duplicate_across_batches ... ok
+test backtest::source_row_key_index::tests::null_identity_and_declared_count_mismatch_are_rejected ... ok
+test backtest::source_row_query_purpose_tests::factor_overlay_cache_identity_cannot_be_reused_as_market_facts ... ok
+test backtest::source_row_query_purpose_tests::factor_overlay_merge_preserves_every_base_market_and_risk_fact ... ok
+test backtest::source_row_query_purpose_tests::factor_overlay_requires_an_explicit_non_market_projection ... ok
+test backtest::source_row_query_purpose_tests::only_explicit_factor_overlays_omit_redundant_risk_columns ... ok
+test backtest::source_rows_columnar::tests::cache_write_failure_does_not_replace_the_current_columnar_input ... ok
+test backtest::source_rows_columnar::tests::actual_selection_and_empty_outputs_do_not_keep_unused_factor_columns ... ok
+test backtest::source_rows_columnar::tests::columnar_normalization_matches_mixed_values_json_aliases_and_sorting ... ok
+test backtest::source_rows_columnar::tests::invalid_keys_and_adjustment_are_rejected_before_selection ... ok
+test backtest::source_rows_columnar::tests::malformed_json_and_dependency_identity_are_not_accepted ... ok
+test backtest::source_rows_columnar::tests::non_cacheable_json_factor_names_keep_the_real_record_path ... ok
+test backtest::source_rows_columnar::tests::normalized_duplicate_symbols_are_not_deduplicated ... ok
+test backtest::source_rows_input_tests::cache_cannot_include_rows_outside_its_declared_date_range ... ok
+test backtest::source_rows_input_tests::cache_write_failure_retains_the_real_window_and_empty_windows_do_not_read_old_rows ... ok
+test backtest::source_rows_input_tests::failed_materialization_does_not_turn_the_source_into_an_empty_success ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_crosses_record_batches_and_preserves_key_normalization ... ok
+test backtest::source_rows_input_tests::independent_windows_stay_columnar_until_daily_snapshot_construction ... ok
+test backtest::source_rows_input_tests::invalid_cache_keys_and_overlay_coverage_never_publish_source_input ... ok
+test backtest::source_rows_input_tests::mapped_input_can_be_materialized_for_mutating_model_and_publication_overlays ... ok
+test backtest::source_rows_input_tests::mapped_input_preserves_empty_scopes_and_filters_only_base_rows ... ok
+test backtest::source_rows_input_tests::mixed_window_storage_and_duplicate_boundaries_keep_original_semantics ... ok
+test backtest::source_rows_input_tests::mapped_inventory_and_final_days_match_owned_rows_with_factor_overlays ... ok
+test backtest::source_rows_input_tests::unsuccessful_window_publication_cannot_read_a_previous_cache_file ... ok
+test backtest::terminal_audit_summary_tests::deferred_strategy_warning_is_not_presented_as_a_submitted_order ... ok
+test backtest::terminal_audit_summary_tests::pending_terminal_state_is_explicit_in_summary_warning ... ok
+test backtest::terminal_calendar_tests::delayed_deposit_requires_terminal_calendar_but_zero_day_does_not ... ok
+test backtest::terminal_calendar_tests::scheduled_terminal_calendar_requires_strict_order_and_range ... ok
+test backtest::tests::accounting_allocation_details_do_not_require_or_fabricate_an_order ... ok
+test backtest::tests::all_source_lake_runtime_caches_are_scoped_by_backtest_bundle ... ok
+test backtest::tests::arrow_reader_accepts_lz4_compressed_stream ... ok
+test backtest::tests::audit_instrument_cache_values_from_request ... ignored, read-only Boris cache comparison with an explicit audit request
+test backtest::tests::benchmark_borrowed_numeric_factor_keys_against_owned_strings ... ignored, manual release-mode allocation benchmark
+test backtest::source_rows_input_tests::separate_arrow_factor_input_preserves_sparse_overlay_values_and_existing_layers ... ok
+test backtest::tests::benchmark_date_symbol_filter_query_range_preserves_index_symbols ... ok
+test backtest::tests::benchmark_query_windows_split_long_source_lake_ranges ... ok
+test backtest::tests::benchmark_row_binary_cache_rejects_metadata_mismatch ... ok
+test backtest::tests::benchmark_row_binary_cache_roundtrips_rows ... ok
+test backtest::tests::benchmark_row_cache_ignores_legacy_csv_cache ... ok
+test backtest::tests::benchmark_row_cache_path_uses_binary_cache_file ... ok
+test backtest::tests::benchmark_row_cache_path_scopes_date_symbol_filter ... ok
+test backtest::tests::benchmark_row_candidate_scan_removes_stale_schema_cache ... ok
+test backtest::tests::benchmark_row_covering_cache_reuses_superset_symbols_and_dates ... ok
+test backtest::tests::benchmark_row_partial_cache_rejects_missing_symbol_segment ... ok
+test backtest::tests::benchmark_row_to_source_row_preserves_false_paused_state ... ok
+test backtest::tests::benchmark_row_partial_cache_reports_missing_ranges ... ok
+test backtest::tests::benchmark_row_window_cache_scope_ignores_out_of_window_filter_dates ... ok
+test backtest::tests::benchmark_rows_dedup_after_window_merge ... ok
+test backtest::tests::benchmark_source_row_arrow_bounded_materialization ... ignored, requires FIDC_BT_SOURCE_ROW_VIEW_PROBE_PATH and explicit release-mode invocation
+test backtest::tests::benchmark_source_row_arrow_view_cache ... ignored, requires FIDC_BT_SOURCE_ROW_VIEW_PROBE_PATH and explicit release-mode invocation
+test backtest::tests::bootstrap_missing_quote_repair_keys_keeps_all_actual_order_gaps_without_fills ... ok
+test backtest::tests::bootstrap_missing_quote_repair_keys_keeps_all_after_fills_exist ... ok
+test backtest::tests::benchmark_rows_empty_date_symbol_filter_does_not_reuse_existing_cache ... ok
+test backtest::tests::build_trade_detail_rows_expands_split_fills_by_order_id ... ok
+test backtest::tests::build_trade_detail_rows_omits_canceled_orders_without_fills ... ok
+test backtest::tests::build_trade_detail_rows_matches_fill_when_order_reason_changes ... ok
+test backtest::tests::build_trade_detail_rows_preserves_decision_and_execution_dates ... ok
+test backtest::tests::carry_forward_target_snapshot_keeps_transition_day_then_replaces_positions ... ok
+test backtest::tests::cn_index_symbols_are_not_stock_execution_quote_repair_symbols ... ok
+test backtest::tests::collect_missing_execution_quote_keys_uses_canceled_stock_orders_only ... ok
+test backtest::tests::compact_progress_retains_manual_counts_and_rejects_a_missing_source ... ok
+test backtest::tests::compacted_carry_forward_filter_keeps_window_semantics ... ok
+test backtest::tests::corporate_action_arrow_preserves_the_independent_delivery_date_and_unknown_quantities ... ok
+test backtest::tests::corporate_action_binary_cache_roundtrips_rows ... ok
+test backtest::tests::corporate_action_cache_ignores_legacy_csv_cache ... ok
+test backtest::tests::corporate_action_cache_path_uses_source_lake_provider_epoch ... ok
+test backtest::tests::bundle_validation_observes_dependency_semantic_change_and_revocation_without_ttl ... ok
+test backtest::tests::corporate_action_covering_cache_reuses_superset_scope ... ok
+test backtest::tests::daily_execution_price_arrow_decode_preserves_unpriced_paused_risk_rows ... ok
+test backtest::tests::daily_execution_price_arrow_requires_execution_contract_fields ... ok
+test backtest::tests::daily_execution_scope_membership_is_normalized_once_and_isolated_by_date ... ok
+test backtest::tests::dataset_signature_scopes_fixed_signal_source_rows ... ok
+test backtest::tests::dataset_signature_scopes_fixed_signal_date_symbol_filter_with_model_score ... ok
+test backtest::tests::date_symbol_filter_query_range_carry_forward_keeps_history_prefix ... ok
+test backtest::tests::date_symbol_filter_query_range_exact_keeps_only_window_dates ... ok
+test backtest::tests::date_symbol_filter_query_range_preserves_empty_request ... ok
+test backtest::tests::dataset_signature_uses_data_requirements_not_strategy_identity_or_thresholds ... ok
+test backtest::tests::default_cache_epochs_ignore_local_manifest_directory ... ok
+test backtest::tests::dense_execution_quote_plan_uses_requested_trade_dates_only ... ok
+test backtest::tests::dynamic_model_score_execution_only_queries_next_date_gaps ... ok
+test backtest::tests::dynamic_model_score_execution_skips_rows_present_on_next_full_calendar_date ... ok
+test backtest::tests::dynamic_model_score_execution_symbols_include_candidate_universe_for_lagged_execution ... ok
+test backtest::tests::dynamic_symbol_expression_does_not_enable_fixed_source_scope ... ok
+test backtest::tests::empty_date_symbol_filter_is_empty_request_not_all_market ... ok
+test backtest::tests::equity_artifact_keeps_external_deposit_out_of_return ... ok
+test backtest::tests::equity_projection_orders_facts_and_includes_the_initial_nav_peak ... ok
+test backtest::tests::execution_arrow_does_not_turn_nonfinite_numbers_into_optional_missing_values ... ok
+test backtest::tests::execution_arrow_requires_the_strict_source_contract_even_when_empty ... ok
+test backtest::tests::execution_price_date_symbol_filter_keeps_benchmark_and_prunes_other_targets ... ok
+test backtest::tests::execution_price_only_source_row_marker_round_trips ... ok
+test backtest::tests::execution_quantities_are_exact_integers_not_rounded_floats ... ok
+test backtest::tests::exact_source_row_windows_restore_in_parallel_and_keep_order ... ok
+test backtest::tests::execution_quote_day_binary_cache_invalidates_duplicate_date_symbol ... ok
+test backtest::tests::execution_quote_day_binary_cache_rejects_metadata_mismatch ... ok
+test backtest::tests::execution_quote_day_cache_ignores_legacy_csv_cache ... ok
+test backtest::tests::execution_quote_day_cache_does_not_persist_empty_negative_result ... ok
+test backtest::tests::execution_quote_day_cache_loads_empty_without_provider_url ... ok
+test backtest::tests::execution_quote_day_cache_path_includes_minute_lookback_and_price_rule ... ok
+test backtest::tests::execution_quote_day_cache_path_uses_quote_epoch ... ok
+test backtest::tests::execution_quote_day_cache_path_uses_source_lake_provider_tag ... ok
+test backtest::tests::execution_quote_day_cache_tracks_returned_symbols_only ... ok
+test backtest::tests::execution_quote_prefetch_seed_tracks_negative_symbols ... ok
+test backtest::tests::execution_quote_query_tasks_keep_target_time_symbol_scopes_narrow ... ok
+test backtest::tests::execution_quote_query_tasks_merge_identical_symbol_scopes_for_same_day ... ok
+test backtest::tests::execution_quote_rows_duplicate_date_symbol_is_rejected ... ok
+test backtest::tests::execution_quote_rows_normalize_base_stock_code_symbols ... ok
+test backtest::tests::execution_quote_loader_reads_a_bounded_minute_window_instead_of_a_point_snapshot ... ok
+test backtest::tests::explicit_cli_source_cache_epoch_is_stable_and_provider_scoped ... ok
+test backtest::tests::external_daily_execution_symbols_without_signals_only_queries_benchmark ... ok
+test backtest::tests::external_daily_execution_symbols_skip_signals_already_in_source_rows ... ok
+test backtest::tests::factor_values_arrow_decode_validates_metadata_and_merges_aliases ... ok
+test backtest::tests::fidc_runner_rejects_ficlaw_data_source_rows_table ... ok
+test backtest::tests::fixed_minute_subscriptions_expand_static_daily_data_scope ... ok
+test backtest::tests::factor_values_arrow_decode_rejects_future_data_and_semantic_drift ... ok
+test backtest::tests::fixed_signal_date_symbol_filter_is_disabled_when_static_symbols_are_mixed_in ... ok
+test backtest::tests::fixed_signal_date_symbol_filter_survives_model_score_rank_metadata ... ok
+test backtest::tests::fixed_signal_date_symbol_filter_seeds_static_symbols_at_query_start ... ok
+test backtest::tests::fixed_signal_next_open_exit_scope_keeps_all_prior_unsold_symbols ... ok
+test backtest::tests::fixed_signal_source_row_date_symbol_filter_extracts_dated_weights_only ... ok
+test backtest::tests::fixed_signal_source_row_symbols_extracts_runtime_target_weights_expr ... ok
+test backtest::tests::fixed_signal_source_row_date_symbol_filter_extracts_target_holding_rows ... ok
+test backtest::tests::fixed_signal_source_row_symbols_extracts_single_quoted_runtime_target_weights_expr ... ok
+test backtest::tests::fixed_signal_source_row_symbols_extracts_strategy_metadata_targets ... ok
+test backtest::tests::fixed_signal_source_row_symbols_extracts_target_weight_codes ... ok
+test backtest::tests::fixed_symbol_order_scope_requires_rotation_disabled ... ok
+test backtest::tests::fixed_symbol_orders_seed_exact_intraday_snapshot_keys ... ok
+test backtest::tests::frozen_bundle_identity_http_failure_is_not_a_mutable_epoch_fallback ... ok
+test backtest::tests::full_minute_prefetch_days_respect_total_bar_budget ... ok
+test backtest::tests::futures_source_lake_catalog_requires_all_truth_datasets ... ok
+test backtest::tests::futures_only_runtime_contract_keeps_stock_scope_empty_and_allocates_cash ... ok
+test backtest::tests::instrument_metadata_binary_cache_rejects_metadata_mismatch ... ok
+test backtest::tests::instrument_metadata_binary_cache_roundtrips_rows ... ok
+test backtest::tests::instrument_metadata_cache_merges_missing_symbols_incrementally ... ok
+test backtest::tests::instrument_metadata_cache_ignores_legacy_csv_cache ... ok
+test backtest::tests::instrument_metadata_cache_path_is_scoped_by_historical_window ... ok
+test backtest::tests::instrument_metadata_cache_path_uses_binary_format ... ok
+test backtest::tests::instrument_metadata_request_serializes_historical_source_window_when_present ... ok
+test backtest::tests::intraday_snapshot_binary_cache_rejects_metadata_mismatch ... ok
+test backtest::tests::intraday_snapshot_binary_cache_roundtrips_rows ... ok
+test backtest::tests::intraday_snapshot_cache_ignores_legacy_csv_cache ... ok
+test backtest::tests::intraday_snapshot_cache_path_uses_source_lake_provider_tag ... ok
+test backtest::tests::intraday_snapshot_seeds_execution_quotes_and_negative_gaps ... ok
+test backtest::tests::kcb_board_and_quantity_use_source_classification ... ok
+test backtest::tests::layered_execution_quote_loader_cache_preserves_shared_seed_and_isolates_overlay ... ok
+test backtest::tests::lazy_execution_quote_window_backfill_keeps_future_missing_symbols ... ok
+test backtest::tests::lazy_execution_quote_window_dates_use_trading_calendar_only ... ok
+test backtest::tests::load_strategy_spec_rejects_removed_compatibility_profile ... ok
+test backtest::tests::load_strategy_spec_rejects_removed_engine_profile_name ... ok
+test backtest::tests::malformed_execution_observations_are_errors_not_empty_successes ... ok
+test backtest::tests::malformed_versioned_factor_ref_fails_closed ... ok
+test backtest::tests::managed_source_rows_route_by_exact_table ... ok
+test backtest::tests::minute_bar_arrow_decode_accepts_bounded_multi_date_stream ... ok
+test backtest::tests::load_strategy_spec_accepts_snake_case_bundle_field ... ok
+test backtest::tests::minute_bar_arrow_decode_preserves_timestamp_symbol_order ... ok
+test backtest::tests::minute_bar_arrow_decode_rejects_retired_string_time_schema ... ok
+test backtest::tests::minute_bar_arrow_decode_rejects_duplicate_or_unordered_rows ... ok
+test backtest::tests::mixed_candidate_book_binds_complete_dates_raw_sources_and_resolved_order ... ok
+test backtest::tests::mixed_stock_futures_contract_requires_explicit_futures_cash ... ok
+test backtest::tests::normalize_symbol_maps_bse_exchange_to_beijing_board ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_matches_row_decoder_for_wide_sparse_null_and_signed_zero_values ... ok
+test backtest::tests::minute_bars_retries_transient_http_failure_and_preserves_caller_header ... ok
+test backtest::tests::partial_source_row_window_cache_crops_covering_segments_in_arrow ... ok
+test backtest::tests::partial_source_row_window_cache_ignores_all_market_cache_for_symbol_scope ... ok
+test backtest::tests::partial_source_row_window_cache_ignores_wide_projection_segment ... ok
+test backtest::tests::partial_source_row_window_cache_reports_only_missing_gaps ... ok
+test backtest::tests::progress_callback_is_forwarded_to_blocking_engine_thread ... ok
+test backtest::tests::published_factor_binding_normalizes_ref_and_builds_arrow_request ... ok
+test backtest::tests::query_scope_batch_preserves_authoritative_window_identities ... ok
+test backtest::tests::platform_quote_plan_uses_current_decision_date_source_rows ... ok
+test backtest::tests::query_scope_identity_reuses_physical_window_across_distinct_bundles ... ok
+test backtest::tests::real_source_quote_json_and_arrow_match_strict_reader ... ignored, requires a bounded real Source JSON/Arrow probe directory
+test backtest::tests::repeated_query_views_share_only_identical_execution_observations ... ok
+test backtest::tests::partial_source_row_window_cache_reuses_exact_projection_with_null_dynamic_columns ... ok
+test backtest::tests::query_scope_http_carries_rolling_dependencies_and_rejects_bad_contracts ... ok
+test backtest::tests::select_instrument_metadata_rejects_missing_symbols ... ok
+test backtest::tests::shared_base_source_projection_keeps_raw_adjustment_contract ... ok
+test backtest::tests::shared_base_source_rows_cache_is_enabled_by_default ... ok
+test backtest::tests::reusable_source_row_window_cache_does_not_reuse_covering_cache ... ok
+test backtest::tests::shared_base_source_rows_cache_is_only_for_unscoped_raw_rows ... ok
+test backtest::tests::sorted_source_row_validator_rejects_unordered_or_duplicate_keys ... ok
+test backtest::tests::source_cache_epoch_default_is_independent_from_quote_plan_epoch ... ok
+test backtest::tests::source_dependency_contract_invalidates_all_authoritative_cache_scopes ... ok
+test backtest::tests::segmented_source_row_cache_reads_only_uncovered_overlap_ranges ... ok
+test backtest::tests::short_range_source_query_window_is_explicit_and_keeps_long_ranges_bounded ... ok
+test backtest::tests::source_lake_contract_epoch_ignores_runtime_build_but_tracks_catalog ... ok
+test backtest::tests::source_lake_health_contract_epoch_ignores_runtime_build ... ok
+test backtest::tests::source_lake_arrow_request_retries_bad_gateway ... ok
+test backtest::tests::source_lake_busy_retry_honors_retryable_capacity_response ... ok
+test backtest::tests::source_lake_source_query_retries_are_bounded_and_transient_only ... ok
+test backtest::tests::source_lake_source_query_timeout_accepts_highmem_alias ... ok
+test backtest::tests::source_query_concurrency_defaults_and_clamps ... ok
+test backtest::tests::source_lake_run_waits_for_manifest_publication_and_holds_shared_lease ... ok
+test backtest::tests::source_row_arrow_cache_rejects_and_does_not_write_empty_rows ... ok
+test backtest::tests::source_row_arrow_cache_rejects_duplicate_date_symbol ... ok
+test backtest::tests::source_row_arrow_decode_keeps_compact_base_rows_without_extra_json ... ok
+test backtest::tests::source_row_arrow_decode_preserves_dynamic_projection_columns ... ok
+test backtest::tests::source_row_arrow_extra_factor_helpers_preserve_projected_columns ... ok
+test backtest::tests::source_lake_uses_wider_windows_for_narrow_queries ... ok
+test backtest::tests::source_row_arrow_dependency_contract_rejects_invalid_metadata ... ok
+test backtest::tests::source_row_cache_candidate_scan_removes_previous_schema_files ... ok
+test backtest::tests::source_row_cache_directory_index_tracks_files_published_by_other_workers ... ok
+test backtest::tests::source_row_arrow_view_keeps_mmap_alive_until_materialization ... ok
+test backtest::tests::source_row_arrow_view_cache_reuses_identity_and_invalidates_replacement ... ok
+test backtest::tests::source_row_cache_file_range_parses_source_cache_dates ... ok
+test backtest::tests::source_row_cache_path_hashes_long_projection_columns ... ok
+test backtest::tests::source_row_cache_path_normalizes_projection_column_order ... ok
+test backtest::tests::source_row_cache_path_scopes_explicit_source_symbols ... ok
+test backtest::tests::source_row_cache_projection_check_allows_source_lake_fixed_aliases ... ok
+test backtest::tests::source_row_cache_projection_check_requires_extra_factor_keys ... ok
+test backtest::tests::source_row_cache_rejects_legacy_raw_bincode_without_magic_header ... ok
+test backtest::tests::source_row_cache_rejects_metadata_mismatch ... ok
+test backtest::tests::source_row_cache_segment_selection_prefers_small_complete_windows ... ok
+test backtest::tests::source_row_cache_segment_selection_rejects_incomplete_windows ... ok
+test backtest::tests::source_row_cache_writes_arrow_file ... ok
+test backtest::tests::source_row_date_windows_keep_interior_buckets_stable_across_ranges ... ok
+test backtest::tests::source_row_date_windows_split_long_ranges ... ok
+test backtest::tests::source_row_date_windows_stay_within_requested_range ... ok
+test backtest::tests::source_row_primary_keys_are_inline_without_growing_the_row_header ... ok
+test backtest::tests::source_row_request_cache_epoch_scopes_runtime_query_context ... ok
+test backtest::tests::source_row_segment_boundary_validator_preserves_fail_closed_integrity ... ok
+test backtest::tests::source_row_symbol_normalization_preserves_canonical_and_maps_board ... ok
+test backtest::tests::source_row_symbol_scope_epoch_changes_with_fixed_signal_symbols ... ok
+test backtest::tests::source_row_window_cache_scope_ignores_out_of_window_filter_dates ... ok
+test backtest::tests::source_rows_duplicate_date_symbol_is_rejected ... ok
+test backtest::tests::source_rows_request_keeps_rolling_enabled_for_rolling_projection_columns ... ok
+test backtest::tests::source_rows_unique_date_symbol_passes_without_reordering ... ok
+test backtest::tests::source_semantic_change_invalidates_bundle_and_window_cache ... ok
+test backtest::tests::static_universe_include_is_an_explicit_source_row_scope ... ok
+test backtest::tests::stock_pool_screen_snapshot_uses_exact_selection_dates_and_full_symbol_history ... ok
+test backtest::tests::strategy_bundle_path_loads_nested_spec_and_signal_scope ... ok
+test backtest::tests::strategy_factor_overlay_only_queries_keys_and_missing_factor_fields ... ok
+test backtest::tests::strategy_factor_overlay_rejects_duplicate_and_unordered_keys ... ok
+test backtest::tests::strategy_factor_overlay_requires_exact_base_key_coverage ... ok
+test backtest::tests::strategy_factory_source_lake_provider_name_is_exact ... ok
+test backtest::tests::source_row_cache_lease_serializes_concurrent_misses ... ok
+test backtest::tests::source_row_cache_path_separates_projection_columns ... ok
+test backtest::tests::strategy_factory_source_lake_requires_url_and_matching_provider ... ok
+test backtest::tests::strategy_factory_source_lake_uses_arrow_sized_query_windows_by_default ... ok
+test backtest::tests::trade_display_metadata_cache_rejects_rows_outside_exact_request ... ok
+test backtest::tests::trade_display_metadata_cache_is_bundle_scoped_and_covers_missing_rows ... ok
+test backtest::tests::typed_equity_result_emits_service_schema ... ok
+test backtest::tests::trade_display_metadata_disk_cache_roundtrips_frozen_bundle_rows ... ok
+test backtest::tests::typed_order_result_keeps_zero_fill_orders ... ok
+test backtest::tests::typed_trade_result_preserves_sub_cent_execution_price ... ok
+test backtest::tests::validated_manifest_scope_reuses_cache_across_distinct_bundle_ids ... ok
+test backtest::tests::versioned_factor_binding_rejects_research_scope ... ok
+test backtest::tests::versioned_factor_binding_requires_declared_semantics ... ok
+test backtest::tests::versioned_factor_ref_requires_a_binding ... ok
+test backtest::typed_exit_dependency_tests::ordinary_strategy_partial_exit_also_contributes_its_window ... ok
+test backtest::typed_exit_dependency_tests::typed_stock_pool_exits_contribute_the_full_rolling_window ... ok
+test backtest::tests::timed_quote_dataset_signature_includes_daily_selection_plan ... ok
+test compute_pool_tests::concurrent_embedded_runs_do_not_change_each_others_pool_budget ... ok
+test compute_pool_tests::current_thread_async_runtime_keeps_the_compute_context ... ok
+test backtest::tests::unused_daily_market_cap_prefilter_does_not_split_identical_input_cache ... ok
+test cache_directory_watch::tests::notifications_cover_publication_rename_delete_and_ignore_unrelated_files ... ok
+test decision_projection::tests::projection_metadata_alias_empty_fields_and_credential_paths_fail_closed ... ok
+test decision_projection::tests::projection_native_request_is_complete_and_never_truncated_to_top_n ... ok
+test compute_pool_tests::embedded_runner_uses_its_declared_budget_and_preserves_results ... ok
+test manual_ledger::corporate_tests::actual_core_corporate_projection_is_preserved_in_the_shared_trade_row ... ok
+test result_store::tests::canonical_first_divergence_reports_json_pointer ... ok
+test result_store::tests::canonical_manifest_is_stable_and_transport_independent ... ok
+test decision_projection::tests::projection_response_is_bound_to_source_model_clock_and_exact_population ... ok
+test manual_ledger::corporate_tests::corporate_adjustments_reject_forged_money_dates_and_reference_chains ... ok
+test result_store::tests::lazy_registration_defers_payload_hashing_to_section_read ... ok
+test result_store::tests::fact_manifest_publish_is_idempotent_under_concurrency ... ok
+test result_store::tests::process_event_store_is_content_addressed_and_round_trips ... ok
+test result_store::tests::run_store_identity_keeps_different_data_epochs_separate ... ok
+test result_store::tests::manual_source_and_applications_are_both_hashed_and_persisted ... ok
+test result_store::tests::run_store_is_content_addressed_and_round_trips ... ok
+test result_store::tests::run_store_reads_only_date_overlapping_blocks ... ok
+test result_store::tests::run_store_rejects_corrupt_manifest ... ok
+test thread_cpu::tests::thread_cpu_clock_keeps_unavailable_or_cross_thread_samples_unknown ... ok
+test thread_cpu::tests::sleeping_time_is_not_reported_as_cpu_execution ... ok
+test backtest::source_rows_columnar::tests::columnar_cache_keeps_original_output_batch_boundaries ... ok
+
+test result: ok. 474 passed; 0 failed; 9 ignored; 0 measured; 0 filtered out; finished in 4.12s
+
+     Running unittests src/main.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/deps/fidc_backtest_runner-95d90db6c05a9877)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+     Running tests/allocation_profile.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/deps/allocation_profile-33a6f9f5570d3138)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+     Running unittests examples/export_manual_corporate_evidence.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/examples/export_manual_corporate_evidence-877623d86b4ef06d)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+     Running unittests src/main.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/deps/fidc_backtest_service-11e588cf5d2c9d39)
+
+running 142 tests
+test daily_patterns::tests::arrow_rejects_truncation_and_forged_lengths_before_decoding ... ok
+test daily_patterns::tests::column_transport_is_lossless_and_rejects_ambiguous_rows ... ok
+test event_stream::tests::effective_initial_cash_is_projected_without_guessing_or_losing_source_precision ... ok
+test daily_patterns::tests::numeric_mode_requires_the_explicit_read_only_context ... ok
+test daily_patterns::tests::daily_patterns_read_only_transport_binds_exact_input ... ok
+test event_stream::tests::ordered_batch_is_idempotent_and_changed_facts_do_not_replace_history ... ignored, requires local FIDC_EVENT_TEST_POSTGRES_DSN on the private fidc-auth-pg cluster
+test event_stream::tests::memory_tail_and_durable_prefix_replay_in_publish_order ... ok
+test daily_patterns::tests::arrow_uses_same_kernel_and_exact_byte_proof_with_partial_scope ... ok
+test event_stream::tests::live_sequence_recent_replay_and_concurrent_runs_remain_isolated ... ok
+test execution_ledger::tests::dated_fact_store_rejects_reverse_order_before_projection ... ok
+test execution_ledger::tests::actual_http_routes_return_both_sources_and_precise_manual_values ... ok
+test execution_ledger::tests::serve_browser_fixture ... ignored, starts a local GET-only API for browser acceptance; set FIDC_LEDGER_UI_QA_PORT explicitly
+test execution_ledger::tests::serve_stream_browser_fixture ... ignored, starts isolated real WebSocket/GET handlers; FIDC_LEDGER_STREAM_QA_PORT required
+test execution_ledger::tests::source_precision_ids_and_later_status_are_not_rewritten ... ok
+test execution_ledger::tests::streamed_manual_facts_equal_final_ledger_without_publishing_a_future_terminal ... ok
+test execution_ledger::tests::typed_accounting_rows_keep_origin_without_order_identity ... ok
+test execution_ledger::tests::performance_counts_both_origins_and_sums_authoritative_fees_exactly ... ok
+test factor_events::tests::market_history_binds_kernel_version_and_preserves_unknown_streak ... ok
+test factor_events::tests::no_account_or_execution_payload_is_accepted ... ok
+test factor_events::tests::rank_history_binds_exact_scope_and_input_hash ... ok
+test factor_events::tests::transport_preserves_input_identity_and_rejects_future_values ... ok
+test idempotency::tests::canonical_json_order_does_not_change_request_identity ... ok
+test idempotency::tests::identity_binds_owner_and_rejects_changed_request ... ok
+test idempotency::tests::malformed_keys_and_unbound_records_are_rejected ... ok
+test performance::tests::accounting_allocations_are_not_unidentified_exchange_fills ... ok
+test performance::tests::builds_daily_weight_diagnostics_from_persisted_holdings ... ok
+test performance::tests::counts_open_underwater_duration_from_the_latest_peak ... ok
+test performance::tests::does_not_fake_risk_ratios_for_one_period ... ok
+test performance::tests::emits_true_nav_and_multiple_recovery_episodes ... ok
+test performance::tests::explicit_frozen_initial_capital_survives_a_first_day_deposit ... ok
+test performance::tests::first_period_loss_has_an_initial_peak_episode_without_a_fake_date ... ok
+test performance::tests::missing_benchmark_does_not_compact_dates_or_invent_a_drawdown_path ... ok
+test performance::tests::missing_order_ids_and_fees_remain_unknown_not_zero_or_report_counts ... ok
+test performance::tests::order_metrics_count_identities_separately_from_reports_and_partial_fills ... ok
+test performance::tests::preserves_a_first_day_strategy_return_and_initial_capital ... ok
+test performance::tests::preserves_the_canonical_pre_period_benchmark_baseline ... ok
+test performance::tests::projects_all_canonical_risk_metrics_and_contract_metadata ... ok
+test performance::tests::separates_longest_underwater_episode_from_deepest_drawdown ... ok
+test performance::tests::zero_nav_is_a_full_loss_not_missing_data ... ok
+test performance::tests::zero_orders_are_known_but_conflicting_order_identity_is_not_a_count ... ok
+test result_analysis_tests::batched_history_bindings_preserve_validation_and_survive_cache_eviction ... ignored, requires isolated FIDC_BACKTEST_TEST_POSTGRES_DSN
+test factor_events::tests::catalog_validator_binds_the_complete_body_and_preserves_contract ... ok
+test result_analysis_tests::copied_real_result_stores_and_browser_fixture ... ignored, requires FIDC_RESULT_QA_FIXTURES containing copied immutable result stores
+test result_analysis_tests::failed_optional_classification_keeps_unmodified_facts ... ok
+test result_analysis_tests::historical_text_search_filters_before_count_and_pagination ... ignored, requires isolated FIDC_BACKTEST_TEST_POSTGRES_DSN
+test result_analysis_tests::history_filters_use_corrected_drawdown_and_never_treat_unknown_as_zero ... ok
+test result_analysis_tests::owned_analysis_reference_does_not_require_a_cached_run_binding ... ok
+test result_analysis_tests::projected_history_filter_sort_and_pagination_on_postgres ... ignored, requires FIDC_BACKTEST_TEST_POSTGRES_DSN; creates an isolated test schema
+test result_analysis_tests::sector_filter_cannot_disable_its_classification_dependency ... ok
+test risk_projection::tests::absent_original_rates_preserve_independent_metrics_without_network_or_zero_rate_claim ... ok
+test risk_projection::tests::canonical_null_overrides_all_legacy_aliases_but_real_zero_survives ... ok
+test risk_projection::tests::original_contract_reprojects_legacy_zero_and_preserves_cash_flow_facts ... ok
+test risk_projection::tests::unavailable_contract_does_not_relabel_legacy_zero_as_a_verified_statistic ... ok
+test stock_pool_candidates::tests::resolve_binds_input_and_preserves_empty_automatic_days ... ok
+test submission_pg_tests::atomic_submission_claim_replay_and_rollback_on_postgres ... ignored, requires FIDC_BACKTEST_TEST_POSTGRES_DSN and creates only an isolated schema
+test tests::backtest_create_body_limit_accepts_bounded_signal_replays ... ok
+test tests::backtest_event_stream_exposes_a_websocket_transport ... ok
+test tests::backtest_list_cache_key_separates_summary_only_runtime_shape ... ok
+test tests::backtest_list_filters_and_sorting_use_generated_summary ... ok
+test tests::backtest_list_reports_cache_hit_and_effective_page_limit ... ok
+test tests::backtest_list_summary_only_uses_compact_query ... ok
+test tests::backtest_performance_contract_records_total_and_runner_seconds ... ok
+test tests::backtest_run_compact_cache_key_separates_strategy_detail_shape ... ok
+test tests::backtest_runner_data_env_accepts_strategy_factory_source_lake_provider ... ok
+test tests::backtest_runner_data_env_infers_strategy_factory_source_lake_from_runtime_source_table ... ok
+test tests::backtest_runner_data_env_rejects_legacy_ficlaw_data_source_table ... ok
+test tests::backtest_runner_data_env_rejects_legacy_source_provider ... ok
+test tests::backtest_runner_data_env_rejects_non_source_lake_provider ... ok
+test tests::backtest_runner_data_env_rejects_source_lake_provider_aliases ... ok
+test tests::backtest_runner_data_env_requires_strategy_factory_source_lake_url ... ok
+test tests::backtest_runner_data_env_uses_strategy_factory_source_lake_only ... ok
+test tests::backtest_schema_initialization_never_deletes_run_data ... ok
+test tests::backtest_schema_materializes_implementation_identity_for_compact_reads ... ok
+test tests::build_run_payload_does_not_mark_empty_running_summary_as_available ... ok
+test tests::build_run_payload_exposes_only_canonical_strategy_detail ... ok
+test tests::build_run_payload_marks_failed_error_summary_as_available ... ok
+test tests::build_run_payload_marks_terminal_metric_summary_as_available ... ok
+test tests::build_run_summary_preview_preserves_strategy_runtime_rebalance_signal ... ok
+test tests::build_run_summary_preview_preserves_terminal_audit ... ok
+test tests::canonical_result_is_recovered_from_runner_summary ... ok
+test tests::capacity_override_is_frozen_once_without_changing_execution_risk ... ok
+test tests::clear_backtest_list_cache_clears_compact_run_cache ... ok
+test tests::compact_result_handler_uses_single_pg_lookup ... ok
+test tests::compact_summary_only_runtime_select_avoids_config_json ... ok
+test tests::compact_summary_sql_removes_heavy_result_artifacts ... ok
+test tests::daily_execution_matching_type_normalizes_next_open_aliases_and_rejects_other_aliases ... ok
+test tests::default_backtest_concurrency_scales_with_available_cpu_threads ... ok
+test tests::default_backtest_source_table_uses_strategy_factory_source_lake ... ok
+test tests::detail_rows_query_page_size_maps_to_offset_limit ... ok
+test tests::equity_rows_hide_diagnostics_unless_explicitly_requested ... ok
+test tests::execution_cost_overrides_strategy_spec_for_runner ... ok
+test tests::execution_dynamic_slippage_overrides_strategy_spec_for_runner ... ok
+test tests::execution_matching_type_overrides_strategy_spec_for_runner ... ok
+test tests::execution_percent_slippage_alias_normalizes_to_price_ratio ... ok
+test tests::execution_rebalance_cash_mode_overrides_strategy_spec_for_runner ... ok
+test tests::execution_risk_overrides_strategy_spec_for_runner ... ok
+test tests::execution_risk_policy_rejects_conflicting_alias_values ... ok
+test tests::execution_risk_policy_rejects_non_object ... ok
+test tests::execution_risk_policy_rejects_unknown_fields_before_queueing ... ok
+test tests::execution_sell_then_buy_delay_slippage_requires_sell_then_buy_mode ... ok
+test tests::execution_slippage_overrides_strategy_spec_for_runner ... ok
+test tests::execution_top_level_risk_enabled_aliases_are_frozen_into_strategy_spec ... ok
+test tests::explicit_cost_override_removes_old_aliases_and_preserves_zero_minimum ... ok
+test tests::history_query_cache_has_a_bounded_entry_budget ... ok
+test tests::history_search_is_bounded_and_retains_literal_characters ... ok
+test tests::implementation_identity_freezes_source_and_binary_generation ... ok
+test tests::manual_observations_are_run_scoped_and_private_in_the_runner_bundle ... ok
+test tests::minute_execution_matching_type_uses_minute_price_and_rejects_daily_modes ... ok
+test tests::persisted_runtime_projection_never_guesses_missing_frequency ... ok
+test tests::persisted_runtime_projection_retains_minute_mode_and_frozen_bundle ... ok
+test tests::process_event_projection_uses_stable_kind_and_filters ... ok
+test tests::projected_fact_block_cache_key_is_shared_across_run_manifests ... ok
+test tests::public_backtest_projection_removes_internal_paths_recursively ... ok
+test tests::public_event_message_removes_internal_paths ... ok
+test tests::public_result_store_manifest_hides_internal_fact_blocks ... ok
+test tests::public_run_projection_does_not_reintroduce_internal_paths ... ok
+test tests::result_artifact_cache_keeps_shared_fact_blocks_after_run_eviction ... ok
+test tests::result_artifact_cache_rejects_conflicting_reference_for_same_sha ... ok
+test tests::result_block_page_plan_reads_only_overlapping_blocks ... ok
+test tests::runner_strategy_spec_path_prefers_bundle ... ok
+test tests::runtime_frequency_normalizes_and_overrides_strategy_spec_for_runner ... ok
+test tests::runtime_frozen_bundle_is_written_to_strategy_metadata_for_runner ... ok
+test tests::runtime_projection_migration_preserves_frozen_config ... ok
+test tests::runtime_symbols_override_strategy_spec_for_runner ... ok
+test tests::source_lake_preflight_rejects_unsupported_minute_cash_mode ... ok
+test tests::source_lake_run_contract_preflight_freezes_runtime_and_execution ... ok
+test tests::source_lake_runtime_requires_frozen_backtest_bundle_contract ... ok
+test tests::start_backtest_run_rejects_unready_data_source_before_persistence ... ok
+test tests::startup_reconciliation_closes_orphaned_runs_and_records_audit_event ... ok
+test tests::strategy_detail_keeps_strategy_body_without_full_config ... ok
+test tests::strategy_detail_returns_none_without_strategy_body ... ok
+test tests::strategy_expression_preflight_rejects_invalid_dsl_before_data_load ... ok
+test tests::summary_list_projection_keeps_table_metrics_and_removes_detail_payloads ... ok
+test tests::terminal_audit_accepts_deferred_intents_and_checks_the_retained_count ... ok
+test tests::terminal_audit_contract_rejects_missing_or_inconsistent_state ... ok
+test tests::top_level_limits_replace_all_nested_execution_aliases_before_preflight ... ok
+test tests::typed_holding_projection_derives_weight_and_final_snapshot ... ok
+test tests::typed_result_rows_filter_and_paginate_without_json_table_roundtrip ... ok
+test tests::typed_risk_filter_applies_execution_fields ... ok
+test event_stream::tests::replay_buffer_is_bounded_and_completed_streams_are_evicted_without_closing_subscribers ... ok
+test result_analysis_tests::complete_performance_and_paged_equity_share_corrected_drawdown ... ok
+test execution_ledger::tests::combined_pages_filter_before_count_and_keep_native_pages_bounded ... ok
+
+test result: ok. 134 passed; 0 failed; 8 ignored; 0 measured; 0 filtered out; finished in 9.28s
+
+     Running unittests examples/risk_projection_readonly.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/examples/risk_projection_readonly-70003ce8ab818e58)
+
+running 4 tests
+test risk_projection::tests::original_contract_reprojects_legacy_zero_and_preserves_cash_flow_facts ... ok
+test risk_projection::tests::absent_original_rates_preserve_independent_metrics_without_network_or_zero_rate_claim ... ok
+test risk_projection::tests::canonical_null_overrides_all_legacy_aliases_but_real_zero_survives ... ok
+test risk_projection::tests::unavailable_contract_does_not_relabel_legacy_zero_as_a_verified_statistic ... ok
+
+test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+     Running unittests examples/stock_pool_contract_probe.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/examples/stock_pool_contract_probe-d3a42410cb4f098c)
+
+running 1 test
+test stock_pool_candidates::tests::resolve_binds_input_and_preserves_empty_automatic_days ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+

docs/evidence/registered-share-delivery-20261005/runner-final-full-linux-tests.log

@@ -0,0 +1,679 @@
+   Compiling fidc-core v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-1d4b32e/fidc-backtest-engine/crates/fidc-core)
+   Compiling fidc-common v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-1d4b32e/fidc-backtest-service/crates/fidc-common)
+   Compiling fidc-signal-client v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-1d4b32e/fidc-backtest-engine/crates/fidc-signal-client)
+   Compiling fidc-backtest-runner v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-1d4b32e/fidc-backtest-service/services/backtest_runner)
+   Compiling fidc-backtest-service v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-1d4b32e/fidc-backtest-service/services/api)
+    Finished `test` profile [unoptimized] target(s) in 40.48s
+     Running unittests src/lib.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/deps/fidc_backtest_runner-e8f8f9d86cad5791)
+
+running 484 tests
+test backtest::columnar_factor_overlay_tests::cache_range_rejects_symbol_disorder_outside_the_requested_date ... ok
+test backtest::columnar_factor_overlay_tests::cache_range_rejects_date_disorder_outside_the_binary_search_slice ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_real_cache_value_equivalence ... ignored, requires a frozen private Boris real-data cache directory on 177
+test backtest::columnar_factor_overlay_tests::columnar_overlay_missing_or_stale_cache_does_not_mutate_base ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_rejects_duplicate_order_and_count_mismatches ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_rejects_duplicate_window_boundary ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_rejects_late_key_mismatch_before_any_base_mutation ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_rejects_market_projection_and_invalid_cached_column_type ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_unknown_keys_are_not_hidden_as_empty_values ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_replaced_file_invalidates_view_without_mutating_pinned_input ... ok
+test backtest::columnar_factor_overlay_tests::row_visitor_preserves_selected_offsets_and_late_validation_errors ... ok
+test backtest::compact_storage_tests::batch_bound_factor_columns_preserve_types_nulls_and_nonfinite_values ... ok
+test backtest::compact_storage_tests::inline_symbols_and_factor_maps_preserve_binary_and_json_contracts ... ok
+test backtest::day_snapshot_builder::tests::a_failed_builder_cannot_publish_earlier_valid_rows ... ok
+test backtest::columnar_factor_overlay_tests::valid_cache_reuses_its_key_index_and_failed_indexes_are_not_published ... ok
+test backtest::day_snapshot_builder::tests::corporate_distribution_quantities_must_be_known_before_a_day_is_published ... ok
+test backtest::day_snapshot_builder::tests::factor_reservation_keeps_missing_and_overwrite_semantics ... ok
+test backtest::day_snapshot_builder::tests::late_source_validation_failure_invalidates_the_streamed_day ... ok
+test backtest::equity_lifecycle_metadata_tests::empty_quotes_require_full_interval_lifecycle_proof_not_a_latest_status ... ok
+test backtest::equity_lifecycle_metadata_tests::lifecycle_cash_days_keep_real_benchmark_without_fabricated_security_rows ... ok
+test backtest::equity_lifecycle_metadata_tests::missing_identity_and_dates_do_not_become_active_securities ... ok
+test backtest::execution_config_tests::capacity_preflight_requires_explicit_daily_assumptions_without_changing_risk_switches ... ok
+test backtest::execution_config_tests::component_execution_quotes_seed_uses_latest_intraday_quote_before_target_time ... ok
+test backtest::execution_config_tests::current_close_respects_explicitly_disabled_liquidity_limit ... ok
+test backtest::execution_config_tests::daily_current_close_preserves_the_strategy_decision_clock ... ok
+test backtest::execution_config_tests::daily_execution_price_request_serializes_date_symbol_filter_scope ... ok
+test backtest::execution_config_tests::daily_execution_projection_keeps_benchmark_narrow_and_trade_risk_complete ... ok
+test backtest::execution_config_tests::data_intraday_snapshot_time_is_strategy_spec_driven ... ok
+test backtest::execution_config_tests::dataset_signature_rejects_source_lake_without_frozen_backtest_bundle ... ok
+test backtest::day_snapshot_builder::tests::arrow_rows_build_the_same_final_snapshots_without_a_row_collection ... ok
+test backtest::execution_config_tests::dataset_signature_scopes_dynamic_model_score_source_rows ... ok
+test backtest::execution_config_tests::default_matching_type_follows_backtest_frequency ... ok
+test backtest::execution_config_tests::dataset_signature_scopes_backtest_data_bundle_source_rows ... ok
+test backtest::execution_config_tests::dynamic_model_score_execution_quotes_are_lazy_by_default ... ok
+test backtest::execution_config_tests::dynamic_model_score_rank_does_not_extract_fixed_signal_symbols ... ok
+test backtest::execution_config_tests::execution_quote_prefilter_keeps_previous_factor_rows_in_current_band ... ok
+test backtest::execution_config_tests::execution_quote_prefilter_prefers_runtime_market_cap_slope ... ok
+test backtest::execution_config_tests::execution_quote_query_times_follow_strategy_trade_times ... ok
+test backtest::execution_config_tests::execution_top_level_fee_overrides_nested_risk_policy_cost ... ok
+test backtest::execution_config_tests::execution_quote_prefilter_keeps_candidates_beyond_legacy_limit ... ok
+test backtest::execution_config_tests::execution_top_level_volume_percent_overrides_nested_risk_policy ... ok
+test backtest::execution_config_tests::factor_keys_use_compact_storage_without_changing_names ... ok
+test backtest::execution_config_tests::extract_score_context_does_not_extract_fixed_signal_symbols ... ok
+test backtest::execution_config_tests::fixed_signal_model_score_scope_does_not_validate_candidate_limit ... ok
+test backtest::execution_config_tests::fixed_signal_symbol_scope_preserves_explicit_empty_targets ... ok
+test backtest::execution_config_tests::full_minute_event_stream_uses_subscriptions_instead_of_point_snapshot ... ok
+test backtest::execution_config_tests::minute_session_bounds_extend_only_after_post_close_rule_effective_date ... ok
+test backtest::execution_config_tests::model_score_source_rows_scope_evidence_verifies_candidate_limit ... ok
+test backtest::execution_config_tests::model_score_source_rows_scope_rejects_unbounded_rows ... ok
+test backtest::execution_config_tests::native_next_open_pool_loads_causal_quotes_without_exposing_them_to_selection ... ok
+test backtest::execution_config_tests::narrow_overlay_projection_does_not_retain_a_wide_value_buffer ... ok
+test backtest::execution_config_tests::owned_date_group_producers_drop_every_input_exactly_once_on_failure ... ok
+test backtest::execution_config_tests::owned_trade_day_preparation_matches_borrowed_rows ... ok
+test backtest::execution_config_tests::parse_matching_type_limits_global_backtest_matching_modes ... ok
+test backtest::execution_config_tests::parse_slippage_model_supports_explicit_historical_model ... ok
+test backtest::execution_config_tests::parse_slippage_model_supports_limit_price ... ok
+test backtest::execution_config_tests::platform_daily_factor_strategy_uses_lazy_execution_quotes_by_default ... ok
+test backtest::execution_config_tests::platform_execution_quote_carry_can_include_recent_candidates ... ok
+test backtest::execution_config_tests::platform_execution_quote_carry_does_not_let_candidates_evict_recent_orders ... ok
+test backtest::execution_config_tests::platform_execution_quote_carry_keeps_today_candidates_without_candidate_carry ... ok
+test backtest::execution_config_tests::platform_execution_quote_carry_prefers_recent_candidates_before_today_candidates ... ok
+test backtest::execution_config_tests::platform_execution_quote_carry_prioritizes_order_symbols ... ok
+test backtest::execution_config_tests::platform_execution_quote_default_carry_keeps_large_recent_candidate_set ... ok
+test backtest::execution_config_tests::platform_execution_route_requires_runtime_contract ... ok
+test backtest::execution_config_tests::platform_runtime_snapshot_preserves_typed_time_in_force ... ok
+test backtest::execution_config_tests::platform_strategy_config_rejects_loose_value_budget_without_panicking ... ok
+test backtest::execution_config_tests::parallel_owned_date_groups_keep_exact_rows_and_owned_factor_allocations ... ok
+test backtest::execution_config_tests::prepare_trade_day_candidate_market_cap_falls_back_to_total_market_cap ... ok
+test backtest::execution_config_tests::prepare_trade_day_daily_selection_price_uses_close_without_limit_allow_flags ... ok
+test backtest::execution_config_tests::prepare_trade_day_does_not_build_execution_quote_from_daily_fallback ... ok
+test backtest::execution_config_tests::platform_strategy_config_uses_same_intraday_time_as_broker ... ok
+test backtest::execution_config_tests::prepare_trade_day_keeps_allow_buy_when_missing_field_is_not_buy_relevant ... ok
+test backtest::execution_config_tests::prepare_trade_day_keeps_daily_volume_when_snapshot_has_intraday_volume ... ok
+test backtest::execution_config_tests::prepare_trade_day_keeps_external_signal_warmup_day ... ok
+test backtest::execution_config_tests::prepare_trade_day_keeps_st_and_star_st_flags_independent ... ok
+test backtest::execution_config_tests::prepare_trade_day_keeps_missing_risk_facts_when_runtime_filters_are_disabled ... ok
+test backtest::execution_config_tests::prepare_trade_day_preserves_missing_daily_volume_contract ... ok
+test backtest::execution_config_tests::prepare_trade_day_preserves_zero_ask_from_intraday_snapshot ... ok
+test backtest::execution_config_tests::prepare_trade_day_records_all_missing_risk_facts_independent_of_policy ... ok
+test backtest::execution_config_tests::raw_yuan_market_cap_normalizes_to_100m_units ... ok
+test backtest::execution_config_tests::resolve_dividend_reinvestment_defaults_false_and_reads_engine_flag ... ok
+test backtest::execution_config_tests::resolve_execution_config_does_not_allow_overspending_value_budget ... ok
+test backtest::execution_config_tests::resolve_execution_config_enables_strict_value_budget_by_default ... ok
+test backtest::execution_config_tests::resolve_execution_config_keeps_explicit_liquidity_quote_limit ... ok
+test backtest::execution_config_tests::resolve_execution_config_distinguishes_timed_daily_current_close ... ok
+test backtest::execution_config_tests::resolve_execution_config_keeps_explicit_same_day_buy_mark_override ... ok
+test backtest::execution_config_tests::resolve_execution_config_keeps_explicit_snapshot_volume_limit ... ok
+test backtest::execution_config_tests::resolve_execution_config_keeps_selection_risk_off_by_default ... ok
+test backtest::execution_config_tests::resolve_execution_config_keeps_volume_limit_for_snapshot_minute_last_by_default ... ok
+test backtest::execution_config_tests::resolve_execution_config_maps_daily_next_open ... ok
+test backtest::execution_config_tests::resolve_execution_config_maps_minute_last_to_minute_price ... ok
+test backtest::execution_config_tests::resolve_execution_config_maps_rebalance_cash_mode_and_forces_minute ... ok
+test backtest::execution_config_tests::resolve_execution_config_preserves_zero_minimum_commission ... ok
+test backtest::execution_config_tests::resolve_execution_config_reads_nested_risk_policy ... ok
+test backtest::execution_config_tests::resolve_execution_config_rejects_delay_slippage_outside_sell_then_buy ... ok
+test backtest::execution_config_tests::resolve_execution_config_rejects_vwap_as_global_matching_type ... ok
+test backtest::execution_config_tests::resolve_execution_config_uses_explicit_market_rules_without_profile ... ok
+test backtest::execution_config_tests::resolve_execution_config_uses_latest_trade_time_as_main_schedule ... ok
+test backtest::execution_config_tests::resolve_execution_config_uses_runtime_schedule_time_for_minute_execution ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_preserves_static_universe_contract ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_preserves_weak_market_threshold ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_reads_delayed_limit_open_exit ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_reads_release_slot_on_exit_signal ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_reads_trading_schedule ... ok
+test backtest::execution_config_tests::retired_slippage_and_invalid_coefficients_never_become_no_slippage ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_reads_trading_stage ... ok
+test backtest::execution_config_tests::risk_policy_alias_normalization_preserves_matching_values ... ok
+test backtest::execution_config_tests::reused_candidate_plan_panel_matches_full_intraday_market_materialization ... ok
+test backtest::execution_config_tests::risk_policy_alias_normalization_rejects_conflicting_values ... ok
+test backtest::execution_config_tests::runtime_selection_intraday_quote_detection_reads_quote_fields_only ... ok
+test backtest::execution_config_tests::sorted_overlay_keeps_unchanged_zero_bits_and_counts_only_changed_rows ... ok
+test backtest::execution_config_tests::sorted_overlay_transfers_owned_factor_storage_without_changing_bits ... ok
+test backtest::execution_config_tests::sorted_source_row_insertion_preserves_existing_duplicate_order ... ok
+test backtest::execution_config_tests::sorted_sparse_overlay_merge_falls_back_for_duplicate_keys ... ok
+test backtest::execution_config_tests::sorted_sparse_overlay_merge_preserves_order_and_unmatched_rows ... ok
+test backtest::execution_config_tests::source_lake_backtest_bundle_context_requires_complete_metadata ... ok
+test backtest::execution_config_tests::source_lake_execution_price_requests_keep_compact_schema ... ok
+test backtest::execution_config_tests::source_lake_market_cap_keeps_current_decision_date_value ... ok
+test backtest::execution_config_tests::source_lake_market_cap_uses_current_decision_date_snapshot ... ok
+test backtest::execution_config_tests::source_lake_model_score_context_accepts_complete_inferred_scope ... ok
+test backtest::execution_config_tests::source_lake_model_score_context_allows_plain_rotation_without_model_score ... ok
+test backtest::execution_config_tests::source_lake_model_score_context_rejects_dynamic_mode_without_source_label_or_scope ... ok
+test backtest::execution_config_tests::source_lake_model_score_context_rejects_partial_scope ... ok
+test backtest::execution_config_tests::source_lake_model_score_context_rejects_sparse_ref_without_scope ... ok
+test backtest::execution_config_tests::source_lake_request_keeps_dynamic_model_score_as_all_market_with_score_context ... ok
+test backtest::execution_config_tests::source_lake_request_keeps_explicit_empty_symbols_empty ... ok
+test backtest::execution_config_tests::source_lake_request_scopes_fixed_signal_symbols_and_keeps_compact_schema ... ok
+test backtest::execution_config_tests::source_lake_request_serializes_date_symbol_filter_scope ... ok
+test backtest::execution_config_tests::source_lake_source_rows_uses_current_row_decision_safe_prev_factor_mode ... ok
+test backtest::execution_config_tests::source_row_adjustment_factor_decode_accepts_positive_finite_values ... ok
+test backtest::execution_config_tests::source_row_adjustment_factor_decode_allows_paused_rows_without_close ... ok
+test backtest::execution_config_tests::source_row_adjustment_factor_decode_rejects_paused_rows_with_close ... ok
+test backtest::execution_config_tests::source_row_adjustment_factor_decode_rejects_missing_or_invalid_values ... ok
+test backtest::execution_config_tests::source_row_cache_and_filter_distinguish_all_from_explicit_empty_symbols ... ok
+test backtest::execution_config_tests::source_row_daily_capacity_is_scoped_to_actual_insertion_dates ... ok
+test backtest::execution_config_tests::source_row_adjustment_factor_decode_skips_unrequested_projection ... ok
+test backtest::execution_config_tests::source_row_grouping_copies_date_keys_only_at_boundaries ... ok
+test backtest::execution_config_tests::source_row_missing_open_does_not_mark_candidate_as_one_yuan ... ok
+test backtest::execution_config_tests::source_row_model_score_context_accepts_extract_only_score_metadata ... ok
+test backtest::execution_config_tests::source_row_model_score_context_can_disable_candidate_limit_inference ... ok
+test backtest::execution_config_tests::source_row_model_score_context_infers_candidate_limit_from_selection_limit ... ok
+test backtest::execution_config_tests::source_row_daily_capacity_keeps_supplemental_inserts_in_place ... ok
+test backtest::execution_config_tests::source_row_model_score_context_merges_bundle_extract_and_scopes_cache ... ok
+test backtest::execution_config_tests::source_row_projection_does_not_require_adjustment_factor_for_volume_only_rolling ... ok
+test backtest::execution_config_tests::source_row_projection_keeps_select_all_for_generic_empty_factor_refs ... ok
+test backtest::execution_config_tests::source_row_projection_includes_amount_for_stock_amount_expressions ... ok
+test backtest::execution_config_tests::source_row_projection_keeps_source_lake_empty_factor_refs_narrow ... ok
+test backtest::execution_config_tests::source_row_projection_keeps_source_lake_without_strategy_spec_narrow ... ok
+test backtest::execution_config_tests::source_row_projection_splits_sparse_model_score_factor_refs ... ok
+test backtest::execution_config_tests::source_row_projection_uses_framework_rolling_inputs ... ok
+test backtest::execution_config_tests::source_row_sort_preserves_published_order_and_stably_repairs_merges ... ok
+test backtest::execution_config_tests::source_row_projection_uses_raw_market_columns_for_framework_rollings ... ok
+test backtest::execution_config_tests::source_rows_query_engine_is_validated_and_scopes_cache_epoch ... ok
+test backtest::execution_config_tests::source_rows_scope_evidence_preserves_unordered_date_counts ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_dates_exclude_warmup_rows ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_keeps_named_score_when_context_uses_default_score ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_merges_only_requested_extra_factors ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_query_windows_are_chunked_by_date_span ... ok
+test backtest::execution_config_tests::source_warmup_uses_required_trading_windows ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_skips_primary_score_columns ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_reuses_source_row_cache_without_http ... ok
+test backtest::execution_config_tests::stock_cost_model_for_execution_uses_explicit_fee_overrides ... ok
+test backtest::execution_config_tests::sparse_overlay_skips_source_lake_when_scoped_date_symbol_filter_is_empty ... ok
+test backtest::execution_config_tests::strategy_execution_top_level_risk_enabled_aliases_are_applied ... ok
+test backtest::execution_config_tests::strategy_risk_policy_accepts_camel_case_fields ... ok
+test backtest::execution_config_tests::supplemental_execution_key_index_only_materializes_requested_symbols ... ok
+test backtest::execution_config_tests::timed_daily_current_close_loads_the_intraday_decision_snapshot ... ok
+test backtest::execution_config_tests::strategy_factory_model_rank_rotation_keeps_explicit_execution_contract ... ok
+test backtest::execution_config_tests::top_level_execution_limits_override_nested_risk_policy_defaults ... ok
+test backtest::execution_config_tests::unique_source_row_trade_dates_preserves_sorted_and_unordered_inputs ... ok
+test backtest::execution_config_tests::unsupported_backtest_frequency_is_rejected ... ok
+test backtest::execution_config_tests::validated_source_limit_prices_allows_explicit_no_limit_stock ... ok
+test backtest::execution_config_tests::validated_source_limit_prices_allows_index_without_limits ... ok
+test backtest::execution_config_tests::validated_source_limit_prices_allows_paused_stock_without_limits ... ok
+test backtest::execution_config_tests::validated_source_limit_prices_rejects_missing_stock_limit ... ok
+test backtest::execution_config_tests::validated_source_limit_prices_trusts_source_limits ... ok
+test backtest::factor_history_calendar_tests::history_uses_actual_sessions_and_rejects_short_or_future_calendars ... ok
+test backtest::factor_history_calendar_tests::contextual_pattern_expands_data_scope_but_not_candidate_members ... ok
+test backtest::factor_history_calendar_tests::index_policy_preloads_its_reference_without_widening_the_candidate_universe ... ok
+test backtest::factor_history_calendar_tests::selection_buy_permission_carries_its_complete_pattern_window ... ok
+test backtest::fund_metadata::tests::day_preparation_distinguishes_etf_optional_risk_from_missing_prices ... ok
+test backtest::fund_metadata::tests::etf_metadata_binds_identity_dates_and_units ... ok
+test backtest::fund_metadata::tests::real_etf_fallback_fills_match_source_opens_dates_and_fee_budgets ... ignored, requires exact frontend-compiled frozen Source Lake ETF replay artifacts
+test backtest::fund_metadata::tests::real_mixed_prices_preserve_holdings_until_explicit_zero_allocation ... ignored, requires FIDC_FUND_REPLAY_PREFIX containing read-only real Source Arrow fixtures
+test backtest::fund_metadata::tests::real_source_arrow_preserves_etf_identity_and_detects_tampering ... ignored, requires FIDC_FUND_METADATA_TEST_ARROW from the read-only real Source probe
+test backtest::fund_metadata::tests::preliminary_candidate_panel_uses_verified_etf_rules_without_inventing_limits ... ok
+test backtest::manual_data_scope::tests::explicit_data_scope_can_expand_without_mutating_the_strategy_or_empty_pool ... ok
+test backtest::manual_data_scope::tests::dataset_cache_tracks_extra_market_demand_not_manual_price_or_execution_identity ... ok
+test backtest::prepared_source_row::tests::all_supported_numeric_types_keep_the_existing_conversion_and_null_policy ... ok
+test backtest::prepared_source_row::tests::arbitrary_slices_and_supplemental_rows_keep_symbol_order ... ok
+test backtest::prepared_source_row::tests::finite_values_keep_exact_float_bits_and_metadata ... ok
+test backtest::prepared_source_row::tests::invalid_json_is_not_hidden_by_a_consumer_that_needs_no_factors ... ok
+test backtest::prepared_source_row::tests::actual_arrow_day_uses_columnar_rows_and_matches_owned_final_snapshots ... ok
+test backtest::prepared_source_row::tests::json_typed_duplicates_and_projected_overlay_preserve_overwrite_order ... ok
+test backtest::prepared_source_row::tests::nonfinite_price_policy_does_not_mutate_original_arrow_values ... ok
+test backtest::prepared_source_row::tests::overlay_cannot_relax_base_adjustment_validation ... ok
+test backtest::risk_free_rate_cache_identity_includes_bundle_and_full_calendar ... ok
+test backtest::prepared_source_row::tests::schema_error_precedence_and_null_keys_are_preserved ... ok
+test backtest::risk_free_rate_cache_round_trips_validated_contract ... ok
+test backtest::saved_risk_cache::tests::saved_reference_cancelled_reader_does_not_leave_a_claim ... ok
+test backtest::saved_risk_cache::tests::saved_reference_identity_includes_endpoint_hash_and_calendar ... ok
+test backtest::saved_risk_reference_requires_original_content_not_only_server_claimed_hash ... ok
+test backtest::source_query_windows::tests::actual_cached_boundaries_are_kept_and_gaps_are_covered ... ok
+test backtest::source_query_windows::tests::all_days_remain_once_and_scope_count_is_bounded ... ok
+test backtest::source_query_windows::tests::discovery_never_crosses_source_keys_schemas_or_file_types ... ok
+test backtest::source_query_windows::tests::overlap_prefers_more_covered_days_then_fewer_windows ... ok
+test backtest::source_query_windows::tests::projection_and_symbol_scope_have_distinct_boundary_keys ... ok
+test backtest::source_query_windows::tests::uncached_gaps_keep_the_existing_calendar_anchor ... ok
+test backtest::source_row_key_index::tests::indexed_date_ranges_cover_days_split_across_batches ... ok
+test backtest::saved_risk_cache::tests::saved_reference_coalesces_only_validated_original_contracts ... ok
+test backtest::source_row_key_index::tests::normalized_keys_cannot_duplicate_across_batches ... ok
+test backtest::source_row_key_index::tests::null_identity_and_declared_count_mismatch_are_rejected ... ok
+test backtest::source_row_query_purpose_tests::factor_overlay_cache_identity_cannot_be_reused_as_market_facts ... ok
+test backtest::source_row_query_purpose_tests::factor_overlay_merge_preserves_every_base_market_and_risk_fact ... ok
+test backtest::source_row_query_purpose_tests::only_explicit_factor_overlays_omit_redundant_risk_columns ... ok
+test backtest::source_row_query_purpose_tests::factor_overlay_requires_an_explicit_non_market_projection ... ok
+test backtest::source_rows_columnar::tests::cache_write_failure_does_not_replace_the_current_columnar_input ... ok
+test backtest::source_rows_columnar::tests::actual_selection_and_empty_outputs_do_not_keep_unused_factor_columns ... ok
+test backtest::source_rows_columnar::tests::columnar_normalization_matches_mixed_values_json_aliases_and_sorting ... ok
+test backtest::source_rows_columnar::tests::invalid_keys_and_adjustment_are_rejected_before_selection ... ok
+test backtest::source_rows_columnar::tests::malformed_json_and_dependency_identity_are_not_accepted ... ok
+test backtest::source_rows_columnar::tests::non_cacheable_json_factor_names_keep_the_real_record_path ... ok
+test backtest::source_rows_columnar::tests::normalized_duplicate_symbols_are_not_deduplicated ... ok
+test backtest::source_rows_input_tests::cache_cannot_include_rows_outside_its_declared_date_range ... ok
+test backtest::source_rows_input_tests::cache_write_failure_retains_the_real_window_and_empty_windows_do_not_read_old_rows ... ok
+test backtest::source_rows_input_tests::failed_materialization_does_not_turn_the_source_into_an_empty_success ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_crosses_record_batches_and_preserves_key_normalization ... ok
+test backtest::source_rows_input_tests::independent_windows_stay_columnar_until_daily_snapshot_construction ... ok
+test backtest::source_rows_input_tests::mapped_input_can_be_materialized_for_mutating_model_and_publication_overlays ... ok
+test backtest::source_rows_input_tests::invalid_cache_keys_and_overlay_coverage_never_publish_source_input ... ok
+test backtest::source_rows_input_tests::mapped_input_preserves_empty_scopes_and_filters_only_base_rows ... ok
+test backtest::source_rows_input_tests::mixed_window_storage_and_duplicate_boundaries_keep_original_semantics ... ok
+test backtest::source_rows_input_tests::mapped_inventory_and_final_days_match_owned_rows_with_factor_overlays ... ok
+test backtest::source_rows_input_tests::separate_arrow_factor_input_preserves_sparse_overlay_values_and_existing_layers ... ok
+test backtest::terminal_audit_summary_tests::deferred_strategy_warning_is_not_presented_as_a_submitted_order ... ok
+test backtest::terminal_audit_summary_tests::pending_terminal_state_is_explicit_in_summary_warning ... ok
+test backtest::terminal_calendar_tests::delayed_deposit_requires_terminal_calendar_but_zero_day_does_not ... ok
+test backtest::source_rows_input_tests::unsuccessful_window_publication_cannot_read_a_previous_cache_file ... ok
+test backtest::terminal_calendar_tests::scheduled_terminal_calendar_requires_strict_order_and_range ... ok
+test backtest::tests::accounting_allocation_details_do_not_require_or_fabricate_an_order ... ok
+test backtest::tests::all_source_lake_runtime_caches_are_scoped_by_backtest_bundle ... ok
+test backtest::tests::audit_instrument_cache_values_from_request ... ignored, read-only Boris cache comparison with an explicit audit request
+test backtest::tests::benchmark_borrowed_numeric_factor_keys_against_owned_strings ... ignored, manual release-mode allocation benchmark
+test backtest::tests::benchmark_date_symbol_filter_query_range_preserves_index_symbols ... ok
+test backtest::tests::benchmark_query_windows_split_long_source_lake_ranges ... ok
+test backtest::tests::arrow_reader_accepts_lz4_compressed_stream ... ok
+test backtest::tests::benchmark_row_binary_cache_rejects_metadata_mismatch ... ok
+test backtest::tests::benchmark_row_binary_cache_roundtrips_rows ... ok
+test backtest::tests::benchmark_row_cache_ignores_legacy_csv_cache ... ok
+test backtest::tests::benchmark_row_cache_path_scopes_date_symbol_filter ... ok
+test backtest::tests::benchmark_row_cache_path_uses_binary_cache_file ... ok
+test backtest::tests::benchmark_row_candidate_scan_removes_stale_schema_cache ... ok
+test backtest::tests::benchmark_row_covering_cache_reuses_superset_symbols_and_dates ... ok
+test backtest::tests::benchmark_row_partial_cache_rejects_missing_symbol_segment ... ok
+test backtest::tests::benchmark_row_to_source_row_preserves_false_paused_state ... ok
+test backtest::tests::benchmark_row_partial_cache_reports_missing_ranges ... ok
+test backtest::tests::benchmark_row_window_cache_scope_ignores_out_of_window_filter_dates ... ok
+test backtest::tests::benchmark_rows_dedup_after_window_merge ... ok
+test backtest::tests::benchmark_source_row_arrow_bounded_materialization ... ignored, requires FIDC_BT_SOURCE_ROW_VIEW_PROBE_PATH and explicit release-mode invocation
+test backtest::tests::benchmark_source_row_arrow_view_cache ... ignored, requires FIDC_BT_SOURCE_ROW_VIEW_PROBE_PATH and explicit release-mode invocation
+test backtest::tests::bootstrap_missing_quote_repair_keys_keeps_all_actual_order_gaps_without_fills ... ok
+test backtest::tests::bootstrap_missing_quote_repair_keys_keeps_all_after_fills_exist ... ok
+test backtest::tests::benchmark_rows_empty_date_symbol_filter_does_not_reuse_existing_cache ... ok
+test backtest::tests::build_trade_detail_rows_expands_split_fills_by_order_id ... ok
+test backtest::tests::build_trade_detail_rows_matches_fill_when_order_reason_changes ... ok
+test backtest::tests::build_trade_detail_rows_omits_canceled_orders_without_fills ... ok
+test backtest::tests::build_trade_detail_rows_preserves_decision_and_execution_dates ... ok
+test backtest::tests::carry_forward_target_snapshot_keeps_transition_day_then_replaces_positions ... ok
+test backtest::tests::cn_index_symbols_are_not_stock_execution_quote_repair_symbols ... ok
+test backtest::tests::collect_missing_execution_quote_keys_uses_canceled_stock_orders_only ... ok
+test backtest::tests::compact_progress_retains_manual_counts_and_rejects_a_missing_source ... ok
+test backtest::tests::compacted_carry_forward_filter_keeps_window_semantics ... ok
+test backtest::tests::corporate_action_arrow_preserves_the_independent_delivery_date_and_unknown_quantities ... ok
+test backtest::tests::corporate_action_binary_cache_roundtrips_rows ... ok
+test backtest::tests::corporate_action_cache_ignores_legacy_csv_cache ... ok
+test backtest::tests::corporate_action_cache_path_uses_source_lake_provider_epoch ... ok
+test backtest::tests::bundle_validation_observes_dependency_semantic_change_and_revocation_without_ttl ... ok
+test backtest::tests::corporate_action_covering_cache_reuses_superset_scope ... ok
+test backtest::tests::daily_execution_price_arrow_decode_preserves_unpriced_paused_risk_rows ... ok
+test backtest::tests::daily_execution_scope_membership_is_normalized_once_and_isolated_by_date ... ok
+test backtest::tests::daily_execution_price_arrow_requires_execution_contract_fields ... ok
+test backtest::tests::dataset_signature_scopes_fixed_signal_source_rows ... ok
+test backtest::tests::dataset_signature_scopes_fixed_signal_date_symbol_filter_with_model_score ... ok
+test backtest::tests::date_symbol_filter_query_range_carry_forward_keeps_history_prefix ... ok
+test backtest::tests::date_symbol_filter_query_range_exact_keeps_only_window_dates ... ok
+test backtest::tests::date_symbol_filter_query_range_preserves_empty_request ... ok
+test backtest::tests::dataset_signature_uses_data_requirements_not_strategy_identity_or_thresholds ... ok
+test backtest::tests::default_cache_epochs_ignore_local_manifest_directory ... ok
+test backtest::tests::dense_execution_quote_plan_uses_requested_trade_dates_only ... ok
+test backtest::tests::dynamic_model_score_execution_only_queries_next_date_gaps ... ok
+test backtest::tests::dynamic_model_score_execution_skips_rows_present_on_next_full_calendar_date ... ok
+test backtest::tests::dynamic_model_score_execution_symbols_include_candidate_universe_for_lagged_execution ... ok
+test backtest::tests::dynamic_symbol_expression_does_not_enable_fixed_source_scope ... ok
+test backtest::tests::empty_date_symbol_filter_is_empty_request_not_all_market ... ok
+test backtest::tests::equity_artifact_keeps_external_deposit_out_of_return ... ok
+test backtest::tests::equity_projection_orders_facts_and_includes_the_initial_nav_peak ... ok
+test backtest::tests::execution_arrow_does_not_turn_nonfinite_numbers_into_optional_missing_values ... ok
+test backtest::tests::execution_arrow_requires_the_strict_source_contract_even_when_empty ... ok
+test backtest::tests::execution_price_date_symbol_filter_keeps_benchmark_and_prunes_other_targets ... ok
+test backtest::tests::execution_price_only_source_row_marker_round_trips ... ok
+test backtest::tests::execution_quantities_are_exact_integers_not_rounded_floats ... ok
+test backtest::tests::exact_source_row_windows_restore_in_parallel_and_keep_order ... ok
+test backtest::tests::execution_quote_day_binary_cache_invalidates_duplicate_date_symbol ... ok
+test backtest::tests::execution_quote_day_binary_cache_rejects_metadata_mismatch ... ok
+test backtest::tests::execution_quote_day_cache_does_not_persist_empty_negative_result ... ok
+test backtest::tests::execution_quote_day_cache_ignores_legacy_csv_cache ... ok
+test backtest::tests::execution_quote_day_cache_loads_empty_without_provider_url ... ok
+test backtest::tests::execution_quote_day_cache_path_includes_minute_lookback_and_price_rule ... ok
+test backtest::tests::execution_quote_day_cache_path_uses_quote_epoch ... ok
+test backtest::tests::execution_quote_day_cache_path_uses_source_lake_provider_tag ... ok
+test backtest::tests::execution_quote_day_cache_tracks_returned_symbols_only ... ok
+test backtest::tests::execution_quote_prefetch_seed_tracks_negative_symbols ... ok
+test backtest::tests::execution_quote_query_tasks_keep_target_time_symbol_scopes_narrow ... ok
+test backtest::tests::execution_quote_query_tasks_merge_identical_symbol_scopes_for_same_day ... ok
+test backtest::tests::execution_quote_rows_duplicate_date_symbol_is_rejected ... ok
+test backtest::tests::execution_quote_rows_normalize_base_stock_code_symbols ... ok
+test backtest::tests::execution_quote_loader_reads_a_bounded_minute_window_instead_of_a_point_snapshot ... ok
+test backtest::tests::explicit_cli_source_cache_epoch_is_stable_and_provider_scoped ... ok
+test backtest::tests::external_daily_execution_symbols_without_signals_only_queries_benchmark ... ok
+test backtest::tests::external_daily_execution_symbols_skip_signals_already_in_source_rows ... ok
+test backtest::tests::factor_values_arrow_decode_validates_metadata_and_merges_aliases ... ok
+test backtest::tests::fidc_runner_rejects_ficlaw_data_source_rows_table ... ok
+test backtest::tests::factor_values_arrow_decode_rejects_future_data_and_semantic_drift ... ok
+test backtest::tests::fixed_minute_subscriptions_expand_static_daily_data_scope ... ok
+test backtest::tests::fixed_signal_date_symbol_filter_is_disabled_when_static_symbols_are_mixed_in ... ok
+test backtest::tests::fixed_signal_date_symbol_filter_seeds_static_symbols_at_query_start ... ok
+test backtest::tests::fixed_signal_date_symbol_filter_survives_model_score_rank_metadata ... ok
+test backtest::tests::fixed_signal_next_open_exit_scope_keeps_all_prior_unsold_symbols ... ok
+test backtest::tests::fixed_signal_source_row_date_symbol_filter_extracts_dated_weights_only ... ok
+test backtest::tests::fixed_signal_source_row_symbols_extracts_runtime_target_weights_expr ... ok
+test backtest::tests::fixed_signal_source_row_date_symbol_filter_extracts_target_holding_rows ... ok
+test backtest::tests::fixed_signal_source_row_symbols_extracts_single_quoted_runtime_target_weights_expr ... ok
+test backtest::tests::fixed_signal_source_row_symbols_extracts_strategy_metadata_targets ... ok
+test backtest::tests::fixed_signal_source_row_symbols_extracts_target_weight_codes ... ok
+test backtest::tests::fixed_symbol_order_scope_requires_rotation_disabled ... ok
+test backtest::tests::fixed_symbol_orders_seed_exact_intraday_snapshot_keys ... ok
+test backtest::tests::frozen_bundle_identity_http_failure_is_not_a_mutable_epoch_fallback ... ok
+test backtest::tests::full_minute_prefetch_days_respect_total_bar_budget ... ok
+test backtest::tests::futures_source_lake_catalog_requires_all_truth_datasets ... ok
+test backtest::tests::futures_only_runtime_contract_keeps_stock_scope_empty_and_allocates_cash ... ok
+test backtest::tests::instrument_metadata_binary_cache_rejects_metadata_mismatch ... ok
+test backtest::tests::instrument_metadata_binary_cache_roundtrips_rows ... ok
+test backtest::tests::instrument_metadata_cache_merges_missing_symbols_incrementally ... ok
+test backtest::tests::instrument_metadata_cache_ignores_legacy_csv_cache ... ok
+test backtest::tests::instrument_metadata_cache_path_is_scoped_by_historical_window ... ok
+test backtest::tests::instrument_metadata_cache_path_uses_binary_format ... ok
+test backtest::tests::instrument_metadata_request_serializes_historical_source_window_when_present ... ok
+test backtest::tests::intraday_snapshot_binary_cache_rejects_metadata_mismatch ... ok
+test backtest::tests::intraday_snapshot_binary_cache_roundtrips_rows ... ok
+test backtest::tests::intraday_snapshot_cache_ignores_legacy_csv_cache ... ok
+test backtest::tests::intraday_snapshot_cache_path_uses_source_lake_provider_tag ... ok
+test backtest::tests::kcb_board_and_quantity_use_source_classification ... ok
+test backtest::tests::intraday_snapshot_seeds_execution_quotes_and_negative_gaps ... ok
+test backtest::tests::layered_execution_quote_loader_cache_preserves_shared_seed_and_isolates_overlay ... ok
+test backtest::tests::lazy_execution_quote_window_dates_use_trading_calendar_only ... ok
+test backtest::tests::lazy_execution_quote_window_backfill_keeps_future_missing_symbols ... ok
+test backtest::tests::load_strategy_spec_rejects_removed_compatibility_profile ... ok
+test backtest::tests::load_strategy_spec_rejects_removed_engine_profile_name ... ok
+test backtest::tests::malformed_execution_observations_are_errors_not_empty_successes ... ok
+test backtest::tests::malformed_versioned_factor_ref_fails_closed ... ok
+test backtest::tests::managed_source_rows_route_by_exact_table ... ok
+test backtest::tests::minute_bar_arrow_decode_accepts_bounded_multi_date_stream ... ok
+test backtest::tests::load_strategy_spec_accepts_snake_case_bundle_field ... ok
+test backtest::tests::minute_bar_arrow_decode_preserves_timestamp_symbol_order ... ok
+test backtest::tests::minute_bar_arrow_decode_rejects_retired_string_time_schema ... ok
+test backtest::tests::minute_bar_arrow_decode_rejects_duplicate_or_unordered_rows ... ok
+test backtest::tests::mixed_candidate_book_binds_complete_dates_raw_sources_and_resolved_order ... ok
+test backtest::tests::mixed_stock_futures_contract_requires_explicit_futures_cash ... ok
+test backtest::tests::normalize_symbol_maps_bse_exchange_to_beijing_board ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_matches_row_decoder_for_wide_sparse_null_and_signed_zero_values ... ok
+test backtest::tests::minute_bars_retries_transient_http_failure_and_preserves_caller_header ... ok
+test backtest::tests::partial_source_row_window_cache_crops_covering_segments_in_arrow ... ok
+test backtest::tests::partial_source_row_window_cache_ignores_all_market_cache_for_symbol_scope ... ok
+test backtest::tests::partial_source_row_window_cache_ignores_wide_projection_segment ... ok
+test backtest::tests::partial_source_row_window_cache_reports_only_missing_gaps ... ok
+test backtest::tests::progress_callback_is_forwarded_to_blocking_engine_thread ... ok
+test backtest::tests::published_factor_binding_normalizes_ref_and_builds_arrow_request ... ok
+test backtest::tests::query_scope_batch_preserves_authoritative_window_identities ... ok
+test backtest::tests::partial_source_row_window_cache_reuses_exact_projection_with_null_dynamic_columns ... ok
+test backtest::tests::query_scope_identity_reuses_physical_window_across_distinct_bundles ... ok
+test backtest::tests::real_source_quote_json_and_arrow_match_strict_reader ... ignored, requires a bounded real Source JSON/Arrow probe directory
+test backtest::tests::repeated_query_views_share_only_identical_execution_observations ... ok
+test backtest::tests::platform_quote_plan_uses_current_decision_date_source_rows ... ok
+test backtest::tests::query_scope_http_carries_rolling_dependencies_and_rejects_bad_contracts ... ok
+test backtest::tests::select_instrument_metadata_rejects_missing_symbols ... ok
+test backtest::tests::shared_base_source_projection_keeps_raw_adjustment_contract ... ok
+test backtest::tests::shared_base_source_rows_cache_is_enabled_by_default ... ok
+test backtest::tests::shared_base_source_rows_cache_is_only_for_unscoped_raw_rows ... ok
+test backtest::tests::reusable_source_row_window_cache_does_not_reuse_covering_cache ... ok
+test backtest::tests::sorted_source_row_validator_rejects_unordered_or_duplicate_keys ... ok
+test backtest::tests::source_cache_epoch_default_is_independent_from_quote_plan_epoch ... ok
+test backtest::tests::source_dependency_contract_invalidates_all_authoritative_cache_scopes ... ok
+test backtest::tests::segmented_source_row_cache_reads_only_uncovered_overlap_ranges ... ok
+test backtest::tests::short_range_source_query_window_is_explicit_and_keeps_long_ranges_bounded ... ok
+test backtest::tests::source_lake_contract_epoch_ignores_runtime_build_but_tracks_catalog ... ok
+test backtest::tests::source_lake_health_contract_epoch_ignores_runtime_build ... ok
+test backtest::tests::source_lake_arrow_request_retries_bad_gateway ... ok
+test backtest::tests::source_lake_busy_retry_honors_retryable_capacity_response ... ok
+test backtest::tests::source_lake_source_query_retries_are_bounded_and_transient_only ... ok
+test backtest::tests::source_lake_source_query_timeout_accepts_highmem_alias ... ok
+test backtest::tests::source_lake_run_waits_for_manifest_publication_and_holds_shared_lease ... ok
+test backtest::tests::source_row_arrow_cache_rejects_and_does_not_write_empty_rows ... ok
+test backtest::tests::source_lake_uses_wider_windows_for_narrow_queries ... ok
+test backtest::tests::source_query_concurrency_defaults_and_clamps ... ok
+test backtest::tests::source_row_arrow_decode_preserves_dynamic_projection_columns ... ok
+test backtest::tests::source_row_arrow_cache_rejects_duplicate_date_symbol ... ok
+test backtest::tests::source_row_arrow_dependency_contract_rejects_invalid_metadata ... ok
+test backtest::tests::source_row_arrow_extra_factor_helpers_preserve_projected_columns ... ok
+test backtest::tests::source_row_arrow_decode_keeps_compact_base_rows_without_extra_json ... ok
+test backtest::tests::source_row_arrow_view_keeps_mmap_alive_until_materialization ... ok
+test backtest::tests::source_row_arrow_view_cache_reuses_identity_and_invalidates_replacement ... ok
+test backtest::tests::source_row_cache_file_range_parses_source_cache_dates ... ok
+test backtest::tests::source_row_cache_candidate_scan_removes_previous_schema_files ... ok
+test backtest::tests::source_row_cache_directory_index_tracks_files_published_by_other_workers ... ok
+test backtest::tests::source_row_cache_path_hashes_long_projection_columns ... ok
+test backtest::tests::source_row_cache_path_scopes_explicit_source_symbols ... ok
+test backtest::tests::source_row_cache_lease_serializes_concurrent_misses ... ok
+test backtest::tests::source_row_cache_path_normalizes_projection_column_order ... ok
+test backtest::tests::source_row_cache_projection_check_requires_extra_factor_keys ... ok
+test backtest::tests::source_row_cache_projection_check_allows_source_lake_fixed_aliases ... ok
+test backtest::tests::source_row_cache_path_separates_projection_columns ... ok
+test backtest::tests::source_row_cache_rejects_legacy_raw_bincode_without_magic_header ... ok
+test backtest::tests::source_row_cache_segment_selection_prefers_small_complete_windows ... ok
+test backtest::tests::source_row_cache_segment_selection_rejects_incomplete_windows ... ok
+test backtest::tests::source_row_date_windows_keep_interior_buckets_stable_across_ranges ... ok
+test backtest::tests::source_row_date_windows_split_long_ranges ... ok
+test backtest::tests::source_row_cache_rejects_metadata_mismatch ... ok
+test backtest::tests::source_row_date_windows_stay_within_requested_range ... ok
+test backtest::tests::source_row_primary_keys_are_inline_without_growing_the_row_header ... ok
+test backtest::tests::source_row_cache_writes_arrow_file ... ok
+test backtest::tests::source_row_segment_boundary_validator_preserves_fail_closed_integrity ... ok
+test backtest::tests::source_row_symbol_normalization_preserves_canonical_and_maps_board ... ok
+test backtest::tests::source_row_request_cache_epoch_scopes_runtime_query_context ... ok
+test backtest::tests::source_row_symbol_scope_epoch_changes_with_fixed_signal_symbols ... ok
+test backtest::tests::source_rows_duplicate_date_symbol_is_rejected ... ok
+test backtest::tests::source_rows_request_keeps_rolling_enabled_for_rolling_projection_columns ... ok
+test backtest::tests::source_row_window_cache_scope_ignores_out_of_window_filter_dates ... ok
+test backtest::tests::source_rows_unique_date_symbol_passes_without_reordering ... ok
+test backtest::tests::source_semantic_change_invalidates_bundle_and_window_cache ... ok
+test backtest::tests::static_universe_include_is_an_explicit_source_row_scope ... ok
+test backtest::tests::stock_pool_screen_snapshot_uses_exact_selection_dates_and_full_symbol_history ... ok
+test backtest::tests::strategy_bundle_path_loads_nested_spec_and_signal_scope ... ok
+test backtest::tests::strategy_factor_overlay_only_queries_keys_and_missing_factor_fields ... ok
+test backtest::tests::strategy_factor_overlay_requires_exact_base_key_coverage ... ok
+test backtest::tests::strategy_factor_overlay_rejects_duplicate_and_unordered_keys ... ok
+test backtest::tests::strategy_factory_source_lake_provider_name_is_exact ... ok
+test backtest::tests::strategy_factory_source_lake_requires_url_and_matching_provider ... ok
+test backtest::tests::strategy_factory_source_lake_uses_arrow_sized_query_windows_by_default ... ok
+test backtest::tests::trade_display_metadata_cache_is_bundle_scoped_and_covers_missing_rows ... ok
+test backtest::tests::trade_display_metadata_cache_rejects_rows_outside_exact_request ... ok
+test backtest::tests::typed_equity_result_emits_service_schema ... ok
+test backtest::tests::trade_display_metadata_disk_cache_roundtrips_frozen_bundle_rows ... ok
+test backtest::tests::typed_order_result_keeps_zero_fill_orders ... ok
+test backtest::tests::typed_trade_result_preserves_sub_cent_execution_price ... ok
+test backtest::tests::validated_manifest_scope_reuses_cache_across_distinct_bundle_ids ... ok
+test backtest::tests::versioned_factor_binding_rejects_research_scope ... ok
+test backtest::tests::versioned_factor_binding_requires_declared_semantics ... ok
+test backtest::tests::versioned_factor_ref_requires_a_binding ... ok
+test backtest::typed_exit_dependency_tests::ordinary_strategy_partial_exit_also_contributes_its_window ... ok
+test backtest::typed_exit_dependency_tests::typed_stock_pool_exits_contribute_the_full_rolling_window ... ok
+test cache_directory_watch::tests::notifications_cover_publication_rename_delete_and_ignore_unrelated_files ... ok
+test compute_pool_tests::concurrent_embedded_runs_do_not_change_each_others_pool_budget ... ok
+test compute_pool_tests::current_thread_async_runtime_keeps_the_compute_context ... ok
+test backtest::tests::timed_quote_dataset_signature_includes_daily_selection_plan ... ok
+test decision_projection::tests::projection_metadata_alias_empty_fields_and_credential_paths_fail_closed ... ok
+test decision_projection::tests::projection_native_request_is_complete_and_never_truncated_to_top_n ... ok
+test decision_projection::tests::projection_response_is_bound_to_source_model_clock_and_exact_population ... ok
+test compute_pool_tests::embedded_runner_uses_its_declared_budget_and_preserves_results ... ok
+test manual_ledger::corporate_tests::actual_core_corporate_projection_is_preserved_in_the_shared_trade_row ... ok
+test result_store::tests::canonical_first_divergence_reports_json_pointer ... ok
+test result_store::tests::canonical_manifest_is_stable_and_transport_independent ... ok
+test manual_ledger::corporate_tests::corporate_adjustments_reject_forged_money_dates_and_reference_chains ... ok
+test backtest::tests::unused_daily_market_cap_prefilter_does_not_split_identical_input_cache ... ok
+test result_store::tests::lazy_registration_defers_payload_hashing_to_section_read ... ok
+test result_store::tests::fact_manifest_publish_is_idempotent_under_concurrency ... ok
+test result_store::tests::process_event_store_is_content_addressed_and_round_trips ... ok
+test result_store::tests::run_store_identity_keeps_different_data_epochs_separate ... ok
+test result_store::tests::run_store_is_content_addressed_and_round_trips ... ok
+test result_store::tests::manual_source_and_applications_are_both_hashed_and_persisted ... ok
+test result_store::tests::run_store_rejects_corrupt_manifest ... ok
+test result_store::tests::run_store_reads_only_date_overlapping_blocks ... ok
+test thread_cpu::tests::thread_cpu_clock_keeps_unavailable_or_cross_thread_samples_unknown ... ok
+test thread_cpu::tests::sleeping_time_is_not_reported_as_cpu_execution ... ok
+test backtest::source_rows_columnar::tests::columnar_cache_keeps_original_output_batch_boundaries ... ok
+
+test result: ok. 475 passed; 0 failed; 9 ignored; 0 measured; 0 filtered out; finished in 4.31s
+
+     Running unittests src/main.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/deps/fidc_backtest_runner-b8208f20c65c40bc)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+     Running tests/allocation_profile.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/deps/allocation_profile-1ab90294b6f34b33)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+     Running unittests examples/export_manual_corporate_evidence.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/examples/export_manual_corporate_evidence-400d24419df6725a)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+     Running unittests src/main.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/deps/fidc_backtest_service-e322f82562f9dee9)
+
+running 142 tests
+test daily_patterns::tests::column_transport_is_lossless_and_rejects_ambiguous_rows ... ok
+test daily_patterns::tests::arrow_rejects_truncation_and_forged_lengths_before_decoding ... ok
+test event_stream::tests::effective_initial_cash_is_projected_without_guessing_or_losing_source_precision ... ok
+test daily_patterns::tests::daily_patterns_read_only_transport_binds_exact_input ... ok
+test daily_patterns::tests::numeric_mode_requires_the_explicit_read_only_context ... ok
+test event_stream::tests::ordered_batch_is_idempotent_and_changed_facts_do_not_replace_history ... ignored, requires local FIDC_EVENT_TEST_POSTGRES_DSN on the private fidc-auth-pg cluster
+test event_stream::tests::memory_tail_and_durable_prefix_replay_in_publish_order ... ok
+test daily_patterns::tests::arrow_uses_same_kernel_and_exact_byte_proof_with_partial_scope ... ok
+test event_stream::tests::live_sequence_recent_replay_and_concurrent_runs_remain_isolated ... ok
+test execution_ledger::tests::actual_http_routes_return_both_sources_and_precise_manual_values ... ok
+test execution_ledger::tests::dated_fact_store_rejects_reverse_order_before_projection ... ok
+test execution_ledger::tests::serve_browser_fixture ... ignored, starts a local GET-only API for browser acceptance; set FIDC_LEDGER_UI_QA_PORT explicitly
+test execution_ledger::tests::serve_stream_browser_fixture ... ignored, starts isolated real WebSocket/GET handlers; FIDC_LEDGER_STREAM_QA_PORT required
+test execution_ledger::tests::source_precision_ids_and_later_status_are_not_rewritten ... ok
+test execution_ledger::tests::streamed_manual_facts_equal_final_ledger_without_publishing_a_future_terminal ... ok
+test execution_ledger::tests::typed_accounting_rows_keep_origin_without_order_identity ... ok
+test execution_ledger::tests::performance_counts_both_origins_and_sums_authoritative_fees_exactly ... ok
+test factor_events::tests::market_history_binds_kernel_version_and_preserves_unknown_streak ... ok
+test factor_events::tests::no_account_or_execution_payload_is_accepted ... ok
+test factor_events::tests::rank_history_binds_exact_scope_and_input_hash ... ok
+test factor_events::tests::transport_preserves_input_identity_and_rejects_future_values ... ok
+test idempotency::tests::canonical_json_order_does_not_change_request_identity ... ok
+test idempotency::tests::identity_binds_owner_and_rejects_changed_request ... ok
+test idempotency::tests::malformed_keys_and_unbound_records_are_rejected ... ok
+test performance::tests::accounting_allocations_are_not_unidentified_exchange_fills ... ok
+test performance::tests::builds_daily_weight_diagnostics_from_persisted_holdings ... ok
+test performance::tests::counts_open_underwater_duration_from_the_latest_peak ... ok
+test performance::tests::does_not_fake_risk_ratios_for_one_period ... ok
+test performance::tests::emits_true_nav_and_multiple_recovery_episodes ... ok
+test performance::tests::explicit_frozen_initial_capital_survives_a_first_day_deposit ... ok
+test performance::tests::first_period_loss_has_an_initial_peak_episode_without_a_fake_date ... ok
+test performance::tests::missing_benchmark_does_not_compact_dates_or_invent_a_drawdown_path ... ok
+test performance::tests::missing_order_ids_and_fees_remain_unknown_not_zero_or_report_counts ... ok
+test performance::tests::order_metrics_count_identities_separately_from_reports_and_partial_fills ... ok
+test performance::tests::preserves_a_first_day_strategy_return_and_initial_capital ... ok
+test performance::tests::preserves_the_canonical_pre_period_benchmark_baseline ... ok
+test performance::tests::projects_all_canonical_risk_metrics_and_contract_metadata ... ok
+test performance::tests::separates_longest_underwater_episode_from_deepest_drawdown ... ok
+test performance::tests::zero_nav_is_a_full_loss_not_missing_data ... ok
+test performance::tests::zero_orders_are_known_but_conflicting_order_identity_is_not_a_count ... ok
+test result_analysis_tests::batched_history_bindings_preserve_validation_and_survive_cache_eviction ... ignored, requires isolated FIDC_BACKTEST_TEST_POSTGRES_DSN
+test factor_events::tests::catalog_validator_binds_the_complete_body_and_preserves_contract ... ok
+test result_analysis_tests::copied_real_result_stores_and_browser_fixture ... ignored, requires FIDC_RESULT_QA_FIXTURES containing copied immutable result stores
+test result_analysis_tests::failed_optional_classification_keeps_unmodified_facts ... ok
+test result_analysis_tests::historical_text_search_filters_before_count_and_pagination ... ignored, requires isolated FIDC_BACKTEST_TEST_POSTGRES_DSN
+test result_analysis_tests::history_filters_use_corrected_drawdown_and_never_treat_unknown_as_zero ... ok
+test result_analysis_tests::owned_analysis_reference_does_not_require_a_cached_run_binding ... ok
+test result_analysis_tests::projected_history_filter_sort_and_pagination_on_postgres ... ignored, requires FIDC_BACKTEST_TEST_POSTGRES_DSN; creates an isolated test schema
+test result_analysis_tests::sector_filter_cannot_disable_its_classification_dependency ... ok
+test risk_projection::tests::absent_original_rates_preserve_independent_metrics_without_network_or_zero_rate_claim ... ok
+test risk_projection::tests::canonical_null_overrides_all_legacy_aliases_but_real_zero_survives ... ok
+test risk_projection::tests::original_contract_reprojects_legacy_zero_and_preserves_cash_flow_facts ... ok
+test risk_projection::tests::unavailable_contract_does_not_relabel_legacy_zero_as_a_verified_statistic ... ok
+test stock_pool_candidates::tests::resolve_binds_input_and_preserves_empty_automatic_days ... ok
+test submission_pg_tests::atomic_submission_claim_replay_and_rollback_on_postgres ... ignored, requires FIDC_BACKTEST_TEST_POSTGRES_DSN and creates only an isolated schema
+test tests::backtest_create_body_limit_accepts_bounded_signal_replays ... ok
+test tests::backtest_event_stream_exposes_a_websocket_transport ... ok
+test tests::backtest_list_cache_key_separates_summary_only_runtime_shape ... ok
+test tests::backtest_list_filters_and_sorting_use_generated_summary ... ok
+test tests::backtest_list_reports_cache_hit_and_effective_page_limit ... ok
+test tests::backtest_list_summary_only_uses_compact_query ... ok
+test tests::backtest_performance_contract_records_total_and_runner_seconds ... ok
+test tests::backtest_run_compact_cache_key_separates_strategy_detail_shape ... ok
+test tests::backtest_runner_data_env_accepts_strategy_factory_source_lake_provider ... ok
+test tests::backtest_runner_data_env_infers_strategy_factory_source_lake_from_runtime_source_table ... ok
+test tests::backtest_runner_data_env_rejects_legacy_ficlaw_data_source_table ... ok
+test tests::backtest_runner_data_env_rejects_legacy_source_provider ... ok
+test tests::backtest_runner_data_env_rejects_non_source_lake_provider ... ok
+test tests::backtest_runner_data_env_rejects_source_lake_provider_aliases ... ok
+test tests::backtest_runner_data_env_requires_strategy_factory_source_lake_url ... ok
+test tests::backtest_runner_data_env_uses_strategy_factory_source_lake_only ... ok
+test tests::backtest_schema_initialization_never_deletes_run_data ... ok
+test tests::backtest_schema_materializes_implementation_identity_for_compact_reads ... ok
+test tests::build_run_payload_does_not_mark_empty_running_summary_as_available ... ok
+test tests::build_run_payload_exposes_only_canonical_strategy_detail ... ok
+test tests::build_run_payload_marks_failed_error_summary_as_available ... ok
+test tests::build_run_payload_marks_terminal_metric_summary_as_available ... ok
+test tests::build_run_summary_preview_preserves_strategy_runtime_rebalance_signal ... ok
+test tests::build_run_summary_preview_preserves_terminal_audit ... ok
+test tests::canonical_result_is_recovered_from_runner_summary ... ok
+test tests::capacity_override_is_frozen_once_without_changing_execution_risk ... ok
+test tests::clear_backtest_list_cache_clears_compact_run_cache ... ok
+test tests::compact_result_handler_uses_single_pg_lookup ... ok
+test tests::compact_summary_only_runtime_select_avoids_config_json ... ok
+test tests::compact_summary_sql_removes_heavy_result_artifacts ... ok
+test tests::daily_execution_matching_type_normalizes_next_open_aliases_and_rejects_other_aliases ... ok
+test tests::default_backtest_concurrency_scales_with_available_cpu_threads ... ok
+test tests::default_backtest_source_table_uses_strategy_factory_source_lake ... ok
+test tests::detail_rows_query_page_size_maps_to_offset_limit ... ok
+test tests::equity_rows_hide_diagnostics_unless_explicitly_requested ... ok
+test tests::execution_cost_overrides_strategy_spec_for_runner ... ok
+test tests::execution_dynamic_slippage_overrides_strategy_spec_for_runner ... ok
+test tests::execution_matching_type_overrides_strategy_spec_for_runner ... ok
+test tests::execution_percent_slippage_alias_normalizes_to_price_ratio ... ok
+test tests::execution_rebalance_cash_mode_overrides_strategy_spec_for_runner ... ok
+test tests::execution_risk_overrides_strategy_spec_for_runner ... ok
+test tests::execution_risk_policy_rejects_conflicting_alias_values ... ok
+test tests::execution_risk_policy_rejects_non_object ... ok
+test tests::execution_risk_policy_rejects_unknown_fields_before_queueing ... ok
+test tests::execution_sell_then_buy_delay_slippage_requires_sell_then_buy_mode ... ok
+test tests::execution_slippage_overrides_strategy_spec_for_runner ... ok
+test tests::execution_top_level_risk_enabled_aliases_are_frozen_into_strategy_spec ... ok
+test tests::explicit_cost_override_removes_old_aliases_and_preserves_zero_minimum ... ok
+test tests::history_query_cache_has_a_bounded_entry_budget ... ok
+test tests::history_search_is_bounded_and_retains_literal_characters ... ok
+test tests::implementation_identity_freezes_source_and_binary_generation ... ok
+test tests::manual_observations_are_run_scoped_and_private_in_the_runner_bundle ... ok
+test tests::minute_execution_matching_type_uses_minute_price_and_rejects_daily_modes ... ok
+test tests::persisted_runtime_projection_never_guesses_missing_frequency ... ok
+test tests::persisted_runtime_projection_retains_minute_mode_and_frozen_bundle ... ok
+test tests::process_event_projection_uses_stable_kind_and_filters ... ok
+test tests::projected_fact_block_cache_key_is_shared_across_run_manifests ... ok
+test tests::public_backtest_projection_removes_internal_paths_recursively ... ok
+test tests::public_event_message_removes_internal_paths ... ok
+test tests::public_result_store_manifest_hides_internal_fact_blocks ... ok
+test tests::public_run_projection_does_not_reintroduce_internal_paths ... ok
+test tests::result_artifact_cache_keeps_shared_fact_blocks_after_run_eviction ... ok
+test tests::result_artifact_cache_rejects_conflicting_reference_for_same_sha ... ok
+test tests::result_block_page_plan_reads_only_overlapping_blocks ... ok
+test tests::runner_strategy_spec_path_prefers_bundle ... ok
+test tests::runtime_frequency_normalizes_and_overrides_strategy_spec_for_runner ... ok
+test tests::runtime_frozen_bundle_is_written_to_strategy_metadata_for_runner ... ok
+test tests::runtime_projection_migration_preserves_frozen_config ... ok
+test tests::runtime_symbols_override_strategy_spec_for_runner ... ok
+test tests::source_lake_preflight_rejects_unsupported_minute_cash_mode ... ok
+test tests::source_lake_run_contract_preflight_freezes_runtime_and_execution ... ok
+test tests::source_lake_runtime_requires_frozen_backtest_bundle_contract ... ok
+test tests::start_backtest_run_rejects_unready_data_source_before_persistence ... ok
+test tests::startup_reconciliation_closes_orphaned_runs_and_records_audit_event ... ok
+test tests::strategy_detail_keeps_strategy_body_without_full_config ... ok
+test tests::strategy_detail_returns_none_without_strategy_body ... ok
+test tests::strategy_expression_preflight_rejects_invalid_dsl_before_data_load ... ok
+test tests::summary_list_projection_keeps_table_metrics_and_removes_detail_payloads ... ok
+test tests::terminal_audit_accepts_deferred_intents_and_checks_the_retained_count ... ok
+test tests::terminal_audit_contract_rejects_missing_or_inconsistent_state ... ok
+test tests::top_level_limits_replace_all_nested_execution_aliases_before_preflight ... ok
+test tests::typed_holding_projection_derives_weight_and_final_snapshot ... ok
+test tests::typed_result_rows_filter_and_paginate_without_json_table_roundtrip ... ok
+test tests::typed_risk_filter_applies_execution_fields ... ok
+test event_stream::tests::replay_buffer_is_bounded_and_completed_streams_are_evicted_without_closing_subscribers ... ok
+test result_analysis_tests::complete_performance_and_paged_equity_share_corrected_drawdown ... ok
+test execution_ledger::tests::combined_pages_filter_before_count_and_keep_native_pages_bounded ... ok
+
+test result: ok. 134 passed; 0 failed; 8 ignored; 0 measured; 0 filtered out; finished in 9.37s
+
+     Running unittests examples/risk_projection_readonly.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/examples/risk_projection_readonly-5f8d5aa4ff515b03)
+
+running 4 tests
+test risk_projection::tests::canonical_null_overrides_all_legacy_aliases_but_real_zero_survives ... ok
+test risk_projection::tests::absent_original_rates_preserve_independent_metrics_without_network_or_zero_rate_claim ... ok
+test risk_projection::tests::unavailable_contract_does_not_relabel_legacy_zero_as_a_verified_statistic ... ok
+test risk_projection::tests::original_contract_reprojects_legacy_zero_and_preserves_cash_flow_facts ... ok
+
+test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+     Running unittests examples/stock_pool_contract_probe.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/examples/stock_pool_contract_probe-e8a8af6fd36ebc70)
+
+running 1 test
+test stock_pool_candidates::tests::resolve_binds_input_and_preserves_empty_automatic_days ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+

docs/evidence/registered-share-delivery-20261005/runner-initial-compile-failure.log

@@ -0,0 +1,302 @@
+   Compiling proc-macro2 v1.0.106
+   Compiling unicode-ident v1.0.24
+   Compiling quote v1.0.45
+   Compiling libc v0.2.185
+   Compiling cfg-if v1.0.4
+   Compiling bytes v1.11.1
+   Compiling pin-project-lite v0.2.17
+   Compiling portable-atomic v1.13.1
+   Compiling version_check v0.9.5
+   Compiling autocfg v1.5.0
+   Compiling syn v2.0.117
+   Compiling typenum v1.20.0
+   Compiling libm v0.2.16
+   Compiling num-traits v0.2.19
+   Compiling once_cell v1.21.4
+   Compiling serde_core v1.0.228
+   Compiling zerocopy v0.8.48
+   Compiling errno v0.3.14
+   Compiling memchr v2.8.0
+   Compiling futures-core v0.3.32
+   Compiling signal-hook-registry v1.4.8
+   Compiling socket2 v0.6.3
+   Compiling mio v1.2.0
+   Compiling itoa v1.0.18
+   Compiling smallvec v1.15.1
+   Compiling serde v1.0.228
+   Compiling log v0.4.29
+   Compiling shlex v1.3.0
+   Compiling find-msvc-tools v0.1.9
+   Compiling futures-sink v0.3.32
+   Compiling stable_deref_trait v1.2.1
+   Compiling generic-array v0.14.7
+   Compiling subtle v2.6.1
+   Compiling cc v1.2.60
+   Compiling futures-channel v0.3.32
+   Compiling tracing-core v0.1.36
+   Compiling getrandom v0.3.4
+   Compiling synstructure v0.13.2
+   Compiling http v1.4.0
+   Compiling slab v0.4.12
+   Compiling futures-io v0.3.32
+   Compiling futures-task v0.3.32
+   Compiling crypto-common v0.1.7
+   Compiling block-buffer v0.10.4
+   Compiling getrandom v0.2.17
+   Compiling httparse v1.10.1
+   Compiling const-oid v0.9.6
+   Compiling percent-encoding v2.3.2
+   Compiling crunchy v0.2.4
+   Compiling digest v0.10.7
+   Compiling http-body v1.0.1
+   Compiling ring v0.17.14
+   Compiling zerocopy-derive v0.8.48
+   Compiling tokio-macros v2.7.0
+   Compiling zerofrom-derive v0.1.7
+   Compiling yoke-derive v0.8.2
+   Compiling tokio v1.52.1
+   Compiling zerofrom v0.1.7
+   Compiling serde_derive v1.0.228
+   Compiling yoke v0.8.2
+   Compiling zerovec-derive v0.11.3
+   Compiling zerovec v0.11.6
+   Compiling tracing-attributes v0.1.31
+   Compiling futures-macro v0.3.32
+   Compiling displaydoc v0.2.5
+   Compiling futures-util v0.3.32
+   Compiling tracing v0.1.44
+   Compiling litemap v0.8.2
+   Compiling tinystr v0.8.3
+   Compiling writeable v0.6.3
+   Compiling tiny-keccak v2.0.2
+   Compiling base64 v0.22.1
+   Compiling icu_locale_core v2.2.0
+   Compiling zerotrie v0.2.4
+   Compiling potential_utf v0.1.5
+   Compiling icu_properties_data v2.2.0
+   Compiling icu_normalizer_data v2.2.0
+   Compiling utf8_iter v1.0.4
+   Compiling zeroize v1.8.2
+   Compiling tower-service v0.3.3
+   Compiling rustls-pki-types v1.14.0
+   Compiling icu_collections v2.2.0
+   Compiling icu_provider v2.2.0
+   Compiling ppv-lite86 v0.2.21
+   Compiling num-integer v0.1.46
+   Compiling rand_core v0.10.1
+   Compiling bitflags v2.11.1
+   Compiling getrandom v0.4.2
+   Compiling try-lock v0.2.5
+   Compiling crc32fast v1.5.0
+   Compiling cpufeatures v0.2.17
+   Compiling untrusted v0.9.0
+   Compiling const-random-macro v0.1.16
+   Compiling want v0.3.1
+   Compiling sync_wrapper v1.0.2
+   Compiling ahash v0.8.12
+   Compiling crossbeam-utils v0.8.21
+   Compiling simd-adler32 v0.3.9
+   Compiling rustls v0.23.38
+   Compiling tower-layer v0.3.3
+   Compiling adler2 v2.0.1
+   Compiling ryu v1.0.23
+   Compiling httpdate v1.0.3
+   Compiling serde_json v1.0.145
+   Compiling atomic-waker v1.1.2
+   Compiling iana-time-zone v0.1.65
+   Compiling hyper v1.9.0
+   Compiling miniz_oxide v0.8.9
+   Compiling chrono v0.4.44
+   Compiling icu_properties v2.2.0
+   Compiling rustls-webpki v0.103.13
+   Compiling const-random v0.1.18
+   Compiling icu_normalizer v2.2.0
+   Compiling num-bigint v0.4.6
+   Compiling form_urlencoded v1.2.2
+   Compiling thiserror v2.0.18
+   Compiling ipnet v2.12.0
+   Compiling idna_adapter v1.2.1
+   Compiling flate2 v1.1.9
+   Compiling hyper-util v0.1.20
+   Compiling num-rational v0.4.2
+   Compiling tower v0.5.3
+   Compiling num-iter v0.1.45
+   Compiling tokio-util v0.7.18
+   Compiling http-body-util v0.1.3
+   Compiling thiserror-impl v2.0.18
+   Compiling num-complex v0.4.6
+   Compiling compression-core v0.4.32
+   Compiling rustversion v1.0.22
+   Compiling hashbrown v0.16.1
+   Compiling num v0.4.3
+   Compiling compression-codecs v0.4.38
+   Compiling crossbeam-epoch v0.9.18
+   Compiling idna v1.1.0
+   Compiling serde_urlencoded v0.7.1
+   Compiling sha1 v0.10.6
+   Compiling tokio-rustls v0.26.4
+   Compiling webpki-roots v1.0.7
+   Compiling half v2.7.1
+   Compiling smartstring v1.0.1
+   Compiling rayon-core v1.13.0
+   Compiling zmij v1.0.23
+   Compiling static_assertions v1.1.0
+   Compiling iri-string v0.7.12
+   Compiling semver v1.0.28
+   Compiling lazy_static v1.5.0
+   Compiling arrow-buffer v56.2.1
+   Compiling rustc_version v0.4.1
+   Compiling hyper-rustls v0.27.9
+   Compiling url v2.5.8
+   Compiling crossbeam-deque v0.8.6
+   Compiling async-compression v0.4.42
+   Compiling tower-http v0.6.8
+   Compiling sha2 v0.10.9
+   Compiling async-trait v0.1.89
+   Compiling rand_core v0.6.4
+   Compiling hybrid-array v0.4.10
+   Compiling rust_decimal v1.39.0
+   Compiling anyhow v1.0.102
+   Compiling utf8parse v0.2.2
+   Compiling arrow-schema v56.2.1
+   Compiling regex-syntax v0.8.10
+   Compiling anstyle-parse v1.0.0
+   Compiling reqwest v0.12.24
+   Compiling rand_chacha v0.3.1
+   Compiling arrow-data v56.2.1
+   Compiling castaway v0.2.4
+   Compiling regex-automata v0.4.14
+   Compiling flatbuffers v25.12.19
+   Compiling rhai_codegen v3.1.0
+   Compiling tikv-jemalloc-sys v0.7.1+5.3.1-0-g81034ce1f1373e37dc865038e1bc8eeecf559ce8
+   Compiling is_terminal_polyfill v1.70.2
+   Compiling arrayvec v0.7.8
+   Compiling anstyle v1.0.14
+   Compiling colorchoice v1.0.5
+   Compiling cmov v0.5.3
+   Compiling either v1.15.0
+   Compiling equivalent v1.0.2
+   Compiling anstyle-query v1.1.5
+   Compiling ta-lib-dispatch v0.1.2 (https://github.com/TA-Lib/ta-lib.git?rev=dd5a90259a3f9e04e2da9f38bf0719a841b40108#dd5a9025)
+   Compiling thin-vec v0.2.16
+   Compiling anstream v1.0.0
+   Compiling ta-lib v0.8.1 (https://github.com/TA-Lib/ta-lib.git?rev=dd5a90259a3f9e04e2da9f38bf0719a841b40108#dd5a9025)
+   Compiling rhai v1.23.6
+   Compiling matchers v0.2.0
+   Compiling indexmap v2.11.4
+   Compiling rayon v1.12.0
+   Compiling ctutils v0.4.2
+   Compiling compact_str v0.10.0
+   Compiling arrow-array v56.2.1
+   Compiling rand v0.8.6
+   Compiling crypto-common v0.2.1
+   Compiling block-buffer v0.12.0
+   Compiling sharded-slab v0.1.7
+   Compiling hmac v0.12.1
+   Compiling tracing-log v0.2.0
+   Compiling thread_local v1.1.9
+   Compiling nu-ansi-term v0.50.3
+   Compiling const-oid v0.10.2
+   Compiling fastrand v2.4.1
+   Compiling clap_lex v1.1.0
+   Compiling twox-hash v2.1.3
+   Compiling hex v0.4.3
+   Compiling strsim v0.11.1
+   Compiling home v0.5.12
+   Compiling heck v0.5.0
+   Compiling clap_derive v4.6.1
+   Compiling reqsign v0.16.5
+   Compiling clap_builder v4.6.0
+   Compiling lz4_flex v0.11.6
+   Compiling backon v1.6.0
+   Compiling digest v0.11.2
+   Compiling tracing-subscriber v0.3.23
+   Compiling fidc-core v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-1fa73bb/fidc-backtest-engine/crates/fidc-core)
+   Compiling arrow-select v56.2.1
+   Compiling uuid v1.23.1
+   Compiling futures v0.3.32
+   Compiling quick-xml v0.36.2
+   Compiling md-5 v0.10.6
+   Compiling rmp v0.8.15
+   Compiling flagset v0.4.7
+   Compiling dotenvy v0.15.7
+   Compiling cpufeatures v0.3.0
+   Compiling tinyvec_macros v0.1.1
+   Compiling tinyvec v1.11.0
+   Compiling fidc-common v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-1fa73bb/fidc-backtest-service/crates/fidc-common)
+   Compiling opendal v0.50.2
+   Compiling rmp-serde v1.3.1
+   Compiling arrow-ipc v56.2.1
+   Compiling clap v4.6.1
+   Compiling bincode v1.3.3
+   Compiling memmap2 v0.9.11
+   Compiling unicode-normalization v0.1.25
+   Compiling chacha20 v0.10.0
+   Compiling rand_core v0.9.5
+   Compiling unicode-properties v0.1.4
+   Compiling parking_lot_core v0.9.12
+   Compiling unicode-bidi v0.3.18
+   Compiling stringprep v0.1.5
+   Compiling rand_chacha v0.9.0
+   Compiling rand v0.10.1
+   Compiling sha2 v0.11.0
+   Compiling hmac v0.13.0
+   Compiling md-5 v0.11.0
+   Compiling fallible-iterator v0.2.0
+   Compiling scopeguard v1.2.0
+   Compiling byteorder v1.5.0
+   Compiling siphasher v1.0.2
+   Compiling phf_shared v0.13.1
+   Compiling postgres-protocol v0.6.11
+   Compiling lock_api v0.4.14
+   Compiling rand v0.9.4
+   Compiling data-encoding v2.11.1
+   Compiling parking_lot v0.12.5
+   Compiling tungstenite v0.29.0
+   Compiling postgres-types v0.2.13
+   Compiling phf v0.13.1
+   Compiling deadpool-runtime v0.1.4
+   Compiling num_cpus v1.17.0
+   Compiling whoami v2.1.1
+   Compiling mime v0.3.17
+   Compiling axum-core v0.5.6
+   Compiling tokio-postgres v0.7.17
+   Compiling fidc-signal-client v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-1fa73bb/fidc-backtest-engine/crates/fidc-signal-client)
+   Compiling deadpool v0.12.3
+   Compiling tokio-tungstenite v0.29.0
+   Compiling async-stream-impl v0.3.6
+   Compiling serde_path_to_error v0.1.20
+   Compiling matchit v0.8.4
+   Compiling async-stream v0.3.6
+   Compiling axum v0.8.9
+   Compiling deadpool-postgres v0.14.1
+   Compiling tikv-jemallocator v0.7.0
+   Compiling fidc-backtest-runner v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-1fa73bb/fidc-backtest-service/services/backtest_runner)
+error[E0425]: cannot find function `decode_source_lake_corporate_actions_arrow` in this scope
+     --> services/backtest_runner/src/backtest.rs:25124:20
+      |
+25124 |           let rows = decode_source_lake_corporate_actions_arrow(&body).unwrap();
+      |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+...
+39780 | / fn decode_source_lake_source_rows_arrow(
+39781 | |     body: &[u8],
+39782 | |     validate_adjustment_factor: bool,
+39783 | | ) -> Result<Vec<SourceRowRecord>> {
+...     |
+39801 | |     Ok(rows)
+39802 | | }
+      | |_- similarly named function `decode_source_lake_source_rows_arrow` defined here
+      |
+help: a function with a similar name exists
+      |
+25124 -         let rows = decode_source_lake_corporate_actions_arrow(&body).unwrap();
+25124 +         let rows = decode_source_lake_source_rows_arrow(&body).unwrap();
+      |
+help: consider importing this function
+      |
+20351 +     use crate::backtest::decode_source_lake_corporate_actions_arrow;
+      |
+
+For more information about this error, try `rustc --explain E0425`.
+error: could not compile `fidc-backtest-runner` (lib test) due to 1 previous error
+warning: build failed, waiting for other jobs to finish...

docs/evidence/registered-share-delivery-20261005/runner-successor-pair-success.log

@@ -0,0 +1,678 @@
+   Compiling fidc-core v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-ce46c13/fidc-backtest-engine/crates/fidc-core)
+   Compiling fidc-common v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-ce46c13/fidc-backtest-service/crates/fidc-common)
+   Compiling fidc-signal-client v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-ce46c13/fidc-backtest-engine/crates/fidc-signal-client)
+   Compiling fidc-backtest-runner v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-ce46c13/fidc-backtest-service/services/backtest_runner)
+   Compiling fidc-backtest-service v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-ce46c13/fidc-backtest-service/services/api)
+    Finished `test` profile [unoptimized] target(s) in 41.16s
+     Running unittests src/lib.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/deps/fidc_backtest_runner-01cc3db11a686fbb)
+
+running 483 tests
+test backtest::columnar_factor_overlay_tests::cache_range_rejects_date_disorder_outside_the_binary_search_slice ... ok
+test backtest::columnar_factor_overlay_tests::cache_range_rejects_symbol_disorder_outside_the_requested_date ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_real_cache_value_equivalence ... ignored, requires a frozen private Boris real-data cache directory on 177
+test backtest::columnar_factor_overlay_tests::columnar_overlay_missing_or_stale_cache_does_not_mutate_base ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_rejects_duplicate_window_boundary ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_rejects_duplicate_order_and_count_mismatches ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_rejects_market_projection_and_invalid_cached_column_type ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_rejects_late_key_mismatch_before_any_base_mutation ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_replaced_file_invalidates_view_without_mutating_pinned_input ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_unknown_keys_are_not_hidden_as_empty_values ... ok
+test backtest::columnar_factor_overlay_tests::row_visitor_preserves_selected_offsets_and_late_validation_errors ... ok
+test backtest::compact_storage_tests::batch_bound_factor_columns_preserve_types_nulls_and_nonfinite_values ... ok
+test backtest::columnar_factor_overlay_tests::valid_cache_reuses_its_key_index_and_failed_indexes_are_not_published ... ok
+test backtest::compact_storage_tests::inline_symbols_and_factor_maps_preserve_binary_and_json_contracts ... ok
+test backtest::day_snapshot_builder::tests::a_failed_builder_cannot_publish_earlier_valid_rows ... ok
+test backtest::day_snapshot_builder::tests::factor_reservation_keeps_missing_and_overwrite_semantics ... ok
+test backtest::day_snapshot_builder::tests::late_source_validation_failure_invalidates_the_streamed_day ... ok
+test backtest::equity_lifecycle_metadata_tests::empty_quotes_require_full_interval_lifecycle_proof_not_a_latest_status ... ok
+test backtest::equity_lifecycle_metadata_tests::lifecycle_cash_days_keep_real_benchmark_without_fabricated_security_rows ... ok
+test backtest::equity_lifecycle_metadata_tests::missing_identity_and_dates_do_not_become_active_securities ... ok
+test backtest::execution_config_tests::capacity_preflight_requires_explicit_daily_assumptions_without_changing_risk_switches ... ok
+test backtest::execution_config_tests::component_execution_quotes_seed_uses_latest_intraday_quote_before_target_time ... ok
+test backtest::execution_config_tests::current_close_respects_explicitly_disabled_liquidity_limit ... ok
+test backtest::execution_config_tests::daily_current_close_preserves_the_strategy_decision_clock ... ok
+test backtest::execution_config_tests::daily_execution_price_request_serializes_date_symbol_filter_scope ... ok
+test backtest::execution_config_tests::daily_execution_projection_keeps_benchmark_narrow_and_trade_risk_complete ... ok
+test backtest::execution_config_tests::data_intraday_snapshot_time_is_strategy_spec_driven ... ok
+test backtest::execution_config_tests::dataset_signature_rejects_source_lake_without_frozen_backtest_bundle ... ok
+test backtest::day_snapshot_builder::tests::arrow_rows_build_the_same_final_snapshots_without_a_row_collection ... ok
+test backtest::execution_config_tests::dataset_signature_scopes_dynamic_model_score_source_rows ... ok
+test backtest::execution_config_tests::default_matching_type_follows_backtest_frequency ... ok
+test backtest::execution_config_tests::dataset_signature_scopes_backtest_data_bundle_source_rows ... ok
+test backtest::execution_config_tests::dynamic_model_score_execution_quotes_are_lazy_by_default ... ok
+test backtest::execution_config_tests::dynamic_model_score_rank_does_not_extract_fixed_signal_symbols ... ok
+test backtest::execution_config_tests::execution_quote_prefilter_keeps_previous_factor_rows_in_current_band ... ok
+test backtest::execution_config_tests::execution_quote_prefilter_prefers_runtime_market_cap_slope ... ok
+test backtest::execution_config_tests::execution_quote_query_times_follow_strategy_trade_times ... ok
+test backtest::execution_config_tests::execution_quote_prefilter_keeps_candidates_beyond_legacy_limit ... ok
+test backtest::execution_config_tests::execution_top_level_fee_overrides_nested_risk_policy_cost ... ok
+test backtest::execution_config_tests::execution_top_level_volume_percent_overrides_nested_risk_policy ... ok
+test backtest::execution_config_tests::extract_score_context_does_not_extract_fixed_signal_symbols ... ok
+test backtest::execution_config_tests::factor_keys_use_compact_storage_without_changing_names ... ok
+test backtest::execution_config_tests::fixed_signal_model_score_scope_does_not_validate_candidate_limit ... ok
+test backtest::execution_config_tests::fixed_signal_symbol_scope_preserves_explicit_empty_targets ... ok
+test backtest::execution_config_tests::full_minute_event_stream_uses_subscriptions_instead_of_point_snapshot ... ok
+test backtest::execution_config_tests::minute_session_bounds_extend_only_after_post_close_rule_effective_date ... ok
+test backtest::execution_config_tests::model_score_source_rows_scope_evidence_verifies_candidate_limit ... ok
+test backtest::execution_config_tests::model_score_source_rows_scope_rejects_unbounded_rows ... ok
+test backtest::execution_config_tests::native_next_open_pool_loads_causal_quotes_without_exposing_them_to_selection ... ok
+test backtest::execution_config_tests::narrow_overlay_projection_does_not_retain_a_wide_value_buffer ... ok
+test backtest::execution_config_tests::owned_date_group_producers_drop_every_input_exactly_once_on_failure ... ok
+test backtest::execution_config_tests::owned_trade_day_preparation_matches_borrowed_rows ... ok
+test backtest::execution_config_tests::parse_matching_type_limits_global_backtest_matching_modes ... ok
+test backtest::execution_config_tests::parse_slippage_model_supports_explicit_historical_model ... ok
+test backtest::execution_config_tests::parse_slippage_model_supports_limit_price ... ok
+test backtest::execution_config_tests::platform_daily_factor_strategy_uses_lazy_execution_quotes_by_default ... ok
+test backtest::execution_config_tests::platform_execution_quote_carry_can_include_recent_candidates ... ok
+test backtest::execution_config_tests::platform_execution_quote_carry_does_not_let_candidates_evict_recent_orders ... ok
+test backtest::execution_config_tests::platform_execution_quote_carry_keeps_today_candidates_without_candidate_carry ... ok
+test backtest::execution_config_tests::platform_execution_quote_carry_prefers_recent_candidates_before_today_candidates ... ok
+test backtest::execution_config_tests::platform_execution_quote_carry_prioritizes_order_symbols ... ok
+test backtest::execution_config_tests::platform_execution_quote_default_carry_keeps_large_recent_candidate_set ... ok
+test backtest::execution_config_tests::platform_execution_route_requires_runtime_contract ... ok
+test backtest::execution_config_tests::platform_runtime_snapshot_preserves_typed_time_in_force ... ok
+test backtest::execution_config_tests::parallel_owned_date_groups_keep_exact_rows_and_owned_factor_allocations ... ok
+test backtest::execution_config_tests::platform_strategy_config_rejects_loose_value_budget_without_panicking ... ok
+test backtest::execution_config_tests::platform_strategy_config_uses_same_intraday_time_as_broker ... ok
+test backtest::execution_config_tests::prepare_trade_day_candidate_market_cap_falls_back_to_total_market_cap ... ok
+test backtest::execution_config_tests::prepare_trade_day_daily_selection_price_uses_close_without_limit_allow_flags ... ok
+test backtest::execution_config_tests::prepare_trade_day_does_not_build_execution_quote_from_daily_fallback ... ok
+test backtest::execution_config_tests::prepare_trade_day_keeps_allow_buy_when_missing_field_is_not_buy_relevant ... ok
+test backtest::execution_config_tests::prepare_trade_day_keeps_daily_volume_when_snapshot_has_intraday_volume ... ok
+test backtest::execution_config_tests::prepare_trade_day_keeps_external_signal_warmup_day ... ok
+test backtest::execution_config_tests::prepare_trade_day_keeps_missing_risk_facts_when_runtime_filters_are_disabled ... ok
+test backtest::execution_config_tests::prepare_trade_day_keeps_st_and_star_st_flags_independent ... ok
+test backtest::execution_config_tests::prepare_trade_day_preserves_missing_daily_volume_contract ... ok
+test backtest::execution_config_tests::prepare_trade_day_preserves_zero_ask_from_intraday_snapshot ... ok
+test backtest::execution_config_tests::prepare_trade_day_records_all_missing_risk_facts_independent_of_policy ... ok
+test backtest::execution_config_tests::raw_yuan_market_cap_normalizes_to_100m_units ... ok
+test backtest::execution_config_tests::resolve_dividend_reinvestment_defaults_false_and_reads_engine_flag ... ok
+test backtest::execution_config_tests::resolve_execution_config_does_not_allow_overspending_value_budget ... ok
+test backtest::execution_config_tests::resolve_execution_config_enables_strict_value_budget_by_default ... ok
+test backtest::execution_config_tests::resolve_execution_config_keeps_explicit_liquidity_quote_limit ... ok
+test backtest::execution_config_tests::resolve_execution_config_distinguishes_timed_daily_current_close ... ok
+test backtest::execution_config_tests::resolve_execution_config_keeps_explicit_same_day_buy_mark_override ... ok
+test backtest::execution_config_tests::resolve_execution_config_keeps_explicit_snapshot_volume_limit ... ok
+test backtest::execution_config_tests::resolve_execution_config_keeps_selection_risk_off_by_default ... ok
+test backtest::execution_config_tests::resolve_execution_config_keeps_volume_limit_for_snapshot_minute_last_by_default ... ok
+test backtest::execution_config_tests::resolve_execution_config_maps_daily_next_open ... ok
+test backtest::execution_config_tests::resolve_execution_config_maps_minute_last_to_minute_price ... ok
+test backtest::execution_config_tests::resolve_execution_config_maps_rebalance_cash_mode_and_forces_minute ... ok
+test backtest::execution_config_tests::resolve_execution_config_preserves_zero_minimum_commission ... ok
+test backtest::execution_config_tests::resolve_execution_config_reads_nested_risk_policy ... ok
+test backtest::execution_config_tests::resolve_execution_config_rejects_delay_slippage_outside_sell_then_buy ... ok
+test backtest::execution_config_tests::resolve_execution_config_rejects_vwap_as_global_matching_type ... ok
+test backtest::execution_config_tests::resolve_execution_config_uses_explicit_market_rules_without_profile ... ok
+test backtest::execution_config_tests::resolve_execution_config_uses_latest_trade_time_as_main_schedule ... ok
+test backtest::execution_config_tests::resolve_execution_config_uses_runtime_schedule_time_for_minute_execution ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_preserves_static_universe_contract ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_preserves_weak_market_threshold ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_reads_delayed_limit_open_exit ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_reads_release_slot_on_exit_signal ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_reads_trading_schedule ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_reads_trading_stage ... ok
+test backtest::execution_config_tests::retired_slippage_and_invalid_coefficients_never_become_no_slippage ... ok
+test backtest::execution_config_tests::risk_policy_alias_normalization_preserves_matching_values ... ok
+test backtest::execution_config_tests::risk_policy_alias_normalization_rejects_conflicting_values ... ok
+test backtest::execution_config_tests::runtime_selection_intraday_quote_detection_reads_quote_fields_only ... ok
+test backtest::execution_config_tests::reused_candidate_plan_panel_matches_full_intraday_market_materialization ... ok
+test backtest::execution_config_tests::sorted_overlay_keeps_unchanged_zero_bits_and_counts_only_changed_rows ... ok
+test backtest::execution_config_tests::sorted_overlay_transfers_owned_factor_storage_without_changing_bits ... ok
+test backtest::execution_config_tests::sorted_source_row_insertion_preserves_existing_duplicate_order ... ok
+test backtest::execution_config_tests::sorted_sparse_overlay_merge_falls_back_for_duplicate_keys ... ok
+test backtest::execution_config_tests::sorted_sparse_overlay_merge_preserves_order_and_unmatched_rows ... ok
+test backtest::execution_config_tests::source_lake_backtest_bundle_context_requires_complete_metadata ... ok
+test backtest::execution_config_tests::source_lake_execution_price_requests_keep_compact_schema ... ok
+test backtest::execution_config_tests::source_lake_market_cap_keeps_current_decision_date_value ... ok
+test backtest::execution_config_tests::source_lake_market_cap_uses_current_decision_date_snapshot ... ok
+test backtest::execution_config_tests::source_lake_model_score_context_allows_plain_rotation_without_model_score ... ok
+test backtest::execution_config_tests::source_lake_model_score_context_accepts_complete_inferred_scope ... ok
+test backtest::execution_config_tests::source_lake_model_score_context_rejects_dynamic_mode_without_source_label_or_scope ... ok
+test backtest::execution_config_tests::source_lake_model_score_context_rejects_partial_scope ... ok
+test backtest::execution_config_tests::source_lake_model_score_context_rejects_sparse_ref_without_scope ... ok
+test backtest::execution_config_tests::source_lake_request_keeps_dynamic_model_score_as_all_market_with_score_context ... ok
+test backtest::execution_config_tests::source_lake_request_keeps_explicit_empty_symbols_empty ... ok
+test backtest::execution_config_tests::source_lake_request_scopes_fixed_signal_symbols_and_keeps_compact_schema ... ok
+test backtest::execution_config_tests::source_lake_request_serializes_date_symbol_filter_scope ... ok
+test backtest::execution_config_tests::source_lake_source_rows_uses_current_row_decision_safe_prev_factor_mode ... ok
+test backtest::execution_config_tests::source_row_adjustment_factor_decode_accepts_positive_finite_values ... ok
+test backtest::execution_config_tests::source_row_adjustment_factor_decode_allows_paused_rows_without_close ... ok
+test backtest::execution_config_tests::source_row_adjustment_factor_decode_rejects_missing_or_invalid_values ... ok
+test backtest::execution_config_tests::source_row_adjustment_factor_decode_rejects_paused_rows_with_close ... ok
+test backtest::execution_config_tests::source_row_cache_and_filter_distinguish_all_from_explicit_empty_symbols ... ok
+test backtest::execution_config_tests::source_row_adjustment_factor_decode_skips_unrequested_projection ... ok
+test backtest::execution_config_tests::source_row_daily_capacity_is_scoped_to_actual_insertion_dates ... ok
+test backtest::execution_config_tests::source_row_grouping_copies_date_keys_only_at_boundaries ... ok
+test backtest::execution_config_tests::source_row_missing_open_does_not_mark_candidate_as_one_yuan ... ok
+test backtest::execution_config_tests::source_row_model_score_context_accepts_extract_only_score_metadata ... ok
+test backtest::execution_config_tests::source_row_model_score_context_can_disable_candidate_limit_inference ... ok
+test backtest::execution_config_tests::source_row_model_score_context_infers_candidate_limit_from_selection_limit ... ok
+test backtest::execution_config_tests::source_row_model_score_context_merges_bundle_extract_and_scopes_cache ... ok
+test backtest::execution_config_tests::source_row_daily_capacity_keeps_supplemental_inserts_in_place ... ok
+test backtest::execution_config_tests::source_row_projection_does_not_require_adjustment_factor_for_volume_only_rolling ... ok
+test backtest::execution_config_tests::source_row_projection_includes_amount_for_stock_amount_expressions ... ok
+test backtest::execution_config_tests::source_row_projection_keeps_select_all_for_generic_empty_factor_refs ... ok
+test backtest::execution_config_tests::source_row_projection_keeps_source_lake_empty_factor_refs_narrow ... ok
+test backtest::execution_config_tests::source_row_projection_keeps_source_lake_without_strategy_spec_narrow ... ok
+test backtest::execution_config_tests::source_row_projection_splits_sparse_model_score_factor_refs ... ok
+test backtest::execution_config_tests::source_row_projection_uses_framework_rolling_inputs ... ok
+test backtest::execution_config_tests::source_row_sort_preserves_published_order_and_stably_repairs_merges ... ok
+test backtest::execution_config_tests::source_row_projection_uses_raw_market_columns_for_framework_rollings ... ok
+test backtest::execution_config_tests::source_rows_query_engine_is_validated_and_scopes_cache_epoch ... ok
+test backtest::execution_config_tests::source_rows_scope_evidence_preserves_unordered_date_counts ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_dates_exclude_warmup_rows ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_keeps_named_score_when_context_uses_default_score ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_merges_only_requested_extra_factors ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_query_windows_are_chunked_by_date_span ... ok
+test backtest::execution_config_tests::source_warmup_uses_required_trading_windows ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_skips_primary_score_columns ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_reuses_source_row_cache_without_http ... ok
+test backtest::execution_config_tests::stock_cost_model_for_execution_uses_explicit_fee_overrides ... ok
+test backtest::execution_config_tests::sparse_overlay_skips_source_lake_when_scoped_date_symbol_filter_is_empty ... ok
+test backtest::execution_config_tests::strategy_execution_top_level_risk_enabled_aliases_are_applied ... ok
+test backtest::execution_config_tests::strategy_risk_policy_accepts_camel_case_fields ... ok
+test backtest::execution_config_tests::supplemental_execution_key_index_only_materializes_requested_symbols ... ok
+test backtest::execution_config_tests::strategy_factory_model_rank_rotation_keeps_explicit_execution_contract ... ok
+test backtest::execution_config_tests::timed_daily_current_close_loads_the_intraday_decision_snapshot ... ok
+test backtest::execution_config_tests::top_level_execution_limits_override_nested_risk_policy_defaults ... ok
+test backtest::execution_config_tests::unique_source_row_trade_dates_preserves_sorted_and_unordered_inputs ... ok
+test backtest::execution_config_tests::unsupported_backtest_frequency_is_rejected ... ok
+test backtest::execution_config_tests::validated_source_limit_prices_allows_explicit_no_limit_stock ... ok
+test backtest::execution_config_tests::validated_source_limit_prices_allows_index_without_limits ... ok
+test backtest::execution_config_tests::validated_source_limit_prices_allows_paused_stock_without_limits ... ok
+test backtest::execution_config_tests::validated_source_limit_prices_rejects_missing_stock_limit ... ok
+test backtest::execution_config_tests::validated_source_limit_prices_trusts_source_limits ... ok
+test backtest::factor_history_calendar_tests::history_uses_actual_sessions_and_rejects_short_or_future_calendars ... ok
+test backtest::factor_history_calendar_tests::contextual_pattern_expands_data_scope_but_not_candidate_members ... ok
+test backtest::factor_history_calendar_tests::index_policy_preloads_its_reference_without_widening_the_candidate_universe ... ok
+test backtest::factor_history_calendar_tests::selection_buy_permission_carries_its_complete_pattern_window ... ok
+test backtest::fund_metadata::tests::day_preparation_distinguishes_etf_optional_risk_from_missing_prices ... ok
+test backtest::fund_metadata::tests::etf_metadata_binds_identity_dates_and_units ... ok
+test backtest::fund_metadata::tests::real_etf_fallback_fills_match_source_opens_dates_and_fee_budgets ... ignored, requires exact frontend-compiled frozen Source Lake ETF replay artifacts
+test backtest::fund_metadata::tests::real_mixed_prices_preserve_holdings_until_explicit_zero_allocation ... ignored, requires FIDC_FUND_REPLAY_PREFIX containing read-only real Source Arrow fixtures
+test backtest::fund_metadata::tests::real_source_arrow_preserves_etf_identity_and_detects_tampering ... ignored, requires FIDC_FUND_METADATA_TEST_ARROW from the read-only real Source probe
+test backtest::fund_metadata::tests::preliminary_candidate_panel_uses_verified_etf_rules_without_inventing_limits ... ok
+test backtest::manual_data_scope::tests::explicit_data_scope_can_expand_without_mutating_the_strategy_or_empty_pool ... ok
+test backtest::manual_data_scope::tests::dataset_cache_tracks_extra_market_demand_not_manual_price_or_execution_identity ... ok
+test backtest::prepared_source_row::tests::all_supported_numeric_types_keep_the_existing_conversion_and_null_policy ... ok
+test backtest::prepared_source_row::tests::arbitrary_slices_and_supplemental_rows_keep_symbol_order ... ok
+test backtest::prepared_source_row::tests::finite_values_keep_exact_float_bits_and_metadata ... ok
+test backtest::prepared_source_row::tests::invalid_json_is_not_hidden_by_a_consumer_that_needs_no_factors ... ok
+test backtest::prepared_source_row::tests::json_typed_duplicates_and_projected_overlay_preserve_overwrite_order ... ok
+test backtest::prepared_source_row::tests::actual_arrow_day_uses_columnar_rows_and_matches_owned_final_snapshots ... ok
+test backtest::prepared_source_row::tests::nonfinite_price_policy_does_not_mutate_original_arrow_values ... ok
+test backtest::prepared_source_row::tests::schema_error_precedence_and_null_keys_are_preserved ... ok
+test backtest::prepared_source_row::tests::overlay_cannot_relax_base_adjustment_validation ... ok
+test backtest::risk_free_rate_cache_identity_includes_bundle_and_full_calendar ... ok
+test backtest::risk_free_rate_cache_round_trips_validated_contract ... ok
+test backtest::saved_risk_cache::tests::saved_reference_cancelled_reader_does_not_leave_a_claim ... ok
+test backtest::saved_risk_cache::tests::saved_reference_identity_includes_endpoint_hash_and_calendar ... ok
+test backtest::saved_risk_reference_requires_original_content_not_only_server_claimed_hash ... ok
+test backtest::source_query_windows::tests::actual_cached_boundaries_are_kept_and_gaps_are_covered ... ok
+test backtest::source_query_windows::tests::all_days_remain_once_and_scope_count_is_bounded ... ok
+test backtest::source_query_windows::tests::discovery_never_crosses_source_keys_schemas_or_file_types ... ok
+test backtest::source_query_windows::tests::overlap_prefers_more_covered_days_then_fewer_windows ... ok
+test backtest::source_query_windows::tests::projection_and_symbol_scope_have_distinct_boundary_keys ... ok
+test backtest::saved_risk_cache::tests::saved_reference_coalesces_only_validated_original_contracts ... ok
+test backtest::source_query_windows::tests::uncached_gaps_keep_the_existing_calendar_anchor ... ok
+test backtest::source_row_key_index::tests::indexed_date_ranges_cover_days_split_across_batches ... ok
+test backtest::source_row_key_index::tests::normalized_keys_cannot_duplicate_across_batches ... ok
+test backtest::source_row_key_index::tests::null_identity_and_declared_count_mismatch_are_rejected ... ok
+test backtest::source_row_query_purpose_tests::factor_overlay_cache_identity_cannot_be_reused_as_market_facts ... ok
+test backtest::source_row_query_purpose_tests::factor_overlay_merge_preserves_every_base_market_and_risk_fact ... ok
+test backtest::source_row_query_purpose_tests::factor_overlay_requires_an_explicit_non_market_projection ... ok
+test backtest::source_row_query_purpose_tests::only_explicit_factor_overlays_omit_redundant_risk_columns ... ok
+test backtest::source_rows_columnar::tests::cache_write_failure_does_not_replace_the_current_columnar_input ... ok
+test backtest::source_rows_columnar::tests::actual_selection_and_empty_outputs_do_not_keep_unused_factor_columns ... ok
+test backtest::source_rows_columnar::tests::columnar_normalization_matches_mixed_values_json_aliases_and_sorting ... ok
+test backtest::source_rows_columnar::tests::invalid_keys_and_adjustment_are_rejected_before_selection ... ok
+test backtest::source_rows_columnar::tests::malformed_json_and_dependency_identity_are_not_accepted ... ok
+test backtest::source_rows_columnar::tests::non_cacheable_json_factor_names_keep_the_real_record_path ... ok
+test backtest::source_rows_columnar::tests::normalized_duplicate_symbols_are_not_deduplicated ... ok
+test backtest::source_rows_input_tests::cache_cannot_include_rows_outside_its_declared_date_range ... ok
+test backtest::source_rows_input_tests::cache_write_failure_retains_the_real_window_and_empty_windows_do_not_read_old_rows ... ok
+test backtest::source_rows_input_tests::failed_materialization_does_not_turn_the_source_into_an_empty_success ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_crosses_record_batches_and_preserves_key_normalization ... ok
+test backtest::source_rows_input_tests::independent_windows_stay_columnar_until_daily_snapshot_construction ... ok
+test backtest::source_rows_input_tests::mapped_input_can_be_materialized_for_mutating_model_and_publication_overlays ... ok
+test backtest::source_rows_input_tests::invalid_cache_keys_and_overlay_coverage_never_publish_source_input ... ok
+test backtest::source_rows_input_tests::mapped_input_preserves_empty_scopes_and_filters_only_base_rows ... ok
+test backtest::source_rows_input_tests::mixed_window_storage_and_duplicate_boundaries_keep_original_semantics ... ok
+test backtest::source_rows_input_tests::mapped_inventory_and_final_days_match_owned_rows_with_factor_overlays ... ok
+test backtest::source_rows_input_tests::unsuccessful_window_publication_cannot_read_a_previous_cache_file ... ok
+test backtest::terminal_audit_summary_tests::deferred_strategy_warning_is_not_presented_as_a_submitted_order ... ok
+test backtest::terminal_audit_summary_tests::pending_terminal_state_is_explicit_in_summary_warning ... ok
+test backtest::terminal_calendar_tests::delayed_deposit_requires_terminal_calendar_but_zero_day_does_not ... ok
+test backtest::terminal_calendar_tests::scheduled_terminal_calendar_requires_strict_order_and_range ... ok
+test backtest::source_rows_input_tests::separate_arrow_factor_input_preserves_sparse_overlay_values_and_existing_layers ... ok
+test backtest::tests::accounting_allocation_details_do_not_require_or_fabricate_an_order ... ok
+test backtest::tests::all_source_lake_runtime_caches_are_scoped_by_backtest_bundle ... ok
+test backtest::tests::audit_instrument_cache_values_from_request ... ignored, read-only Boris cache comparison with an explicit audit request
+test backtest::tests::benchmark_borrowed_numeric_factor_keys_against_owned_strings ... ignored, manual release-mode allocation benchmark
+test backtest::tests::benchmark_date_symbol_filter_query_range_preserves_index_symbols ... ok
+test backtest::tests::benchmark_query_windows_split_long_source_lake_ranges ... ok
+test backtest::tests::arrow_reader_accepts_lz4_compressed_stream ... ok
+test backtest::tests::benchmark_row_binary_cache_rejects_metadata_mismatch ... ok
+test backtest::tests::benchmark_row_binary_cache_roundtrips_rows ... ok
+test backtest::tests::benchmark_row_cache_ignores_legacy_csv_cache ... ok
+test backtest::tests::benchmark_row_cache_path_scopes_date_symbol_filter ... ok
+test backtest::tests::benchmark_row_cache_path_uses_binary_cache_file ... ok
+test backtest::tests::benchmark_row_candidate_scan_removes_stale_schema_cache ... ok
+test backtest::tests::benchmark_row_covering_cache_reuses_superset_symbols_and_dates ... ok
+test backtest::tests::benchmark_row_partial_cache_rejects_missing_symbol_segment ... ok
+test backtest::tests::benchmark_row_to_source_row_preserves_false_paused_state ... ok
+test backtest::tests::benchmark_row_partial_cache_reports_missing_ranges ... ok
+test backtest::tests::benchmark_row_window_cache_scope_ignores_out_of_window_filter_dates ... ok
+test backtest::tests::benchmark_rows_dedup_after_window_merge ... ok
+test backtest::tests::benchmark_source_row_arrow_bounded_materialization ... ignored, requires FIDC_BT_SOURCE_ROW_VIEW_PROBE_PATH and explicit release-mode invocation
+test backtest::tests::benchmark_source_row_arrow_view_cache ... ignored, requires FIDC_BT_SOURCE_ROW_VIEW_PROBE_PATH and explicit release-mode invocation
+test backtest::tests::bootstrap_missing_quote_repair_keys_keeps_all_actual_order_gaps_without_fills ... ok
+test backtest::tests::bootstrap_missing_quote_repair_keys_keeps_all_after_fills_exist ... ok
+test backtest::tests::benchmark_rows_empty_date_symbol_filter_does_not_reuse_existing_cache ... ok
+test backtest::tests::build_trade_detail_rows_expands_split_fills_by_order_id ... ok
+test backtest::tests::build_trade_detail_rows_omits_canceled_orders_without_fills ... ok
+test backtest::tests::build_trade_detail_rows_matches_fill_when_order_reason_changes ... ok
+test backtest::tests::build_trade_detail_rows_preserves_decision_and_execution_dates ... ok
+test backtest::tests::carry_forward_target_snapshot_keeps_transition_day_then_replaces_positions ... ok
+test backtest::tests::cn_index_symbols_are_not_stock_execution_quote_repair_symbols ... ok
+test backtest::tests::collect_missing_execution_quote_keys_uses_canceled_stock_orders_only ... ok
+test backtest::tests::compact_progress_retains_manual_counts_and_rejects_a_missing_source ... ok
+test backtest::tests::compacted_carry_forward_filter_keeps_window_semantics ... ok
+test backtest::tests::corporate_action_arrow_preserves_the_independent_delivery_date_and_unknown_quantities ... ok
+test backtest::tests::corporate_action_binary_cache_roundtrips_rows ... ok
+test backtest::tests::corporate_action_cache_ignores_legacy_csv_cache ... ok
+test backtest::tests::corporate_action_cache_path_uses_source_lake_provider_epoch ... ok
+test backtest::tests::bundle_validation_observes_dependency_semantic_change_and_revocation_without_ttl ... ok
+test backtest::tests::corporate_action_covering_cache_reuses_superset_scope ... ok
+test backtest::tests::daily_execution_price_arrow_decode_preserves_unpriced_paused_risk_rows ... ok
+test backtest::tests::daily_execution_price_arrow_requires_execution_contract_fields ... ok
+test backtest::tests::daily_execution_scope_membership_is_normalized_once_and_isolated_by_date ... ok
+test backtest::tests::dataset_signature_scopes_fixed_signal_source_rows ... ok
+test backtest::tests::dataset_signature_scopes_fixed_signal_date_symbol_filter_with_model_score ... ok
+test backtest::tests::date_symbol_filter_query_range_carry_forward_keeps_history_prefix ... ok
+test backtest::tests::date_symbol_filter_query_range_exact_keeps_only_window_dates ... ok
+test backtest::tests::date_symbol_filter_query_range_preserves_empty_request ... ok
+test backtest::tests::dataset_signature_uses_data_requirements_not_strategy_identity_or_thresholds ... ok
+test backtest::tests::default_cache_epochs_ignore_local_manifest_directory ... ok
+test backtest::tests::dense_execution_quote_plan_uses_requested_trade_dates_only ... ok
+test backtest::tests::dynamic_model_score_execution_only_queries_next_date_gaps ... ok
+test backtest::tests::dynamic_model_score_execution_skips_rows_present_on_next_full_calendar_date ... ok
+test backtest::tests::dynamic_model_score_execution_symbols_include_candidate_universe_for_lagged_execution ... ok
+test backtest::tests::dynamic_symbol_expression_does_not_enable_fixed_source_scope ... ok
+test backtest::tests::empty_date_symbol_filter_is_empty_request_not_all_market ... ok
+test backtest::tests::equity_artifact_keeps_external_deposit_out_of_return ... ok
+test backtest::tests::equity_projection_orders_facts_and_includes_the_initial_nav_peak ... ok
+test backtest::tests::execution_arrow_does_not_turn_nonfinite_numbers_into_optional_missing_values ... ok
+test backtest::tests::execution_arrow_requires_the_strict_source_contract_even_when_empty ... ok
+test backtest::tests::execution_price_date_symbol_filter_keeps_benchmark_and_prunes_other_targets ... ok
+test backtest::tests::execution_price_only_source_row_marker_round_trips ... ok
+test backtest::tests::execution_quantities_are_exact_integers_not_rounded_floats ... ok
+test backtest::tests::exact_source_row_windows_restore_in_parallel_and_keep_order ... ok
+test backtest::tests::execution_quote_day_binary_cache_invalidates_duplicate_date_symbol ... ok
+test backtest::tests::execution_quote_day_binary_cache_rejects_metadata_mismatch ... ok
+test backtest::tests::execution_quote_day_cache_does_not_persist_empty_negative_result ... ok
+test backtest::tests::execution_quote_day_cache_ignores_legacy_csv_cache ... ok
+test backtest::tests::execution_quote_day_cache_loads_empty_without_provider_url ... ok
+test backtest::tests::execution_quote_day_cache_path_includes_minute_lookback_and_price_rule ... ok
+test backtest::tests::execution_quote_day_cache_path_uses_quote_epoch ... ok
+test backtest::tests::execution_quote_day_cache_path_uses_source_lake_provider_tag ... ok
+test backtest::tests::execution_quote_day_cache_tracks_returned_symbols_only ... ok
+test backtest::tests::execution_quote_prefetch_seed_tracks_negative_symbols ... ok
+test backtest::tests::execution_quote_query_tasks_keep_target_time_symbol_scopes_narrow ... ok
+test backtest::tests::execution_quote_query_tasks_merge_identical_symbol_scopes_for_same_day ... ok
+test backtest::tests::execution_quote_rows_duplicate_date_symbol_is_rejected ... ok
+test backtest::tests::execution_quote_rows_normalize_base_stock_code_symbols ... ok
+test backtest::tests::execution_quote_loader_reads_a_bounded_minute_window_instead_of_a_point_snapshot ... ok
+test backtest::tests::explicit_cli_source_cache_epoch_is_stable_and_provider_scoped ... ok
+test backtest::tests::external_daily_execution_symbols_without_signals_only_queries_benchmark ... ok
+test backtest::tests::external_daily_execution_symbols_skip_signals_already_in_source_rows ... ok
+test backtest::tests::factor_values_arrow_decode_validates_metadata_and_merges_aliases ... ok
+test backtest::tests::fidc_runner_rejects_ficlaw_data_source_rows_table ... ok
+test backtest::tests::factor_values_arrow_decode_rejects_future_data_and_semantic_drift ... ok
+test backtest::tests::fixed_minute_subscriptions_expand_static_daily_data_scope ... ok
+test backtest::tests::fixed_signal_date_symbol_filter_is_disabled_when_static_symbols_are_mixed_in ... ok
+test backtest::tests::fixed_signal_date_symbol_filter_seeds_static_symbols_at_query_start ... ok
+test backtest::tests::fixed_signal_date_symbol_filter_survives_model_score_rank_metadata ... ok
+test backtest::tests::fixed_signal_next_open_exit_scope_keeps_all_prior_unsold_symbols ... ok
+test backtest::tests::fixed_signal_source_row_date_symbol_filter_extracts_dated_weights_only ... ok
+test backtest::tests::fixed_signal_source_row_date_symbol_filter_extracts_target_holding_rows ... ok
+test backtest::tests::fixed_signal_source_row_symbols_extracts_runtime_target_weights_expr ... ok
+test backtest::tests::fixed_signal_source_row_symbols_extracts_single_quoted_runtime_target_weights_expr ... ok
+test backtest::tests::fixed_signal_source_row_symbols_extracts_strategy_metadata_targets ... ok
+test backtest::tests::fixed_signal_source_row_symbols_extracts_target_weight_codes ... ok
+test backtest::tests::fixed_symbol_order_scope_requires_rotation_disabled ... ok
+test backtest::tests::fixed_symbol_orders_seed_exact_intraday_snapshot_keys ... ok
+test backtest::tests::frozen_bundle_identity_http_failure_is_not_a_mutable_epoch_fallback ... ok
+test backtest::tests::full_minute_prefetch_days_respect_total_bar_budget ... ok
+test backtest::tests::futures_source_lake_catalog_requires_all_truth_datasets ... ok
+test backtest::tests::futures_only_runtime_contract_keeps_stock_scope_empty_and_allocates_cash ... ok
+test backtest::tests::instrument_metadata_binary_cache_rejects_metadata_mismatch ... ok
+test backtest::tests::instrument_metadata_binary_cache_roundtrips_rows ... ok
+test backtest::tests::instrument_metadata_cache_ignores_legacy_csv_cache ... ok
+test backtest::tests::instrument_metadata_cache_merges_missing_symbols_incrementally ... ok
+test backtest::tests::instrument_metadata_cache_path_is_scoped_by_historical_window ... ok
+test backtest::tests::instrument_metadata_cache_path_uses_binary_format ... ok
+test backtest::tests::instrument_metadata_request_serializes_historical_source_window_when_present ... ok
+test backtest::tests::intraday_snapshot_binary_cache_rejects_metadata_mismatch ... ok
+test backtest::tests::intraday_snapshot_binary_cache_roundtrips_rows ... ok
+test backtest::tests::intraday_snapshot_cache_ignores_legacy_csv_cache ... ok
+test backtest::tests::intraday_snapshot_cache_path_uses_source_lake_provider_tag ... ok
+test backtest::tests::kcb_board_and_quantity_use_source_classification ... ok
+test backtest::tests::intraday_snapshot_seeds_execution_quotes_and_negative_gaps ... ok
+test backtest::tests::layered_execution_quote_loader_cache_preserves_shared_seed_and_isolates_overlay ... ok
+test backtest::tests::lazy_execution_quote_window_dates_use_trading_calendar_only ... ok
+test backtest::tests::lazy_execution_quote_window_backfill_keeps_future_missing_symbols ... ok
+test backtest::tests::load_strategy_spec_rejects_removed_compatibility_profile ... ok
+test backtest::tests::load_strategy_spec_rejects_removed_engine_profile_name ... ok
+test backtest::tests::malformed_execution_observations_are_errors_not_empty_successes ... ok
+test backtest::tests::malformed_versioned_factor_ref_fails_closed ... ok
+test backtest::tests::managed_source_rows_route_by_exact_table ... ok
+test backtest::tests::minute_bar_arrow_decode_accepts_bounded_multi_date_stream ... ok
+test backtest::tests::load_strategy_spec_accepts_snake_case_bundle_field ... ok
+test backtest::tests::minute_bar_arrow_decode_preserves_timestamp_symbol_order ... ok
+test backtest::tests::minute_bar_arrow_decode_rejects_retired_string_time_schema ... ok
+test backtest::tests::minute_bar_arrow_decode_rejects_duplicate_or_unordered_rows ... ok
+test backtest::tests::mixed_candidate_book_binds_complete_dates_raw_sources_and_resolved_order ... ok
+test backtest::tests::mixed_stock_futures_contract_requires_explicit_futures_cash ... ok
+test backtest::tests::normalize_symbol_maps_bse_exchange_to_beijing_board ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_matches_row_decoder_for_wide_sparse_null_and_signed_zero_values ... ok
+test backtest::tests::minute_bars_retries_transient_http_failure_and_preserves_caller_header ... ok
+test backtest::tests::partial_source_row_window_cache_crops_covering_segments_in_arrow ... ok
+test backtest::tests::partial_source_row_window_cache_ignores_all_market_cache_for_symbol_scope ... ok
+test backtest::tests::partial_source_row_window_cache_ignores_wide_projection_segment ... ok
+test backtest::tests::partial_source_row_window_cache_reports_only_missing_gaps ... ok
+test backtest::tests::progress_callback_is_forwarded_to_blocking_engine_thread ... ok
+test backtest::tests::published_factor_binding_normalizes_ref_and_builds_arrow_request ... ok
+test backtest::tests::query_scope_batch_preserves_authoritative_window_identities ... ok
+test backtest::tests::partial_source_row_window_cache_reuses_exact_projection_with_null_dynamic_columns ... ok
+test backtest::tests::query_scope_identity_reuses_physical_window_across_distinct_bundles ... ok
+test backtest::tests::real_source_quote_json_and_arrow_match_strict_reader ... ignored, requires a bounded real Source JSON/Arrow probe directory
+test backtest::tests::repeated_query_views_share_only_identical_execution_observations ... ok
+test backtest::tests::platform_quote_plan_uses_current_decision_date_source_rows ... ok
+test backtest::tests::query_scope_http_carries_rolling_dependencies_and_rejects_bad_contracts ... ok
+test backtest::tests::select_instrument_metadata_rejects_missing_symbols ... ok
+test backtest::tests::shared_base_source_projection_keeps_raw_adjustment_contract ... ok
+test backtest::tests::shared_base_source_rows_cache_is_enabled_by_default ... ok
+test backtest::tests::shared_base_source_rows_cache_is_only_for_unscoped_raw_rows ... ok
+test backtest::tests::reusable_source_row_window_cache_does_not_reuse_covering_cache ... ok
+test backtest::tests::sorted_source_row_validator_rejects_unordered_or_duplicate_keys ... ok
+test backtest::tests::source_cache_epoch_default_is_independent_from_quote_plan_epoch ... ok
+test backtest::tests::source_dependency_contract_invalidates_all_authoritative_cache_scopes ... ok
+test backtest::tests::segmented_source_row_cache_reads_only_uncovered_overlap_ranges ... ok
+test backtest::tests::short_range_source_query_window_is_explicit_and_keeps_long_ranges_bounded ... ok
+test backtest::tests::source_lake_contract_epoch_ignores_runtime_build_but_tracks_catalog ... ok
+test backtest::tests::source_lake_health_contract_epoch_ignores_runtime_build ... ok
+test backtest::tests::source_lake_arrow_request_retries_bad_gateway ... ok
+test backtest::tests::source_lake_busy_retry_honors_retryable_capacity_response ... ok
+test backtest::tests::source_lake_source_query_retries_are_bounded_and_transient_only ... ok
+test backtest::tests::source_lake_source_query_timeout_accepts_highmem_alias ... ok
+test backtest::tests::source_query_concurrency_defaults_and_clamps ... ok
+test backtest::tests::source_lake_run_waits_for_manifest_publication_and_holds_shared_lease ... ok
+test backtest::tests::source_row_arrow_cache_rejects_and_does_not_write_empty_rows ... ok
+test backtest::tests::source_row_arrow_cache_rejects_duplicate_date_symbol ... ok
+test backtest::tests::source_lake_uses_wider_windows_for_narrow_queries ... ok
+test backtest::tests::source_row_arrow_decode_preserves_dynamic_projection_columns ... ok
+test backtest::tests::source_row_arrow_decode_keeps_compact_base_rows_without_extra_json ... ok
+test backtest::tests::source_row_arrow_dependency_contract_rejects_invalid_metadata ... ok
+test backtest::tests::source_row_arrow_extra_factor_helpers_preserve_projected_columns ... ok
+test backtest::tests::source_row_arrow_view_keeps_mmap_alive_until_materialization ... ok
+test backtest::tests::source_row_arrow_view_cache_reuses_identity_and_invalidates_replacement ... ok
+test backtest::tests::source_row_cache_file_range_parses_source_cache_dates ... ok
+test backtest::tests::source_row_cache_candidate_scan_removes_previous_schema_files ... ok
+test backtest::tests::source_row_cache_directory_index_tracks_files_published_by_other_workers ... ok
+test backtest::tests::source_row_cache_path_hashes_long_projection_columns ... ok
+test backtest::tests::source_row_cache_path_scopes_explicit_source_symbols ... ok
+test backtest::tests::source_row_cache_lease_serializes_concurrent_misses ... ok
+test backtest::tests::source_row_cache_path_normalizes_projection_column_order ... ok
+test backtest::tests::source_row_cache_path_separates_projection_columns ... ok
+test backtest::tests::source_row_cache_projection_check_allows_source_lake_fixed_aliases ... ok
+test backtest::tests::source_row_cache_projection_check_requires_extra_factor_keys ... ok
+test backtest::tests::source_row_cache_rejects_legacy_raw_bincode_without_magic_header ... ok
+test backtest::tests::source_row_cache_segment_selection_prefers_small_complete_windows ... ok
+test backtest::tests::source_row_cache_segment_selection_rejects_incomplete_windows ... ok
+test backtest::tests::source_row_date_windows_keep_interior_buckets_stable_across_ranges ... ok
+test backtest::tests::source_row_date_windows_split_long_ranges ... ok
+test backtest::tests::source_row_date_windows_stay_within_requested_range ... ok
+test backtest::tests::source_row_cache_rejects_metadata_mismatch ... ok
+test backtest::tests::source_row_primary_keys_are_inline_without_growing_the_row_header ... ok
+test backtest::tests::source_row_segment_boundary_validator_preserves_fail_closed_integrity ... ok
+test backtest::tests::source_row_symbol_normalization_preserves_canonical_and_maps_board ... ok
+test backtest::tests::source_row_symbol_scope_epoch_changes_with_fixed_signal_symbols ... ok
+test backtest::tests::source_row_request_cache_epoch_scopes_runtime_query_context ... ok
+test backtest::tests::source_row_cache_writes_arrow_file ... ok
+test backtest::tests::source_rows_duplicate_date_symbol_is_rejected ... ok
+test backtest::tests::source_row_window_cache_scope_ignores_out_of_window_filter_dates ... ok
+test backtest::tests::source_rows_request_keeps_rolling_enabled_for_rolling_projection_columns ... ok
+test backtest::tests::source_rows_unique_date_symbol_passes_without_reordering ... ok
+test backtest::tests::static_universe_include_is_an_explicit_source_row_scope ... ok
+test backtest::tests::source_semantic_change_invalidates_bundle_and_window_cache ... ok
+test backtest::tests::strategy_factor_overlay_only_queries_keys_and_missing_factor_fields ... ok
+test backtest::tests::stock_pool_screen_snapshot_uses_exact_selection_dates_and_full_symbol_history ... ok
+test backtest::tests::strategy_bundle_path_loads_nested_spec_and_signal_scope ... ok
+test backtest::tests::strategy_factor_overlay_rejects_duplicate_and_unordered_keys ... ok
+test backtest::tests::strategy_factor_overlay_requires_exact_base_key_coverage ... ok
+test backtest::tests::strategy_factory_source_lake_provider_name_is_exact ... ok
+test backtest::tests::strategy_factory_source_lake_requires_url_and_matching_provider ... ok
+test backtest::tests::strategy_factory_source_lake_uses_arrow_sized_query_windows_by_default ... ok
+test backtest::tests::trade_display_metadata_cache_rejects_rows_outside_exact_request ... ok
+test backtest::tests::trade_display_metadata_cache_is_bundle_scoped_and_covers_missing_rows ... ok
+test backtest::tests::typed_equity_result_emits_service_schema ... ok
+test backtest::tests::trade_display_metadata_disk_cache_roundtrips_frozen_bundle_rows ... ok
+test backtest::tests::typed_order_result_keeps_zero_fill_orders ... ok
+test backtest::tests::typed_trade_result_preserves_sub_cent_execution_price ... ok
+test backtest::tests::validated_manifest_scope_reuses_cache_across_distinct_bundle_ids ... ok
+test backtest::tests::versioned_factor_binding_rejects_research_scope ... ok
+test backtest::tests::versioned_factor_binding_requires_declared_semantics ... ok
+test backtest::tests::versioned_factor_ref_requires_a_binding ... ok
+test backtest::typed_exit_dependency_tests::ordinary_strategy_partial_exit_also_contributes_its_window ... ok
+test backtest::typed_exit_dependency_tests::typed_stock_pool_exits_contribute_the_full_rolling_window ... ok
+test cache_directory_watch::tests::notifications_cover_publication_rename_delete_and_ignore_unrelated_files ... ok
+test compute_pool_tests::concurrent_embedded_runs_do_not_change_each_others_pool_budget ... ok
+test compute_pool_tests::current_thread_async_runtime_keeps_the_compute_context ... ok
+test backtest::tests::timed_quote_dataset_signature_includes_daily_selection_plan ... ok
+test decision_projection::tests::projection_metadata_alias_empty_fields_and_credential_paths_fail_closed ... ok
+test decision_projection::tests::projection_native_request_is_complete_and_never_truncated_to_top_n ... ok
+test compute_pool_tests::embedded_runner_uses_its_declared_budget_and_preserves_results ... ok
+test decision_projection::tests::projection_response_is_bound_to_source_model_clock_and_exact_population ... ok
+test manual_ledger::corporate_tests::actual_core_corporate_projection_is_preserved_in_the_shared_trade_row ... ok
+test result_store::tests::canonical_first_divergence_reports_json_pointer ... ok
+test result_store::tests::canonical_manifest_is_stable_and_transport_independent ... ok
+test manual_ledger::corporate_tests::corporate_adjustments_reject_forged_money_dates_and_reference_chains ... ok
+test backtest::tests::unused_daily_market_cap_prefilter_does_not_split_identical_input_cache ... ok
+test result_store::tests::fact_manifest_publish_is_idempotent_under_concurrency ... ok
+test result_store::tests::lazy_registration_defers_payload_hashing_to_section_read ... ok
+test result_store::tests::process_event_store_is_content_addressed_and_round_trips ... ok
+test result_store::tests::run_store_identity_keeps_different_data_epochs_separate ... ok
+test result_store::tests::manual_source_and_applications_are_both_hashed_and_persisted ... ok
+test result_store::tests::run_store_is_content_addressed_and_round_trips ... ok
+test result_store::tests::run_store_reads_only_date_overlapping_blocks ... ok
+test thread_cpu::tests::thread_cpu_clock_keeps_unavailable_or_cross_thread_samples_unknown ... ok
+test result_store::tests::run_store_rejects_corrupt_manifest ... ok
+test thread_cpu::tests::sleeping_time_is_not_reported_as_cpu_execution ... ok
+test backtest::source_rows_columnar::tests::columnar_cache_keeps_original_output_batch_boundaries ... ok
+
+test result: ok. 474 passed; 0 failed; 9 ignored; 0 measured; 0 filtered out; finished in 4.24s
+
+     Running unittests src/main.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/deps/fidc_backtest_runner-86f3f46fa8dc66e0)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+     Running tests/allocation_profile.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/deps/allocation_profile-a941e54820726a92)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+     Running unittests examples/export_manual_corporate_evidence.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/examples/export_manual_corporate_evidence-0a5023c51d949afa)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+     Running unittests src/main.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/deps/fidc_backtest_service-4c9243df6eb45c3d)
+
+running 142 tests
+test daily_patterns::tests::column_transport_is_lossless_and_rejects_ambiguous_rows ... ok
+test daily_patterns::tests::arrow_rejects_truncation_and_forged_lengths_before_decoding ... ok
+test event_stream::tests::effective_initial_cash_is_projected_without_guessing_or_losing_source_precision ... ok
+test daily_patterns::tests::daily_patterns_read_only_transport_binds_exact_input ... ok
+test daily_patterns::tests::numeric_mode_requires_the_explicit_read_only_context ... ok
+test event_stream::tests::ordered_batch_is_idempotent_and_changed_facts_do_not_replace_history ... ignored, requires local FIDC_EVENT_TEST_POSTGRES_DSN on the private fidc-auth-pg cluster
+test event_stream::tests::memory_tail_and_durable_prefix_replay_in_publish_order ... ok
+test daily_patterns::tests::arrow_uses_same_kernel_and_exact_byte_proof_with_partial_scope ... ok
+test event_stream::tests::live_sequence_recent_replay_and_concurrent_runs_remain_isolated ... ok
+test execution_ledger::tests::dated_fact_store_rejects_reverse_order_before_projection ... ok
+test execution_ledger::tests::actual_http_routes_return_both_sources_and_precise_manual_values ... ok
+test execution_ledger::tests::serve_browser_fixture ... ignored, starts a local GET-only API for browser acceptance; set FIDC_LEDGER_UI_QA_PORT explicitly
+test execution_ledger::tests::serve_stream_browser_fixture ... ignored, starts isolated real WebSocket/GET handlers; FIDC_LEDGER_STREAM_QA_PORT required
+test execution_ledger::tests::source_precision_ids_and_later_status_are_not_rewritten ... ok
+test execution_ledger::tests::streamed_manual_facts_equal_final_ledger_without_publishing_a_future_terminal ... ok
+test execution_ledger::tests::typed_accounting_rows_keep_origin_without_order_identity ... ok
+test execution_ledger::tests::performance_counts_both_origins_and_sums_authoritative_fees_exactly ... ok
+test factor_events::tests::market_history_binds_kernel_version_and_preserves_unknown_streak ... ok
+test factor_events::tests::no_account_or_execution_payload_is_accepted ... ok
+test factor_events::tests::rank_history_binds_exact_scope_and_input_hash ... ok
+test factor_events::tests::transport_preserves_input_identity_and_rejects_future_values ... ok
+test idempotency::tests::canonical_json_order_does_not_change_request_identity ... ok
+test idempotency::tests::identity_binds_owner_and_rejects_changed_request ... ok
+test idempotency::tests::malformed_keys_and_unbound_records_are_rejected ... ok
+test performance::tests::accounting_allocations_are_not_unidentified_exchange_fills ... ok
+test performance::tests::builds_daily_weight_diagnostics_from_persisted_holdings ... ok
+test performance::tests::counts_open_underwater_duration_from_the_latest_peak ... ok
+test performance::tests::does_not_fake_risk_ratios_for_one_period ... ok
+test performance::tests::emits_true_nav_and_multiple_recovery_episodes ... ok
+test performance::tests::explicit_frozen_initial_capital_survives_a_first_day_deposit ... ok
+test performance::tests::first_period_loss_has_an_initial_peak_episode_without_a_fake_date ... ok
+test performance::tests::missing_benchmark_does_not_compact_dates_or_invent_a_drawdown_path ... ok
+test performance::tests::missing_order_ids_and_fees_remain_unknown_not_zero_or_report_counts ... ok
+test performance::tests::order_metrics_count_identities_separately_from_reports_and_partial_fills ... ok
+test performance::tests::preserves_a_first_day_strategy_return_and_initial_capital ... ok
+test performance::tests::preserves_the_canonical_pre_period_benchmark_baseline ... ok
+test performance::tests::projects_all_canonical_risk_metrics_and_contract_metadata ... ok
+test performance::tests::separates_longest_underwater_episode_from_deepest_drawdown ... ok
+test performance::tests::zero_nav_is_a_full_loss_not_missing_data ... ok
+test performance::tests::zero_orders_are_known_but_conflicting_order_identity_is_not_a_count ... ok
+test result_analysis_tests::batched_history_bindings_preserve_validation_and_survive_cache_eviction ... ignored, requires isolated FIDC_BACKTEST_TEST_POSTGRES_DSN
+test factor_events::tests::catalog_validator_binds_the_complete_body_and_preserves_contract ... ok
+test result_analysis_tests::copied_real_result_stores_and_browser_fixture ... ignored, requires FIDC_RESULT_QA_FIXTURES containing copied immutable result stores
+test result_analysis_tests::failed_optional_classification_keeps_unmodified_facts ... ok
+test result_analysis_tests::historical_text_search_filters_before_count_and_pagination ... ignored, requires isolated FIDC_BACKTEST_TEST_POSTGRES_DSN
+test result_analysis_tests::history_filters_use_corrected_drawdown_and_never_treat_unknown_as_zero ... ok
+test result_analysis_tests::owned_analysis_reference_does_not_require_a_cached_run_binding ... ok
+test result_analysis_tests::projected_history_filter_sort_and_pagination_on_postgres ... ignored, requires FIDC_BACKTEST_TEST_POSTGRES_DSN; creates an isolated test schema
+test result_analysis_tests::sector_filter_cannot_disable_its_classification_dependency ... ok
+test risk_projection::tests::absent_original_rates_preserve_independent_metrics_without_network_or_zero_rate_claim ... ok
+test risk_projection::tests::canonical_null_overrides_all_legacy_aliases_but_real_zero_survives ... ok
+test risk_projection::tests::original_contract_reprojects_legacy_zero_and_preserves_cash_flow_facts ... ok
+test risk_projection::tests::unavailable_contract_does_not_relabel_legacy_zero_as_a_verified_statistic ... ok
+test stock_pool_candidates::tests::resolve_binds_input_and_preserves_empty_automatic_days ... ok
+test submission_pg_tests::atomic_submission_claim_replay_and_rollback_on_postgres ... ignored, requires FIDC_BACKTEST_TEST_POSTGRES_DSN and creates only an isolated schema
+test tests::backtest_create_body_limit_accepts_bounded_signal_replays ... ok
+test tests::backtest_event_stream_exposes_a_websocket_transport ... ok
+test tests::backtest_list_cache_key_separates_summary_only_runtime_shape ... ok
+test tests::backtest_list_filters_and_sorting_use_generated_summary ... ok
+test tests::backtest_list_reports_cache_hit_and_effective_page_limit ... ok
+test tests::backtest_list_summary_only_uses_compact_query ... ok
+test tests::backtest_performance_contract_records_total_and_runner_seconds ... ok
+test tests::backtest_run_compact_cache_key_separates_strategy_detail_shape ... ok
+test tests::backtest_runner_data_env_accepts_strategy_factory_source_lake_provider ... ok
+test tests::backtest_runner_data_env_infers_strategy_factory_source_lake_from_runtime_source_table ... ok
+test tests::backtest_runner_data_env_rejects_legacy_ficlaw_data_source_table ... ok
+test tests::backtest_runner_data_env_rejects_legacy_source_provider ... ok
+test tests::backtest_runner_data_env_rejects_non_source_lake_provider ... ok
+test tests::backtest_runner_data_env_rejects_source_lake_provider_aliases ... ok
+test tests::backtest_runner_data_env_requires_strategy_factory_source_lake_url ... ok
+test tests::backtest_runner_data_env_uses_strategy_factory_source_lake_only ... ok
+test tests::backtest_schema_initialization_never_deletes_run_data ... ok
+test tests::backtest_schema_materializes_implementation_identity_for_compact_reads ... ok
+test tests::build_run_payload_does_not_mark_empty_running_summary_as_available ... ok
+test tests::build_run_payload_exposes_only_canonical_strategy_detail ... ok
+test tests::build_run_payload_marks_failed_error_summary_as_available ... ok
+test tests::build_run_payload_marks_terminal_metric_summary_as_available ... ok
+test tests::build_run_summary_preview_preserves_strategy_runtime_rebalance_signal ... ok
+test tests::build_run_summary_preview_preserves_terminal_audit ... ok
+test tests::canonical_result_is_recovered_from_runner_summary ... ok
+test tests::capacity_override_is_frozen_once_without_changing_execution_risk ... ok
+test tests::clear_backtest_list_cache_clears_compact_run_cache ... ok
+test tests::compact_result_handler_uses_single_pg_lookup ... ok
+test tests::compact_summary_only_runtime_select_avoids_config_json ... ok
+test tests::compact_summary_sql_removes_heavy_result_artifacts ... ok
+test tests::daily_execution_matching_type_normalizes_next_open_aliases_and_rejects_other_aliases ... ok
+test tests::default_backtest_concurrency_scales_with_available_cpu_threads ... ok
+test tests::default_backtest_source_table_uses_strategy_factory_source_lake ... ok
+test tests::detail_rows_query_page_size_maps_to_offset_limit ... ok
+test tests::equity_rows_hide_diagnostics_unless_explicitly_requested ... ok
+test tests::execution_cost_overrides_strategy_spec_for_runner ... ok
+test tests::execution_dynamic_slippage_overrides_strategy_spec_for_runner ... ok
+test tests::execution_matching_type_overrides_strategy_spec_for_runner ... ok
+test tests::execution_percent_slippage_alias_normalizes_to_price_ratio ... ok
+test tests::execution_rebalance_cash_mode_overrides_strategy_spec_for_runner ... ok
+test tests::execution_risk_overrides_strategy_spec_for_runner ... ok
+test tests::execution_risk_policy_rejects_conflicting_alias_values ... ok
+test tests::execution_risk_policy_rejects_non_object ... ok
+test tests::execution_risk_policy_rejects_unknown_fields_before_queueing ... ok
+test tests::execution_sell_then_buy_delay_slippage_requires_sell_then_buy_mode ... ok
+test tests::execution_slippage_overrides_strategy_spec_for_runner ... ok
+test tests::execution_top_level_risk_enabled_aliases_are_frozen_into_strategy_spec ... ok
+test tests::explicit_cost_override_removes_old_aliases_and_preserves_zero_minimum ... ok
+test tests::history_query_cache_has_a_bounded_entry_budget ... ok
+test tests::history_search_is_bounded_and_retains_literal_characters ... ok
+test tests::implementation_identity_freezes_source_and_binary_generation ... ok
+test tests::manual_observations_are_run_scoped_and_private_in_the_runner_bundle ... ok
+test tests::minute_execution_matching_type_uses_minute_price_and_rejects_daily_modes ... ok
+test tests::persisted_runtime_projection_never_guesses_missing_frequency ... ok
+test tests::persisted_runtime_projection_retains_minute_mode_and_frozen_bundle ... ok
+test tests::process_event_projection_uses_stable_kind_and_filters ... ok
+test tests::projected_fact_block_cache_key_is_shared_across_run_manifests ... ok
+test tests::public_backtest_projection_removes_internal_paths_recursively ... ok
+test tests::public_event_message_removes_internal_paths ... ok
+test tests::public_result_store_manifest_hides_internal_fact_blocks ... ok
+test tests::public_run_projection_does_not_reintroduce_internal_paths ... ok
+test tests::result_artifact_cache_keeps_shared_fact_blocks_after_run_eviction ... ok
+test tests::result_artifact_cache_rejects_conflicting_reference_for_same_sha ... ok
+test tests::result_block_page_plan_reads_only_overlapping_blocks ... ok
+test tests::runner_strategy_spec_path_prefers_bundle ... ok
+test tests::runtime_frequency_normalizes_and_overrides_strategy_spec_for_runner ... ok
+test tests::runtime_frozen_bundle_is_written_to_strategy_metadata_for_runner ... ok
+test tests::runtime_projection_migration_preserves_frozen_config ... ok
+test tests::runtime_symbols_override_strategy_spec_for_runner ... ok
+test tests::source_lake_preflight_rejects_unsupported_minute_cash_mode ... ok
+test tests::source_lake_run_contract_preflight_freezes_runtime_and_execution ... ok
+test tests::source_lake_runtime_requires_frozen_backtest_bundle_contract ... ok
+test tests::start_backtest_run_rejects_unready_data_source_before_persistence ... ok
+test tests::startup_reconciliation_closes_orphaned_runs_and_records_audit_event ... ok
+test tests::strategy_detail_keeps_strategy_body_without_full_config ... ok
+test tests::strategy_detail_returns_none_without_strategy_body ... ok
+test tests::strategy_expression_preflight_rejects_invalid_dsl_before_data_load ... ok
+test tests::summary_list_projection_keeps_table_metrics_and_removes_detail_payloads ... ok
+test tests::terminal_audit_accepts_deferred_intents_and_checks_the_retained_count ... ok
+test tests::terminal_audit_contract_rejects_missing_or_inconsistent_state ... ok
+test tests::top_level_limits_replace_all_nested_execution_aliases_before_preflight ... ok
+test tests::typed_holding_projection_derives_weight_and_final_snapshot ... ok
+test tests::typed_result_rows_filter_and_paginate_without_json_table_roundtrip ... ok
+test tests::typed_risk_filter_applies_execution_fields ... ok
+test event_stream::tests::replay_buffer_is_bounded_and_completed_streams_are_evicted_without_closing_subscribers ... ok
+test result_analysis_tests::complete_performance_and_paged_equity_share_corrected_drawdown ... ok
+test execution_ledger::tests::combined_pages_filter_before_count_and_keep_native_pages_bounded ... ok
+
+test result: ok. 134 passed; 0 failed; 8 ignored; 0 measured; 0 filtered out; finished in 9.15s
+
+     Running unittests examples/risk_projection_readonly.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/examples/risk_projection_readonly-b7328e36ec4d5bbd)
+
+running 4 tests
+test risk_projection::tests::canonical_null_overrides_all_legacy_aliases_but_real_zero_survives ... ok
+test risk_projection::tests::unavailable_contract_does_not_relabel_legacy_zero_as_a_verified_statistic ... ok
+test risk_projection::tests::original_contract_reprojects_legacy_zero_and_preserves_cash_flow_facts ... ok
+test risk_projection::tests::absent_original_rates_preserve_independent_metrics_without_network_or_zero_rate_claim ... ok
+
+test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+     Running unittests examples/stock_pool_contract_probe.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/examples/stock_pool_contract_probe-58c8f70095cabf04)
+
+running 1 test
+test stock_pool_candidates::tests::resolve_binds_input_and_preserves_empty_automatic_days ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+

docs/evidence/registered-share-delivery-20261005/validation-pg-receipt.json

@@ -0,0 +1,211 @@
+{
+  "artifact_bytes": 8192,
+  "artifact_id": "strategy_research_59f5a031d3cc7e0e5080c91e",
+  "artifact_path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1d4b32e/validation-receipt.json",
+  "artifact_sha256": "097101988e5f6875c8933012534cfa1ca72f9e2742c04d002aba7d00a69fc346",
+  "artifact_type": "research_source_scope_probe",
+  "contract_sha256": "054241b3df4e522159691c6ee27506667790f73a04c42989b87b5504cf587ee4",
+  "created_at": "2026-10-04T22:08:19Z",
+  "created_by": "boris",
+  "department_id": null,
+  "organization_id": "local_org",
+  "persisted_at": "2026-10-04T22:08:19Z",
+  "production_ready": false,
+  "record_json": {
+    "all_attempt_log_references": [
+      {
+        "bytes": 3625,
+        "compiler_failure": false,
+        "complete_success": false,
+        "failed": 2,
+        "ignored": 0,
+        "passed": 20,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-0bbeed4/initial-targeted-linux-tests.log",
+        "sha256": "9684e4e1c10aabe426c15cd408bb61b198ada8eed1258231e4b81fc30716ac49"
+      },
+      {
+        "bytes": 82467,
+        "compiler_failure": false,
+        "complete_success": false,
+        "failed": 1,
+        "ignored": 7,
+        "passed": 798,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-0caac44/full-linux-tests-attempt1.log",
+        "sha256": "9535151bd7a29a5f56265ef35dbff89b3e48729688cb34c32aa8a8fc9347e41c"
+      },
+      {
+        "bytes": 95343,
+        "compiler_failure": false,
+        "complete_success": false,
+        "failed": 4,
+        "ignored": 9,
+        "passed": 923,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-4eb4c17/full-linux-tests-attempt2.log",
+        "sha256": "db18ad5e876ce482dc1f76ac244e170a6095c2ead8a991af5dce45e72af8e9ac"
+      },
+      {
+        "bytes": 98381,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 9,
+        "passed": 967,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-05315f0/full-linux-tests-attempt3.log",
+        "sha256": "66879f838ec21001cb3e6c284f497cfb6a80c2d3a724ee9cb04e09476afc101b"
+      },
+      {
+        "bytes": 98381,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 9,
+        "passed": 967,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-a267052/final-full-linux-tests.log",
+        "sha256": "b565d8b983fb87881974da37ad5bd0721db3f51acda3af0cbe1b62406f18371c"
+      },
+      {
+        "bytes": 98381,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 9,
+        "passed": 967,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-7d7cce8/final-full-linux-tests.log",
+        "sha256": "b8f7a20a93335801950e40ce3a7124ae039e84fbb1db7dd821c314d2b05b4447"
+      },
+      {
+        "bytes": 98572,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 9,
+        "passed": 969,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-ce46c13/final-full-linux-tests.log",
+        "sha256": "cfd1cb81fde9f34991a54a54e2a734844bd8fab52292e043856b08d30090d19a"
+      },
+      {
+        "bytes": 10543,
+        "compiler_failure": true,
+        "complete_success": false,
+        "failed": 0,
+        "ignored": 0,
+        "passed": 0,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1fa73bb/full-linux-tests-attempt1.log",
+        "sha256": "e758be915373f707a460e7d08ab4162f3b80d86b98091c555cb3351c2bb4d7b8"
+      },
+      {
+        "bytes": 65133,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 17,
+        "passed": 613,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ffc6e1f/full-linux-tests-attempt2.log",
+        "sha256": "d053e4e432cbe0b198f85ceee349b241eac4cf90b8e6a75289c322c59538b2b7"
+      },
+      {
+        "bytes": 65133,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 17,
+        "passed": 613,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ce46c13/final-full-linux-tests.log",
+        "sha256": "6f2e8974a90d5cdbce788e2744a1276dff9fe94b79958869cfb0730c096d1a42"
+      },
+      {
+        "bytes": 65258,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 17,
+        "passed": 614,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1d4b32e/final-full-linux-tests.log",
+        "sha256": "2ba99fb0198a68ff5bc3d6341b1cdeb3da1a4d0ca5496b2faa3e79e3494ae434"
+      }
+    ],
+    "contract_sha256": "5b4389afc3bbda8f30cbe141cc2a05af75bc0e69724aa04c09b258b98326105f",
+    "core_test_result": {
+      "bytes": 98572,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 9,
+      "passed": 969,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-ce46c13/final-full-linux-tests.log",
+      "sha256": "cfd1cb81fde9f34991a54a54e2a734844bd8fab52292e043856b08d30090d19a"
+    },
+    "corporate_action_cache_schema_version": 5,
+    "engine_commit": "ce46c13f37f028393e689babbe5c348d482d3a32",
+    "fractional_quantity_requires_explicit_settlement_rule": true,
+    "full_source_event_and_revision_scope_verified": false,
+    "new_runtime_release_performed": false,
+    "numeric_research_budget_reopened": false,
+    "observed_at": "2026-10-04T22:08:10.219296+00:00",
+    "operational_verification_reference": {
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1d4b32e/operational-verification.json",
+      "sha256": "3ce2ba78ed28f549ddc675429565e578fe61eee1db4374c375e5049761c8fd06"
+    },
+    "owner_uid": 1003,
+    "pending_share_successor_conversion_without_carry_terms_rejected": true,
+    "performance_speedup_claimed": false,
+    "prior_validation_pg_artifact": "strategy_research_cb32517064d7558f69713001",
+    "prior_validation_reference": {
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ce46c13/validation-receipt.json",
+      "sha256": "5240dbf5f1d7382531a4c0dce5fcdb722f4d1137a41854269159b61f0236d412"
+    },
+    "production_ready": false,
+    "production_runtime_deployed": false,
+    "production_strategy_count": 0,
+    "registered_share_entitlements_separate_from_delivered_and_sellable_quantity": true,
+    "resource_contract_live_verification_reference": {
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1d4b32e/live-test-resource-verification.json",
+      "sha256": "1686248392f29ae93f023ff147fcc0abb06b6b2fb15a9806b5718e320ed75a40"
+    },
+    "resource_contract_requested": {
+      "build_jobs": 4,
+      "core_target_path": "/tmp/fidc-cash-receivable-build-20261005-af655de",
+      "cpu_quota_percent": 400,
+      "incremental": false,
+      "locked": true,
+      "memory_max_bytes": 17179869184,
+      "memory_swap_max_bytes": 0,
+      "offline": true,
+      "resource_properties_after_transient_scope_exit_are_not_live_validation": true,
+      "runner_target_path": "/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb",
+      "rustc": "rustc 1.98.0 (88d9e12ae 2026-08-18)",
+      "target_filesystem": "executable_tmpfs",
+      "tasks_max": 256,
+      "toolchain": "stable-x86_64-unknown-linux-gnu"
+    },
+    "runner_api_test_result": {
+      "bytes": 65258,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 17,
+      "passed": 614,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1d4b32e/final-full-linux-tests.log",
+      "sha256": "2ba99fb0198a68ff5bc3d6341b1cdeb3da1a4d0ca5496b2faa3e79e3494ae434"
+    },
+    "schema_version": "fidc.linux-registered-share-delivery-validation/v1",
+    "service_commit": "1d4b32e18d3836b5844130ae0c95d90247768882",
+    "share_receivable_assets_included_in_equity_and_target_sizing": true,
+    "simulation_rounding_fixture_not_official_settlement_evidence": true,
+    "source_pair_root": "/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-1d4b32e",
+    "source_publication_times_admitted_as_PIT": false,
+    "source_rows_semantic_sha256": "eec65df828f97a3e51827cb6b0e9ec2c86079a333481d55ec9eb6ab2845d73c5",
+    "source_rows_semantic_version": "v10",
+    "source_transport_commit": "12eeae5d570004499a30f7faa42c0da93c1578cc",
+    "status": "core_and_runner_api_regressions_passed_not_source_runtime_or_strategy_acceptance",
+    "trading_allowed": false,
+    "two_framework_financial_reconciliation_completed": false,
+    "unknown_delivery_date_not_defaulted_to_ex_date": true,
+    "unknown_distribution_quantities_not_defaulted_to_zero": true
+  },
+  "research_key": "fidc-registered-share-delivery-validation-20261005-ce46c13-1d4b32e",
+  "schema_table": "strategy_research_artifact",
+  "schema_version": "fidc.linux-registered-share-delivery-validation/v1",
+  "status": "core_and_runner_api_regressions_passed_not_source_runtime_or_strategy_acceptance",
+  "storage": "postgres"
+}

docs/evidence/registered-share-delivery-20261005/validation-probe-assembly-failure.json

@@ -0,0 +1,20 @@
+{
+  "schema_version": "fidc.validation-probe-assembly-failure/v1",
+  "recorded_on": "2026-10-05",
+  "error_type": "SyntaxError",
+  "reported_frames": [
+    {
+      "function": "<module>",
+      "line": 6
+    }
+  ],
+  "request_path": "/tmp/fidc-share-delivery-quantity-request-20261005.json",
+  "request_sha256": "2a91810a4d30ae811fa8dfb010ac7ce761d9bdfd144af608318886617292fed7",
+  "cause": "probe string replacement left a dot immediately before an equality operator",
+  "remote_probe_code_execution_started": false,
+  "remote_source_or_test_outcome_unknown": false,
+  "correction": "assembled probe compiled locally before executing corrected validation",
+  "corrected_test_source_pair": "/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-1d4b32e",
+  "production_ready": false,
+  "trading_allowed": false
+}

docs/evidence/registered-share-delivery-20261005/validation-receipt.json

@@ -0,0 +1,192 @@
+{
+  "all_attempt_log_references": [
+    {
+      "bytes": 3625,
+      "compiler_failure": false,
+      "complete_success": false,
+      "failed": 2,
+      "ignored": 0,
+      "passed": 20,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-0bbeed4/initial-targeted-linux-tests.log",
+      "sha256": "9684e4e1c10aabe426c15cd408bb61b198ada8eed1258231e4b81fc30716ac49"
+    },
+    {
+      "bytes": 82467,
+      "compiler_failure": false,
+      "complete_success": false,
+      "failed": 1,
+      "ignored": 7,
+      "passed": 798,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-0caac44/full-linux-tests-attempt1.log",
+      "sha256": "9535151bd7a29a5f56265ef35dbff89b3e48729688cb34c32aa8a8fc9347e41c"
+    },
+    {
+      "bytes": 95343,
+      "compiler_failure": false,
+      "complete_success": false,
+      "failed": 4,
+      "ignored": 9,
+      "passed": 923,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-4eb4c17/full-linux-tests-attempt2.log",
+      "sha256": "db18ad5e876ce482dc1f76ac244e170a6095c2ead8a991af5dce45e72af8e9ac"
+    },
+    {
+      "bytes": 98381,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 9,
+      "passed": 967,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-05315f0/full-linux-tests-attempt3.log",
+      "sha256": "66879f838ec21001cb3e6c284f497cfb6a80c2d3a724ee9cb04e09476afc101b"
+    },
+    {
+      "bytes": 98381,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 9,
+      "passed": 967,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-a267052/final-full-linux-tests.log",
+      "sha256": "b565d8b983fb87881974da37ad5bd0721db3f51acda3af0cbe1b62406f18371c"
+    },
+    {
+      "bytes": 98381,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 9,
+      "passed": 967,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-7d7cce8/final-full-linux-tests.log",
+      "sha256": "b8f7a20a93335801950e40ce3a7124ae039e84fbb1db7dd821c314d2b05b4447"
+    },
+    {
+      "bytes": 98572,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 9,
+      "passed": 969,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-ce46c13/final-full-linux-tests.log",
+      "sha256": "cfd1cb81fde9f34991a54a54e2a734844bd8fab52292e043856b08d30090d19a"
+    },
+    {
+      "bytes": 10543,
+      "compiler_failure": true,
+      "complete_success": false,
+      "failed": 0,
+      "ignored": 0,
+      "passed": 0,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1fa73bb/full-linux-tests-attempt1.log",
+      "sha256": "e758be915373f707a460e7d08ab4162f3b80d86b98091c555cb3351c2bb4d7b8"
+    },
+    {
+      "bytes": 65133,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 17,
+      "passed": 613,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ffc6e1f/full-linux-tests-attempt2.log",
+      "sha256": "d053e4e432cbe0b198f85ceee349b241eac4cf90b8e6a75289c322c59538b2b7"
+    },
+    {
+      "bytes": 65133,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 17,
+      "passed": 613,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ce46c13/final-full-linux-tests.log",
+      "sha256": "6f2e8974a90d5cdbce788e2744a1276dff9fe94b79958869cfb0730c096d1a42"
+    },
+    {
+      "bytes": 65258,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 17,
+      "passed": 614,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1d4b32e/final-full-linux-tests.log",
+      "sha256": "2ba99fb0198a68ff5bc3d6341b1cdeb3da1a4d0ca5496b2faa3e79e3494ae434"
+    }
+  ],
+  "contract_sha256": "5b4389afc3bbda8f30cbe141cc2a05af75bc0e69724aa04c09b258b98326105f",
+  "core_test_result": {
+    "bytes": 98572,
+    "compiler_failure": false,
+    "complete_success": true,
+    "failed": 0,
+    "ignored": 9,
+    "passed": 969,
+    "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-ce46c13/final-full-linux-tests.log",
+    "sha256": "cfd1cb81fde9f34991a54a54e2a734844bd8fab52292e043856b08d30090d19a"
+  },
+  "corporate_action_cache_schema_version": 5,
+  "engine_commit": "ce46c13f37f028393e689babbe5c348d482d3a32",
+  "fractional_quantity_requires_explicit_settlement_rule": true,
+  "full_source_event_and_revision_scope_verified": false,
+  "new_runtime_release_performed": false,
+  "numeric_research_budget_reopened": false,
+  "observed_at": "2026-10-04T22:08:10.219296+00:00",
+  "operational_verification_reference": {
+    "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1d4b32e/operational-verification.json",
+    "sha256": "3ce2ba78ed28f549ddc675429565e578fe61eee1db4374c375e5049761c8fd06"
+  },
+  "owner_uid": 1003,
+  "pending_share_successor_conversion_without_carry_terms_rejected": true,
+  "performance_speedup_claimed": false,
+  "prior_validation_pg_artifact": "strategy_research_cb32517064d7558f69713001",
+  "prior_validation_reference": {
+    "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ce46c13/validation-receipt.json",
+    "sha256": "5240dbf5f1d7382531a4c0dce5fcdb722f4d1137a41854269159b61f0236d412"
+  },
+  "production_ready": false,
+  "production_runtime_deployed": false,
+  "production_strategy_count": 0,
+  "registered_share_entitlements_separate_from_delivered_and_sellable_quantity": true,
+  "resource_contract_live_verification_reference": {
+    "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1d4b32e/live-test-resource-verification.json",
+    "sha256": "1686248392f29ae93f023ff147fcc0abb06b6b2fb15a9806b5718e320ed75a40"
+  },
+  "resource_contract_requested": {
+    "build_jobs": 4,
+    "core_target_path": "/tmp/fidc-cash-receivable-build-20261005-af655de",
+    "cpu_quota_percent": 400,
+    "incremental": false,
+    "locked": true,
+    "memory_max_bytes": 17179869184,
+    "memory_swap_max_bytes": 0,
+    "offline": true,
+    "resource_properties_after_transient_scope_exit_are_not_live_validation": true,
+    "runner_target_path": "/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb",
+    "rustc": "rustc 1.98.0 (88d9e12ae 2026-08-18)",
+    "target_filesystem": "executable_tmpfs",
+    "tasks_max": 256,
+    "toolchain": "stable-x86_64-unknown-linux-gnu"
+  },
+  "runner_api_test_result": {
+    "bytes": 65258,
+    "compiler_failure": false,
+    "complete_success": true,
+    "failed": 0,
+    "ignored": 17,
+    "passed": 614,
+    "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1d4b32e/final-full-linux-tests.log",
+    "sha256": "2ba99fb0198a68ff5bc3d6341b1cdeb3da1a4d0ca5496b2faa3e79e3494ae434"
+  },
+  "schema_version": "fidc.linux-registered-share-delivery-validation/v1",
+  "service_commit": "1d4b32e18d3836b5844130ae0c95d90247768882",
+  "share_receivable_assets_included_in_equity_and_target_sizing": true,
+  "simulation_rounding_fixture_not_official_settlement_evidence": true,
+  "source_pair_root": "/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-1d4b32e",
+  "source_publication_times_admitted_as_PIT": false,
+  "source_rows_semantic_sha256": "eec65df828f97a3e51827cb6b0e9ec2c86079a333481d55ec9eb6ab2845d73c5",
+  "source_rows_semantic_version": "v10",
+  "source_transport_commit": "12eeae5d570004499a30f7faa42c0da93c1578cc",
+  "status": "core_and_runner_api_regressions_passed_not_source_runtime_or_strategy_acceptance",
+  "trading_allowed": false,
+  "two_framework_financial_reconciliation_completed": false,
+  "unknown_delivery_date_not_defaulted_to_ex_date": true,
+  "unknown_distribution_quantities_not_defaulted_to_zero": true
+}

docs/evidence/registered-share-risk-20261005/core-risk-initial-failure.log

@@ -0,0 +1,809 @@
+   Compiling fidc-core v0.1.0 (/srv/fidc/programs/src/fidc-share-receivable-validation-20261005-4a41057/crates/fidc-core)
+    Finished `test` profile [unoptimized] target(s) in 42.79s
+     Running unittests src/lib.rs (/tmp/fidc-cash-receivable-build-20261005-af655de/debug/deps/fidc_core-dbea4d4f6cb5d2d7)
+
+running 789 tests
+test broker::tests::aiquant_rules_keep_structured_buy_risk_while_using_aiquant_limit_price ... ok
+test broker::tests::aiquant_sell_rule_still_blocks_real_allow_sell_false ... ok
+test broker::tests::aiquant_sell_rule_uses_intraday_quote_when_daily_snapshot_is_stale_lower_limit ... ok
+test broker::tests::aiquant_target_portfolio_smart_keeps_batch_semantics_after_failed_full_close_sell ... ok
+test broker::tests::aiquant_target_portfolio_smart_rejects_deferred_buy_risk_at_order_stage ... ok
+test broker::stock_pool::successor_protection_tests::deferred_etf_open_rechecks_inherited_locks_and_cooldown_before_any_order ... ok
+test broker::tests::aiquant_target_value_delta_uses_scheduled_mark_price ... ok
+test broker::tests::algorithm_clock::algorithm_expiry_without_a_quote_does_not_reuse_old_liquidity ... ok
+test broker::tests::algorithm_clock::an_explicit_ioc_or_fok_does_not_become_a_persistent_algorithm ... ok
+test broker::tests::algorithm_clock::algorithm_sell_honors_t_plus_one_and_keeps_original_quantity_after_partial_fills ... ok
+test broker::tests::algorithm_clock::a_clock_slice_does_not_turn_window_twap_into_an_unlimited_instant_order ... ok
+test broker::tests::algorithm_clock::control_only_phase_cannot_be_used_to_submit_an_order_or_leave_matching_disabled ... ok
+test broker::tests::algorithm_clock::changing_the_later_daily_close_does_not_resize_an_algorithm_submitted_now ... ok
+test broker::tests::algorithm_clock::global_vwap_matching_keeps_the_same_working_order_between_clock_ticks ... ok
+test broker::tests::algorithm_clock::non_matching_controls_amend_or_cancel_without_filling_a_crossing_quote ... ok
+test broker::tests::algorithm_clock::partial_algorithm_cancel_releases_reservation_and_never_executes_the_remainder ... ok
+test broker::tests::algorithm_clock::two_working_algorithms_reserve_only_real_cash_without_starving_the_first ... ok
+test broker::tests::algorithm_clock::twap_clock_preserves_quantity_prices_fees_budget_and_parent_order ... ok
+test broker::tests::complete_daily_target_batch_uses_positive_target_count_for_slot_limit ... ok
+test broker::tests::algorithm_clock::separate_buy_cannot_spend_the_working_algorithms_cash_budget ... ok
+test broker::tests::daily_capacity_requires_a_timed_observation_instead_of_falling_back_to_total_volume ... ok
+test broker::tests::daily_matching_does_not_require_intraday_quote_quantity ... ok
+test broker::tests::custom_valuation_missing_with_current_market_still_fails_closed ... ok
+test broker::tests::algorithm_clock::vwap_clock_preserves_cash_costs_and_does_not_spend_future_volume ... ok
+test broker::tests::decision_buy_denial_allows_reducing_an_existing_buy ... ok
+test broker::tests::decision_buy_denial_does_not_rewrite_existing_pending_order ... ok
+test broker::tests::daily_session_volume_changes_only_audit_not_opening_fills ... ok
+test broker::tests::decision_buy_denial_blocks_topup_but_allows_sell_and_does_not_leak ... ok
+test broker::tests::decision_buy_denial_rejects_increasing_amendments_without_mutation ... ok
+test broker::tests::each_execution_leg_rechecks_one_yuan_including_slippage_and_limit_price ... ok
+test broker::tests::explicit_quote_price_models_do_not_replace_missing_prices_or_reuse_older_ones ... ok
+test broker::tests::decision_buy_denial_uses_actual_next_open_target_delta ... ok
+test broker::tests::failed_target_exit_blocks_replacement_entry_when_no_position_slot_is_released ... ok
+test broker::tests::gtc_resting_order_keeps_its_session_and_original_dates_across_days ... ok
+test broker::tests::deferred_etf_batch_failure_keeps_both_targets_and_prior_generation_progress ... ok
+test broker::tests::failed_new_batch_does_not_erase_prior_success_or_double_charge_on_retry ... ok
+test broker::tests::historical_slippage_rejects_missing_future_or_invalid_calibration_without_raw_price_fallback ... ok
+test broker::tests::instantaneous_twap_without_limits_does_not_cap_quote_quantity ... ok
+test broker::tests::intraday_execution_rejects_buy_at_upper_limit_price ... ok
+test broker::tests::intraday_execution_rejects_sell_at_lower_limit_price ... ok
+test broker::tests::later_execution_clocks_do_not_replenish_the_same_observed_volume ... ok
+test broker::tests::independent_target_entry_is_not_subject_to_replacement_slot_limit ... ok
+test broker::tests::minute_last_exact_time_does_not_fallback_to_older_liquid_quote ... ok
+test broker::tests::minute_last_execution_uses_latest_quote_before_decision_time ... ok
+test broker::tests::market_share_buy_skips_quantity_that_rounds_below_one_lot ... ok
+test broker::tests::minute_last_prefilter_does_not_use_snapshot_minute_volume ... ok
+test broker::tests::minute_last_quote_quantity_cap_depends_on_liquidity_limit ... ok
+test broker::tests::minute_last_uses_volume_delta_when_level1_depth_missing ... ok
+test broker::tests::minute_last_volume_limit_caps_quote_volume_delta_without_liquidity_limit ... ok
+test broker::tests::minute_last_volume_limit_rejects_sub_lot_quote_volume ... ok
+test broker::tests::minute_last_without_volume_or_liquidity_limit_does_not_cap_quote_quantity ... ok
+test broker::tests::historical_slippage_does_not_read_later_daily_fields_for_open_or_minute_fills ... ok
+test broker::tests::next_open_buy_limit_risk_rejects_open_upper_limit_even_when_close_is_clean ... ok
+test broker::tests::next_open_buy_limit_risk_uses_open_not_close ... ok
+test broker::tests::next_open_buy_risk_rejects_execution_date_delisted_even_without_market_snapshot ... ok
+test broker::tests::next_open_buy_risk_rejects_execution_date_st_even_if_signal_date_was_clean ... ok
+test broker::tests::next_open_sell_limit_risk_rejects_open_lower_limit_even_when_close_is_clean ... ok
+test broker::tests::next_open_buy_risk_uses_execution_date_not_signal_date ... ok
+test broker::tests::next_open_day_limit_remainder_matches_intraday_with_execution_day_ttl ... ok
+test broker::tests::next_open_sell_limit_risk_uses_open_not_close ... ok
+test broker::tests::next_open_sell_risk_rejects_execution_date_lower_limit_even_if_signal_date_was_clean ... ok
+test broker::tests::next_open_sell_risk_uses_execution_date_not_signal_date ... ok
+test broker::tests::next_open_target_portfolio_unpriced_symbol_does_not_abort_batch ... ok
+test broker::tests::next_open_target_value_valuation_uses_execution_open ... ok
+test broker::tests::next_open_target_value_recomputes_quantity_from_execution_open ... ok
+test broker::tests::next_open_unpriced_active_snapshot_rejects_without_historical_fill ... ok
+test broker::tests::next_open_unpriced_paused_snapshot_prefers_execution_day_pause_risk ... ok
+test broker::tests::next_open_with_observations_uses_opening_volume_not_daily_totals_or_future_quotes ... ok
+test broker::tests::open_order_upsert_replaces_in_place_and_preserves_queue_position ... ok
+test broker::tests::pending_registered_shares_do_not_trigger_duplicate_target_buys ... ok
+test broker::tests::post_close_phase_is_derived_from_actual_same_day_submission_time ... ok
+test broker::tests::queued_order_retains_the_real_creation_clock_when_retried ... ok
+test broker::tests::post_close_order_uses_close_without_slippage_and_waits_until_matching_window ... ok
+test broker::tests::session_audit_does_not_infer_an_opening_suspension_from_future_zero_volume ... ok
+test broker::tests::scheduled_target_value_valuation_and_sizing_use_same_intraday_price ... ok
+test broker::tests::session_capacity_audit_never_caps_an_early_odd_lot_sell ... ok
+test broker::tests::public_callback_unwind_does_not_leak_order_context_or_authoritative_prior_state ... ok
+test broker::tests::stock_pool_after_sell_rejects_missing_quote_instead_of_reusing_daily_open ... ok
+test broker::tests::stock_pool_after_sell_uses_fresh_quotes_and_actual_submission_clock ... ok
+test broker::tests::stock_pool_delayed_sell_does_not_start_buys_after_the_configured_window ... ok
+test broker::tests::stock_pool_delayed_take_profit_does_not_rebuy_the_same_generation_exit ... ok
+test broker::tests::stock_pool_engine_drives_the_pending_buy_without_a_minute_strategy_callback ... ok
+test broker::tests::stock_pool_new_signal_supersedes_the_unsubmitted_buy_phase ... ok
+test broker::tests::stock_pool_partial_sell_waits_for_the_whole_batch_and_never_reissues_buys ... ok
+test broker::tests::stock_pool_pending_phase_cannot_cross_the_execution_session ... ok
+test broker::tests::strict_value_buy_budget_includes_commission_at_execution_price ... ok
+test broker::tests::successful_target_exit_releases_position_slot_for_replacement_entry ... ok
+test broker::tests::stock_pool_pending_sell_continues_buy_after_actual_fill_without_strategy_rerun ... ok
+test broker::tests::target_percent_reduction_from_full_to_twenty_percent_sells_eighty_percent ... ok
+test broker::tests::target_portfolio_smart_custom_valuation_does_not_create_limit_orders ... ok
+test broker::tests::target_portfolio_smart_budgets_each_buy_before_cash_optimization ... ok
+test broker::tests::target_portfolio_smart_defers_buy_risk_until_order_validation ... ok
+test broker::tests::target_portfolio_smart_ignores_zero_weight_symbols_without_market_snapshot ... ok
+test broker::tests::target_portfolio_smart_keeps_position_when_sell_snapshot_missing ... ok
+test broker::tests::target_portfolio_smart_open_auction_uses_day_open_for_valuation ... ok
+test broker::tests::target_portfolio_smart_records_buy_rejection_when_target_is_blacklisted ... ok
+test broker::tests::target_portfolio_smart_pre_open_cash_does_not_spend_same_batch_sell_proceeds ... ok
+test broker::tests::target_portfolio_smart_uses_prior_close_only_for_missing_day_valuation ... ok
+test broker::tests::target_value_delta_below_order_step_is_audited_without_creating_zero_quantity_order ... ok
+test broker::tests::target_value_batch_executes_reductions_before_increases_when_sell_cash_is_reusable ... ok
+test broker::tests::target_value_reduction_from_full_to_twenty_percent_sells_eighty_percent ... ok
+test broker::tests::target_value_zero_rejects_sell_when_market_snapshot_missing ... ok
+test broker::tests::target_weight_buy_quantity_respects_per_symbol_budget_after_slippage_and_fees ... ok
+test broker::tests::timed_target_value_zero_sells_full_position_at_requested_time_quote ... ok
+test broker::tests::failed_resting_order_batch_keeps_accepted_orders_and_unpublished_financial_state ... ok
+test broker::tests::twap_earlier_fills_do_not_depend_on_later_quote_liquidity_or_count ... ok
+test broker::tests::unchanged_targets_do_not_create_zero_quantity_orders ... ok
+test broker::tests::unwinding_an_unpublished_simulator_transaction_restores_its_state ... ok
+test broker::tests::value_buy_process_uses_latest_quote_before_decision_time ... ok
+test broker::tests::value_buy_rejects_when_slippage_clamps_execution_price_to_upper_limit ... ok
+test corporate_book::tests::closing_register_cannot_be_replaced_by_later_holdings ... ok
+test corporate_book::tests::dividend_receivable_survives_a_flat_position_without_becoming_spendable_cash ... ok
+test corporate_book::tests::a_late_corporate_batch_failure_keeps_prior_cash_positions_and_notes ... ok
+test corporate_book::tests::entitlement_survives_complete_sale_and_a_successor_unit_conversion ... ok
+test corporate_book::tests::corporate_quantity_overflow_fails_without_saturation_or_a_negative_delta ... ok
+test corporate_book::tests::flat_position_retirement_does_not_change_issued_lot_state_or_next_purchase_origin ... ok
+test corporate_book::tests::explicitly_delayed_dividend_remains_receivable_until_actual_payment ... ok
+test corporate_book::tests::manual_zero_skips_only_unused_allocation_facts_not_invalid_cash_evidence ... ok
+test corporate_book::tests::missing_accounting_reference_is_atomic_not_a_silent_cash_only_success ... ok
+test corporate_book::tests::invalid_delivery_negative_rates_and_unresolved_fractional_claims_are_atomic ... ok
+test corporate_book::tests::missing_or_backward_cash_payment_date_never_updates_the_account ... ok
+test corporate_book::tests::per_share_precision_is_retained_until_the_registered_cash_amount_is_rounded ... ok
+test corporate_book::tests::missing_record_date_or_unobserved_closing_book_is_atomic ... ok
+test corporate_book::tests::post_record_buy_cannot_receive_the_earlier_dividend ... ok
+test corporate_book::tests::post_record_purchase_does_not_inherit_registered_shares ... ok
+test corporate_book::tests::registered_shares_are_valued_but_not_delivered_or_sellable_before_the_original_date ... ok
+test corporate_book::tests::sale_after_registration_preserves_cash_and_excludes_new_lots_from_cost_adjustment ... ok
+test corporate_book::tests::successor_without_frozen_instrument_metadata_is_not_an_implicit_new_security ... ok
+test corporate_book::tests::terminated_security_keeps_paid_cash_and_is_not_recreated_by_reinvestment ... ok
+test corporate_book::tests::successor_conversion_cannot_discard_unresolved_share_entitlements ... ok
+test corporate_book::tests::tiny_known_cash_rate_is_preserved_and_cannot_waive_payment_or_record_evidence ... ok
+test corporate_book::tests::unresolved_delisting_cannot_zero_a_pending_share_asset ... FAILED
+test cost::tests::cost_model_can_use_configurable_stamp_tax_change_date ... ok
+test cost::tests::default_quantizes_fees_to_micro_yuan ... ok
+test cost::tests::fund_fees_use_admitted_instrument_type_and_share_the_order_commission_budget ... ok
+test corporate_book::tests::invalid_successor_terms_cannot_be_replaced_with_one_share_or_zero_cash ... ok
+test corporate_book::tests::verified_conversion_preserves_lots_without_creating_orders_or_fills ... ok
+test daily_patterns::tests::breakout_retest_needs_a_later_retest_not_the_breakout_candle_itself ... ok
+test daily_patterns::tests::daily_patterns_adjusts_all_prices_not_volume ... ok
+test daily_patterns::tests::daily_patterns_flat_decimal_prices_do_not_create_a_sell_signal ... ok
+test daily_patterns::tests::daily_patterns_helper_literal_preserves_parameters ... ok
+test daily_patterns::tests::daily_patterns_rejects_future_and_duplicate_bars ... ok
+test daily_patterns::tests::daily_patterns_no_missing_data_fallback ... ok
+test daily_patterns::tests::daily_patterns_all_templates_and_score_absence ... ok
+test daily_patterns::tests::limit_consolidation_requires_real_limit_and_never_infers_ten_percent ... ok
+test daily_patterns::tests::mean_volume_followup_requires_bullish_breakout_and_shrink ... ok
+test daily_patterns::tests::mean_volume_is_not_prior_max_and_excludes_current_bar ... ok
+test daily_patterns::tests::expression_condition_preserves_native_types_and_rejects_numeric_as_signal ... ok
+test daily_patterns::tests::research_index_and_ranking_context_never_unlock_strategy_mapping ... ok
+test data::series_columns::tests::differing_prices_preserve_zero_nan_payloads_and_prior_rows ... ok
+test data::series_columns::tests::identical_prices_share_only_after_exact_bit_comparison ... ok
+test daily_patterns::tests::research_isolates_missing_listing_day_without_weakening_execution ... ok
+test data::series_columns::tests::optional_values_keep_none_distinct_from_empty_and_repeated_text ... ok
+test data::series_columns::tests::repeated_values_preserve_nonzero_values_and_copy_on_change ... ok
+test daily_patterns::tests::research_numeric_output_keeps_warmup_unknown_without_a_false_signal ... ok
+test data::series_columns::tests::repeated_values_reject_out_of_range_access - should panic ... ok
+test data::tests::adjusted_close_average_normalization_prevents_strict_crossover_drift ... ok
+test data::tests::baseline_selection_uses_dated_lifecycle_not_latest_undated_status ... ok
+test data::tests::benchmark_current_rolling_reuses_symbol_boundary ... ignored, manual release-mode current rolling boundary benchmark
+test data::tests::benchmark_daily_snapshot_view_lookup ... ignored, manual component benchmark
+test data::tests::benchmark_decision_close_windows_exclude_current_close ... ok
+test data::tests::benchmark_instrument_symbol_id_lookup ... ignored, manual release-mode instrument lookup benchmark
+test data::tests::benchmark_series_boundary_reuses_calendar_index ... ignored, manual release-mode calendar index reuse benchmark
+test data::tests::additional_terminal_calendar_dates_are_isolated_from_shared_market_data ... ok
+test data::tests::current_close_average_uses_backward_adjustment_factor_and_current_base ... ok
+test data::tests::batched_standard_rolling_means_match_scalar_lookups ... ok
+test data::tests::daily_bundle_constructor_rejects_duplicate_or_mismatched_dates ... ok
+test data::tests::day_open_moving_average_uses_its_own_historical_column ... ok
+test data::tests::dataset_clone_shares_immutable_base_and_isolates_execution_quotes ... ok
+test data::tests::decision_close_average_ignores_current_day_close ... ok
+test data::tests::decision_market_cap_uses_factor_date_snapshot_without_price_reconstruction ... ok
+test data::tests::decision_volume_average_ignores_paused_zero_volume_days ... ok
+test data::tests::decision_volume_average_uses_previous_completed_days_only ... ok
+test data::tests::daily_bundle_constructor_matches_flat_component_constructor ... ok
+test data::tests::eligible_universe_can_use_configured_risk_policy ... ok
+test data::tests::direct_symbol_id_snapshot_lookups_preserve_alignment_for_sparse_rows ... ok
+test data::tests::eligible_universe_does_not_require_candidate_risk_state_when_selection_risk_is_disabled ... ok
+test data::tests::factor_numeric_value_normalizes_fields_without_changing_aliases ... ok
+test data::tests::factor_snapshot_normalization_moves_clean_maps_and_repairs_dirty_maps ... ok
+test data::tests::eligible_universe_uses_decision_market_cap_same_date ... ok
+test data::tests::execution_quotes_use_stable_k_way_merge_and_release_by_date ... ok
+test data::tests::factor_snapshot_rejects_legacy_or_invalid_adjustment_storage ... ok
+test data::tests::intraday_overlay_fails_closed_when_daily_panel_is_shared ... ok
+test data::tests::future_missing_adjustment_factor_does_not_invalidate_historical_window ... ok
+test data::tests::parallel_dense_index_rejects_invalid_days_without_publishing_partial_index ... ok
+test data::tests::parallel_daily_symbol_indices_match_scalar_for_sparse_and_empty_days ... ok
+test data::tests::replacing_execution_quotes_preserves_duplicate_timestamp_rows ... ok
+test data::tests::series_columns_preserve_full_snapshots_and_distinct_price_bits ... ok
+test data::tests::series_end_position_index_preserves_decision_and_current_boundaries ... ok
+test data::tests::series_overlay_materializes_only_changed_values_and_preserves_history_cutoff ... ok
+test data::tests::shared_execution_quote_release_does_not_clone_the_base_map ... ok
+test data::tests::symbol_id_union_preserves_lexical_order_and_all_component_sources ... ok
+test data::tests::source_volume_contract_rejects_windows_containing_missing_values ... ok
+test data::tests::symbol_price_series_test_constructor_sorts_unsorted_rows ... ok
+test data::tests::unique_dataset_applies_sparse_intraday_overlay_to_daily_and_symbol_views ... ok
+test data::tests::parallel_daily_bundle_validation_keeps_earliest_error_and_component_order ... ok
+test decision_projection::tests::projection_contract_does_not_shadow_core_market_or_typed_fields ... ok
+test decision_projection::tests::exact_projection_coverage_and_classified_absence_are_receipted ... ok
+test decision_projection::tests::projection_rejects_future_drift_or_unbound_receipts ... ok
+test data::tests::volume_rolling_ignores_zero_volume_rows_for_source_and_legacy_data ... ok
+test decision_projection::tests::projection_rejects_incomplete_duplicate_extra_and_overlapping_population ... ok
+test decision_projection::tests::projection_rejects_nonfinite_wrong_fields_and_unproven_absence ... ok
+test engine::tests::backtest_execution_dates_match_sparse_lagged_equity_schedule ... ok
+test engine::tests::after_trading_cancel_is_executed_as_a_control_not_a_next_session_order ... ok
+test engine::tests::compact_progress_keeps_counts_without_event_payload_clones ... ok
+test engine::tests::current_bar_close_uses_decision_day_close_for_fill ... ok
+test engine::tests::decision_projection_does_not_silently_shift_a_start_without_prior_inputs ... ok
+test engine::tests::current_close_order_at_1500_loads_and_uses_post_close_matching_window ... ok
+test engine::tests::compact_manual_progress_keeps_exact_applications_and_fallible_delivery_stops_the_run ... ok
+test engine::tests::decision_projection_failure_never_reaches_strategy_and_does_not_blindly_retry ... ok
+test engine::tests::decision_projection_rejects_future_response_before_any_strategy_callback ... ok
+test engine::tests::decision_projection_refuses_static_scores_and_same_session_inputs ... ok
+test engine::tests::decision_projection_rejects_missing_calendar_inputs_instead_of_dropping_a_session ... ok
+test engine::tests::decision_projection_is_called_before_callbacks_and_is_not_shared_or_carried_forward ... ok
+test engine::tests::decision_projection_requested_first_session_uses_visible_preperiod_inputs ... ok
+test engine::tests::default_close_phase_waits_for_close_and_callbacks_receive_completed_trade_history ... ok
+test engine::tests::early_pre_open_schedules_observe_manual_receipts_in_chronological_order ... ok
+test engine::tests::empty_manual_source_does_not_retime_natural_strategy_execution ... ok
+test engine::tests::join_text_parts_matches_vec_join_contract ... ok
+test engine::tests::final_day_late_intents_are_retained_without_orders_or_fills_past_the_end ... ok
+test engine::tests::full_minute_coverage_rejects_missing_active_bars_but_allows_paused_or_zero_volume ... ok
+test engine::tests::lagged_signal_callbacks_keep_signal_date_but_process_notifications_use_execution_date ... ok
+test engine::tests::late_day_callbacks_read_the_actual_earlier_trade_and_keep_their_current_clock ... ok
+test engine::tests::late_complete_targets_use_latest_target_and_next_day_zero_supersedes_them ... ok
+test engine::tests::late_intents_do_not_wait_for_another_selection_snapshot ... ok
+test engine::tests::late_imperative_orders_execute_once_in_next_session_with_original_dates_and_new_price ... ok
+test engine::tests::lifecycle_quote_filter_skips_only_dated_legal_absence_before_loading ... ok
+test engine::tests::late_opening_callback_is_interleaved_with_earlier_quotes_and_manual_observations ... ok
+test engine::tests::minute_event_clock_uses_timestamp_order_and_coalesces_equal_heads ... ok
+test engine::tests::latest_unsent_complete_portfolio_does_not_union_an_older_pre_market_target ... ok
+test engine::tests::minute_schedules_fire_at_each_declared_time_without_market_rows_at_those_times ... ok
+test engine::tests::next_bar_open_eligible_universe_helper_does_not_block_on_decision_day_risk ... ok
+test engine::tests::next_bar_open_executes_last_decision_without_execution_day_factor_snapshot ... ok
+test engine::tests::minute_observer_never_sees_a_later_fill_from_a_coarse_phase ... ok
+test engine::tests::next_bar_open_execution_risk_ignores_decision_day_paused_state ... ok
+test engine::tests::manual_observations_are_visible_at_their_real_phase_and_each_receipt_sequence ... ok
+test engine::tests::next_bar_open_execution_risk_ignores_decision_day_st_state ... ok
+test engine::tests::next_bar_open_execution_risk_ignores_decision_day_star_st_state ... ok
+test engine::tests::next_bar_open_execution_risk_ignores_decision_day_upper_limit_state ... ok
+test engine::tests::next_bar_open_execution_risk_ignores_later_one_yuan_close ... ok
+test engine::tests::next_bar_open_execution_risk_rejects_execution_day_delisted_state ... ok
+test engine::tests::next_bar_open_execution_risk_rejects_blacklisted_buy_on_execution_day ... ok
+test engine::tests::next_bar_open_execution_risk_rejects_execution_day_paused_state ... ok
+test engine::tests::next_bar_open_execution_risk_rejects_execution_day_star_st_state ... ok
+test engine::tests::next_bar_open_execution_risk_rejects_execution_day_st_state ... ok
+test engine::tests::next_bar_open_execution_risk_rejects_execution_day_upper_limit_buy ... ok
+test engine::tests::next_bar_open_execution_risk_rejects_one_yuan_open_despite_higher_close ... ok
+test engine::tests::next_bar_open_execution_risk_uses_open_not_close_for_upper_limit_buy ... ok
+test engine::tests::next_bar_open_same_day_rebuy_uses_actual_execution_date ... ok
+test engine::tests::next_bar_open_scheduled_signal_uses_decision_date_not_execution_date ... ok
+test engine::tests::next_bar_open_sell_respects_allow_sell_policy_on_execution_day ... ok
+test engine::tests::next_bar_open_sell_risk_ignores_decision_day_paused_and_lower_limit_state ... ok
+test engine::tests::next_bar_open_sell_risk_rejects_execution_day_lower_limit_state ... ok
+test engine::tests::next_bar_open_sell_risk_uses_open_not_close_for_lower_limit_sell ... ok
+test engine::tests::next_bar_open_sell_volume_limit_ignores_decision_day_zero_volume ... ok
+test engine::tests::next_bar_open_session_audit_flags_zero_volume_without_rewriting_fills ... ok
+test engine::tests::next_bar_open_skips_unavailable_lag_day_and_fills_next_open ... ok
+test engine::tests::next_bar_open_strategy_context_data_helpers_use_decision_date ... ok
+test engine::tests::next_bar_open_target_percent_freezes_decision_day_equity ... ok
+test engine::tests::next_bar_open_target_portfolio_smart_sizes_with_execution_day_open ... ok
+test engine::tests::observed_manual_sale_updates_the_shared_same_day_rebuy_rule ... ok
+test engine::tests::next_open_observation_loads_quotes_even_when_execution_price_is_open ... ok
+test engine::tests::opening_and_late_lifecycle_schedules_do_not_read_past_or_future_manual_state ... ok
+test engine::tests::opening_schedule_cannot_cross_the_after_trading_phase ... ok
+test engine::tests::physical_on_day_rules_keep_each_actual_submission_time ... ok
+test engine::tests::opening_subscription_is_loaded_without_replaying_quotes_before_its_activation ... ok
+test engine::tests::opening_orders_are_submitted_once_at_their_real_clock_even_with_an_earlier_execution_window ... ok
+test engine::tests::post_close_phase_callbacks_never_rewind_before_completed_fills ... ok
+test engine::tests::post_close_wait_has_no_position_before_the_first_actual_matching_tick ... ok
+test engine::tests::pre_trading_orders_wait_for_the_configured_window_and_keep_their_audit ... ok
+test engine::tests::process_callbacks_observe_the_completed_minute_trade_and_its_clock ... ok
+test engine::tests::scheduled_event_detail_records_actual_time_only_for_timed_rules ... ok
+test engine::tests::pre_market_cancel_is_observed_before_the_next_open_and_new_signal ... ok
+test engine::tests::unknown_identity_or_missing_candidate_does_not_waive_quote_coverage ... ok
+test engine::tests::window_algorithm_cannot_publish_future_fill_quantity_to_earlier_callbacks ... ok
+test etf_execution::tests::latest_generation_overwrites_pending_targets_and_preserves_candidate_order ... ok
+test engine::tests::wholly_prelisting_universe_retains_cash_days_without_fabricating_prices ... ok
+test etf_execution::tests::no_loaded_next_session_is_not_guessed_from_natural_days ... ok
+test events::tests::accounting_origin_cannot_disguise_an_exchange_order_or_fee ... ok
+test events::tests::order_event_status_quantity_contract_is_explicit ... ok
+test events::tests::fill_execution_timestamp_range_is_explicit_and_backward_compatible ... ok
+test events::tests::process_event_business_lifecycle_filter_keeps_audit_events_only ... ok
+test execution_capacity::tests::completed_volume_cannot_be_used_for_an_earlier_open ... ok
+test execution_capacity::tests::decimal_participation_never_rounds_a_fractional_share_up_or_overflows ... ok
+test execution_capacity::tests::delayed_publication_and_invalid_bounds_are_not_treated_as_zero_volume ... ok
+test execution_capacity::tests::session_audit_changes_verdict_not_executed_quantity ... ok
+test execution_schedule::tests::clock_entitlements_are_exact_and_allow_backlog_without_future_quote_counts ... ok
+test factor_cross_section::tests::neutralization_preserves_input_order ... ok
+test factor_cross_section::tests::ties_keep_equal_rank_and_missing_universe_rejects ... ok
+test factor_cross_section::tests::historical_ranks_keep_ties_and_unknown_full_cross_sections ... ok
+test factor_events::tests::cross_is_event_not_state_and_never_uses_future ... ok
+test factor_events::tests::every_parameter_domain_is_structured_and_matches_native_defaults ... ok
+test factor_events::tests::missing_is_not_zero_and_breakout_excludes_current ... ok
+test factor_events::tests::no_event_has_no_bars_since_and_type_errors_reject ... ok
+test engine::tests::scheduled_day_limit_order_loads_later_quotes_without_strategy_minute_subscription ... ok
+test factor_events::tests::ta_rewarms_after_gap_and_const_zscore_is_unknown ... ok
+test factor_events::tests::ta_sma_real_values_and_parameter_validation ... ok
+test finite_serialization::tests::pending_numbers_cannot_be_silently_serialized_as_optional_nulls ... ok
+test fixed_point::tests::decimal_parser_rounds_only_beyond_money_scale ... ok
+test fixed_point::tests::fixed_budget_comparison_rejects_one_micro_yuan_overrun ... ok
+test fixed_point::tests::fixed_budget_never_exceeds_cash_after_cost ... ok
+test fixed_point::tests::fixed_fifo_pnl_and_external_flow_are_deterministic ... ok
+test fixed_point::tests::runtime_cost_model_matches_fixed_execution_primitive ... ok
+test fixed_point::tests::runtime_split_commission_matches_fixed_execution_primitive ... ok
+test holding_policy::tests::absolute_locks_are_inclusive_and_override_timed_exit_without_changing_other_symbols ... ok
+test holding_policy::tests::manual_origin_only_bypasses_automatic_policy_not_an_order_or_broker_permission ... ok
+test holding_policy::tests::opening_date_follows_fills_not_partial_sales_or_corporate_conversions ... ok
+test holding_policy::tests::three_complete_sessions_protect_through_wednesday_not_72_hours ... ok
+test holding_policy::tests::zero_disabled_and_missing_calendar_or_opened_date_are_not_inferred ... ok
+test instrument::tests::lifecycle_is_dated_and_latest_undated_terminal_status_is_not_historical_evidence ... ok
+test instrument::tests::listing_sector_is_explicit_and_unknown_stays_unknown ... ok
+test instrument::tests::order_quantity_rules_are_case_insensitive_without_allocating_normalized_boards ... ok
+test manual_execution::tests::a_failed_corporate_projection_does_not_change_the_book_or_receipt_cursor ... ok
+test manual_execution::tests::all_required_money_and_binding_fields_reject_missing_or_wrong_values ... ok
+test manual_execution::tests::authoritative_total_fee_does_not_require_inventing_unknown_components ... ok
+test manual_execution::tests::changing_any_external_price_or_identity_invalidates_the_frozen_trace ... ok
+test manual_execution::tests::complete_exact_decimal_evidence_allows_later_observation_and_retains_source_digits ... ok
+test manual_execution::tests::confirmed_manual_fill_changes_cash_and_lots_but_not_external_cash_flow_units ... ok
+test manual_execution::tests::confirmed_no_order_outcome_is_distinct_from_unconfirmed_or_unknown_work ... ok
+test manual_execution::tests::cursor_waits_for_observation_and_never_reapplies_or_rewinds ... ok
+test manual_execution::tests::data_scope_only_contains_actual_filled_securities_and_validates_the_source ... ok
+test manual_execution::tests::failed_multi_receipt_advance_keeps_both_progress_and_portfolio_unchanged ... ok
+test manual_execution::tests::fixed_money_decimal_text_preserves_micro_units_without_float_conversion ... ok
+test factor_events::tests::literal_unknown_fields_reject_and_catalog_is_not_trading_permission ... ok
+test manual_execution::tests::inconsistent_counts_terminals_audits_and_duplicate_facts_are_rejected ... ok
+test factor_events::tests::parameter_domains_keep_enumeration_labels_without_debug_string_parsing ... ok
+test manual_execution::tests::late_buy_fifo_depletion_preserves_costs_and_cannot_unlock_today_lots ... ok
+test manual_execution::tests::late_fee_evidence_keeps_the_original_fill_observation_clock ... ok
+test manual_execution::tests::late_buy_retains_the_earliest_opening_and_latest_buy_dates ... ok
+test manual_execution::tests::manual_fee_total_includes_extra_charges_and_rejects_inconsistent_components ... ok
+test manual_execution::tests::manual_mismatches_are_atomic_and_do_not_borrow_shares_cash_or_override_pending_orders ... ok
+test manual_execution::tests::observations_follow_durable_receipt_order_and_not_input_array_order ... ok
+test manual_execution::tests::partial_cancel_is_valid_but_full_fill_cannot_be_reported_as_cancelled ... ok
+test manual_execution::tests::runtime_position_events_cannot_claim_observations_after_the_source_cutoff ... ok
+test manual_execution::tests::raw_timezone_and_cutoff_are_required ... ok
+test manual_execution::tests::the_next_day_manual_sale_keeps_the_actual_quantity_and_fee_contract ... ok
+test manual_execution::tests::v2_facts_keep_their_encoding_but_cannot_silently_carry_new_runtime_settings ... ok
+test market_event_context::tests::formulas_use_real_limits_and_full_denominators ... ok
+test market_event_context::tests::missing_duplicate_and_unproven_limit_states_fail ... ok
+test market_event_context::tests::chunking_and_future_append_preserve_history ... ok
+test manual_execution::tests::source_time_precision_is_not_invented_and_submitted_time_must_fit_the_interval ... ok
+test metrics::risk_adjusted_contract_tests::changing_daily_rates_adjusts_each_return_before_variance_and_downside ... ok
+test metrics::risk_adjusted_contract_tests::incomplete_or_invalid_rates_are_not_zero_rate_observations ... ok
+test market_event_context::tests::missing_industry_does_not_invent_groups_or_disable_independent_market_facts ... ok
+test metrics::risk_adjusted_contract_tests::zero_deviation_and_single_sample_ratios_remain_undefined ... ok
+test metrics::tests::a_defined_zero_ratio_is_not_missing ... ok
+test metrics::tests::drawdown_includes_initial_nav_without_adding_a_trading_day ... ok
+test metrics::tests::benchmark_cumulative_return_uses_first_day_previous_close ... ok
+test metrics::tests::external_cash_flow_is_excluded_from_return_and_reported_separately ... ok
+test metrics::tests::first_day_loss_is_preserved_in_shared_backtest_metrics ... ok
+test metrics::tests::gains_without_downside_have_no_sortino_or_monthly_sharpe ... ok
+test metrics::tests::no_risk_ratio_is_fabricated_after_nav_has_reached_zero ... ok
+test metrics::tests::signal_baseline_uses_same_close_for_strategy_and_benchmark ... ok
+test metrics::tests::risk_adjusted_metrics_use_daily_pit_rates_and_all_period_downside ... ok
+test numeric_expr_vm::tests::benchmark_numeric_vm_against_rhai ... ignored, manual release-mode performance evidence
+test metrics::tests::undefined_ratios_remain_null_in_backtest_metrics ... ok
+test numeric_expr_vm::tests::evaluates_numeric_boolean_and_if_expressions ... ok
+test numeric_expr_vm::tests::floating_comparisons_match_rhai_epsilon_semantics ... ok
+test numeric_expr_vm::tests::invalid_clamp_returns_error_without_panicking ... ok
+test numeric_expr_vm::tests::nullable_boolean_truth_table_preserves_unknown_under_negation ... ok
+test numeric_expr_vm::tests::nullable_short_circuit_and_explicit_conditional_branches_are_lazy ... ok
+test numeric_expr_vm::tests::missing_numeric_operands_do_not_become_boolean_false_or_zero ... ok
+test numeric_expr_vm::tests::rejects_dynamic_language_features ... ok
+test numeric_expr_vm::tests::scratch_reuses_allocations_across_program_runs ... ok
+test numeric_expr_vm::tests::short_circuit_does_not_resolve_unused_variable ... ok
+test numeric_expr_vm::tests::supports_numeric_builtins_and_local_reuse ... ok
+test numeric_factors::tests::bulk_load_is_sorted_and_keeps_last_value_for_each_field ... ok
+test numeric_factors::tests::clone_does_not_share_mutable_values ... ok
+test numeric_factors::tests::compact_keys_inline_dynamic_names_and_keep_long_static_storage ... ok
+test numeric_factors::tests::exact_reservation_preserves_values_and_avoids_growth_during_known_inserts ... ok
+test numeric_factors::tests::long_dynamic_unicode_and_short_keys_keep_the_same_json_map ... ok
+test numeric_factors::tests::serialization_keeps_the_map_contract_and_precise_numbers ... ok
+test numeric_expr_vm::tests::matches_rhai_for_representative_numeric_boolean_corpus ... ok
+test numeric_factors::tests::wide_batch_merge_matches_tree_and_preserves_old_key_ownership ... ok
+test pattern_context::tests::normalized_rule_does_not_turn_an_omitted_window_into_explicit_null ... ok
+test pattern_context::tests::reference_index_never_defaults_to_performance_benchmark ... ok
+test pattern_context::tests::runtime_contract_rejects_missing_range_and_recursive_ranks ... ok
+test numeric_factors::tests::updates_order_removal_and_values_match_tree_map ... ok
+test pattern_context::tests::dataset_rank_is_full_scope_causal_and_equal_to_pure_cross_section ... ok
+test pattern_context::tests::structured_pool_conditions_are_not_rescanned_inside_serialized_source_code ... ok
+test platform_expr_strategy::tests::allocation_buy_scale_preserves_explicit_overweight_multiplier ... ok
+test platform_expr_strategy::tests::benchmark_compiled_runtime_helper_arguments ... ignored, manual release-mode runtime helper binding benchmark
+test platform_expr_strategy::tests::bjse_symbol_detection_is_case_insensitive_without_normalizing_all_symbols ... ok
+test platform_expr_strategy::tests::available_factor_name_collection_preserves_sparse_and_repeated_fields ... ok
+test platform_expr_strategy::tests::buy_filter_attaches_denials_without_rewriting_selection ... ok
+test platform_expr_strategy::tests::available_factor_name_collection_preserves_wide_dynamic_field_identity ... ok
+test platform_expr_strategy::tests::buy_filter_uses_active_schedule_time_instead_of_first_configured_time ... ok
+test platform_expr_strategy::tests::completed_session_factor_dates_exclude_intraday_and_preserve_next_open ... ok
+test platform_expr_strategy::tests::buy_quote_filter_rejects_missing_intraday_quote_not_daily_close ... ok
+test platform_expr_strategy::tests::completed_session_bound_value_does_not_read_same_day_future_value ... ok
+test platform_expr_strategy::tests::current_rolling_helpers_do_not_load_factor_maps_or_decision_rollings ... ok
+test platform_expr_strategy::tests::daily_pattern_runtime_uses_the_shared_kernel_and_rejects_early_visibility ... ok
+test platform_expr_strategy::tests::dated_position_exposure_uses_the_latest_effective_point ... ok
+test platform_expr_strategy::tests::daily_replacement_reference_records_an_explicit_empty_previous_target ... ok
+test platform_expr_strategy::tests::daily_replacement_reference_uses_previous_target_before_lagged_orders_fill ... ok
+test platform_expr_strategy::tests::expression_plan_only_executes_prelude_when_expression_depends_on_it ... ok
+test platform_expr_strategy::tests::expression_plan_skips_unreferenced_market_scope_maps ... ok
+test platform_expr_strategy::tests::framework_rolling_factor_aliases_resolve_to_raw_market_series ... ok
+test platform_expr_strategy::tests::lagged_rebalance_emits_target_value_even_when_projection_is_unchanged ... ok
+test platform_expr_strategy::tests::factor_position_target_reduces_once_without_daily_rebalance_override ... ok
+test platform_expr_strategy::tests::market_cap_ordered_selection_range_is_inclusive_and_field_specific ... ok
+test platform_expr_strategy::tests::model_target_lifecycle_removes_exits_and_appends_replacements ... ok
+test platform_expr_strategy::tests::numeric_vm_compiles_static_runtime_helper_arguments ... ok
+test platform_expr_strategy::tests::numeric_vm_reuses_compiled_program_across_invocations ... ok
+test platform_expr_strategy::tests::numeric_vm_rewrites_only_valid_iso_date_literals ... ok
+test platform_expr_strategy::tests::numeric_vm_reuses_rolling_helper_program_across_dates ... ok
+test platform_expr_strategy::tests::market_cap_ascending_rank_reuses_only_equivalent_universe_order ... ok
+test platform_expr_strategy::tests::periodic_selected_bjse_buy_rejection_is_audited_without_creating_an_order ... ok
+test platform_expr_strategy::tests::platform_aiquant_buy_rejection_keeps_candidate_buy_disabled ... ok
+test platform_expr_strategy::tests::platform_aiquant_blocks_target_increase_when_stop_loss_sell_is_lower_limit_blocked ... ok
+test platform_expr_strategy::tests::platform_aiquant_buy_rejection_uses_scheduled_price_not_open_limit ... ok
+test platform_expr_strategy::tests::platform_aiquant_daily_top_up_releases_slot_after_take_profit_exit ... ok
+test platform_expr_strategy::tests::platform_aiquant_daily_top_up_uses_remaining_slot_budget ... ok
+test platform_expr_strategy::tests::platform_aiquant_daily_top_up_releases_second_slot_after_prior_top_up ... ok
+test platform_expr_strategy::tests::platform_aiquant_delays_upper_limit_take_profit_to_configured_open_time ... ok
+test platform_expr_strategy::tests::platform_aiquant_marked_total_uses_intraday_last_not_close ... ok
+test platform_expr_strategy::tests::platform_aiquant_marked_total_value_uses_scheduled_quote ... ok
+test platform_expr_strategy::tests::platform_aiquant_minute_last_projection_uses_last_quote_for_buy_budget ... ok
+test platform_expr_strategy::tests::platform_aiquant_marks_highlimit_before_cptrade_time ... ok
+test platform_expr_strategy::tests::platform_aiquant_minute_stop_loss_requires_intraday_quote ... ok
+test platform_expr_strategy::tests::platform_aiquant_next_open_stop_loss_uses_signal_close_not_execution_last_price ... ok
+test platform_expr_strategy::tests::platform_aiquant_missing_risk_state_does_not_force_existing_position_exit ... ok
+test platform_expr_strategy::tests::platform_aiquant_next_open_target_delta_uses_previous_close_and_sizes_at_open ... ok
+test platform_expr_strategy::tests::platform_aiquant_projection_allows_signal_day_market_fallback_for_next_open ... ok
+test platform_expr_strategy::tests::platform_aiquant_projection_does_not_release_sell_slot_without_execution_quote ... ok
+test platform_expr_strategy::tests::platform_aiquant_projection_rejects_missing_symbol_execution_quote ... ok
+test platform_expr_strategy::tests::platform_aiquant_projection_reserves_sell_cost_without_same_callback_proceeds ... ok
+test platform_expr_strategy::tests::platform_aiquant_periodic_rebalance_uses_total_equity_equal_weight_buy_budget ... ok
+test platform_expr_strategy::tests::platform_aiquant_remaining_buy_cash_uses_strategy_visible_price_and_projected_quantity ... ok
+test platform_expr_strategy::tests::platform_aiquant_risk_level_forces_existing_position_exit ... ok
+test platform_expr_strategy::tests::platform_aiquant_selection_uses_decision_market_cap ... ok
+test platform_expr_strategy::tests::platform_aiquant_sell_projection_uses_signal_day_market_for_lagged_execution ... ok
+test platform_expr_strategy::tests::platform_aiquant_scheduled_quote_uses_configured_intraday_time ... ok
+test platform_expr_strategy::tests::platform_aiquant_sells_down_before_actionable_take_profit_exit ... ok
+test platform_expr_strategy::tests::platform_aiquant_skips_positive_target_adjust_when_position_will_close ... ok
+test platform_expr_strategy::tests::platform_aiquant_stock_expr_uses_scheduled_minute_price_for_limit_check ... ok
+test platform_expr_strategy::tests::platform_aiquant_target_adjust_uses_scheduled_quote_for_position_value ... ok
+test platform_expr_strategy::tests::platform_aiquant_target_value_uses_scheduled_mark_for_delta ... ok
+test platform_expr_strategy::tests::platform_aiquant_stop_loss_uses_fee_cost_basis_avg_cost ... ok
+test platform_expr_strategy::tests::platform_aiquant_weak_market_allows_pending_highlimit_target_adjust_after_open ... ok
+test platform_expr_strategy::tests::platform_aiquant_upper_limit_buy_disabled_does_not_force_exit_existing_position ... ok
+test platform_expr_strategy::tests::platform_aiquant_weak_market_emits_daily_position_target_adjustment ... ok
+test platform_expr_strategy::tests::platform_aiquant_weak_market_marks_upper_limit_but_allows_target_adjust ... ok
+test platform_expr_strategy::tests::platform_aiquant_weak_market_threshold_only_sells_overweight_positions ... ok
+test platform_expr_strategy::tests::platform_aiquant_weak_market_threshold_top_up_uses_projected_remaining_budget ... ok
+test platform_expr_strategy::tests::platform_aiquant_weak_market_retargets_same_ratio_every_day ... ok
+test platform_expr_strategy::tests::platform_calendar_day_rebalance_interval_can_be_enabled_explicitly ... ok
+test platform_expr_strategy::tests::platform_aiquant_weak_market_waits_pending_highlimit_target_adjust ... ok
+test platform_expr_strategy::tests::platform_buy_rejection_allows_lower_limit_buy_when_ask_is_available ... ok
+test platform_expr_strategy::tests::platform_current_rolling_uses_decision_date_row_not_prior_factor_row ... ok
+test platform_expr_strategy::tests::platform_can_sell_position_uses_configured_lower_limit_policy ... ok
+test platform_expr_strategy::tests::platform_daily_top_up_caps_empty_slot_to_equal_weight_target ... ok
+test platform_expr_strategy::tests::platform_daily_top_up_counts_submitted_zero_fill_candidate_as_strategy_slot ... ok
+test platform_expr_strategy::tests::platform_daily_top_up_does_not_buy_back_same_day_exit ... ok
+test platform_expr_strategy::tests::platform_daily_top_up_keeps_selection_limited_to_target_count ... ok
+test platform_expr_strategy::tests::platform_daily_top_up_releases_unsellable_stop_loss_slot ... ok
+test platform_expr_strategy::tests::platform_daily_top_up_release_slot_flag_matches_aiquant_exit_signal_state ... ok
+test platform_expr_strategy::tests::platform_daily_top_up_skips_current_stop_loss_symbol_like_aiquant ... ok
+test platform_expr_strategy::tests::platform_day_state_uses_decision_benchmark_close ... ok
+test platform_expr_strategy::tests::platform_daily_top_up_uses_same_day_sell_cash ... ok
+test platform_expr_strategy::tests::platform_delayed_open_day_carried_full_close_releases_second_top_up_slot ... ok
+test platform_expr_strategy::tests::platform_delayed_open_exit_uses_delayed_time_for_slot_projection ... ok
+test platform_expr_strategy::tests::platform_delayed_open_day_take_profit_releases_second_top_up_slot ... ok
+test platform_expr_strategy::tests::platform_expr_code_number_extracts_stock_digits ... ok
+test platform_expr_strategy::tests::platform_explicit_actions_keep_every_declared_trade_time ... ok
+test platform_expr_strategy::tests::platform_expr_cost_model_honors_zero_minimum_commission ... ok
+test platform_expr_strategy::tests::platform_expr_expands_day_factor_in_prelude ... ok
+test platform_expr_strategy::tests::platform_expr_limit_flags_are_directional ... ok
+test platform_expr_strategy::tests::platform_delayed_open_partial_exit_releases_top_up_slot ... ok
+test platform_expr_strategy::tests::platform_expr_normalizes_python_style_integer_division ... ok
+test platform_expr_strategy::tests::platform_expr_normalizes_signal_field_alias_in_prelude ... ok
+test platform_expr_strategy::tests::platform_expr_cost_model_uses_commission_override ... ok
+test platform_expr_strategy::tests::platform_expr_preflight_rejects_malformed_expression_with_field_name ... ok
+test platform_expr_strategy::tests::platform_expr_missing_requested_factor_does_not_default_to_zero ... ok
+test platform_expr_strategy::tests::platform_expr_preflight_accepts_all_configured_expression_categories ... ok
+test platform_expr_strategy::tests::platform_expr_rewrites_nested_ternary ... ok
+test platform_expr_strategy::tests::platform_expr_rewrites_prelude_assignment_ternary ... ok
+test platform_expr_strategy::tests::platform_expr_rewrites_multiple_nested_ternaries_inside_function_calls ... ok
+test platform_expr_strategy::tests::platform_expr_safe_div_supports_two_and_three_arg_forms ... ok
+test platform_expr_strategy::tests::platform_expr_supports_python_style_string_aliases ... ok
+test platform_expr_strategy::tests::platform_expr_tracks_requested_dynamic_factor_identifiers ... ok
+test platform_expr_strategy::tests::platform_full_exposure_carried_full_close_releases_second_top_up_slot ... ok
+test platform_expr_strategy::tests::platform_lagged_exit_does_not_reserve_replacement_slot_before_execution ... ok
+test platform_expr_strategy::tests::platform_full_exposure_partial_stop_loss_releases_second_top_up_slot ... ok
+test platform_expr_strategy::tests::platform_helpers_support_generic_rolling_stats_and_normalized_factors ... ok
+test platform_expr_strategy::tests::platform_max_holding_days_counts_decision_trading_days_not_calendar_days ... ok
+test platform_expr_strategy::tests::platform_marked_total_value_uses_current_day_close ... ok
+test platform_expr_strategy::tests::platform_market_cap_field_uses_storage_unit_without_extra_scaling ... ok
+test platform_expr_strategy::tests::platform_minute_last_volume_limit_does_not_require_l1_quantity ... ok
+test platform_expr_strategy::tests::platform_max_holding_days_exit_preempts_take_profit_exit ... ok
+test platform_expr_strategy::tests::platform_next_open_defers_complete_static_selection_risk_before_universe_output ... ok
+test platform_expr_strategy::tests::platform_next_open_risk_level_exit_ignores_decision_day_sellability ... ok
+test platform_expr_strategy::tests::platform_next_open_projected_execution_price_uses_open_not_close ... ok
+test platform_expr_strategy::tests::platform_next_open_selection_applies_explicit_signal_day_risk_filter ... ok
+test platform_expr_strategy::tests::platform_next_open_select_symbols_defers_decision_day_limit_state ... ok
+test platform_expr_strategy::tests::platform_next_open_selection_ignores_execution_day_limit_state ... ok
+test platform_expr_strategy::tests::platform_next_open_sell_risk_uses_open_not_close_for_lower_limit ... ok
+test platform_expr_strategy::tests::platform_order_value_quantity_includes_buy_commission_budget ... ok
+test platform_expr_strategy::tests::platform_numeric_stop_loss_is_strictly_below_multiplier ... ok
+test platform_expr_strategy::tests::platform_periodic_rebalance_caps_empty_slot_to_equal_weight_target ... ok
+test platform_expr_strategy::tests::platform_periodic_rebalance_skips_unsellable_stop_loss_symbol ... ok
+test platform_expr_strategy::tests::platform_projected_execution_limit_checks_respect_risk_policy ... ok
+test platform_expr_strategy::tests::platform_periodic_rebalance_uses_same_day_sell_cash_for_later_buys ... ok
+test platform_expr_strategy::tests::platform_projected_market_fill_caps_volume_limit ... ok
+test platform_expr_strategy::tests::platform_rebalance_date_due_does_not_use_the_on_day_default_clock ... ok
+test platform_expr_strategy::tests::platform_periodic_rebalance_tops_up_underweight_selected_holding ... ok
+test platform_expr_strategy::tests::platform_rebalance_schedule_matches_monthly_tradingday ... ok
+test platform_expr_strategy::tests::platform_rebalance_schedule_matches_physical_time ... ok
+test platform_expr_strategy::tests::platform_rebalance_schedule_matches_weekly_weekday ... ok
+test platform_expr_strategy::tests::platform_projection_does_not_consume_cash_from_unfillable_sell ... ok
+test platform_expr_strategy::tests::platform_rebalance_keeps_unresolved_delisted_position_without_orders_or_replacement ... ok
+test platform_expr_strategy::tests::platform_selection_does_not_fill_candidates_with_buy_risk_rejections ... ok
+test platform_expr_strategy::tests::platform_selection_and_buy_respect_allow_flags_are_configurable ... ok
+test platform_expr_strategy::tests::platform_selection_expands_pct_change_in_filter_and_rank_expr ... ok
+test platform_expr_strategy::tests::platform_selection_kcb_switch_overrides_legacy_universe_exclude ... ok
+test platform_expr_strategy::tests::platform_refresh_rate_uses_stateful_trading_day_counter ... ok
+test platform_expr_strategy::tests::platform_selection_missing_candidate_risk_state_does_not_change_default_universe ... ok
+test platform_expr_strategy::tests::platform_selection_ranks_with_previous_factor_date ... ok
+test broker::tests::simulator_transaction_profile_preserves_successful_output ... ok
+test platform_expr_strategy::tests::platform_signal_price_model_lifecycle_survives_unfilled_buy_and_exits ... ok
+test platform_expr_strategy::tests::platform_selection_uses_complete_static_risk_policy_before_universe_output ... ok
+test platform_expr_strategy::tests::platform_skip_window_keeps_pending_highlimit_until_open ... ok
+test platform_expr_strategy::tests::platform_skip_window_runs_delayed_open_exit_before_seasonal_liquidation ... ok
+test platform_expr_strategy::tests::platform_stock_expr_exposes_star_st_and_bjse_fields_without_default_selection_risk ... ok
+test platform_expr_strategy::tests::platform_selection_ranks_by_candidate_market_cap_with_current_precomputed_factors ... ok
+test platform_expr_strategy::tests::platform_stock_expr_rejects_when_volume_ma5_exceeds_market_volume_ma100 ... ok
+test platform_expr_strategy::tests::platform_stock_expr_handles_positive_volume_guard ... ok
+test platform_expr_strategy::tests::platform_stock_state_uses_completed_day_high_and_low_for_limit_touch ... ok
+test platform_expr_strategy::tests::platform_stock_state_uses_factor_date_for_selection_market_fields ... ok
+test platform_expr_strategy::tests::platform_stop_loss_residual_pending_rechecks_signal_next_day ... ok
+test platform_expr_strategy::tests::platform_stock_state_uses_market_series_when_factor_map_has_no_rolling ... ok
+test platform_expr_strategy::tests::platform_stock_state_uses_framework_rolling_series ... ok
+test platform_expr_strategy::tests::platform_strategy_baseline_risk_rejects_new_listing_buy_without_selection_replacement ... ok
+test platform_expr_strategy::tests::platform_strategy_can_cancel_latest_open_order_by_runtime_id ... ok
+test platform_expr_strategy::tests::platform_strategy_emits_algo_order_actions ... ok
+test platform_expr_strategy::tests::platform_strategy_can_filter_with_string_factors ... ok
+test platform_expr_strategy::tests::platform_strategy_emits_explicit_actions_in_open_auction_stage ... ok
+test platform_expr_strategy::tests::platform_strategy_emits_explicit_actions_when_rotation_is_disabled ... ok
+test platform_expr_strategy::tests::platform_strategy_emits_target_portfolio_smart_algo_order_style ... ok
+test platform_expr_strategy::tests::platform_stop_take_fraction_values_are_return_thresholds ... ok
+test platform_expr_strategy::tests::platform_strategy_emits_target_shares_explicit_action ... ok
+test platform_expr_strategy::tests::platform_strategy_emits_target_portfolio_smart_explicit_action ... ok
+test platform_expr_strategy::tests::platform_strategy_emits_universe_management_actions ... ok
+test platform_expr_strategy::tests::platform_strategy_exposes_open_order_runtime_fields ... ok
+test platform_expr_strategy::tests::platform_strategy_exposes_advanced_data_runtime_helpers ... ok
+test platform_expr_strategy::tests::platform_strategy_exposes_position_lifecycle_runtime_fields ... ok
+test platform_expr_strategy::tests::platform_strategy_empty_exclude_keeps_buy_risk_without_selection_filtering ... ok
+test platform_expr_strategy::tests::platform_strategy_exposes_process_event_runtime_fields ... ok
+test platform_expr_strategy::tests::platform_strategy_filters_target_portfolio_smart_by_subscription_guard ... ok
+test platform_expr_strategy::tests::platform_strategy_skips_explicit_actions_when_schedule_does_not_match ... ok
+test platform_expr_strategy::tests::platform_strategy_suppresses_explicit_target_for_blocked_stop_loss_exit ... ok
+test platform_expr_strategy::tests::platform_strategy_uses_decision_date_for_next_bar_open_signals ... ok
+test platform_expr_strategy::tests::platform_strategy_treats_missing_stock_rolling_window_as_filter_reject ... ok
+test platform_expr_strategy::tests::platform_take_profit_default_uses_position_cost_basis ... ok
+test platform_expr_strategy::tests::platform_take_profit_false_does_not_track_upper_limit_pending_sell ... ok
+test platform_expr_strategy::tests::platform_take_profit_sells_position_at_upper_limit ... ok
+test platform_expr_strategy::tests::platform_weak_exposure_carried_full_close_keeps_residual_slot ... ok
+test platform_expr_strategy::tests::platform_weak_exposure_partial_stop_loss_keeps_residual_slot ... ok
+test platform_expr_strategy::tests::portfolio_drawdown_control_is_idempotent_and_rearms_after_cooldown ... ok
+test platform_expr_strategy::tests::platform_weak_market_skips_target_increase_before_intraday_stop_loss_sell_blocked ... ok
+test platform_expr_strategy::tests::platform_weak_market_skips_target_adjust_before_actionable_stop_loss ... ok
+test platform_expr_strategy::tests::selection_buffer_retains_held_symbols_within_buffer_rank ... ok
+test platform_expr_strategy::tests::platform_weak_market_skips_target_increase_before_lower_limit_blocked_stop_loss ... ok
+test platform_expr_strategy::tests::projected_historical_slippage_does_not_swallow_missing_calibration ... ok
+test platform_expr_strategy::tests::selection_quote_plan_filters_daily_part_before_minute_candidates ... ok
+test platform_expr_strategy::tests::selection_replacement_limit_caps_voluntary_daily_removals ... ok
+test platform_expr_strategy::tests::session_event_uses_previous_bar_and_recomputes_at_each_minute_without_becoming_a_quote ... ok
+test platform_expr_strategy::tests::selection_quote_plan_keeps_configured_static_selection_risk_for_intraday_fields ... ok
+test platform_expr_strategy::tests::selection_limit_state_requires_intraday_selection_quotes ... ok
+test platform_expr_strategy::tests::stock_pool_exit_weight_redistribution_is_explicit_and_uses_integer_bps ... ok
+test platform_expr_strategy::tests::stock_pool_suspension_keeps_budget_and_exit_redistributes_only_available_weights ... ok
+test platform_expr_strategy::tests::signal_date_explicit_actions_are_due_only_on_declared_snapshot_dates ... ok
+test platform_expr_strategy::tests::portfolio_loss_observes_finalized_nav_after_fees_and_cash_flows ... ok
+test platform_expr_strategy::tests::stock_pool_suspension_resolution_never_reads_the_future_execution_day ... ok
+test platform_expr_strategy::tests::stock_pool_target_lifecycle_keeps_exits_for_next_day_reentry ... ok
+test platform_expr_strategy::tests::stock_state_cache_resets_before_reusing_compact_keys_on_another_date ... ok
+test platform_expr_strategy::tests::strategy_specific_labels_are_not_framework_rolling_factors ... ok
+test platform_expr_strategy::tests::target_portfolio_smart_exposes_decision_and_execution_dates ... ok
+test platform_expr_strategy::tests::stock_snapshot_fields_are_loaded_only_when_the_strategy_uses_them ... ok
+test platform_expr_strategy::tests::target_portfolio_smart_respects_current_date_weight_conditions ... ok
+test platform_expr_strategy::tests::target_scale_replenishment_preserves_strategy_cash_allocation ... ok
+test platform_expr_strategy::tests::strategy105_numeric_expressions_compile_to_vm ... ok
+test platform_expr_strategy::tests::typed_runtime_numbers_preserve_legacy_rhai_formatting ... ok
+test platform_expr_strategy::tests::universe_exclude_matches_explicit_symbols_and_bjse_alias ... ok
+test platform_runtime_schema::tests::runtime_schema_includes_known_identifiers ... ok
+test platform_runtime_schema::tests::runtime_schema_serializes_to_json_object ... ok
+test platform_strategy_spec::tests::accepts_equivalent_risk_policy_alias_values ... ok
+test platform_strategy_spec::tests::accepts_scoped_blacklist_context_in_runtime_risk_policy ... ok
+test platform_expr_strategy::tests::timed_rotation_runs_on_its_schedule_instead_of_the_untimed_day_hook ... ok
+test platform_strategy_spec::tests::canonicalizes_duplicate_execution_aliases_without_changing_strategy_intent ... ok
+test platform_strategy_spec::tests::current_close_respects_explicitly_disabled_liquidity_limit ... ok
+test platform_strategy_spec::tests::engine_config_parses_weak_market_shrink_overweight_threshold ... ok
+test platform_strategy_spec::tests::engine_stock_ma_filter_generates_price_and_volume_expr ... ok
+test platform_strategy_spec::tests::explicit_actions_inherit_top_level_runtime_schedule ... ok
+test platform_strategy_spec::tests::execution_limit_aliases_normalize_to_one_serde_field_without_touching_policy ... ok
+test platform_strategy_spec::tests::explicit_delayed_limit_open_exit_false_overrides_trade_times ... ok
+test platform_strategy_spec::tests::explicit_trading_schedule_overrides_rebalance_trade_times ... ok
+test platform_strategy_spec::tests::index_throttle_uses_signal_ma_not_performance_benchmark_ma ... ok
+test platform_strategy_spec::tests::frozen_candidate_order_is_explicit_and_preserves_source_positions ... ok
+test platform_strategy_spec::tests::multiple_trade_times_do_not_imply_delayed_limit_exit ... ok
+test platform_strategy_spec::tests::native_factor_bindings_declare_completed_session_fields ... ok
+test platform_strategy_spec::tests::normalize_board_does_not_infer_kcb_from_security_code ... ok
+test platform_strategy_spec::tests::numeric_strategy_aliases_accept_exact_zero_but_never_hide_rounding_or_conflicts ... ok
+test platform_strategy_spec::tests::parses_and_rejects_invalid_position_target_rules ... ok
+test platform_strategy_spec::tests::parses_buy_filter_as_a_separate_trading_condition ... ok
+test platform_strategy_spec::tests::parses_daily_schedule_time_for_execution_quotes ... ok
+test platform_strategy_spec::tests::parses_delayed_deposit_receiving_days_expression ... ok
+test platform_strategy_spec::tests::parses_dynamic_model_score_dates_into_platform_config ... ok
+test platform_strategy_spec::tests::parses_execution_cost_overrides_into_platform_config ... ok
+test platform_strategy_spec::tests::parses_execution_slippage_overrides_into_platform_config ... ok
+test platform_strategy_spec::tests::parses_explicit_delayed_limit_open_exit ... ok
+test platform_strategy_spec::tests::parses_explicit_historical_slippage_into_platform_config ... ok
+test platform_strategy_spec::tests::parses_lifecycle_target_portfolio_contract ... ok
+test platform_strategy_spec::tests::parses_generic_futures_actions_and_rejects_incomplete_contracts ... ok
+test platform_expr_strategy::tests::timed_current_close_stop_loss_reloads_state_after_quote_arrives ... ok
+test platform_strategy_spec::tests::parses_max_holding_days_from_engine_and_runtime_trading ... ok
+test platform_strategy_spec::tests::parses_percent_slippage_alias_into_platform_config ... ok
+test platform_strategy_spec::tests::parses_minute_stage_schedule_and_initial_subscriptions ... ok
+test platform_strategy_spec::tests::parses_portfolio_drawdown_control_into_platform_config ... ok
+test platform_strategy_spec::tests::parses_position_average_entry_stop_take_reference_price_mode ... ok
+test platform_strategy_spec::tests::parses_rebalance_cash_mode_and_forces_minute_to_actual_sequence ... ok
+test platform_strategy_spec::tests::parses_risk_policy_into_platform_config ... ok
+test platform_strategy_spec::tests::parses_runtime_expression_spec_into_platform_config ... ok
+test platform_strategy_spec::tests::parses_signal_dates_rebalance_into_platform_config ... ok
+test platform_strategy_spec::tests::parses_signal_day_post_adjusted_stop_take_reference_price_mode ... ok
+test platform_strategy_spec::tests::parses_typed_time_in_force_for_explicit_orders ... ok
+test platform_strategy_spec::tests::parses_st_and_star_st_risk_policy_switches_into_platform_config ... ok
+test platform_strategy_spec::tests::rejects_conflicting_non_policy_strategy_aliases ... ok
+test platform_strategy_spec::tests::rejects_conflicting_risk_policy_alias_values ... ok
+test platform_strategy_spec::tests::rejects_invalid_explicit_volume_percent_in_platform_config ... ok
+test platform_strategy_spec::tests::portfolio_loss_contract_is_explicit_and_validated ... ok
+test platform_strategy_spec::tests::rejects_invalid_or_duplicate_static_universe_symbols ... ok
+test platform_strategy_spec::tests::rejects_invalid_portfolio_drawdown_control ... ok
+test platform_strategy_spec::tests::rejects_removed_compatibility_profile ... ok
+test platform_strategy_spec::tests::rejects_removed_engine_profile_name ... ok
+test platform_strategy_spec::tests::rejects_unknown_stop_take_reference_price_mode ... ok
+test platform_strategy_spec::tests::rejects_non_positive_shared_order_limits ... ok
+test platform_strategy_spec::tests::rejects_unknown_strategy_risk_policy_fields_before_deserialization ... ok
+test platform_strategy_spec::tests::platform_spec_accepts_only_supported_matching_types ... ok
+test platform_strategy_spec::tests::rejects_unknown_time_in_force_in_runtime_contract ... ok
+test platform_strategy_spec::tests::runtime_expression_parser_does_not_inherit_microcap_template_defaults ... ok
+test platform_strategy_spec::tests::runtime_expression_parses_dated_position_exposure_schedule ... ok
+test platform_strategy_spec::tests::retired_or_unknown_slippage_models_do_not_fall_back_to_fixed_or_none ... ok
+test platform_strategy_spec::tests::runtime_expressions_infer_ma_windows_from_literal_strategy_logic ... ok
+test portfolio::tests::buy_after_partial_sell_continues_moving_average_cost_basis ... ok
+test platform_strategy_spec::tests::volume_limit_does_not_enable_quote_quantity_limit_for_minute_last ... ok
+test portfolio::tests::cash_dividend_can_preserve_avg_cost_for_aiquant_rules ... ok
+test portfolio::tests::delayed_withdrawals_are_reserved_and_settled_atomically ... ok
+test portfolio::tests::external_cash_flow_rebases_units_without_changing_nav ... ok
+test portfolio::tests::fifo_fixed_pnl_conserves_value_while_alv_average_cost_stays_stable ... ok
+test portfolio::tests::fixed_lot_allocation_rounds_nearest_and_conserves_total ... ok
+test portfolio::tests::holdings_summary_reports_entry_price_pnl_excluding_buy_commission ... ok
+test portfolio::tests::partial_sell_preserves_remaining_average_cost ... ok
+test portfolio::tests::portfolio_exposes_engine_native_account_metrics ... ok
+test portfolio::tests::portfolio_marks_same_day_buy_at_fill_until_next_trading_day ... ok
+test portfolio::tests::portfolio_missing_market_requires_formal_suspension_before_carrying_price ... ok
+test portfolio::tests::portfolio_tracks_dividend_receivable_and_day_pnl ... ok
+test portfolio::tests::position_tracks_day_lifecycle_fields ... ok
+test portfolio::tests::positions_preserve_insertion_order ... ok
+test portfolio::tests::scoped_checkpoint_restores_order_flat_rows_and_progress_without_copying_untouched_lots ... ok
+test portfolio::tests::strategy_entry_price_excludes_buy_commission_cost_basis ... ok
+test portfolio_loss::tests::cash_sessions_preserve_continuity_without_inventing_returns ... ok
+test platform_strategy_spec::tests::session_rotation_keeps_every_declared_clock_not_only_the_last_one ... ok
+test portfolio_loss::tests::refuses_future_missing_corrected_and_incomplete_accounting ... ok
+test portfolio_loss::tests::restart_is_exact_and_duplicate_decisions_do_not_consume_cooldown ... ok
+test portfolio_loss::tests::restored_state_rejects_changed_policy_and_forged_cooldown ... ok
+test portfolio_loss::tests::nav_serialization_preserves_float_bits ... ok
+test position_exposure::tests::allocation_is_dated_and_any_later_scalar_or_restore_clears_it ... ok
+test position_exposure::tests::explicit_equity_targets_and_buys_scale_but_sales_cashflows_and_prices_do_not ... ok
+test position_exposure::tests::rejects_unknown_actions_duplicate_identity_and_invalid_bps ... ok
+test position_exposure::tests::same_day_adjustments_restore_and_future_events_keep_their_own_times ... ok
+test position_exposure::tests::scalar_preserves_strategy_risk_off_and_restore_keeps_original_exposure ... ok
+test risk_control::tests::concrete_kcb_reason_wins_over_generic_missing_risk_state ... ok
+test risk_control::tests::configurable_bjse_filter_can_be_disabled ... ok
+test risk_control::tests::configurable_blacklist_rejects_selection_and_buy ... ok
+test risk_control::tests::configurable_kcb_filter_can_be_disabled ... ok
+test risk_control::tests::configurable_lower_limit_selection_filter_can_be_disabled ... ok
+test risk_control::tests::configurable_upper_limit_buy_filter_can_be_disabled ... ok
+test risk_control::tests::configurable_upper_limit_selection_filter_can_be_disabled ... ok
+test risk_control::tests::delisting_period_status_is_not_terminal_without_delisted_date ... ok
+test risk_control::tests::execution_quote_covers_missing_one_yuan_flag_but_not_other_risk_facts ... ok
+test risk_control::tests::explicit_candidate_inactive_status_is_not_treated_as_missing_risk_state ... ok
+test risk_control::tests::explicit_one_yuan_selection_policy_still_uses_selection_facts ... ok
+test risk_control::tests::fund_identity_excludes_stock_one_yuan_rule_but_not_actual_price_and_pause_checks ... ok
+test risk_control::tests::inactive_selection_checks_preserve_missing_facts_and_execution_rejections ... ok
+test risk_control::tests::kcb_filter_uses_classification_instead_of_security_code ... ok
+test risk_control::tests::missing_risk_state_can_be_relaxed_by_disabling_static_filters ... ok
+test risk_control::tests::missing_risk_state_default_selection_ignores_allow_flags_but_buy_rejects ... ok
+test risk_control::tests::missing_risk_state_rejects_sell_when_sell_risk_facts_are_missing ... ok
+test risk_control::tests::missing_risk_state_respects_field_specific_buy_switches ... ok
+test risk_control::tests::missing_risk_state_respects_field_specific_selection_switches ... ok
+test risk_control::tests::missing_risk_state_selection_audit_keeps_missing_fields_in_reason ... ok
+test risk_control::tests::missing_risk_state_selection_still_respects_configured_static_filters ... ok
+test risk_control::tests::missing_risk_state_sell_can_be_relaxed_by_disabling_sell_static_filters ... ok
+test risk_control::tests::one_yuan_buy_rule_uses_execution_price_not_later_close_or_earlier_open ... ok
+test risk_control::tests::sell_rejection_blocks_execution_price_at_lower_limit ... ok
+test risk_control::tests::sell_rejection_respects_allow_sell_policy_on_execution_day ... ok
+test risk_control::tests::sell_rejects_explicit_candidate_inactive_status_without_instrument_row ... ok
+test risk_control::tests::shared_order_size_limits_apply_to_both_sides_and_buy_position ... ok
+test risk_control::tests::st_and_star_st_filters_are_independent ... ok
+test scheduler::tests::date_due_is_independent_from_the_order_execution_clock ... ok
+test scheduler::tests::scheduler_matches_before_trading_and_minute_level_rules ... ok
+test scheduler::tests::scheduler_matches_daily_weekly_and_monthly_rules ... ok
+test platform_expr_strategy::tests::shared_signal_reduction_and_stops_use_each_accounts_cost_quantity_and_sold_state ... ok
+test portfolio::tests::cash_ledger_accumulates_micro_yuan_exactly ... ok
+test session_events::tests::gaps_and_stale_last_bars_do_not_become_false_or_repeated_signals ... ok
+test session_events::tests::opening_range_is_unavailable_before_the_range_has_completed ... ok
+test signal_contract::tests::changed_valid_contents_must_not_reuse_a_version_hash ... ok
+test signal_contract::tests::completed_daily_inputs_may_be_published_after_market_close ... ok
+test signal_contract::tests::coverage_and_duplicate_actions_fail_closed ... ok
+test signal_contract::tests::empty_complete_snapshot_clears_only_that_accounts_holdings ... ok
+test signal_contract::tests::historical_reconstruction_is_not_online_publication ... ok
+test signal_contract::tests::next_open_uses_decision_session_and_never_nearest_signal ... ok
+test signal_contract::tests::observed_next_open_never_backdates_a_morning_publication_into_yesterdays_orders ... ok
+test signal_contract::tests::platform_spec_consumes_book_without_running_another_selection ... ok
+test signal_contract::tests::reconstruction_ignores_research_wall_clock_but_never_early_input_availability ... ok
+test signal_contract::tests::reduction_is_resolved_from_each_accounts_actual_position ... ok
+test signal_contract::tests::rejects_future_inputs_and_model_knowledge ... ok
+test signal_contract::tests::rejects_overallocation_nonfinite_and_ambiguous_actions ... ok
+test signal_contract::tests::rejects_quantities_prices_and_unknown_signal_fields ... ok
+test stock_pool_candidates::tests::list_order_reuses_explicit_prefix_and_appends_new_candidates ... ok
+test stock_pool_candidates::tests::missing_snapshot_duplicate_input_and_empty_filtered_scope_fail ... ok
+test stock_pool_candidates::tests::mixed_sources_preserve_priority_and_both_provenances ... ok
+test session_events::tests::decision_uses_the_previous_completed_label_and_future_prices_do_not_rewrite ... ok
+test stock_pool_candidates::tests::zero_automatic_day_keeps_manual_members_without_inheriting_old_auto_targets ... ok
+test stock_pool_execution::frozen::ratio_tests::legacy_paused_and_explicit_partial_budgets_are_not_reinterpreted ... ok
+test stock_pool_execution::frozen::ratio_tests::precise_paused_budget_survives_replacement_and_zero_targets ... ok
+test stock_pool_execution::frozen::ratio_tests::precision_is_checked_before_frozen_budget_is_allocated ... ok
+test stock_pool_execution::tests::confirmed_holdings_not_unsettled_sells_determine_remaining_position_budget ... ok
+test stock_pool_execution::tests::all_membership_and_weight_combinations_use_the_same_target_planner ... ok
+test stock_pool_execution::tests::frozen_valuation_is_dated_and_cannot_turn_an_unknown_gap_into_a_pause ... ok
+test stock_pool_execution::tests::full_stop_overrides_a_simultaneous_factor_reduction_without_a_second_target ... ok
+test stock_pool_execution::tests::independent_exit_quote_priority_does_not_bypass_t_plus_one_or_price_validation ... ok
+test stock_pool_execution::tests::independent_full_exit_has_no_ordinary_quote_dependency_but_partial_risk_does_not_fake_missing_facts ... ok
+test stock_pool_execution::tests::independent_stop_does_not_require_unused_ordinary_sell_quote_facts ... ok
+test stock_pool_execution::tests::index_cap_cannot_sell_a_paused_holding_or_use_its_budget_as_free_cash ... ok
+test stock_pool_execution::tests::index_cap_keeps_non_sellable_quantity_and_defers_the_remaining_risk_target ... ok
+test stock_pool_execution::tests::index_cap_reduces_existing_proportions_without_enabling_weight_rebalancing ... ok
+test stock_pool_execution::tests::equal_thirty_seats_use_full_precision_at_a_board_lot_boundary ... ok
+test stock_pool_execution::tests::index_cap_respects_ordinary_weight_changes_and_stronger_fill_protection ... ok
+test stock_pool_execution::tests::instrument_price_tick_and_quantity_units_are_not_a_two_decimal_stock_assumption ... ok
+test stock_pool_execution::tests::legacy_constraints_do_not_gain_an_empty_precision_field ... ok
+test stock_pool_execution::tests::market_quantity_budget_includes_execution_slippage_and_fees ... ok
+test stock_pool_execution::tests::index_exposure_and_reserved_seats_multiply_without_rounding_the_budget_early ... ok
+test stock_pool_execution::tests::native_sell_and_quote_conditions_are_and_but_stop_and_protection_remain_independent ... ok
+test stock_pool_execution::tests::optional_configuration_and_conflicting_aliases_are_explicit ... ok
+test stock_pool_execution::tests::ordinary_sell_keeps_required_quote_failures_and_zero_stop_is_not_an_exit ... ok
+test stock_pool_execution::tests::partial_sell_cooldown_restricts_increases_without_clearing_the_remainder ... ok
+test stock_pool_execution::tests::ordinary_sell_scope_excludes_independent_exits_and_protected_positions ... ok
+test stock_pool_execution::tests::paused_outside_holding_retains_prior_budget_without_an_execution_quote ... ok
+test stock_pool_execution::tests::quote_condition_number_contract_rejects_invalid_facts_and_fractional_shares ... ok
+test stock_pool_execution::tests::paused_held_weight_is_not_replenished_after_another_stock_exits ... ok
+test stock_pool_execution::tests::quote_condition_scopes_are_evaluated_before_target_orders ... ok
+test stock_pool_execution::tests::quote_only_exit_still_works_when_independent_risk_rules_are_configured ... ok
+test session_events::tests::all_thirteen_events_return_native_boolean_series ... ok
+test stock_pool_execution::tests::reserve_slots_keep_requested_and_effective_exposure_distinct ... ok
+test stock_pool_execution::tests::retained_holdings_reserve_actual_value_and_zero_funding_still_clears ... ok
+test stock_pool_execution::tests::risk_only_configuration_never_turns_into_an_unconditional_ordinary_exit ... ok
+test stock_pool_execution::tests::sale_slippage_does_not_prevent_a_marked_value_board_lot_reduction ... ok
+test stock_pool_execution::tests::sell_cooldown_does_not_turn_disabled_weight_rebalancing_back_on ... ok
+test stock_pool_execution::tests::sell_quote_condition_creates_exit_and_unmet_holding_keeps_its_slot ... ok
+test stock_pool_execution::tests::selection_excluding_paused_stock_keeps_the_same_24_stock_budget_as_broker_execution ... ok
+test stock_pool_execution::tests::stop_reduction_merge_matrix_preserves_protection_t_plus_one_and_invalid_config_errors ... ok
+test stock_pool_index_policy::tests::disabled_is_optional_but_enabled_parameters_are_not_invented ... ok
+test stock_pool_index_policy::tests::missing_or_duplicate_or_future_rows_never_shorten_the_window ... ok
+test stock_pool_index_policy::tests::trend_and_caps_match_the_declared_math_and_keep_zero_meaningful ... ok
+test stock_pool_indicators::tests::kdj_uses_the_same_frozen_native_kernel_as_event_conditions ... ok
+test stock_pool_indicators::tests::missing_inputs_require_source_admission_and_future_inputs_fail ... ok
+test stock_pool_indicators::tests::uses_shared_ma_ema_and_preserves_recursive_prefix_before_output_window ... ok
+test stock_pool_market_cap::tests::interpolates_declared_endpoints_and_clamps_without_business_defaults ... ok
+test stock_pool_market_cap::tests::missing_duplicate_or_mismatched_index_inputs_do_not_shrink_the_calendar ... ok
+test stock_pool_quote_facts::tests::lunch_and_post_close_gaps_follow_the_minute_feed_segments ... ok
+test stock_pool_quote_facts::tests::real_source_session_prefix_matches_observed_checkpoints ... ignored, requires FIDC_SESSION_PREFIX_SOURCE_JSON from the frozen Source minute response
+test stock_pool_quote_facts::tests::sparse_unverified_and_overflowing_quotes_cannot_be_called_session_totals ... ok
+test stock_pool_quote_facts::tests::totals_use_only_the_complete_observed_prefix_and_keep_decimal_amounts ... ok
+test strategy::decision_merge_tests::explicit_empty_complete_target_replaces_old_allocation_but_empty_callback_does_not ... ok
+test strategy::decision_merge_tests::newer_complete_target_replaces_old_symbols_without_discarding_explicit_actions ... ok
+test strategy::tests::omni_microcap_projection_uses_configured_trading_cost ... ok
+test strategy::tests::omni_microcap_selection_uses_configured_risk_policy ... ok
+test strategy::tests::order_time_in_force_parsing_and_order_type_contract_are_explicit ... ok
+test strategy_ai::tests::generation_prompt_uses_explicit_performance_acceptance_contract ... ok
+test strategy_ai::tests::manual_separates_explicit_business_selection_from_framework_risk_policy ... ok
+test strategy_ai::tests::optimization_prompt_uses_explicit_performance_acceptance_contract ... ok
+test universe::tests::selector_applies_configured_selection_risk_on_decision_date ... ok
+test universe::tests::selector_can_defer_configured_selection_risk_without_losing_diagnostics ... ok
+test universe::tests::selector_records_structured_selection_risk_decisions ... ok
+test stock_pool_execution::tests::typed_exit_roles_merge_only_satisfied_ordinary_actions_with_independent_risk ... ok
+test risk_control::tests::selection_check_activation_covers_every_configured_flag_and_blacklist_state ... ok
+test stock_pool_execution::tests::quote_field_operator_side_and_scope_matrix_matches_the_configured_predicate ... ok
+
+failures:
+
+---- corporate_book::tests::unresolved_delisting_cannot_zero_a_pending_share_asset stdout ----
+
+thread 'corporate_book::tests::unresolved_delisting_cannot_zero_a_pending_share_asset' (94174) panicked at crates/fidc-core/src/corporate_book.rs:814:94:
+called `Result::unwrap()` on an `Err` value: MultipleBenchmarks
+
+
+failures:
+    corporate_book::tests::unresolved_delisting_cannot_zero_a_pending_share_asset
+
+test result: FAILED. 781 passed; 1 failed; 7 ignored; 0 measured; 0 filtered out; finished in 0.53s
+
+error: test failed, to rerun pass `-p fidc-core --lib`

docs/evidence/registered-share-risk-20261005/core-risk-initial-live-scope.json

@@ -0,0 +1,31 @@
+{
+  "contract_sha256": "572c8925fd4d981b32360b4a781b17133fd1b6cf3fc2ee1bb58626848cdb75cc",
+  "observed_at": "2026-10-04T22:19:02.833088+00:00",
+  "observed_process_owners": [
+    {
+      "pid": 92813,
+      "uid": 1003
+    },
+    {
+      "pid": 92822,
+      "uid": 1003
+    },
+    {
+      "pid": 93744,
+      "uid": 1003
+    }
+  ],
+  "owner_uid": 1003,
+  "production_ready": false,
+  "properties": {
+    "ActiveState": "active",
+    "CPUQuotaPerSecUSec": "4s",
+    "ControlGroup": "/user.slice/user-1003.slice/user@1003.service/app.slice/fidc-share-receivable-risk-validation-20261005.scope",
+    "MemoryMax": "17179869184",
+    "MemorySwapMax": "0",
+    "TasksMax": "256"
+  },
+  "schema_version": "fidc.live-share-risk-core-scope/v1",
+  "trading_allowed": false,
+  "unit": "fidc-share-receivable-risk-validation-20261005.scope"
+}

docs/evidence/registered-share-risk-20261005/file-shas.json

@@ -0,0 +1,63 @@
+{
+  "engine_commit": "1092cd0b80c5b8aee6851231f77e474c8ee2ba0c",
+  "files": [
+    {
+      "bytes": 80065,
+      "file": "core-risk-initial-failure.log",
+      "sha256": "a5a2222afc6d9dd28c892ccec4b44934a757ed385399fe67e893bf83769fee67",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-4a41057/final-full-linux-tests.log",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 831,
+      "file": "core-risk-initial-live-scope.json",
+      "sha256": "e37158c0630bda3c79f67f3a3d1dbbc0b7495f11160615857d98cce798aef119",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-4a41057/live-test-resource-verification.json",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 98662,
+      "file": "core-risk-final-full-linux-tests.log",
+      "sha256": "38bb77591e04784ee1af4043c8792fe84f155a962ff7e5bd26e0e1571efccd42",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-1092cd0/final-full-linux-tests.log",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 65258,
+      "file": "runner-risk-final-full-linux-tests.log",
+      "sha256": "fd6d3de7c1a6f2ebcd1ea65d73720661256786ce7799d86371357871adcadb17",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1092cd0/final-full-linux-tests.log",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 849,
+      "file": "live-test-resource-verification.json",
+      "sha256": "8064619cda9e9f6a9f6e3045fd5e7c9e981314cc1c0877d7e07f57aeeeb39a81",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1092cd0/live-test-resource-verification.json",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 2275,
+      "file": "operational-verification.json",
+      "sha256": "42a6814f9ca215b6a39d838c7faabbb293043b482520b5c4b50e3ccbaf45ea0a",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1092cd0/operational-verification.json",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 9528,
+      "file": "validation-receipt.json",
+      "sha256": "15c1f57fe6a40538ec9d9e487275b731edd9cb15c3c5ae0520b8a88224606cfe",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1092cd0/validation-receipt.json",
+      "source_uid": 1003
+    },
+    {
+      "bytes": 10967,
+      "file": "validation-pg-receipt.json",
+      "sha256": "8f009feba229df40e721b19d281e024b1c4ef9b4ef507b7110307173a5ed10af",
+      "source_path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1092cd0/validation-pg-receipt.json",
+      "source_uid": 1003
+    }
+  ],
+  "schema_version": "fidc.local-share-risk-evidence/v1",
+  "service_commit": "1d4b32e18d3836b5844130ae0c95d90247768882"
+}

docs/evidence/registered-share-risk-20261005/live-test-resource-verification.json

@@ -0,0 +1,31 @@
+{
+  "contract_sha256": "ac4d2fecb75f298a00234b88af05596c99890e9d3449d507a4ad7afe2ac67211",
+  "observed_at": "2026-10-04T22:22:50.816133+00:00",
+  "observed_process_owners": [
+    {
+      "pid": 98509,
+      "uid": 1003
+    },
+    {
+      "pid": 98669,
+      "uid": 1003
+    },
+    {
+      "pid": 98722,
+      "uid": 1003
+    }
+  ],
+  "owner_uid": 1003,
+  "production_ready": false,
+  "properties": {
+    "ActiveState": "active",
+    "CPUQuotaPerSecUSec": "4s",
+    "ControlGroup": "/user.slice/user-1003.slice/user@1003.service/app.slice/fidc-share-delivery-risk-final-pair-validation-20261005.scope",
+    "MemoryMax": "17179869184",
+    "MemorySwapMax": "0",
+    "TasksMax": "256"
+  },
+  "schema_version": "fidc.live-share-risk-test-scope/v1",
+  "trading_allowed": false,
+  "unit": "fidc-share-delivery-risk-final-pair-validation-20261005.scope"
+}

docs/evidence/registered-share-risk-20261005/operational-verification.json

@@ -0,0 +1,70 @@
+{
+  "authorized_incremental_cache_root": "/srv/fidc/programs/src/fidc-backtest-service/target/debug/incremental",
+  "contract_sha256": "40926383e24b626be9591fc0e2837641723d1acb74795195785d5f0c5112d91c",
+  "health": [
+    {
+      "body_sha256": "d9dcd53f6a6ed9668153b18e3cc6332e575ac9ef537078511f9177e1ad3f4a2f",
+      "http_status": 200,
+      "port": 18095
+    },
+    {
+      "body_sha256": "77c9026f5469b1d36bb19dac75477df9ad37165dddd63253f94bf33595155542",
+      "http_status": 200,
+      "port": 18096
+    }
+  ],
+  "incremental_files_present": 0,
+  "numeric_research_budget_reopened": false,
+  "observed_at": "2026-10-04T22:25:11.039350+00:00",
+  "original_research_plan_sha256": "6aa6932b8b7d4538543e7baf48b1b0ab305e684b36003faeaa7f0f4db4067c0c",
+  "original_research_source_commit": "d847b82de3f62a369291c13160b31fcfc0075b8b",
+  "owner_uid": 1003,
+  "production_ready": false,
+  "production_runtime_deployed": false,
+  "production_strategy_count": 0,
+  "schema_version": "fidc.share-delivery-operational-verification/v1",
+  "ssd_free_bytes": 9004457984,
+  "trading_allowed": false,
+  "units": [
+    {
+      "ActiveState": "active",
+      "InvocationID": "b6bd3c6c3a6d4f729291b969590d66a0",
+      "MainPID": "3571059",
+      "NRestarts": "0",
+      "process_uid": 1003,
+      "unit": "fidc-private-agent-runtime.service"
+    },
+    {
+      "ActiveState": "active",
+      "InvocationID": "851771deedc44b78bea58e18c74f9421",
+      "MainPID": "1073961",
+      "NRestarts": "1",
+      "process_uid": 1003,
+      "unit": "fidc-private-source-lake-worker.service"
+    },
+    {
+      "ActiveState": "active",
+      "InvocationID": "ce19e205006945e888c42ff385f96a50",
+      "MainPID": "2371183",
+      "NRestarts": "0",
+      "process_uid": 1003,
+      "unit": "fidc-private-source-lake.service"
+    },
+    {
+      "ActiveState": "active",
+      "InvocationID": "386b6478a0384505a8c9704e2d2a1478",
+      "MainPID": "3571320",
+      "NRestarts": "0",
+      "process_uid": 1003,
+      "unit": "fidc-private-strategy-ai.service"
+    },
+    {
+      "ActiveState": "active",
+      "InvocationID": "0eb28e3a45694a00951aa3aec0e13465",
+      "MainPID": "1396112",
+      "NRestarts": "0",
+      "process_uid": 1003,
+      "unit": "fidc-projection-research-autopilot.service"
+    }
+  ]
+}

docs/evidence/registered-share-risk-20261005/runner-risk-final-full-linux-tests.log

@@ -0,0 +1,679 @@
+   Compiling fidc-core v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-1092cd0/fidc-backtest-engine/crates/fidc-core)
+   Compiling fidc-common v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-1092cd0/fidc-backtest-service/crates/fidc-common)
+   Compiling fidc-signal-client v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-1092cd0/fidc-backtest-engine/crates/fidc-signal-client)
+   Compiling fidc-backtest-runner v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-1092cd0/fidc-backtest-service/services/backtest_runner)
+   Compiling fidc-backtest-service v0.1.0 (/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-1092cd0/fidc-backtest-service/services/api)
+    Finished `test` profile [unoptimized] target(s) in 52.77s
+     Running unittests src/lib.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/deps/fidc_backtest_runner-370b633cb313f2c5)
+
+running 484 tests
+test backtest::columnar_factor_overlay_tests::cache_range_rejects_date_disorder_outside_the_binary_search_slice ... ok
+test backtest::columnar_factor_overlay_tests::cache_range_rejects_symbol_disorder_outside_the_requested_date ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_real_cache_value_equivalence ... ignored, requires a frozen private Boris real-data cache directory on 177
+test backtest::columnar_factor_overlay_tests::columnar_overlay_missing_or_stale_cache_does_not_mutate_base ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_rejects_duplicate_window_boundary ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_rejects_duplicate_order_and_count_mismatches ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_rejects_market_projection_and_invalid_cached_column_type ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_rejects_late_key_mismatch_before_any_base_mutation ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_unknown_keys_are_not_hidden_as_empty_values ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_replaced_file_invalidates_view_without_mutating_pinned_input ... ok
+test backtest::columnar_factor_overlay_tests::row_visitor_preserves_selected_offsets_and_late_validation_errors ... ok
+test backtest::compact_storage_tests::batch_bound_factor_columns_preserve_types_nulls_and_nonfinite_values ... ok
+test backtest::columnar_factor_overlay_tests::valid_cache_reuses_its_key_index_and_failed_indexes_are_not_published ... ok
+test backtest::compact_storage_tests::inline_symbols_and_factor_maps_preserve_binary_and_json_contracts ... ok
+test backtest::day_snapshot_builder::tests::a_failed_builder_cannot_publish_earlier_valid_rows ... ok
+test backtest::day_snapshot_builder::tests::corporate_distribution_quantities_must_be_known_before_a_day_is_published ... ok
+test backtest::day_snapshot_builder::tests::factor_reservation_keeps_missing_and_overwrite_semantics ... ok
+test backtest::day_snapshot_builder::tests::late_source_validation_failure_invalidates_the_streamed_day ... ok
+test backtest::equity_lifecycle_metadata_tests::empty_quotes_require_full_interval_lifecycle_proof_not_a_latest_status ... ok
+test backtest::equity_lifecycle_metadata_tests::lifecycle_cash_days_keep_real_benchmark_without_fabricated_security_rows ... ok
+test backtest::equity_lifecycle_metadata_tests::missing_identity_and_dates_do_not_become_active_securities ... ok
+test backtest::execution_config_tests::capacity_preflight_requires_explicit_daily_assumptions_without_changing_risk_switches ... ok
+test backtest::execution_config_tests::component_execution_quotes_seed_uses_latest_intraday_quote_before_target_time ... ok
+test backtest::execution_config_tests::current_close_respects_explicitly_disabled_liquidity_limit ... ok
+test backtest::execution_config_tests::daily_current_close_preserves_the_strategy_decision_clock ... ok
+test backtest::execution_config_tests::daily_execution_price_request_serializes_date_symbol_filter_scope ... ok
+test backtest::execution_config_tests::daily_execution_projection_keeps_benchmark_narrow_and_trade_risk_complete ... ok
+test backtest::execution_config_tests::data_intraday_snapshot_time_is_strategy_spec_driven ... ok
+test backtest::execution_config_tests::dataset_signature_rejects_source_lake_without_frozen_backtest_bundle ... ok
+test backtest::day_snapshot_builder::tests::arrow_rows_build_the_same_final_snapshots_without_a_row_collection ... ok
+test backtest::execution_config_tests::dataset_signature_scopes_dynamic_model_score_source_rows ... ok
+test backtest::execution_config_tests::default_matching_type_follows_backtest_frequency ... ok
+test backtest::execution_config_tests::dataset_signature_scopes_backtest_data_bundle_source_rows ... ok
+test backtest::execution_config_tests::dynamic_model_score_execution_quotes_are_lazy_by_default ... ok
+test backtest::execution_config_tests::dynamic_model_score_rank_does_not_extract_fixed_signal_symbols ... ok
+test backtest::execution_config_tests::execution_quote_prefilter_keeps_previous_factor_rows_in_current_band ... ok
+test backtest::execution_config_tests::execution_quote_prefilter_prefers_runtime_market_cap_slope ... ok
+test backtest::execution_config_tests::execution_quote_query_times_follow_strategy_trade_times ... ok
+test backtest::execution_config_tests::execution_top_level_fee_overrides_nested_risk_policy_cost ... ok
+test backtest::execution_config_tests::execution_quote_prefilter_keeps_candidates_beyond_legacy_limit ... ok
+test backtest::execution_config_tests::execution_top_level_volume_percent_overrides_nested_risk_policy ... ok
+test backtest::execution_config_tests::extract_score_context_does_not_extract_fixed_signal_symbols ... ok
+test backtest::execution_config_tests::factor_keys_use_compact_storage_without_changing_names ... ok
+test backtest::execution_config_tests::fixed_signal_symbol_scope_preserves_explicit_empty_targets ... ok
+test backtest::execution_config_tests::fixed_signal_model_score_scope_does_not_validate_candidate_limit ... ok
+test backtest::execution_config_tests::minute_session_bounds_extend_only_after_post_close_rule_effective_date ... ok
+test backtest::execution_config_tests::full_minute_event_stream_uses_subscriptions_instead_of_point_snapshot ... ok
+test backtest::execution_config_tests::model_score_source_rows_scope_evidence_verifies_candidate_limit ... ok
+test backtest::execution_config_tests::model_score_source_rows_scope_rejects_unbounded_rows ... ok
+test backtest::execution_config_tests::native_next_open_pool_loads_causal_quotes_without_exposing_them_to_selection ... ok
+test backtest::execution_config_tests::owned_date_group_producers_drop_every_input_exactly_once_on_failure ... ok
+test backtest::execution_config_tests::narrow_overlay_projection_does_not_retain_a_wide_value_buffer ... ok
+test backtest::execution_config_tests::owned_trade_day_preparation_matches_borrowed_rows ... ok
+test backtest::execution_config_tests::parse_matching_type_limits_global_backtest_matching_modes ... ok
+test backtest::execution_config_tests::parse_slippage_model_supports_explicit_historical_model ... ok
+test backtest::execution_config_tests::parse_slippage_model_supports_limit_price ... ok
+test backtest::execution_config_tests::platform_daily_factor_strategy_uses_lazy_execution_quotes_by_default ... ok
+test backtest::execution_config_tests::platform_execution_quote_carry_can_include_recent_candidates ... ok
+test backtest::execution_config_tests::platform_execution_quote_carry_does_not_let_candidates_evict_recent_orders ... ok
+test backtest::execution_config_tests::platform_execution_quote_carry_keeps_today_candidates_without_candidate_carry ... ok
+test backtest::execution_config_tests::platform_execution_quote_carry_prefers_recent_candidates_before_today_candidates ... ok
+test backtest::execution_config_tests::platform_execution_quote_carry_prioritizes_order_symbols ... ok
+test backtest::execution_config_tests::platform_execution_quote_default_carry_keeps_large_recent_candidate_set ... ok
+test backtest::execution_config_tests::platform_execution_route_requires_runtime_contract ... ok
+test backtest::execution_config_tests::platform_runtime_snapshot_preserves_typed_time_in_force ... ok
+test backtest::execution_config_tests::parallel_owned_date_groups_keep_exact_rows_and_owned_factor_allocations ... ok
+test backtest::execution_config_tests::platform_strategy_config_rejects_loose_value_budget_without_panicking ... ok
+test backtest::execution_config_tests::platform_strategy_config_uses_same_intraday_time_as_broker ... ok
+test backtest::execution_config_tests::prepare_trade_day_candidate_market_cap_falls_back_to_total_market_cap ... ok
+test backtest::execution_config_tests::prepare_trade_day_daily_selection_price_uses_close_without_limit_allow_flags ... ok
+test backtest::execution_config_tests::prepare_trade_day_does_not_build_execution_quote_from_daily_fallback ... ok
+test backtest::execution_config_tests::prepare_trade_day_keeps_allow_buy_when_missing_field_is_not_buy_relevant ... ok
+test backtest::execution_config_tests::prepare_trade_day_keeps_daily_volume_when_snapshot_has_intraday_volume ... ok
+test backtest::execution_config_tests::prepare_trade_day_keeps_external_signal_warmup_day ... ok
+test backtest::execution_config_tests::prepare_trade_day_keeps_missing_risk_facts_when_runtime_filters_are_disabled ... ok
+test backtest::execution_config_tests::prepare_trade_day_keeps_st_and_star_st_flags_independent ... ok
+test backtest::execution_config_tests::prepare_trade_day_preserves_missing_daily_volume_contract ... ok
+test backtest::execution_config_tests::prepare_trade_day_preserves_zero_ask_from_intraday_snapshot ... ok
+test backtest::execution_config_tests::prepare_trade_day_records_all_missing_risk_facts_independent_of_policy ... ok
+test backtest::execution_config_tests::raw_yuan_market_cap_normalizes_to_100m_units ... ok
+test backtest::execution_config_tests::resolve_dividend_reinvestment_defaults_false_and_reads_engine_flag ... ok
+test backtest::execution_config_tests::resolve_execution_config_does_not_allow_overspending_value_budget ... ok
+test backtest::execution_config_tests::resolve_execution_config_enables_strict_value_budget_by_default ... ok
+test backtest::execution_config_tests::resolve_execution_config_keeps_explicit_liquidity_quote_limit ... ok
+test backtest::execution_config_tests::resolve_execution_config_distinguishes_timed_daily_current_close ... ok
+test backtest::execution_config_tests::resolve_execution_config_keeps_explicit_same_day_buy_mark_override ... ok
+test backtest::execution_config_tests::resolve_execution_config_keeps_explicit_snapshot_volume_limit ... ok
+test backtest::execution_config_tests::resolve_execution_config_keeps_selection_risk_off_by_default ... ok
+test backtest::execution_config_tests::resolve_execution_config_keeps_volume_limit_for_snapshot_minute_last_by_default ... ok
+test backtest::execution_config_tests::resolve_execution_config_maps_daily_next_open ... ok
+test backtest::execution_config_tests::resolve_execution_config_maps_minute_last_to_minute_price ... ok
+test backtest::execution_config_tests::resolve_execution_config_maps_rebalance_cash_mode_and_forces_minute ... ok
+test backtest::execution_config_tests::resolve_execution_config_preserves_zero_minimum_commission ... ok
+test backtest::execution_config_tests::resolve_execution_config_reads_nested_risk_policy ... ok
+test backtest::execution_config_tests::resolve_execution_config_rejects_delay_slippage_outside_sell_then_buy ... ok
+test backtest::execution_config_tests::resolve_execution_config_rejects_vwap_as_global_matching_type ... ok
+test backtest::execution_config_tests::resolve_execution_config_uses_explicit_market_rules_without_profile ... ok
+test backtest::execution_config_tests::resolve_execution_config_uses_runtime_schedule_time_for_minute_execution ... ok
+test backtest::execution_config_tests::resolve_execution_config_uses_latest_trade_time_as_main_schedule ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_preserves_static_universe_contract ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_preserves_weak_market_threshold ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_reads_delayed_limit_open_exit ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_reads_release_slot_on_exit_signal ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_reads_trading_schedule ... ok
+test backtest::execution_config_tests::retired_slippage_and_invalid_coefficients_never_become_no_slippage ... ok
+test backtest::execution_config_tests::resolve_platform_expr_strategy_config_reads_trading_stage ... ok
+test backtest::execution_config_tests::risk_policy_alias_normalization_preserves_matching_values ... ok
+test backtest::execution_config_tests::risk_policy_alias_normalization_rejects_conflicting_values ... ok
+test backtest::execution_config_tests::reused_candidate_plan_panel_matches_full_intraday_market_materialization ... ok
+test backtest::execution_config_tests::runtime_selection_intraday_quote_detection_reads_quote_fields_only ... ok
+test backtest::execution_config_tests::sorted_overlay_transfers_owned_factor_storage_without_changing_bits ... ok
+test backtest::execution_config_tests::sorted_overlay_keeps_unchanged_zero_bits_and_counts_only_changed_rows ... ok
+test backtest::execution_config_tests::sorted_source_row_insertion_preserves_existing_duplicate_order ... ok
+test backtest::execution_config_tests::sorted_sparse_overlay_merge_falls_back_for_duplicate_keys ... ok
+test backtest::execution_config_tests::sorted_sparse_overlay_merge_preserves_order_and_unmatched_rows ... ok
+test backtest::execution_config_tests::source_lake_backtest_bundle_context_requires_complete_metadata ... ok
+test backtest::execution_config_tests::source_lake_execution_price_requests_keep_compact_schema ... ok
+test backtest::execution_config_tests::source_lake_market_cap_keeps_current_decision_date_value ... ok
+test backtest::execution_config_tests::source_lake_market_cap_uses_current_decision_date_snapshot ... ok
+test backtest::execution_config_tests::source_lake_model_score_context_accepts_complete_inferred_scope ... ok
+test backtest::execution_config_tests::source_lake_model_score_context_allows_plain_rotation_without_model_score ... ok
+test backtest::execution_config_tests::source_lake_model_score_context_rejects_dynamic_mode_without_source_label_or_scope ... ok
+test backtest::execution_config_tests::source_lake_model_score_context_rejects_partial_scope ... ok
+test backtest::execution_config_tests::source_lake_model_score_context_rejects_sparse_ref_without_scope ... ok
+test backtest::execution_config_tests::source_lake_request_keeps_dynamic_model_score_as_all_market_with_score_context ... ok
+test backtest::execution_config_tests::source_lake_request_keeps_explicit_empty_symbols_empty ... ok
+test backtest::execution_config_tests::source_lake_request_scopes_fixed_signal_symbols_and_keeps_compact_schema ... ok
+test backtest::execution_config_tests::source_lake_request_serializes_date_symbol_filter_scope ... ok
+test backtest::execution_config_tests::source_lake_source_rows_uses_current_row_decision_safe_prev_factor_mode ... ok
+test backtest::execution_config_tests::source_row_adjustment_factor_decode_accepts_positive_finite_values ... ok
+test backtest::execution_config_tests::source_row_adjustment_factor_decode_allows_paused_rows_without_close ... ok
+test backtest::execution_config_tests::source_row_adjustment_factor_decode_rejects_missing_or_invalid_values ... ok
+test backtest::execution_config_tests::source_row_adjustment_factor_decode_rejects_paused_rows_with_close ... ok
+test backtest::execution_config_tests::source_row_cache_and_filter_distinguish_all_from_explicit_empty_symbols ... ok
+test backtest::execution_config_tests::source_row_adjustment_factor_decode_skips_unrequested_projection ... ok
+test backtest::execution_config_tests::source_row_daily_capacity_is_scoped_to_actual_insertion_dates ... ok
+test backtest::execution_config_tests::source_row_grouping_copies_date_keys_only_at_boundaries ... ok
+test backtest::execution_config_tests::source_row_missing_open_does_not_mark_candidate_as_one_yuan ... ok
+test backtest::execution_config_tests::source_row_model_score_context_accepts_extract_only_score_metadata ... ok
+test backtest::execution_config_tests::source_row_model_score_context_can_disable_candidate_limit_inference ... ok
+test backtest::execution_config_tests::source_row_model_score_context_infers_candidate_limit_from_selection_limit ... ok
+test backtest::execution_config_tests::source_row_daily_capacity_keeps_supplemental_inserts_in_place ... ok
+test backtest::execution_config_tests::source_row_model_score_context_merges_bundle_extract_and_scopes_cache ... ok
+test backtest::execution_config_tests::source_row_projection_does_not_require_adjustment_factor_for_volume_only_rolling ... ok
+test backtest::execution_config_tests::source_row_projection_keeps_select_all_for_generic_empty_factor_refs ... ok
+test backtest::execution_config_tests::source_row_projection_includes_amount_for_stock_amount_expressions ... ok
+test backtest::execution_config_tests::source_row_projection_keeps_source_lake_empty_factor_refs_narrow ... ok
+test backtest::execution_config_tests::source_row_projection_keeps_source_lake_without_strategy_spec_narrow ... ok
+test backtest::execution_config_tests::source_row_projection_splits_sparse_model_score_factor_refs ... ok
+test backtest::execution_config_tests::source_row_projection_uses_framework_rolling_inputs ... ok
+test backtest::execution_config_tests::source_row_sort_preserves_published_order_and_stably_repairs_merges ... ok
+test backtest::execution_config_tests::source_row_projection_uses_raw_market_columns_for_framework_rollings ... ok
+test backtest::execution_config_tests::source_rows_query_engine_is_validated_and_scopes_cache_epoch ... ok
+test backtest::execution_config_tests::source_rows_scope_evidence_preserves_unordered_date_counts ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_dates_exclude_warmup_rows ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_keeps_named_score_when_context_uses_default_score ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_merges_only_requested_extra_factors ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_query_windows_are_chunked_by_date_span ... ok
+test backtest::execution_config_tests::source_warmup_uses_required_trading_windows ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_skips_primary_score_columns ... ok
+test backtest::execution_config_tests::sparse_model_score_overlay_reuses_source_row_cache_without_http ... ok
+test backtest::execution_config_tests::stock_cost_model_for_execution_uses_explicit_fee_overrides ... ok
+test backtest::execution_config_tests::sparse_overlay_skips_source_lake_when_scoped_date_symbol_filter_is_empty ... ok
+test backtest::execution_config_tests::strategy_execution_top_level_risk_enabled_aliases_are_applied ... ok
+test backtest::execution_config_tests::strategy_risk_policy_accepts_camel_case_fields ... ok
+test backtest::execution_config_tests::supplemental_execution_key_index_only_materializes_requested_symbols ... ok
+test backtest::execution_config_tests::timed_daily_current_close_loads_the_intraday_decision_snapshot ... ok
+test backtest::execution_config_tests::strategy_factory_model_rank_rotation_keeps_explicit_execution_contract ... ok
+test backtest::execution_config_tests::top_level_execution_limits_override_nested_risk_policy_defaults ... ok
+test backtest::execution_config_tests::unsupported_backtest_frequency_is_rejected ... ok
+test backtest::execution_config_tests::unique_source_row_trade_dates_preserves_sorted_and_unordered_inputs ... ok
+test backtest::execution_config_tests::validated_source_limit_prices_allows_explicit_no_limit_stock ... ok
+test backtest::execution_config_tests::validated_source_limit_prices_allows_index_without_limits ... ok
+test backtest::execution_config_tests::validated_source_limit_prices_allows_paused_stock_without_limits ... ok
+test backtest::execution_config_tests::validated_source_limit_prices_rejects_missing_stock_limit ... ok
+test backtest::execution_config_tests::validated_source_limit_prices_trusts_source_limits ... ok
+test backtest::factor_history_calendar_tests::history_uses_actual_sessions_and_rejects_short_or_future_calendars ... ok
+test backtest::factor_history_calendar_tests::index_policy_preloads_its_reference_without_widening_the_candidate_universe ... ok
+test backtest::factor_history_calendar_tests::contextual_pattern_expands_data_scope_but_not_candidate_members ... ok
+test backtest::factor_history_calendar_tests::selection_buy_permission_carries_its_complete_pattern_window ... ok
+test backtest::fund_metadata::tests::day_preparation_distinguishes_etf_optional_risk_from_missing_prices ... ok
+test backtest::fund_metadata::tests::etf_metadata_binds_identity_dates_and_units ... ok
+test backtest::fund_metadata::tests::real_etf_fallback_fills_match_source_opens_dates_and_fee_budgets ... ignored, requires exact frontend-compiled frozen Source Lake ETF replay artifacts
+test backtest::fund_metadata::tests::real_mixed_prices_preserve_holdings_until_explicit_zero_allocation ... ignored, requires FIDC_FUND_REPLAY_PREFIX containing read-only real Source Arrow fixtures
+test backtest::fund_metadata::tests::real_source_arrow_preserves_etf_identity_and_detects_tampering ... ignored, requires FIDC_FUND_METADATA_TEST_ARROW from the read-only real Source probe
+test backtest::fund_metadata::tests::preliminary_candidate_panel_uses_verified_etf_rules_without_inventing_limits ... ok
+test backtest::manual_data_scope::tests::explicit_data_scope_can_expand_without_mutating_the_strategy_or_empty_pool ... ok
+test backtest::manual_data_scope::tests::dataset_cache_tracks_extra_market_demand_not_manual_price_or_execution_identity ... ok
+test backtest::prepared_source_row::tests::all_supported_numeric_types_keep_the_existing_conversion_and_null_policy ... ok
+test backtest::prepared_source_row::tests::arbitrary_slices_and_supplemental_rows_keep_symbol_order ... ok
+test backtest::prepared_source_row::tests::finite_values_keep_exact_float_bits_and_metadata ... ok
+test backtest::prepared_source_row::tests::invalid_json_is_not_hidden_by_a_consumer_that_needs_no_factors ... ok
+test backtest::prepared_source_row::tests::actual_arrow_day_uses_columnar_rows_and_matches_owned_final_snapshots ... ok
+test backtest::prepared_source_row::tests::json_typed_duplicates_and_projected_overlay_preserve_overwrite_order ... ok
+test backtest::prepared_source_row::tests::nonfinite_price_policy_does_not_mutate_original_arrow_values ... ok
+test backtest::prepared_source_row::tests::overlay_cannot_relax_base_adjustment_validation ... ok
+test backtest::prepared_source_row::tests::schema_error_precedence_and_null_keys_are_preserved ... ok
+test backtest::risk_free_rate_cache_round_trips_validated_contract ... ok
+test backtest::risk_free_rate_cache_identity_includes_bundle_and_full_calendar ... ok
+test backtest::saved_risk_cache::tests::saved_reference_cancelled_reader_does_not_leave_a_claim ... ok
+test backtest::saved_risk_cache::tests::saved_reference_identity_includes_endpoint_hash_and_calendar ... ok
+test backtest::saved_risk_reference_requires_original_content_not_only_server_claimed_hash ... ok
+test backtest::source_query_windows::tests::actual_cached_boundaries_are_kept_and_gaps_are_covered ... ok
+test backtest::source_query_windows::tests::all_days_remain_once_and_scope_count_is_bounded ... ok
+test backtest::source_query_windows::tests::discovery_never_crosses_source_keys_schemas_or_file_types ... ok
+test backtest::source_query_windows::tests::overlap_prefers_more_covered_days_then_fewer_windows ... ok
+test backtest::source_query_windows::tests::projection_and_symbol_scope_have_distinct_boundary_keys ... ok
+test backtest::saved_risk_cache::tests::saved_reference_coalesces_only_validated_original_contracts ... ok
+test backtest::source_query_windows::tests::uncached_gaps_keep_the_existing_calendar_anchor ... ok
+test backtest::source_row_key_index::tests::indexed_date_ranges_cover_days_split_across_batches ... ok
+test backtest::source_row_key_index::tests::normalized_keys_cannot_duplicate_across_batches ... ok
+test backtest::source_row_key_index::tests::null_identity_and_declared_count_mismatch_are_rejected ... ok
+test backtest::source_row_query_purpose_tests::factor_overlay_cache_identity_cannot_be_reused_as_market_facts ... ok
+test backtest::source_row_query_purpose_tests::factor_overlay_merge_preserves_every_base_market_and_risk_fact ... ok
+test backtest::source_row_query_purpose_tests::factor_overlay_requires_an_explicit_non_market_projection ... ok
+test backtest::source_row_query_purpose_tests::only_explicit_factor_overlays_omit_redundant_risk_columns ... ok
+test backtest::source_rows_columnar::tests::cache_write_failure_does_not_replace_the_current_columnar_input ... ok
+test backtest::source_rows_columnar::tests::actual_selection_and_empty_outputs_do_not_keep_unused_factor_columns ... ok
+test backtest::source_rows_columnar::tests::columnar_normalization_matches_mixed_values_json_aliases_and_sorting ... ok
+test backtest::source_rows_columnar::tests::invalid_keys_and_adjustment_are_rejected_before_selection ... ok
+test backtest::source_rows_columnar::tests::malformed_json_and_dependency_identity_are_not_accepted ... ok
+test backtest::source_rows_columnar::tests::non_cacheable_json_factor_names_keep_the_real_record_path ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_crosses_record_batches_and_preserves_key_normalization ... ok
+test backtest::source_rows_columnar::tests::normalized_duplicate_symbols_are_not_deduplicated ... ok
+test backtest::source_rows_input_tests::cache_write_failure_retains_the_real_window_and_empty_windows_do_not_read_old_rows ... ok
+test backtest::source_rows_input_tests::cache_cannot_include_rows_outside_its_declared_date_range ... ok
+test backtest::source_rows_input_tests::failed_materialization_does_not_turn_the_source_into_an_empty_success ... ok
+test backtest::source_rows_input_tests::independent_windows_stay_columnar_until_daily_snapshot_construction ... ok
+test backtest::source_rows_input_tests::invalid_cache_keys_and_overlay_coverage_never_publish_source_input ... ok
+test backtest::source_rows_input_tests::mapped_input_preserves_empty_scopes_and_filters_only_base_rows ... ok
+test backtest::source_rows_input_tests::mapped_input_can_be_materialized_for_mutating_model_and_publication_overlays ... ok
+test backtest::source_rows_input_tests::mixed_window_storage_and_duplicate_boundaries_keep_original_semantics ... ok
+test backtest::source_rows_input_tests::mapped_inventory_and_final_days_match_owned_rows_with_factor_overlays ... ok
+test backtest::source_rows_input_tests::unsuccessful_window_publication_cannot_read_a_previous_cache_file ... ok
+test backtest::terminal_audit_summary_tests::deferred_strategy_warning_is_not_presented_as_a_submitted_order ... ok
+test backtest::terminal_audit_summary_tests::pending_terminal_state_is_explicit_in_summary_warning ... ok
+test backtest::terminal_calendar_tests::delayed_deposit_requires_terminal_calendar_but_zero_day_does_not ... ok
+test backtest::terminal_calendar_tests::scheduled_terminal_calendar_requires_strict_order_and_range ... ok
+test backtest::tests::accounting_allocation_details_do_not_require_or_fabricate_an_order ... ok
+test backtest::tests::all_source_lake_runtime_caches_are_scoped_by_backtest_bundle ... ok
+test backtest::tests::arrow_reader_accepts_lz4_compressed_stream ... ok
+test backtest::tests::audit_instrument_cache_values_from_request ... ignored, read-only Boris cache comparison with an explicit audit request
+test backtest::tests::benchmark_borrowed_numeric_factor_keys_against_owned_strings ... ignored, manual release-mode allocation benchmark
+test backtest::tests::benchmark_date_symbol_filter_query_range_preserves_index_symbols ... ok
+test backtest::tests::benchmark_query_windows_split_long_source_lake_ranges ... ok
+test backtest::source_rows_input_tests::separate_arrow_factor_input_preserves_sparse_overlay_values_and_existing_layers ... ok
+test backtest::tests::benchmark_row_binary_cache_rejects_metadata_mismatch ... ok
+test backtest::tests::benchmark_row_binary_cache_roundtrips_rows ... ok
+test backtest::tests::benchmark_row_cache_ignores_legacy_csv_cache ... ok
+test backtest::tests::benchmark_row_cache_path_uses_binary_cache_file ... ok
+test backtest::tests::benchmark_row_cache_path_scopes_date_symbol_filter ... ok
+test backtest::tests::benchmark_row_candidate_scan_removes_stale_schema_cache ... ok
+test backtest::tests::benchmark_row_covering_cache_reuses_superset_symbols_and_dates ... ok
+test backtest::tests::benchmark_row_partial_cache_rejects_missing_symbol_segment ... ok
+test backtest::tests::benchmark_row_to_source_row_preserves_false_paused_state ... ok
+test backtest::tests::benchmark_row_partial_cache_reports_missing_ranges ... ok
+test backtest::tests::benchmark_row_window_cache_scope_ignores_out_of_window_filter_dates ... ok
+test backtest::tests::benchmark_rows_dedup_after_window_merge ... ok
+test backtest::tests::benchmark_source_row_arrow_bounded_materialization ... ignored, requires FIDC_BT_SOURCE_ROW_VIEW_PROBE_PATH and explicit release-mode invocation
+test backtest::tests::benchmark_source_row_arrow_view_cache ... ignored, requires FIDC_BT_SOURCE_ROW_VIEW_PROBE_PATH and explicit release-mode invocation
+test backtest::tests::bootstrap_missing_quote_repair_keys_keeps_all_actual_order_gaps_without_fills ... ok
+test backtest::tests::bootstrap_missing_quote_repair_keys_keeps_all_after_fills_exist ... ok
+test backtest::tests::benchmark_rows_empty_date_symbol_filter_does_not_reuse_existing_cache ... ok
+test backtest::tests::build_trade_detail_rows_expands_split_fills_by_order_id ... ok
+test backtest::tests::build_trade_detail_rows_matches_fill_when_order_reason_changes ... ok
+test backtest::tests::build_trade_detail_rows_omits_canceled_orders_without_fills ... ok
+test backtest::tests::build_trade_detail_rows_preserves_decision_and_execution_dates ... ok
+test backtest::tests::carry_forward_target_snapshot_keeps_transition_day_then_replaces_positions ... ok
+test backtest::tests::cn_index_symbols_are_not_stock_execution_quote_repair_symbols ... ok
+test backtest::tests::collect_missing_execution_quote_keys_uses_canceled_stock_orders_only ... ok
+test backtest::tests::compact_progress_retains_manual_counts_and_rejects_a_missing_source ... ok
+test backtest::tests::compacted_carry_forward_filter_keeps_window_semantics ... ok
+test backtest::tests::corporate_action_arrow_preserves_the_independent_delivery_date_and_unknown_quantities ... ok
+test backtest::tests::corporate_action_binary_cache_roundtrips_rows ... ok
+test backtest::tests::corporate_action_cache_ignores_legacy_csv_cache ... ok
+test backtest::tests::corporate_action_cache_path_uses_source_lake_provider_epoch ... ok
+test backtest::tests::bundle_validation_observes_dependency_semantic_change_and_revocation_without_ttl ... ok
+test backtest::tests::corporate_action_covering_cache_reuses_superset_scope ... ok
+test backtest::tests::daily_execution_price_arrow_decode_preserves_unpriced_paused_risk_rows ... ok
+test backtest::tests::daily_execution_price_arrow_requires_execution_contract_fields ... ok
+test backtest::tests::daily_execution_scope_membership_is_normalized_once_and_isolated_by_date ... ok
+test backtest::tests::dataset_signature_scopes_fixed_signal_source_rows ... ok
+test backtest::tests::dataset_signature_scopes_fixed_signal_date_symbol_filter_with_model_score ... ok
+test backtest::tests::date_symbol_filter_query_range_carry_forward_keeps_history_prefix ... ok
+test backtest::tests::date_symbol_filter_query_range_exact_keeps_only_window_dates ... ok
+test backtest::tests::date_symbol_filter_query_range_preserves_empty_request ... ok
+test backtest::tests::dataset_signature_uses_data_requirements_not_strategy_identity_or_thresholds ... ok
+test backtest::tests::default_cache_epochs_ignore_local_manifest_directory ... ok
+test backtest::tests::dense_execution_quote_plan_uses_requested_trade_dates_only ... ok
+test backtest::tests::dynamic_model_score_execution_only_queries_next_date_gaps ... ok
+test backtest::tests::dynamic_model_score_execution_skips_rows_present_on_next_full_calendar_date ... ok
+test backtest::tests::dynamic_symbol_expression_does_not_enable_fixed_source_scope ... ok
+test backtest::tests::dynamic_model_score_execution_symbols_include_candidate_universe_for_lagged_execution ... ok
+test backtest::tests::empty_date_symbol_filter_is_empty_request_not_all_market ... ok
+test backtest::tests::equity_artifact_keeps_external_deposit_out_of_return ... ok
+test backtest::tests::equity_projection_orders_facts_and_includes_the_initial_nav_peak ... ok
+test backtest::tests::execution_arrow_does_not_turn_nonfinite_numbers_into_optional_missing_values ... ok
+test backtest::tests::execution_arrow_requires_the_strict_source_contract_even_when_empty ... ok
+test backtest::tests::execution_price_date_symbol_filter_keeps_benchmark_and_prunes_other_targets ... ok
+test backtest::tests::execution_price_only_source_row_marker_round_trips ... ok
+test backtest::tests::execution_quantities_are_exact_integers_not_rounded_floats ... ok
+test backtest::tests::exact_source_row_windows_restore_in_parallel_and_keep_order ... ok
+test backtest::tests::execution_quote_day_binary_cache_invalidates_duplicate_date_symbol ... ok
+test backtest::tests::execution_quote_day_binary_cache_rejects_metadata_mismatch ... ok
+test backtest::tests::execution_quote_day_cache_does_not_persist_empty_negative_result ... ok
+test backtest::tests::execution_quote_day_cache_ignores_legacy_csv_cache ... ok
+test backtest::tests::execution_quote_day_cache_loads_empty_without_provider_url ... ok
+test backtest::tests::execution_quote_day_cache_path_includes_minute_lookback_and_price_rule ... ok
+test backtest::tests::execution_quote_day_cache_path_uses_quote_epoch ... ok
+test backtest::tests::execution_quote_day_cache_path_uses_source_lake_provider_tag ... ok
+test backtest::tests::execution_quote_day_cache_tracks_returned_symbols_only ... ok
+test backtest::tests::execution_quote_prefetch_seed_tracks_negative_symbols ... ok
+test backtest::tests::execution_quote_query_tasks_keep_target_time_symbol_scopes_narrow ... ok
+test backtest::tests::execution_quote_query_tasks_merge_identical_symbol_scopes_for_same_day ... ok
+test backtest::tests::execution_quote_rows_duplicate_date_symbol_is_rejected ... ok
+test backtest::tests::execution_quote_rows_normalize_base_stock_code_symbols ... ok
+test backtest::tests::execution_quote_loader_reads_a_bounded_minute_window_instead_of_a_point_snapshot ... ok
+test backtest::tests::explicit_cli_source_cache_epoch_is_stable_and_provider_scoped ... ok
+test backtest::tests::external_daily_execution_symbols_without_signals_only_queries_benchmark ... ok
+test backtest::tests::external_daily_execution_symbols_skip_signals_already_in_source_rows ... ok
+test backtest::tests::factor_values_arrow_decode_validates_metadata_and_merges_aliases ... ok
+test backtest::tests::fidc_runner_rejects_ficlaw_data_source_rows_table ... ok
+test backtest::tests::factor_values_arrow_decode_rejects_future_data_and_semantic_drift ... ok
+test backtest::tests::fixed_minute_subscriptions_expand_static_daily_data_scope ... ok
+test backtest::tests::fixed_signal_date_symbol_filter_is_disabled_when_static_symbols_are_mixed_in ... ok
+test backtest::tests::fixed_signal_date_symbol_filter_seeds_static_symbols_at_query_start ... ok
+test backtest::tests::fixed_signal_date_symbol_filter_survives_model_score_rank_metadata ... ok
+test backtest::tests::fixed_signal_next_open_exit_scope_keeps_all_prior_unsold_symbols ... ok
+test backtest::tests::fixed_signal_source_row_date_symbol_filter_extracts_dated_weights_only ... ok
+test backtest::tests::fixed_signal_source_row_symbols_extracts_runtime_target_weights_expr ... ok
+test backtest::tests::fixed_signal_source_row_date_symbol_filter_extracts_target_holding_rows ... ok
+test backtest::tests::fixed_signal_source_row_symbols_extracts_single_quoted_runtime_target_weights_expr ... ok
+test backtest::tests::fixed_signal_source_row_symbols_extracts_strategy_metadata_targets ... ok
+test backtest::tests::fixed_signal_source_row_symbols_extracts_target_weight_codes ... ok
+test backtest::tests::fixed_symbol_order_scope_requires_rotation_disabled ... ok
+test backtest::tests::fixed_symbol_orders_seed_exact_intraday_snapshot_keys ... ok
+test backtest::tests::frozen_bundle_identity_http_failure_is_not_a_mutable_epoch_fallback ... ok
+test backtest::tests::full_minute_prefetch_days_respect_total_bar_budget ... ok
+test backtest::tests::futures_source_lake_catalog_requires_all_truth_datasets ... ok
+test backtest::tests::futures_only_runtime_contract_keeps_stock_scope_empty_and_allocates_cash ... ok
+test backtest::tests::instrument_metadata_binary_cache_rejects_metadata_mismatch ... ok
+test backtest::tests::instrument_metadata_binary_cache_roundtrips_rows ... ok
+test backtest::tests::instrument_metadata_cache_ignores_legacy_csv_cache ... ok
+test backtest::tests::instrument_metadata_cache_merges_missing_symbols_incrementally ... ok
+test backtest::tests::instrument_metadata_cache_path_is_scoped_by_historical_window ... ok
+test backtest::tests::instrument_metadata_cache_path_uses_binary_format ... ok
+test backtest::tests::instrument_metadata_request_serializes_historical_source_window_when_present ... ok
+test backtest::tests::intraday_snapshot_binary_cache_rejects_metadata_mismatch ... ok
+test backtest::tests::intraday_snapshot_binary_cache_roundtrips_rows ... ok
+test backtest::tests::intraday_snapshot_cache_ignores_legacy_csv_cache ... ok
+test backtest::tests::intraday_snapshot_cache_path_uses_source_lake_provider_tag ... ok
+test backtest::tests::kcb_board_and_quantity_use_source_classification ... ok
+test backtest::tests::intraday_snapshot_seeds_execution_quotes_and_negative_gaps ... ok
+test backtest::tests::layered_execution_quote_loader_cache_preserves_shared_seed_and_isolates_overlay ... ok
+test backtest::tests::lazy_execution_quote_window_backfill_keeps_future_missing_symbols ... ok
+test backtest::tests::lazy_execution_quote_window_dates_use_trading_calendar_only ... ok
+test backtest::tests::load_strategy_spec_rejects_removed_compatibility_profile ... ok
+test backtest::tests::load_strategy_spec_rejects_removed_engine_profile_name ... ok
+test backtest::tests::malformed_execution_observations_are_errors_not_empty_successes ... ok
+test backtest::tests::malformed_versioned_factor_ref_fails_closed ... ok
+test backtest::tests::managed_source_rows_route_by_exact_table ... ok
+test backtest::tests::minute_bar_arrow_decode_accepts_bounded_multi_date_stream ... ok
+test backtest::tests::load_strategy_spec_accepts_snake_case_bundle_field ... ok
+test backtest::tests::minute_bar_arrow_decode_preserves_timestamp_symbol_order ... ok
+test backtest::tests::minute_bar_arrow_decode_rejects_retired_string_time_schema ... ok
+test backtest::tests::minute_bar_arrow_decode_rejects_duplicate_or_unordered_rows ... ok
+test backtest::tests::mixed_candidate_book_binds_complete_dates_raw_sources_and_resolved_order ... ok
+test backtest::tests::mixed_stock_futures_contract_requires_explicit_futures_cash ... ok
+test backtest::tests::normalize_symbol_maps_bse_exchange_to_beijing_board ... ok
+test backtest::columnar_factor_overlay_tests::columnar_overlay_matches_row_decoder_for_wide_sparse_null_and_signed_zero_values ... ok
+test backtest::tests::minute_bars_retries_transient_http_failure_and_preserves_caller_header ... ok
+test backtest::tests::partial_source_row_window_cache_crops_covering_segments_in_arrow ... ok
+test backtest::tests::partial_source_row_window_cache_ignores_all_market_cache_for_symbol_scope ... ok
+test backtest::tests::partial_source_row_window_cache_ignores_wide_projection_segment ... ok
+test backtest::tests::partial_source_row_window_cache_reports_only_missing_gaps ... ok
+test backtest::tests::progress_callback_is_forwarded_to_blocking_engine_thread ... ok
+test backtest::tests::published_factor_binding_normalizes_ref_and_builds_arrow_request ... ok
+test backtest::tests::query_scope_batch_preserves_authoritative_window_identities ... ok
+test backtest::tests::platform_quote_plan_uses_current_decision_date_source_rows ... ok
+test backtest::tests::partial_source_row_window_cache_reuses_exact_projection_with_null_dynamic_columns ... ok
+test backtest::tests::query_scope_identity_reuses_physical_window_across_distinct_bundles ... ok
+test backtest::tests::real_source_quote_json_and_arrow_match_strict_reader ... ignored, requires a bounded real Source JSON/Arrow probe directory
+test backtest::tests::repeated_query_views_share_only_identical_execution_observations ... ok
+test backtest::tests::query_scope_http_carries_rolling_dependencies_and_rejects_bad_contracts ... ok
+test backtest::tests::select_instrument_metadata_rejects_missing_symbols ... ok
+test backtest::tests::shared_base_source_projection_keeps_raw_adjustment_contract ... ok
+test backtest::tests::reusable_source_row_window_cache_does_not_reuse_covering_cache ... ok
+test backtest::tests::shared_base_source_rows_cache_is_enabled_by_default ... ok
+test backtest::tests::shared_base_source_rows_cache_is_only_for_unscoped_raw_rows ... ok
+test backtest::tests::sorted_source_row_validator_rejects_unordered_or_duplicate_keys ... ok
+test backtest::tests::source_cache_epoch_default_is_independent_from_quote_plan_epoch ... ok
+test backtest::tests::source_dependency_contract_invalidates_all_authoritative_cache_scopes ... ok
+test backtest::tests::segmented_source_row_cache_reads_only_uncovered_overlap_ranges ... ok
+test backtest::tests::short_range_source_query_window_is_explicit_and_keeps_long_ranges_bounded ... ok
+test backtest::tests::source_lake_contract_epoch_ignores_runtime_build_but_tracks_catalog ... ok
+test backtest::tests::source_lake_health_contract_epoch_ignores_runtime_build ... ok
+test backtest::tests::source_lake_arrow_request_retries_bad_gateway ... ok
+test backtest::tests::source_lake_busy_retry_honors_retryable_capacity_response ... ok
+test backtest::tests::source_lake_source_query_retries_are_bounded_and_transient_only ... ok
+test backtest::tests::source_lake_source_query_timeout_accepts_highmem_alias ... ok
+test backtest::tests::source_lake_run_waits_for_manifest_publication_and_holds_shared_lease ... ok
+test backtest::tests::source_row_arrow_cache_rejects_and_does_not_write_empty_rows ... ok
+test backtest::tests::source_row_arrow_cache_rejects_duplicate_date_symbol ... ok
+test backtest::tests::source_lake_uses_wider_windows_for_narrow_queries ... ok
+test backtest::tests::source_query_concurrency_defaults_and_clamps ... ok
+test backtest::tests::source_row_arrow_decode_keeps_compact_base_rows_without_extra_json ... ok
+test backtest::tests::source_row_arrow_decode_preserves_dynamic_projection_columns ... ok
+test backtest::tests::source_row_arrow_extra_factor_helpers_preserve_projected_columns ... ok
+test backtest::tests::source_row_arrow_dependency_contract_rejects_invalid_metadata ... ok
+test backtest::tests::source_row_arrow_view_cache_reuses_identity_and_invalidates_replacement ... ok
+test backtest::tests::source_row_arrow_view_keeps_mmap_alive_until_materialization ... ok
+test backtest::tests::source_row_cache_file_range_parses_source_cache_dates ... ok
+test backtest::tests::source_row_cache_candidate_scan_removes_previous_schema_files ... ok
+test backtest::tests::source_row_cache_directory_index_tracks_files_published_by_other_workers ... ok
+test backtest::tests::source_row_cache_path_hashes_long_projection_columns ... ok
+test backtest::tests::source_row_cache_path_scopes_explicit_source_symbols ... ok
+test backtest::tests::source_row_cache_lease_serializes_concurrent_misses ... ok
+test backtest::tests::source_row_cache_path_normalizes_projection_column_order ... ok
+test backtest::tests::source_row_cache_path_separates_projection_columns ... ok
+test backtest::tests::source_row_cache_projection_check_allows_source_lake_fixed_aliases ... ok
+test backtest::tests::source_row_cache_projection_check_requires_extra_factor_keys ... ok
+test backtest::tests::source_row_cache_segment_selection_prefers_small_complete_windows ... ok
+test backtest::tests::source_row_cache_rejects_legacy_raw_bincode_without_magic_header ... ok
+test backtest::tests::source_row_cache_segment_selection_rejects_incomplete_windows ... ok
+test backtest::tests::source_row_date_windows_keep_interior_buckets_stable_across_ranges ... ok
+test backtest::tests::source_row_date_windows_split_long_ranges ... ok
+test backtest::tests::source_row_date_windows_stay_within_requested_range ... ok
+test backtest::tests::source_row_primary_keys_are_inline_without_growing_the_row_header ... ok
+test backtest::tests::source_row_cache_rejects_metadata_mismatch ... ok
+test backtest::tests::source_row_request_cache_epoch_scopes_runtime_query_context ... ok
+test backtest::tests::source_row_segment_boundary_validator_preserves_fail_closed_integrity ... ok
+test backtest::tests::source_row_symbol_normalization_preserves_canonical_and_maps_board ... ok
+test backtest::tests::source_row_symbol_scope_epoch_changes_with_fixed_signal_symbols ... ok
+test backtest::tests::source_row_cache_writes_arrow_file ... ok
+test backtest::tests::source_rows_duplicate_date_symbol_is_rejected ... ok
+test backtest::tests::source_row_window_cache_scope_ignores_out_of_window_filter_dates ... ok
+test backtest::tests::source_rows_request_keeps_rolling_enabled_for_rolling_projection_columns ... ok
+test backtest::tests::source_rows_unique_date_symbol_passes_without_reordering ... ok
+test backtest::tests::source_semantic_change_invalidates_bundle_and_window_cache ... ok
+test backtest::tests::static_universe_include_is_an_explicit_source_row_scope ... ok
+test backtest::tests::strategy_factor_overlay_only_queries_keys_and_missing_factor_fields ... ok
+test backtest::tests::stock_pool_screen_snapshot_uses_exact_selection_dates_and_full_symbol_history ... ok
+test backtest::tests::strategy_bundle_path_loads_nested_spec_and_signal_scope ... ok
+test backtest::tests::strategy_factor_overlay_rejects_duplicate_and_unordered_keys ... ok
+test backtest::tests::strategy_factor_overlay_requires_exact_base_key_coverage ... ok
+test backtest::tests::strategy_factory_source_lake_provider_name_is_exact ... ok
+test backtest::tests::strategy_factory_source_lake_requires_url_and_matching_provider ... ok
+test backtest::tests::strategy_factory_source_lake_uses_arrow_sized_query_windows_by_default ... ok
+test backtest::tests::trade_display_metadata_cache_is_bundle_scoped_and_covers_missing_rows ... ok
+test backtest::tests::trade_display_metadata_cache_rejects_rows_outside_exact_request ... ok
+test backtest::tests::typed_equity_result_emits_service_schema ... ok
+test backtest::tests::typed_order_result_keeps_zero_fill_orders ... ok
+test backtest::tests::trade_display_metadata_disk_cache_roundtrips_frozen_bundle_rows ... ok
+test backtest::tests::typed_trade_result_preserves_sub_cent_execution_price ... ok
+test backtest::tests::validated_manifest_scope_reuses_cache_across_distinct_bundle_ids ... ok
+test backtest::tests::versioned_factor_binding_rejects_research_scope ... ok
+test backtest::tests::versioned_factor_binding_requires_declared_semantics ... ok
+test backtest::tests::versioned_factor_ref_requires_a_binding ... ok
+test backtest::typed_exit_dependency_tests::ordinary_strategy_partial_exit_also_contributes_its_window ... ok
+test backtest::typed_exit_dependency_tests::typed_stock_pool_exits_contribute_the_full_rolling_window ... ok
+test cache_directory_watch::tests::notifications_cover_publication_rename_delete_and_ignore_unrelated_files ... ok
+test compute_pool_tests::concurrent_embedded_runs_do_not_change_each_others_pool_budget ... ok
+test compute_pool_tests::current_thread_async_runtime_keeps_the_compute_context ... ok
+test backtest::tests::timed_quote_dataset_signature_includes_daily_selection_plan ... ok
+test decision_projection::tests::projection_metadata_alias_empty_fields_and_credential_paths_fail_closed ... ok
+test decision_projection::tests::projection_native_request_is_complete_and_never_truncated_to_top_n ... ok
+test decision_projection::tests::projection_response_is_bound_to_source_model_clock_and_exact_population ... ok
+test compute_pool_tests::embedded_runner_uses_its_declared_budget_and_preserves_results ... ok
+test manual_ledger::corporate_tests::actual_core_corporate_projection_is_preserved_in_the_shared_trade_row ... ok
+test result_store::tests::canonical_first_divergence_reports_json_pointer ... ok
+test result_store::tests::canonical_manifest_is_stable_and_transport_independent ... ok
+test manual_ledger::corporate_tests::corporate_adjustments_reject_forged_money_dates_and_reference_chains ... ok
+test backtest::tests::unused_daily_market_cap_prefilter_does_not_split_identical_input_cache ... ok
+test result_store::tests::fact_manifest_publish_is_idempotent_under_concurrency ... ok
+test result_store::tests::lazy_registration_defers_payload_hashing_to_section_read ... ok
+test result_store::tests::process_event_store_is_content_addressed_and_round_trips ... ok
+test result_store::tests::run_store_identity_keeps_different_data_epochs_separate ... ok
+test result_store::tests::manual_source_and_applications_are_both_hashed_and_persisted ... ok
+test result_store::tests::run_store_is_content_addressed_and_round_trips ... ok
+test result_store::tests::run_store_reads_only_date_overlapping_blocks ... ok
+test result_store::tests::run_store_rejects_corrupt_manifest ... ok
+test thread_cpu::tests::thread_cpu_clock_keeps_unavailable_or_cross_thread_samples_unknown ... ok
+test thread_cpu::tests::sleeping_time_is_not_reported_as_cpu_execution ... ok
+test backtest::source_rows_columnar::tests::columnar_cache_keeps_original_output_batch_boundaries ... ok
+
+test result: ok. 475 passed; 0 failed; 9 ignored; 0 measured; 0 filtered out; finished in 4.43s
+
+     Running unittests src/main.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/deps/fidc_backtest_runner-d9576ad0213a3f52)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+     Running tests/allocation_profile.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/deps/allocation_profile-d0f3f7d0fac79090)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+     Running unittests examples/export_manual_corporate_evidence.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/examples/export_manual_corporate_evidence-c94413bd1e0c9fa1)
+
+running 0 tests
+
+test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+     Running unittests src/main.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/deps/fidc_backtest_service-23dd72fc1212afbe)
+
+running 142 tests
+test daily_patterns::tests::column_transport_is_lossless_and_rejects_ambiguous_rows ... ok
+test daily_patterns::tests::arrow_rejects_truncation_and_forged_lengths_before_decoding ... ok
+test event_stream::tests::effective_initial_cash_is_projected_without_guessing_or_losing_source_precision ... ok
+test daily_patterns::tests::numeric_mode_requires_the_explicit_read_only_context ... ok
+test daily_patterns::tests::daily_patterns_read_only_transport_binds_exact_input ... ok
+test event_stream::tests::memory_tail_and_durable_prefix_replay_in_publish_order ... ok
+test event_stream::tests::ordered_batch_is_idempotent_and_changed_facts_do_not_replace_history ... ignored, requires local FIDC_EVENT_TEST_POSTGRES_DSN on the private fidc-auth-pg cluster
+test daily_patterns::tests::arrow_uses_same_kernel_and_exact_byte_proof_with_partial_scope ... ok
+test event_stream::tests::live_sequence_recent_replay_and_concurrent_runs_remain_isolated ... ok
+test execution_ledger::tests::actual_http_routes_return_both_sources_and_precise_manual_values ... ok
+test execution_ledger::tests::dated_fact_store_rejects_reverse_order_before_projection ... ok
+test execution_ledger::tests::serve_browser_fixture ... ignored, starts a local GET-only API for browser acceptance; set FIDC_LEDGER_UI_QA_PORT explicitly
+test execution_ledger::tests::serve_stream_browser_fixture ... ignored, starts isolated real WebSocket/GET handlers; FIDC_LEDGER_STREAM_QA_PORT required
+test execution_ledger::tests::source_precision_ids_and_later_status_are_not_rewritten ... ok
+test execution_ledger::tests::streamed_manual_facts_equal_final_ledger_without_publishing_a_future_terminal ... ok
+test execution_ledger::tests::typed_accounting_rows_keep_origin_without_order_identity ... ok
+test execution_ledger::tests::performance_counts_both_origins_and_sums_authoritative_fees_exactly ... ok
+test factor_events::tests::market_history_binds_kernel_version_and_preserves_unknown_streak ... ok
+test factor_events::tests::no_account_or_execution_payload_is_accepted ... ok
+test factor_events::tests::rank_history_binds_exact_scope_and_input_hash ... ok
+test factor_events::tests::transport_preserves_input_identity_and_rejects_future_values ... ok
+test idempotency::tests::canonical_json_order_does_not_change_request_identity ... ok
+test idempotency::tests::identity_binds_owner_and_rejects_changed_request ... ok
+test idempotency::tests::malformed_keys_and_unbound_records_are_rejected ... ok
+test performance::tests::accounting_allocations_are_not_unidentified_exchange_fills ... ok
+test performance::tests::builds_daily_weight_diagnostics_from_persisted_holdings ... ok
+test performance::tests::counts_open_underwater_duration_from_the_latest_peak ... ok
+test performance::tests::does_not_fake_risk_ratios_for_one_period ... ok
+test performance::tests::emits_true_nav_and_multiple_recovery_episodes ... ok
+test performance::tests::explicit_frozen_initial_capital_survives_a_first_day_deposit ... ok
+test performance::tests::first_period_loss_has_an_initial_peak_episode_without_a_fake_date ... ok
+test performance::tests::missing_benchmark_does_not_compact_dates_or_invent_a_drawdown_path ... ok
+test performance::tests::missing_order_ids_and_fees_remain_unknown_not_zero_or_report_counts ... ok
+test performance::tests::order_metrics_count_identities_separately_from_reports_and_partial_fills ... ok
+test performance::tests::preserves_a_first_day_strategy_return_and_initial_capital ... ok
+test performance::tests::preserves_the_canonical_pre_period_benchmark_baseline ... ok
+test performance::tests::projects_all_canonical_risk_metrics_and_contract_metadata ... ok
+test performance::tests::separates_longest_underwater_episode_from_deepest_drawdown ... ok
+test performance::tests::zero_nav_is_a_full_loss_not_missing_data ... ok
+test performance::tests::zero_orders_are_known_but_conflicting_order_identity_is_not_a_count ... ok
+test result_analysis_tests::batched_history_bindings_preserve_validation_and_survive_cache_eviction ... ignored, requires isolated FIDC_BACKTEST_TEST_POSTGRES_DSN
+test factor_events::tests::catalog_validator_binds_the_complete_body_and_preserves_contract ... ok
+test result_analysis_tests::copied_real_result_stores_and_browser_fixture ... ignored, requires FIDC_RESULT_QA_FIXTURES containing copied immutable result stores
+test result_analysis_tests::failed_optional_classification_keeps_unmodified_facts ... ok
+test result_analysis_tests::historical_text_search_filters_before_count_and_pagination ... ignored, requires isolated FIDC_BACKTEST_TEST_POSTGRES_DSN
+test result_analysis_tests::history_filters_use_corrected_drawdown_and_never_treat_unknown_as_zero ... ok
+test result_analysis_tests::owned_analysis_reference_does_not_require_a_cached_run_binding ... ok
+test result_analysis_tests::projected_history_filter_sort_and_pagination_on_postgres ... ignored, requires FIDC_BACKTEST_TEST_POSTGRES_DSN; creates an isolated test schema
+test result_analysis_tests::sector_filter_cannot_disable_its_classification_dependency ... ok
+test risk_projection::tests::absent_original_rates_preserve_independent_metrics_without_network_or_zero_rate_claim ... ok
+test risk_projection::tests::canonical_null_overrides_all_legacy_aliases_but_real_zero_survives ... ok
+test risk_projection::tests::original_contract_reprojects_legacy_zero_and_preserves_cash_flow_facts ... ok
+test risk_projection::tests::unavailable_contract_does_not_relabel_legacy_zero_as_a_verified_statistic ... ok
+test stock_pool_candidates::tests::resolve_binds_input_and_preserves_empty_automatic_days ... ok
+test submission_pg_tests::atomic_submission_claim_replay_and_rollback_on_postgres ... ignored, requires FIDC_BACKTEST_TEST_POSTGRES_DSN and creates only an isolated schema
+test tests::backtest_create_body_limit_accepts_bounded_signal_replays ... ok
+test tests::backtest_event_stream_exposes_a_websocket_transport ... ok
+test tests::backtest_list_cache_key_separates_summary_only_runtime_shape ... ok
+test tests::backtest_list_filters_and_sorting_use_generated_summary ... ok
+test tests::backtest_list_reports_cache_hit_and_effective_page_limit ... ok
+test tests::backtest_list_summary_only_uses_compact_query ... ok
+test tests::backtest_performance_contract_records_total_and_runner_seconds ... ok
+test tests::backtest_run_compact_cache_key_separates_strategy_detail_shape ... ok
+test tests::backtest_runner_data_env_accepts_strategy_factory_source_lake_provider ... ok
+test tests::backtest_runner_data_env_infers_strategy_factory_source_lake_from_runtime_source_table ... ok
+test tests::backtest_runner_data_env_rejects_legacy_ficlaw_data_source_table ... ok
+test tests::backtest_runner_data_env_rejects_legacy_source_provider ... ok
+test tests::backtest_runner_data_env_rejects_non_source_lake_provider ... ok
+test tests::backtest_runner_data_env_rejects_source_lake_provider_aliases ... ok
+test tests::backtest_runner_data_env_requires_strategy_factory_source_lake_url ... ok
+test tests::backtest_runner_data_env_uses_strategy_factory_source_lake_only ... ok
+test tests::backtest_schema_initialization_never_deletes_run_data ... ok
+test tests::backtest_schema_materializes_implementation_identity_for_compact_reads ... ok
+test tests::build_run_payload_does_not_mark_empty_running_summary_as_available ... ok
+test tests::build_run_payload_exposes_only_canonical_strategy_detail ... ok
+test tests::build_run_payload_marks_failed_error_summary_as_available ... ok
+test tests::build_run_payload_marks_terminal_metric_summary_as_available ... ok
+test tests::build_run_summary_preview_preserves_strategy_runtime_rebalance_signal ... ok
+test tests::build_run_summary_preview_preserves_terminal_audit ... ok
+test tests::canonical_result_is_recovered_from_runner_summary ... ok
+test tests::capacity_override_is_frozen_once_without_changing_execution_risk ... ok
+test tests::clear_backtest_list_cache_clears_compact_run_cache ... ok
+test tests::compact_result_handler_uses_single_pg_lookup ... ok
+test tests::compact_summary_only_runtime_select_avoids_config_json ... ok
+test tests::compact_summary_sql_removes_heavy_result_artifacts ... ok
+test tests::daily_execution_matching_type_normalizes_next_open_aliases_and_rejects_other_aliases ... ok
+test tests::default_backtest_concurrency_scales_with_available_cpu_threads ... ok
+test tests::default_backtest_source_table_uses_strategy_factory_source_lake ... ok
+test tests::detail_rows_query_page_size_maps_to_offset_limit ... ok
+test tests::equity_rows_hide_diagnostics_unless_explicitly_requested ... ok
+test tests::execution_cost_overrides_strategy_spec_for_runner ... ok
+test tests::execution_dynamic_slippage_overrides_strategy_spec_for_runner ... ok
+test tests::execution_matching_type_overrides_strategy_spec_for_runner ... ok
+test tests::execution_percent_slippage_alias_normalizes_to_price_ratio ... ok
+test tests::execution_rebalance_cash_mode_overrides_strategy_spec_for_runner ... ok
+test tests::execution_risk_overrides_strategy_spec_for_runner ... ok
+test tests::execution_risk_policy_rejects_conflicting_alias_values ... ok
+test tests::execution_risk_policy_rejects_non_object ... ok
+test tests::execution_risk_policy_rejects_unknown_fields_before_queueing ... ok
+test tests::execution_sell_then_buy_delay_slippage_requires_sell_then_buy_mode ... ok
+test tests::execution_slippage_overrides_strategy_spec_for_runner ... ok
+test tests::execution_top_level_risk_enabled_aliases_are_frozen_into_strategy_spec ... ok
+test tests::explicit_cost_override_removes_old_aliases_and_preserves_zero_minimum ... ok
+test tests::history_query_cache_has_a_bounded_entry_budget ... ok
+test tests::history_search_is_bounded_and_retains_literal_characters ... ok
+test tests::implementation_identity_freezes_source_and_binary_generation ... ok
+test tests::manual_observations_are_run_scoped_and_private_in_the_runner_bundle ... ok
+test tests::minute_execution_matching_type_uses_minute_price_and_rejects_daily_modes ... ok
+test tests::persisted_runtime_projection_never_guesses_missing_frequency ... ok
+test tests::persisted_runtime_projection_retains_minute_mode_and_frozen_bundle ... ok
+test tests::process_event_projection_uses_stable_kind_and_filters ... ok
+test tests::projected_fact_block_cache_key_is_shared_across_run_manifests ... ok
+test tests::public_backtest_projection_removes_internal_paths_recursively ... ok
+test tests::public_event_message_removes_internal_paths ... ok
+test tests::public_result_store_manifest_hides_internal_fact_blocks ... ok
+test tests::public_run_projection_does_not_reintroduce_internal_paths ... ok
+test tests::result_artifact_cache_keeps_shared_fact_blocks_after_run_eviction ... ok
+test tests::result_artifact_cache_rejects_conflicting_reference_for_same_sha ... ok
+test tests::result_block_page_plan_reads_only_overlapping_blocks ... ok
+test tests::runner_strategy_spec_path_prefers_bundle ... ok
+test tests::runtime_frequency_normalizes_and_overrides_strategy_spec_for_runner ... ok
+test tests::runtime_frozen_bundle_is_written_to_strategy_metadata_for_runner ... ok
+test tests::runtime_projection_migration_preserves_frozen_config ... ok
+test tests::runtime_symbols_override_strategy_spec_for_runner ... ok
+test tests::source_lake_preflight_rejects_unsupported_minute_cash_mode ... ok
+test tests::source_lake_run_contract_preflight_freezes_runtime_and_execution ... ok
+test tests::source_lake_runtime_requires_frozen_backtest_bundle_contract ... ok
+test tests::start_backtest_run_rejects_unready_data_source_before_persistence ... ok
+test tests::startup_reconciliation_closes_orphaned_runs_and_records_audit_event ... ok
+test tests::strategy_detail_keeps_strategy_body_without_full_config ... ok
+test tests::strategy_detail_returns_none_without_strategy_body ... ok
+test tests::strategy_expression_preflight_rejects_invalid_dsl_before_data_load ... ok
+test tests::summary_list_projection_keeps_table_metrics_and_removes_detail_payloads ... ok
+test tests::terminal_audit_accepts_deferred_intents_and_checks_the_retained_count ... ok
+test tests::terminal_audit_contract_rejects_missing_or_inconsistent_state ... ok
+test tests::top_level_limits_replace_all_nested_execution_aliases_before_preflight ... ok
+test tests::typed_holding_projection_derives_weight_and_final_snapshot ... ok
+test tests::typed_result_rows_filter_and_paginate_without_json_table_roundtrip ... ok
+test tests::typed_risk_filter_applies_execution_fields ... ok
+test event_stream::tests::replay_buffer_is_bounded_and_completed_streams_are_evicted_without_closing_subscribers ... ok
+test result_analysis_tests::complete_performance_and_paged_equity_share_corrected_drawdown ... ok
+test execution_ledger::tests::combined_pages_filter_before_count_and_keep_native_pages_bounded ... ok
+
+test result: ok. 134 passed; 0 failed; 8 ignored; 0 measured; 0 filtered out; finished in 9.47s
+
+     Running unittests examples/risk_projection_readonly.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/examples/risk_projection_readonly-466df29735f9d7d7)
+
+running 4 tests
+test risk_projection::tests::canonical_null_overrides_all_legacy_aliases_but_real_zero_survives ... ok
+test risk_projection::tests::original_contract_reprojects_legacy_zero_and_preserves_cash_flow_facts ... ok
+test risk_projection::tests::absent_original_rates_preserve_independent_metrics_without_network_or_zero_rate_claim ... ok
+test risk_projection::tests::unavailable_contract_does_not_relabel_legacy_zero_as_a_verified_statistic ... ok
+
+test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+
+     Running unittests examples/stock_pool_contract_probe.rs (/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb/debug/examples/stock_pool_contract_probe-58f0bd489ea866d6)
+
+running 1 test
+test stock_pool_candidates::tests::resolve_binds_input_and_preserves_empty_automatic_days ... ok
+
+test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s
+

docs/evidence/registered-share-risk-20261005/validation-pg-receipt.json

@@ -0,0 +1,244 @@
+{
+  "artifact_bytes": 9528,
+  "artifact_id": "strategy_research_7d866453d4ae4768b5a25bb9",
+  "artifact_path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1092cd0/validation-receipt.json",
+  "artifact_sha256": "15c1f57fe6a40538ec9d9e487275b731edd9cb15c3c5ae0520b8a88224606cfe",
+  "artifact_type": "research_source_scope_probe",
+  "contract_sha256": "590dbc7f2f9983ff4cdaeaaec261fead7bdb41b389ac9ee8fc66b3fca3609fc8",
+  "created_at": "2026-10-04T22:25:19Z",
+  "created_by": "boris",
+  "department_id": null,
+  "organization_id": "local_org",
+  "persisted_at": "2026-10-04T22:25:19Z",
+  "production_ready": false,
+  "record_json": {
+    "all_attempt_log_references": [
+      {
+        "bytes": 3625,
+        "compiler_failure": false,
+        "complete_success": false,
+        "failed": 2,
+        "ignored": 0,
+        "passed": 20,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-0bbeed4/initial-targeted-linux-tests.log",
+        "sha256": "9684e4e1c10aabe426c15cd408bb61b198ada8eed1258231e4b81fc30716ac49"
+      },
+      {
+        "bytes": 82467,
+        "compiler_failure": false,
+        "complete_success": false,
+        "failed": 1,
+        "ignored": 7,
+        "passed": 798,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-0caac44/full-linux-tests-attempt1.log",
+        "sha256": "9535151bd7a29a5f56265ef35dbff89b3e48729688cb34c32aa8a8fc9347e41c"
+      },
+      {
+        "bytes": 95343,
+        "compiler_failure": false,
+        "complete_success": false,
+        "failed": 4,
+        "ignored": 9,
+        "passed": 923,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-4eb4c17/full-linux-tests-attempt2.log",
+        "sha256": "db18ad5e876ce482dc1f76ac244e170a6095c2ead8a991af5dce45e72af8e9ac"
+      },
+      {
+        "bytes": 98381,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 9,
+        "passed": 967,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-05315f0/full-linux-tests-attempt3.log",
+        "sha256": "66879f838ec21001cb3e6c284f497cfb6a80c2d3a724ee9cb04e09476afc101b"
+      },
+      {
+        "bytes": 98381,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 9,
+        "passed": 967,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-a267052/final-full-linux-tests.log",
+        "sha256": "b565d8b983fb87881974da37ad5bd0721db3f51acda3af0cbe1b62406f18371c"
+      },
+      {
+        "bytes": 98381,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 9,
+        "passed": 967,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-7d7cce8/final-full-linux-tests.log",
+        "sha256": "b8f7a20a93335801950e40ce3a7124ae039e84fbb1db7dd821c314d2b05b4447"
+      },
+      {
+        "bytes": 98572,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 9,
+        "passed": 969,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-ce46c13/final-full-linux-tests.log",
+        "sha256": "cfd1cb81fde9f34991a54a54e2a734844bd8fab52292e043856b08d30090d19a"
+      },
+      {
+        "bytes": 80065,
+        "compiler_failure": false,
+        "complete_success": false,
+        "failed": 1,
+        "ignored": 7,
+        "passed": 781,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-4a41057/final-full-linux-tests.log",
+        "sha256": "a5a2222afc6d9dd28c892ccec4b44934a757ed385399fe67e893bf83769fee67"
+      },
+      {
+        "bytes": 98662,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 9,
+        "passed": 970,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-1092cd0/final-full-linux-tests.log",
+        "sha256": "38bb77591e04784ee1af4043c8792fe84f155a962ff7e5bd26e0e1571efccd42"
+      },
+      {
+        "bytes": 10543,
+        "compiler_failure": true,
+        "complete_success": false,
+        "failed": 0,
+        "ignored": 0,
+        "passed": 0,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1fa73bb/full-linux-tests-attempt1.log",
+        "sha256": "e758be915373f707a460e7d08ab4162f3b80d86b98091c555cb3351c2bb4d7b8"
+      },
+      {
+        "bytes": 65133,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 17,
+        "passed": 613,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ffc6e1f/full-linux-tests-attempt2.log",
+        "sha256": "d053e4e432cbe0b198f85ceee349b241eac4cf90b8e6a75289c322c59538b2b7"
+      },
+      {
+        "bytes": 65133,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 17,
+        "passed": 613,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ce46c13/final-full-linux-tests.log",
+        "sha256": "6f2e8974a90d5cdbce788e2744a1276dff9fe94b79958869cfb0730c096d1a42"
+      },
+      {
+        "bytes": 65258,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 17,
+        "passed": 614,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1d4b32e/final-full-linux-tests.log",
+        "sha256": "2ba99fb0198a68ff5bc3d6341b1cdeb3da1a4d0ca5496b2faa3e79e3494ae434"
+      },
+      {
+        "bytes": 65258,
+        "compiler_failure": false,
+        "complete_success": true,
+        "failed": 0,
+        "ignored": 17,
+        "passed": 614,
+        "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1092cd0/final-full-linux-tests.log",
+        "sha256": "fd6d3de7c1a6f2ebcd1ea65d73720661256786ce7799d86371357871adcadb17"
+      }
+    ],
+    "contract_sha256": "e025710eaa56f81f2bfad6e67009b6d476eebe9228e6fbe05c7e870164348586",
+    "core_test_result": {
+      "bytes": 98662,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 9,
+      "passed": 970,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-1092cd0/final-full-linux-tests.log",
+      "sha256": "38bb77591e04784ee1af4043c8792fe84f155a962ff7e5bd26e0e1571efccd42"
+    },
+    "corporate_action_cache_schema_version": 5,
+    "engine_commit": "1092cd0b80c5b8aee6851231f77e474c8ee2ba0c",
+    "fractional_quantity_requires_explicit_settlement_rule": true,
+    "full_source_event_and_revision_scope_verified": false,
+    "missed_core_live_scope_probe_after_test_finished_not_claimed_live_verification": true,
+    "new_runtime_release_performed": false,
+    "numeric_research_budget_reopened": false,
+    "observed_at": "2026-10-04T22:25:11.053398+00:00",
+    "operational_verification_reference": {
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1092cd0/operational-verification.json",
+      "sha256": "42a6814f9ca215b6a39d838c7faabbb293043b482520b5c4b50e3ccbaf45ea0a"
+    },
+    "owner_uid": 1003,
+    "pending_only_symbols_count_toward_position_limits": true,
+    "pending_share_successor_conversion_without_carry_terms_rejected": true,
+    "performance_speedup_claimed": false,
+    "prior_validation_pg_artifact": "strategy_research_59f5a031d3cc7e0e5080c91e",
+    "prior_validation_reference": {
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1d4b32e/validation-receipt.json",
+      "sha256": "097101988e5f6875c8933012534cfa1ca72f9e2742c04d002aba7d00a69fc346"
+    },
+    "production_ready": false,
+    "production_runtime_deployed": false,
+    "production_strategy_count": 0,
+    "registered_share_entitlements_separate_from_delivered_and_sellable_quantity": true,
+    "resource_contract_live_verification_reference": {
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1092cd0/live-test-resource-verification.json",
+      "sha256": "8064619cda9e9f6a9f6e3045fd5e7c9e981314cc1c0877d7e07f57aeeeb39a81"
+    },
+    "resource_contract_requested": {
+      "build_jobs": 4,
+      "core_target_path": "/tmp/fidc-cash-receivable-build-20261005-af655de",
+      "cpu_quota_percent": 400,
+      "incremental": false,
+      "locked": true,
+      "memory_max_bytes": 17179869184,
+      "memory_swap_max_bytes": 0,
+      "offline": true,
+      "resource_properties_after_transient_scope_exit_are_not_live_validation": true,
+      "runner_target_path": "/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb",
+      "rustc": "rustc 1.98.0 (88d9e12ae 2026-08-18)",
+      "target_filesystem": "executable_tmpfs",
+      "tasks_max": 256,
+      "toolchain": "stable-x86_64-unknown-linux-gnu"
+    },
+    "runner_api_test_result": {
+      "bytes": 65258,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 17,
+      "passed": 614,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1092cd0/final-full-linux-tests.log",
+      "sha256": "fd6d3de7c1a6f2ebcd1ea65d73720661256786ce7799d86371357871adcadb17"
+    },
+    "schema_version": "fidc.linux-registered-share-risk-validation/v1",
+    "service_commit": "1d4b32e18d3836b5844130ae0c95d90247768882",
+    "share_receivable_assets_included_in_equity_and_target_sizing": true,
+    "simulation_rounding_fixture_not_official_settlement_evidence": true,
+    "source_pair_root": "/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-1092cd0",
+    "source_publication_times_admitted_as_PIT": false,
+    "source_rows_semantic_sha256": "eec65df828f97a3e51827cb6b0e9ec2c86079a333481d55ec9eb6ab2845d73c5",
+    "source_rows_semantic_version": "v10",
+    "source_transport_commit": "12eeae5d570004499a30f7faa42c0da93c1578cc",
+    "status": "core_and_runner_api_regressions_passed_not_source_runtime_or_strategy_acceptance",
+    "trading_allowed": false,
+    "two_framework_financial_reconciliation_completed": false,
+    "unknown_delivery_date_not_defaulted_to_ex_date": true,
+    "unknown_distribution_quantities_not_defaulted_to_zero": true,
+    "unresolved_delisting_cannot_zero_pending_share_assets": true
+  },
+  "research_key": "fidc-registered-share-risk-validation-20261005-1092cd0-1d4b32e",
+  "schema_table": "strategy_research_artifact",
+  "schema_version": "fidc.linux-registered-share-risk-validation/v1",
+  "status": "core_and_runner_api_regressions_passed_not_source_runtime_or_strategy_acceptance",
+  "storage": "postgres"
+}

docs/evidence/registered-share-risk-20261005/validation-receipt.json

@@ -0,0 +1,225 @@
+{
+  "all_attempt_log_references": [
+    {
+      "bytes": 3625,
+      "compiler_failure": false,
+      "complete_success": false,
+      "failed": 2,
+      "ignored": 0,
+      "passed": 20,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-0bbeed4/initial-targeted-linux-tests.log",
+      "sha256": "9684e4e1c10aabe426c15cd408bb61b198ada8eed1258231e4b81fc30716ac49"
+    },
+    {
+      "bytes": 82467,
+      "compiler_failure": false,
+      "complete_success": false,
+      "failed": 1,
+      "ignored": 7,
+      "passed": 798,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-0caac44/full-linux-tests-attempt1.log",
+      "sha256": "9535151bd7a29a5f56265ef35dbff89b3e48729688cb34c32aa8a8fc9347e41c"
+    },
+    {
+      "bytes": 95343,
+      "compiler_failure": false,
+      "complete_success": false,
+      "failed": 4,
+      "ignored": 9,
+      "passed": 923,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-4eb4c17/full-linux-tests-attempt2.log",
+      "sha256": "db18ad5e876ce482dc1f76ac244e170a6095c2ead8a991af5dce45e72af8e9ac"
+    },
+    {
+      "bytes": 98381,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 9,
+      "passed": 967,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-05315f0/full-linux-tests-attempt3.log",
+      "sha256": "66879f838ec21001cb3e6c284f497cfb6a80c2d3a724ee9cb04e09476afc101b"
+    },
+    {
+      "bytes": 98381,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 9,
+      "passed": 967,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-a267052/final-full-linux-tests.log",
+      "sha256": "b565d8b983fb87881974da37ad5bd0721db3f51acda3af0cbe1b62406f18371c"
+    },
+    {
+      "bytes": 98381,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 9,
+      "passed": 967,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-7d7cce8/final-full-linux-tests.log",
+      "sha256": "b8f7a20a93335801950e40ce3a7124ae039e84fbb1db7dd821c314d2b05b4447"
+    },
+    {
+      "bytes": 98572,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 9,
+      "passed": 969,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-ce46c13/final-full-linux-tests.log",
+      "sha256": "cfd1cb81fde9f34991a54a54e2a734844bd8fab52292e043856b08d30090d19a"
+    },
+    {
+      "bytes": 80065,
+      "compiler_failure": false,
+      "complete_success": false,
+      "failed": 1,
+      "ignored": 7,
+      "passed": 781,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-4a41057/final-full-linux-tests.log",
+      "sha256": "a5a2222afc6d9dd28c892ccec4b44934a757ed385399fe67e893bf83769fee67"
+    },
+    {
+      "bytes": 98662,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 9,
+      "passed": 970,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-1092cd0/final-full-linux-tests.log",
+      "sha256": "38bb77591e04784ee1af4043c8792fe84f155a962ff7e5bd26e0e1571efccd42"
+    },
+    {
+      "bytes": 10543,
+      "compiler_failure": true,
+      "complete_success": false,
+      "failed": 0,
+      "ignored": 0,
+      "passed": 0,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1fa73bb/full-linux-tests-attempt1.log",
+      "sha256": "e758be915373f707a460e7d08ab4162f3b80d86b98091c555cb3351c2bb4d7b8"
+    },
+    {
+      "bytes": 65133,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 17,
+      "passed": 613,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ffc6e1f/full-linux-tests-attempt2.log",
+      "sha256": "d053e4e432cbe0b198f85ceee349b241eac4cf90b8e6a75289c322c59538b2b7"
+    },
+    {
+      "bytes": 65133,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 17,
+      "passed": 613,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-ce46c13/final-full-linux-tests.log",
+      "sha256": "6f2e8974a90d5cdbce788e2744a1276dff9fe94b79958869cfb0730c096d1a42"
+    },
+    {
+      "bytes": 65258,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 17,
+      "passed": 614,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1d4b32e/final-full-linux-tests.log",
+      "sha256": "2ba99fb0198a68ff5bc3d6341b1cdeb3da1a4d0ca5496b2faa3e79e3494ae434"
+    },
+    {
+      "bytes": 65258,
+      "compiler_failure": false,
+      "complete_success": true,
+      "failed": 0,
+      "ignored": 17,
+      "passed": 614,
+      "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1092cd0/final-full-linux-tests.log",
+      "sha256": "fd6d3de7c1a6f2ebcd1ea65d73720661256786ce7799d86371357871adcadb17"
+    }
+  ],
+  "contract_sha256": "e025710eaa56f81f2bfad6e67009b6d476eebe9228e6fbe05c7e870164348586",
+  "core_test_result": {
+    "bytes": 98662,
+    "compiler_failure": false,
+    "complete_success": true,
+    "failed": 0,
+    "ignored": 9,
+    "passed": 970,
+    "path": "/data/fidc-cold/autonomous-research/fidc-share-receivable-validation-20261005-1092cd0/final-full-linux-tests.log",
+    "sha256": "38bb77591e04784ee1af4043c8792fe84f155a962ff7e5bd26e0e1571efccd42"
+  },
+  "corporate_action_cache_schema_version": 5,
+  "engine_commit": "1092cd0b80c5b8aee6851231f77e474c8ee2ba0c",
+  "fractional_quantity_requires_explicit_settlement_rule": true,
+  "full_source_event_and_revision_scope_verified": false,
+  "missed_core_live_scope_probe_after_test_finished_not_claimed_live_verification": true,
+  "new_runtime_release_performed": false,
+  "numeric_research_budget_reopened": false,
+  "observed_at": "2026-10-04T22:25:11.053398+00:00",
+  "operational_verification_reference": {
+    "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1092cd0/operational-verification.json",
+    "sha256": "42a6814f9ca215b6a39d838c7faabbb293043b482520b5c4b50e3ccbaf45ea0a"
+  },
+  "owner_uid": 1003,
+  "pending_only_symbols_count_toward_position_limits": true,
+  "pending_share_successor_conversion_without_carry_terms_rejected": true,
+  "performance_speedup_claimed": false,
+  "prior_validation_pg_artifact": "strategy_research_59f5a031d3cc7e0e5080c91e",
+  "prior_validation_reference": {
+    "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1d4b32e/validation-receipt.json",
+    "sha256": "097101988e5f6875c8933012534cfa1ca72f9e2742c04d002aba7d00a69fc346"
+  },
+  "production_ready": false,
+  "production_runtime_deployed": false,
+  "production_strategy_count": 0,
+  "registered_share_entitlements_separate_from_delivered_and_sellable_quantity": true,
+  "resource_contract_live_verification_reference": {
+    "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1092cd0/live-test-resource-verification.json",
+    "sha256": "8064619cda9e9f6a9f6e3045fd5e7c9e981314cc1c0877d7e07f57aeeeb39a81"
+  },
+  "resource_contract_requested": {
+    "build_jobs": 4,
+    "core_target_path": "/tmp/fidc-cash-receivable-build-20261005-af655de",
+    "cpu_quota_percent": 400,
+    "incremental": false,
+    "locked": true,
+    "memory_max_bytes": 17179869184,
+    "memory_swap_max_bytes": 0,
+    "offline": true,
+    "resource_properties_after_transient_scope_exit_are_not_live_validation": true,
+    "runner_target_path": "/tmp/fidc-share-delivery-runner-build-20261005-1fa73bb",
+    "rustc": "rustc 1.98.0 (88d9e12ae 2026-08-18)",
+    "target_filesystem": "executable_tmpfs",
+    "tasks_max": 256,
+    "toolchain": "stable-x86_64-unknown-linux-gnu"
+  },
+  "runner_api_test_result": {
+    "bytes": 65258,
+    "compiler_failure": false,
+    "complete_success": true,
+    "failed": 0,
+    "ignored": 17,
+    "passed": 614,
+    "path": "/data/fidc-cold/autonomous-research/fidc-share-delivery-pair-validation-20261005-1092cd0/final-full-linux-tests.log",
+    "sha256": "fd6d3de7c1a6f2ebcd1ea65d73720661256786ce7799d86371357871adcadb17"
+  },
+  "schema_version": "fidc.linux-registered-share-risk-validation/v1",
+  "service_commit": "1d4b32e18d3836b5844130ae0c95d90247768882",
+  "share_receivable_assets_included_in_equity_and_target_sizing": true,
+  "simulation_rounding_fixture_not_official_settlement_evidence": true,
+  "source_pair_root": "/srv/fidc/programs/src/fidc-share-delivery-pair-validation-20261005-1092cd0",
+  "source_publication_times_admitted_as_PIT": false,
+  "source_rows_semantic_sha256": "eec65df828f97a3e51827cb6b0e9ec2c86079a333481d55ec9eb6ab2845d73c5",
+  "source_rows_semantic_version": "v10",
+  "source_transport_commit": "12eeae5d570004499a30f7faa42c0da93c1578cc",
+  "status": "core_and_runner_api_regressions_passed_not_source_runtime_or_strategy_acceptance",
+  "trading_allowed": false,
+  "two_framework_financial_reconciliation_completed": false,
+  "unknown_delivery_date_not_defaulted_to_ex_date": true,
+  "unknown_distribution_quantities_not_defaulted_to_zero": true,
+  "unresolved_delisting_cannot_zero_pending_share_assets": true
+}

docs/registered-share-delivery-20261005.md

@@ -0,0 +1,44 @@
+# 登记股份应收、实际交付与可卖数量修复
+
+2026-10-05。此前送股、转增按除权日的当前持仓立即增加股票，既可能给登记日后买入者错误分派，也可能在真正股份上市前增加可卖数量。此次按真实登记持仓确认独立股份应收，到明确交付日才进入实际持仓；权益计价、目标仓位和重放身份同步承接。生产策略验收仍为 0/10。
+
+## 账簿行为
+
+`CorporateAction` 独立携带 `record_date`、`share_effective_date` 和显式 `share_rounding_rule`。登记权益来自不可变收盘批次记录；登记日后买入不继承此前权益。缺登记日、缺收盘事实、缺交付日、交付日早于除权日、负分派率和未核验碎股处理均拒绝，整个批次保持原账簿和原说明。
+
+股份应收计入总权益和经济持仓数量，实际 `quantity` 与 `sellable_qty` 只包含已交付股份。示例为登记持有 100 股、每股 10 元，送转比例 0.5：除权后 100 股实际持仓和 50 股应收分别按约 6.6667 元计价，证券经济价值仍为 1,000 元；交付前只能卖出实际可卖的 100 股。交付只把原应收转换为 150 股实际持仓，不产生买单、成交或现金支出。此例为账簿合成回归，不是新的市场价格观察。
+
+交付保留原持有起点，逐登记批次分配账户总权益；不按每个碎片独立四舍五入。账户总权益为整数时进行精确分配；非整数必须有显式结算规则。`aggregate_half_up` 仅是既有模拟回归明确声明的合同，不作为官方实际结算证据。已有应收股份或同一行为的股份分派遇到证券转换时，缺少承接条款直接拒绝，不能丢弃应收资产。
+
+计价区分真实市场标记日期：除权日前的价格按分派比例转换，当日真实报价保留；缺少市场标记时需要受控登记日参考价格。目标市值、目标股数、分时目标和重平衡使用实际加应收的经济数量，避免交付等待期间重复买入；实际卖出仍受交付及原交易规则约束。现金应收仍独立计入资产，不变成可用资金。
+
+## 版本与验证
+
+最终核心提交为 `ce46c13f37f028393e689babbe5c348d482d3a32`，配套 Runner/API 提交为 `1d4b32e18d3836b5844130ae0c95d90247768882`，使用既有 `codex/decision-projection-20261003` 工作分支。Runner 接收登记日和独立交付日，权益缓存 schema 从 4 升为 5；旧版本缓存、原模型、评分、预算、输入和失败证据保留。
+
+177 的 Boris UID 1003 私有 checkout 使用批准的 Rust 1.98.0、锁文件和离线依赖，编译目录位于可执行 `/tmp` tmpfs。测试命令设置 CPUQuota=400%、MemoryMax=16GiB、MemorySwapMax=0、TasksMax=256、4 个构建 worker，关闭增量构建。最终配套测试在运行时独立读取 scope 属性并核验所有观测进程为 Boris，原件见 `live-test-resource-verification.json`。
+
+| 最终测试范围 | 通过 | 既有忽略项 | 完整日志 SHA256 |
+| --- | ---: | ---: | --- |
+| `fidc-core --all-targets` | 969 | 9 | `cfd1cb81fde9f34991a54a54e2a734844bd8fab52292e043856b08d30090d19a` |
+| Runner/API `--all-targets` | 614 | 17 | `2ba99fb0198a68ff5bc3d6341b1cdeb3da1a4d0ca5496b2faa3e79e3494ae434` |
+
+回归覆盖未交付不可卖、正常与迟到交付、重复结算、登记后买入、净值守恒、目标仓位不重复买入、证券转换原子拒绝以及整日快照对未知数量的拒绝。首次核心 20 通过、2 失败，后续旧事件说明和模拟交付日期/舍入夹具失败，以及 Runner 新测试作用域编译失败，均按原字节和 SHA 保存。首次回执构造缺少 `organization_id`，在 PG 写调用前失败；原回执保留，补全真实构造参数后独立完整 JSONB 回读。另一次验证驱动组装语法错误发生在远端代码执行前，已保留说明，修正后先通过本地语法编译再执行。
+
+最终回执 SHA256 为 `097101988e5f6875c8933012534cfa1ca72f9e2742c04d002aba7d00a69fc346`，PG18 artifact 为 `strategy_research_59f5a031d3cc7e0e5080c91e`，完整 JSONB 独立回读通过。较早的成功回执 `5240dbf5f1d7382531a4c0dce5fcdb722f4d1137a41854269159b61f0236d412` 和 PG artifact `strategy_research_cb32517064d7558f69713001` 保留，不覆盖。全部测试、失败日志、运行核验和回执见 [证据清单](evidence/registered-share-delivery-20261005/file-shas.json)。
+
+## 实际运行与剩余门禁
+
+五个原活动 FIDC 用户服务的 PID、InvocationID、状态和重启计数保持原值；冻结研究执行器仍为 PID 1396112、InvocationID `0eb28e3a45694a00951aa3aec0e13465`，原 v11 计划 SHA 未变。Source 18095 和回测 18096 健康为 200，已授权 incremental 清理目标仍为零文件。没有切换活动 Source、Runner 或研究代码，健康不等于新版本已部署。
+
+完整事件/无事件、合法参与对象、历史证券身份、修订和 PIT 发布证据，以及复杂权益承接和真实碎股规则仍需完成。当前回归不替代 AiQuant 同条件财务对账、冻结样本外、容量压力、Hermes、模拟盘准入和人工生产审批；没有速度提升结论，`production_runtime_deployed=false`、`production_ready=false`、`trading_allowed=false`。
+
+## 2026-10-05 收尾风险更正与最终版本
+
+上文 969 项阶段回执和原日志保持原样。本节追加随后发现的两个错误及更正：持仓上限原只统计已交付股数，漏掉只剩股份应收的证券；退市且缺行情时，原通用计价分支还可能把股份应收一并归零。现在持仓占用、换仓集合和新建持仓判断统一使用经济持仓数量；存在待交付权益而退市条款未解决时，在修改任何价格前明确拒绝，原权益、应收数量和账簿身份保持不变。
+
+最终有效核心提交为 `1092cd0b80c5b8aee6851231f77e474c8ee2ba0c`，配套 Service 业务提交仍为 `1d4b32e18d3836b5844130ae0c95d90247768882`。核心完整 Linux 回归 **970 项通过、9 项既有忽略**，日志 SHA256 `38bb77591e04784ee1af4043c8792fe84f155a962ff7e5bd26e0e1571efccd42`；最新成对 Runner/API 回归 **614 项通过、17 项既有忽略**，日志 SHA256 `fd6d3de7c1a6f2ebcd1ea65d73720661256786ce7799d86371357871adcadb17`。新增退市回归首次因夹具缺少独立基准而失败，原 `781 passed / 1 failed / 7 ignored` 日志 SHA `a5a2222afc6d9dd28c892ccec4b44934a757ed385399fe67e893bf83769fee67` 保留；补齐明确合成基准后重跑完整核心，没有放宽账户或数据门禁。
+
+较大 Git bundle 在本地长度预检拒绝直接传输，未执行远端修改；随后分成三个有独立 SHA 的受控片段，重组 SHA `36a50358e1bc41d2322fe9fb3984949fef95782f2b71dc345c6a70e520a40b9f` 核验后才构建。核心最终测试的现场 scope 采样晚于完成，未当作有效现场资源证明；首次核心测试及最新配套测试的实际 scope 记录分别保留，最终配套的 CPU/内存/任务限制和 Boris 进程属主独立核验通过。
+
+追加最终回执 SHA256 `15c1f57fe6a40538ec9d9e487275b731edd9cb15c3c5ae0520b8a88224606cfe`，PG18 artifact `strategy_research_7d866453d4ae4768b5a25bb9`，完整 JSONB 独立回读通过。[追加证据清单](evidence/registered-share-risk-20261005/file-shas.json)保留失败、最终测试、现场资源、运行核验和完整回执。五个原服务身份、冻结计划、数值预算及已清理缓存状态再次核验不变；Source/回测健康为 200。生产未部署、生产策略仍为 0/10，所有上文未完成准入门禁继续保留。