Skip to main content

nautilus_live/execution/
manager.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Execution reconciliation and state tracking for live hosts.
17//!
18//! [`ExecutionManager`] owns activity windows, retry state, fill identities, and cache-dependent
19//! decisions. It prepares queries and events, validates reports, and verifies applied fills.
20//! External-order registration updates the cache and publishes its initialization notification.
21//!
22//! The manager requests reports for individual checks and applies mass-status events to the engine.
23//! The live node owns recurring tasks, deadlines, and continuous event dispatch. Preparation snapshots
24//! retain activity revisions so decisions can be rechecked after requests or event callbacks.
25//! Activity revision counters are retained for the manager's lifetime so an older snapshot cannot
26//! mistake a reset counter for unchanged activity.
27
28use std::{
29    cell::{Ref, RefCell},
30    fmt::Debug,
31    rc::Rc,
32    sync::LazyLock,
33    time::Duration,
34};
35
36use anyhow::Context;
37use indexmap::{IndexMap, IndexSet};
38use nautilus_common::{
39    cache::{Cache, refs::PositionRef},
40    clients::{DEFAULT_POSITION_RECONCILIATION_TOLERANCE, ExecutionClient},
41    clock::Clock,
42    config::ConfigResult,
43    enums::{LogColor, LogLevel},
44    live::dst,
45    log_info,
46    messages::{
47        ExecutionReport,
48        execution::{
49            QueryOrder, TradingCommand,
50            report::{
51                GenerateFillReports, GenerateOrderStatusReport, GenerateOrderStatusReports,
52                GeneratePositionStatusReports,
53            },
54        },
55    },
56    msgbus::{self, MessagingSwitchboard, switchboard},
57};
58use nautilus_core::{DurationNanos, UUID4, UnixNanos, datetime::mins_to_secs};
59use nautilus_execution::{
60    engine::ExecutionEngine,
61    reconciliation::{
62        RECONCILIATION_ORDER_TAG, ReconciliationResult as AdjustedReports,
63        calculate_reconciliation_price, create_inferred_fill_for_qty,
64        create_reconciliation_rejected, create_reconciliation_triggered,
65        fill_precedes_snapshot_reconciled_position,
66        generate_external_order_status_events_with_commission,
67        generate_reconciliation_order_pre_fill_events,
68        generate_reconciliation_order_snapshot_events_with_commission,
69        incremental_inferred_fill_price_and_liquidity, inferred_fill_price_and_liquidity,
70        position_prices_match, preserve_order_amendment, process_mass_status_for_reconciliation,
71        process_mass_status_for_reconciliation_without_synthetic_reports,
72        reconcile_order_report_with_commission, should_reconciliation_update,
73    },
74};
75use nautilus_model::{
76    enums::{AvgPxReconciliation, OmsType, OrderSide, OrderStatus},
77    events::{OrderEventAny, OrderFilled, OrderInitialized, OrderUpdated},
78    identifiers::{
79        AccountId, ClientId, ClientOrderId, InstrumentId, PositionId, StrategyId, TradeId,
80        TraderId, VenueOrderId,
81    },
82    instruments::{Instrument, InstrumentAny},
83    orders::{Order, OrderAny, TRIGGERABLE_ORDER_TYPES},
84    position::{Position, PositionReplayEvent},
85    reports::{ExecutionMassStatus, FillReport, OrderStatusReport, PositionStatusReport},
86    types::{Money, Quantity},
87};
88use rust_decimal::Decimal;
89use ustr::Ustr;
90
91#[cfg(feature = "node")]
92pub(crate) use super::reconciliation::collect_targeted_order_reports;
93pub(crate) use super::reconciliation::{
94    OpenOrderReconciliationResult, OpenOrderReportCheck, SourcedOrderStatusReport,
95    TargetedOrderQuery, TargetedOrderReportResult, request_targeted_order_reports,
96    resolve_position_report_client_coverage,
97};
98pub use super::{
99    config::ExecutionManagerConfig,
100    reconciliation::{
101        ExternalOrderMetadata, InflightCheckResult, InstrumentAccountKey, PositionFillReportPlan,
102        PositionFillReportPreparation, PositionFillReportQuery, PositionReportCheck,
103        ReconciliationResult, ReportClientCoverage,
104    },
105};
106use super::{
107    recency::RecencyMap,
108    reconciliation::{
109        FillKey, InflightCheck, PositionQuantityComparison, PositionReconciliationState,
110        PositionReportShape, ReconciliationFillQueue, RetainedFillState,
111        create_orphan_fill_order_report, create_position_reconciliation_report,
112        create_reconciliation_canceled, create_reconciliation_command_rejections,
113        distinct_position_reports, has_active_inferred_fill, is_exact_order_match,
114        order_report_has_missing_fills, position_avg_px, position_qty_aggregates,
115        resolve_inferred_fill_commission, responsible_client_ids, should_project_fill,
116        sort_reconciliation_events,
117    },
118    submission::{SubmissionRecoveryExhausted, SubmissionRecoveryPolicy, SubmissionRecoverySource},
119};
120
121/// Tag for orders originating from venue (external orders).
122static TAG_VENUE: LazyLock<Ustr> = LazyLock::new(|| Ustr::from("VENUE"));
123
124/// Tag for orders generated by reconciliation logic (synthetic orders).
125static TAG_RECONCILIATION: LazyLock<Ustr> = LazyLock::new(|| Ustr::from(RECONCILIATION_ORDER_TAG));
126
127const LOG_SAMPLES_MAX: usize = 5;
128const INFLIGHT_TIMEOUT_REASON: &str = "INFLIGHT_TIMEOUT";
129
130#[derive(Clone, Debug)]
131struct SubmissionRecoveryState {
132    trader_id: TraderId,
133    client_id: Option<ClientId>,
134    strategy_id: StrategyId,
135    instrument_id: InstrumentId,
136    exhausted: bool,
137    venue_confirmed: bool,
138}
139
140/// Manager for execution state.
141///
142/// The `ExecutionManager` handles:
143/// - Startup reconciliation to align state on system start.
144/// - Continuous reconciliation of inflight orders.
145/// - External order discovery and claiming.
146/// - Fill report processing and validation.
147/// - Purging of old orders, positions, and account events.
148///
149/// # Thread safety
150///
151/// The manager shares its clock and cache through `Rc<RefCell<_>>` and stays on one thread.
152/// Hosts must release cache and engine borrows before dispatching callbacks that may reenter them.
153#[derive(Clone)]
154pub struct ExecutionManager {
155    clock: Rc<RefCell<dyn Clock>>,
156    cache: Rc<RefCell<Cache>>,
157    config: ExecutionManagerConfig,
158
159    order_activity: RecencyMap<ClientOrderId>,
160    order_inflight_checks: IndexMap<ClientOrderId, InflightCheck>,
161    submissions: IndexMap<ClientOrderId, SubmissionRecoveryState>,
162    submission_exhaustions: Vec<SubmissionRecoveryExhausted>,
163    submission_retention: IndexMap<ClientId, AccountId>,
164    order_query_recency: RecencyMap<ClientOrderId>,
165    order_query_pending: IndexSet<ClientOrderId>,
166    order_recon_retries: IndexMap<ClientOrderId, u32>,
167    order_coverage_unresolved: IndexSet<ClientOrderId>,
168    order_coverage_warnings: IndexSet<ClientOrderId>,
169    order_lookback_warnings: IndexSet<ClientOrderId>,
170
171    fills_processed: RecencyMap<FillKey>,
172    fills_recent: RecencyMap<FillKey>,
173    fills_unapplied: RecencyMap<FillKey>,
174
175    position_activity: RecencyMap<InstrumentAccountKey>,
176    position_activity_revisions: IndexMap<InstrumentAccountKey, u64>,
177    position_recon: IndexMap<InstrumentAccountKey, PositionReconciliationState>,
178    position_recon_tolerances: IndexMap<AccountId, Decimal>,
179}
180
181impl Debug for ExecutionManager {
182    #[rustfmt::skip]
183    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
184        f.debug_struct(stringify!(ExecutionManager))
185            .field("clock", &self.clock)
186            .field("cache", &self.cache)
187            .field("config", &self.config)
188            .field("order_activity", &self.order_activity)
189            .field("order_inflight_checks", &self.order_inflight_checks)
190            .field("submissions", &self.submissions)
191            .field("submission_exhaustions", &self.submission_exhaustions)
192            .field("submission_retention", &self.submission_retention)
193            .field("order_query_recency", &self.order_query_recency)
194            .field("order_query_pending", &self.order_query_pending)
195            .field("order_recon_retries", &self.order_recon_retries)
196            .field("order_coverage_unresolved", &self.order_coverage_unresolved)
197            .field("order_coverage_warnings", &self.order_coverage_warnings)
198            .field("order_lookback_warnings", &self.order_lookback_warnings)
199            .field("fills_processed", &self.fills_processed)
200            .field("fills_recent", &self.fills_recent)
201            .field("fills_unapplied", &self.fills_unapplied)
202            .field("position_activity", &self.position_activity)
203            .field("position_activity_revisions", &self.position_activity_revisions)
204            .field("position_recon", &self.position_recon)
205            .field("position_recon_tolerances", &self.position_recon_tolerances)
206            .finish()
207    }
208}
209
210impl ExecutionManager {
211    /// Creates a new [`ExecutionManager`] instance.
212    ///
213    /// # Errors
214    ///
215    /// Returns an error if `config` fails validation.
216    pub fn new(
217        clock: Rc<RefCell<dyn Clock>>,
218        cache: Rc<RefCell<Cache>>,
219        config: ExecutionManagerConfig,
220    ) -> ConfigResult<Self> {
221        config.validate()?;
222
223        Ok(Self {
224            clock,
225            cache,
226            config,
227            order_activity: RecencyMap::default(),
228            order_inflight_checks: IndexMap::new(),
229            submissions: IndexMap::new(),
230            submission_exhaustions: Vec::new(),
231            submission_retention: IndexMap::new(),
232            order_query_recency: RecencyMap::default(),
233            order_query_pending: IndexSet::new(),
234            order_recon_retries: IndexMap::new(),
235            order_coverage_unresolved: IndexSet::new(),
236            order_coverage_warnings: IndexSet::new(),
237            order_lookback_warnings: IndexSet::new(),
238            fills_processed: RecencyMap::default(),
239            fills_recent: RecencyMap::default(),
240            fills_unapplied: RecencyMap::default(),
241            position_activity: RecencyMap::default(),
242            position_activity_revisions: IndexMap::new(),
243            position_recon: IndexMap::new(),
244            position_recon_tolerances: IndexMap::new(),
245        })
246    }
247
248    /// Returns the execution manager configuration.
249    pub(crate) const fn config(&self) -> &ExecutionManagerConfig {
250        &self.config
251    }
252
253    /// Returns the trading clock timestamp in nanoseconds.
254    pub(crate) fn timestamp_ns(&self) -> UnixNanos {
255        self.clock.borrow().timestamp_ns()
256    }
257
258    /// Borrows the execution cache for reading.
259    pub(crate) fn cache(&self) -> Ref<'_, Cache> {
260        self.cache.borrow()
261    }
262
263    /// Registers an inflight command at dispatch, starting its recovery budget.
264    ///
265    /// Skips filtered orders and preserves an active submission's remaining budget.
266    /// Submission identity and duplicate suppression require [`Self::register_submission`].
267    pub fn register_inflight(&mut self, client_order_id: ClientOrderId, command_id: UUID4) {
268        self.confirm_submission_outcome(&client_order_id);
269
270        if self.submission_recovery_pending(client_order_id)
271            && (self.order_inflight_checks.contains_key(&client_order_id)
272                || self.submission_is_retained(client_order_id))
273        {
274            return;
275        }
276
277        if self
278            .order_inflight_checks
279            .get(&client_order_id)
280            .is_none_or(|check| check.command_ids.is_empty())
281        {
282            self.start_inflight_check(client_order_id);
283        }
284
285        if let Some(check) = self.order_inflight_checks.get_mut(&client_order_id)
286            && !check.command_ids.contains(&command_id)
287        {
288            check.command_ids.push(command_id);
289        }
290    }
291
292    /// Registers a submission's identity before execution dispatch or cache insertion.
293    ///
294    /// With submission tracking enabled, duplicate registration preserves the current
295    /// recovery budget until acknowledgement or exhaustion. After exhaustion, duplicate
296    /// registration preserves the unresolved identity without restarting recovery.
297    pub fn register_submission(
298        &mut self,
299        initialized: &OrderInitialized,
300        client_id: Option<ClientId>,
301    ) {
302        let client_order_id = initialized.client_order_id;
303        if self.submissions.contains_key(&client_order_id)
304            || self.submission_retention_enabled(client_order_id, client_id)
305        {
306            self.confirm_submission_outcome(&client_order_id);
307
308            if self.submissions.contains_key(&client_order_id)
309                || self.submission_is_acknowledged(client_order_id)
310            {
311                return;
312            }
313
314            self.track_submission(initialized, client_id);
315        }
316
317        self.start_inflight_check(client_order_id);
318    }
319
320    fn start_inflight_check(&mut self, client_order_id: ClientOrderId) {
321        if self
322            .config
323            .filtered_client_order_ids
324            .contains(&client_order_id)
325        {
326            return;
327        }
328
329        self.order_inflight_checks.insert(
330            client_order_id,
331            InflightCheck {
332                command_ids: Vec::new(),
333                submitted_at: dst::time::Instant::now(),
334                retry_count: 0,
335                last_query_at: None,
336            },
337        );
338
339        self.order_recon_retries.insert(client_order_id, 0);
340        self.order_query_recency.remove(&client_order_id);
341        self.order_activity.remove(&client_order_id);
342    }
343
344    fn track_submission(&mut self, initialized: &OrderInitialized, client_id: Option<ClientId>) {
345        if !self.submission_retention_enabled(initialized.client_order_id, client_id)
346            || self
347                .config
348                .filtered_client_order_ids
349                .contains(&initialized.client_order_id)
350        {
351            return;
352        }
353
354        self.submissions
355            .entry(initialized.client_order_id)
356            .or_insert(SubmissionRecoveryState {
357                trader_id: initialized.trader_id,
358                client_id,
359                strategy_id: initialized.strategy_id,
360                instrument_id: initialized.instrument_id,
361                exhausted: false,
362                venue_confirmed: false,
363            });
364    }
365
366    fn submission_is_unacknowledged(order: &OrderAny) -> bool {
367        !order.events().iter().any(|event| {
368            matches!(
369                event,
370                OrderEventAny::Accepted(_)
371                    | OrderEventAny::Triggered(_)
372                    | OrderEventAny::Filled(_)
373                    | OrderEventAny::FillVoided(_)
374                    | OrderEventAny::Rejected(_)
375                    | OrderEventAny::Denied(_)
376                    | OrderEventAny::Canceled(_)
377                    | OrderEventAny::Expired(_)
378            ) || matches!(event, OrderEventAny::Updated(updated) if updated.venue_order_id.is_some())
379        })
380    }
381
382    fn submission_is_acknowledged(&self, client_order_id: ClientOrderId) -> bool {
383        self.cache
384            .borrow()
385            .order_ref(&client_order_id)
386            .is_some_and(|order| !Self::submission_is_unacknowledged(&order))
387    }
388
389    fn submission_recovery_pending(&self, client_order_id: ClientOrderId) -> bool {
390        self.submissions
391            .get(&client_order_id)
392            .is_some_and(|submission| !submission.venue_confirmed)
393            && !self.submission_is_acknowledged(client_order_id)
394    }
395
396    /// Returns retained submissions which still lack a native outcome or venue confirmation.
397    ///
398    /// Only the node's shutdown path reads this, so it is gated with its callers: without the
399    /// `node` feature the method has none, and a dependent crate that leaves the feature off would
400    /// see it as dead code.
401    #[cfg(feature = "node")]
402    pub(crate) fn unresolved_submission_ids(&self) -> Vec<ClientOrderId> {
403        self.submissions
404            .keys()
405            .copied()
406            .filter(|client_order_id| self.submission_recovery_pending(*client_order_id))
407            .collect()
408    }
409
410    /// Retires submission recovery after a native outcome has been applied.
411    ///
412    /// An acknowledgement ends the submission budget, including recovery for commands
413    /// dispatched before acknowledgement. A later command starts its own inflight check.
414    pub fn confirm_submission_outcome(&mut self, client_order_id: &ClientOrderId) {
415        let Some(submission) = self.submissions.get(client_order_id) else {
416            return;
417        };
418
419        let venue_confirmed = submission.venue_confirmed;
420
421        if !self.submission_is_acknowledged(*client_order_id) {
422            return;
423        }
424
425        if venue_confirmed {
426            // Native history replaces the report-only marker without clearing a later command
427            self.submissions.shift_remove(client_order_id);
428            return;
429        }
430
431        self.clear_recon_tracking(client_order_id, true);
432        self.record_local_activity(*client_order_id);
433    }
434
435    fn exhaust_submission(
436        &mut self,
437        client_order_id: ClientOrderId,
438        source: SubmissionRecoverySource,
439        retry_count: u32,
440    ) -> bool {
441        if !self.submissions.contains_key(&client_order_id)
442            && !self.submission_retention_enabled(client_order_id, None)
443        {
444            return false;
445        }
446
447        let budget = match source {
448            SubmissionRecoverySource::Inflight => self.config.inflight_max_retries,
449            SubmissionRecoverySource::MissingOrder => self.config.open_check_missing_retries,
450        };
451
452        if retry_count < budget {
453            return false;
454        }
455
456        if let Some(order) = self.get_order(client_order_id) {
457            if !Self::submission_is_unacknowledged(&order) {
458                return false;
459            }
460
461            let client_id = self.cache.borrow().client_id(&client_order_id).copied();
462            self.track_submission(order.init_event(), client_id);
463        }
464
465        let Some(submission) = self.submissions.get_mut(&client_order_id) else {
466            return false;
467        };
468
469        if submission.venue_confirmed {
470            return false;
471        }
472
473        if !submission.exhausted {
474            submission.exhausted = true;
475            self.submission_exhaustions
476                .push(SubmissionRecoveryExhausted {
477                    trader_id: submission.trader_id,
478                    client_id: submission
479                        .client_id
480                        .or_else(|| self.cache.borrow().client_id(&client_order_id).copied()),
481                    strategy_id: submission.strategy_id,
482                    instrument_id: submission.instrument_id,
483                    client_order_id,
484                    source,
485                    retry_count,
486                    ts_event: self.clock.borrow().timestamp_ns(),
487                });
488
489            log::warn!(
490                "Submission recovery exhausted for {client_order_id}, retaining unacknowledged order pending venue evidence"
491            );
492        }
493
494        self.clear_recon_tracking(&client_order_id, true);
495        true
496    }
497
498    /// Takes exhaustion diagnostics produced by recovery checks since the previous call.
499    ///
500    /// Hosts apply the returned reconciliation events before publishing these diagnostics,
501    /// so subscribers cannot invalidate a prepared local resolution through reentrancy.
502    /// Diagnostics describe query exhaustion for retained submissions,
503    /// not an authoritative venue outcome.
504    pub fn take_submission_recovery_exhaustions(&mut self) -> Vec<SubmissionRecoveryExhausted> {
505        std::mem::take(&mut self.submission_exhaustions)
506    }
507
508    /// Records local activity for the specified order.
509    ///
510    /// Uses a monotonic receipt instant, not venue or domain time, to accurately
511    /// track when we last processed activity for this order. This avoids race
512    /// conditions where network/queue latency makes events appear "old" even
513    /// though they just arrived.
514    pub fn record_local_activity(&mut self, client_order_id: ClientOrderId) {
515        self.order_activity.mark(client_order_id);
516    }
517
518    /// Returns the order's reconciliation retry count, or zero if no entry exists.
519    ///
520    /// Inflight checks and missing-order queries share this counter.
521    #[must_use]
522    pub fn recon_check_retry_count(&self, client_order_id: &ClientOrderId) -> u32 {
523        self.order_recon_retries
524            .get(client_order_id)
525            .copied()
526            .unwrap_or(0)
527    }
528
529    /// Clears pending targeted queries for the supplied orders.
530    pub(crate) fn remove_targeted_order_queries(&mut self, client_order_ids: &[ClientOrderId]) {
531        for client_order_id in client_order_ids {
532            self.order_query_pending.shift_remove(client_order_id);
533        }
534    }
535
536    /// Clears reconciliation tracking state for an order.
537    ///
538    /// An active submission's identity and budget survive pre-dispatch cleanup until
539    /// native state or a matching venue report acknowledges it. Exhaustion removes timers
540    /// and query bookkeeping but preserves the unresolved submission identity.
541    pub fn clear_recon_tracking(&mut self, client_order_id: &ClientOrderId, drop_last_query: bool) {
542        let pending = self.submission_recovery_pending(*client_order_id);
543        if pending && !self.submission_is_retained(*client_order_id) {
544            return;
545        }
546
547        self.order_inflight_checks.shift_remove(client_order_id);
548
549        let keep_confirmation = self
550            .submissions
551            .get(client_order_id)
552            .is_some_and(|submission| submission.venue_confirmed)
553            && self
554                .cache
555                .borrow()
556                .order_ref(client_order_id)
557                .is_some_and(|order| Self::submission_is_unacknowledged(&order));
558
559        if !pending && !keep_confirmation {
560            self.submissions.shift_remove(client_order_id);
561        }
562
563        self.order_recon_retries.shift_remove(client_order_id);
564        self.order_coverage_warnings.shift_remove(client_order_id);
565        self.order_lookback_warnings.shift_remove(client_order_id);
566        self.order_coverage_unresolved.shift_remove(client_order_id);
567        self.remove_targeted_order_queries(&[*client_order_id]);
568        if drop_last_query {
569            self.order_query_recency.remove(client_order_id);
570        }
571
572        self.order_activity.remove(client_order_id);
573    }
574
575    /// Prunes order activity outside the continuous reconciliation settling window.
576    pub fn prune_order_local_activity(&mut self) {
577        self.order_activity
578            .prune_older_than(Duration::from(self.config.open_check_threshold_ns));
579    }
580
581    /// Checks if a fill has been recently processed (for deduplication).
582    #[must_use]
583    pub fn is_fill_recently_processed(
584        &self,
585        account_id: AccountId,
586        instrument_id: InstrumentId,
587        trade_id: TradeId,
588    ) -> bool {
589        self.fills_recent
590            .contains_key(&(account_id, instrument_id, trade_id))
591    }
592
593    /// Marks a fill as recently processed when it is present on its canonical order.
594    pub fn commit_recent_fill_if_applied(&mut self, fill: &OrderFilled) {
595        let fill_key = (fill.account_id, fill.instrument_id, fill.trade_id);
596        if self.applied_fill_key(fill) == Some(fill_key) {
597            self.mark_fill_processed(fill_key.0, fill_key.1, fill_key.2);
598        }
599    }
600
601    /// Marks a fill as recently processed with the current monotonic instant.
602    pub fn mark_fill_processed(
603        &mut self,
604        account_id: AccountId,
605        instrument_id: InstrumentId,
606        trade_id: TradeId,
607    ) {
608        self.fills_recent
609            .mark((account_id, instrument_id, trade_id));
610    }
611
612    /// Prunes expired fills from the recent fills cache.
613    ///
614    /// Default TTL is 60 seconds.
615    pub fn prune_recent_fills_cache(&mut self, ttl_secs: f64) {
616        // Map the f64 TTL to a Duration, reproducing the old
617        // (ttl_secs * NANOSECONDS_IN_SECOND) as u64 cast at the boundaries
618        // rather than panicking on this pub fn. The as cast saturated:
619        //   - negative / NaN            -> 0        (prune everything)
620        //   - positive overflow / +inf  -> u64::MAX (keep everything)
621        // try_from_secs_f64 returns Err for all three, so branch on the sign
622        // to keep the two behaviors distinct.
623        let ttl = match Duration::try_from_secs_f64(ttl_secs) {
624            Ok(ttl) => ttl,
625            Err(_) if ttl_secs > 0.0 => Duration::MAX,
626            Err(_) => Duration::ZERO,
627        };
628
629        self.fills_recent.prune_older_than(ttl);
630    }
631
632    /// Prunes committed mass-reconciliation fills outside the startup report window.
633    ///
634    /// An unbounded startup lookback requires indefinite retention because no finite
635    /// horizon can safely exclude a replayed fill report.
636    pub fn prune_processed_fills(&mut self) {
637        let Some(lookback_mins) = self.config.lookback_mins else {
638            return;
639        };
640
641        let ttl = Duration::from_mins(lookback_mins).max(Duration::from_mins(1));
642        self.fills_processed.prune_older_than(ttl);
643    }
644
645    /// Sets the account tolerance, substituting the default for negative values.
646    pub(crate) fn set_position_reconciliation_tolerance(
647        &mut self,
648        account_id: AccountId,
649        tolerance: Decimal,
650    ) {
651        let tolerance = if tolerance < Decimal::ZERO {
652            log::error!(
653                "Invalid negative position reconciliation tolerance {tolerance} for \
654                 {account_id}; using the default"
655            );
656            DEFAULT_POSITION_RECONCILIATION_TOLERANCE
657        } else {
658            tolerance
659        };
660
661        self.position_recon_tolerances.insert(account_id, tolerance);
662    }
663
664    /// Returns the account tolerance, falling back to the default.
665    pub(crate) fn position_reconciliation_tolerance(&self, account_id: AccountId) -> Decimal {
666        self.position_recon_tolerances
667            .get(&account_id)
668            .copied()
669            .unwrap_or(DEFAULT_POSITION_RECONCILIATION_TOLERANCE)
670    }
671
672    /// Records position activity for the instrument and account.
673    ///
674    /// Restarts the reconciliation grace window and advances the activity revision, so position
675    /// report checks prepared earlier are no longer current. Uses monotonic `dst::time` so the
676    /// grace window is unaffected by trading-clock acceleration or venue timestamps.
677    pub fn record_position_activity(&mut self, instrument_id: InstrumentId, account_id: AccountId) {
678        let key = (instrument_id, account_id);
679        self.position_activity.mark(key);
680        let revision = self.position_activity_revisions.entry(key).or_default();
681        *revision = revision.saturating_add(1);
682    }
683
684    /// Checks whether position activity falls within the reconciliation grace window.
685    pub(crate) fn position_activity_is_recent(&self, key: &InstrumentAccountKey) -> bool {
686        self.position_activity
687            .within(key, Duration::from(self.config.position_check_threshold_ns))
688    }
689
690    /// Returns the position activity revision, or zero if no activity is recorded.
691    pub(crate) fn position_activity_revision(&self, key: &InstrumentAccountKey) -> u64 {
692        self.position_activity_revisions
693            .get(key)
694            .copied()
695            .unwrap_or_default()
696    }
697
698    fn set_position_reconciliation_retries(
699        &mut self,
700        key: InstrumentAccountKey,
701        report_shape: PositionReportShape,
702        retries: u32,
703    ) {
704        self.position_recon.insert(
705            key,
706            PositionReconciliationState {
707                report_shape,
708                retries,
709            },
710        );
711    }
712
713    /// Returns retries for the matching report shape, or zero if none match.
714    fn position_reconciliation_retries(
715        &self,
716        key: &InstrumentAccountKey,
717        report_shape: PositionReportShape,
718    ) -> u32 {
719        self.position_recon
720            .get(key)
721            .filter(|state| state.report_shape == report_shape)
722            .map_or(0, |state| state.retries)
723    }
724
725    /// Returns the current position-reconciliation retry count for the given
726    /// `(instrument, account)` key, or zero if no entry exists.
727    #[must_use]
728    pub fn position_recon_retry_count(&self, key: &InstrumentAccountKey) -> u32 {
729        self.position_recon
730            .get(key)
731            .map_or(0, |state| state.retries)
732    }
733
734    /// Clears reconciliation retry state for an instrument and account.
735    pub(crate) fn clear_position_reconciliation(&mut self, key: &InstrumentAccountKey) {
736        self.position_recon.shift_remove(key);
737    }
738
739    /// Retains reconciliation retry state only for active position keys.
740    pub(crate) fn retain_position_reconciliation(
741        &mut self,
742        active_keys: &IndexSet<InstrumentAccountKey>,
743    ) {
744        self.position_recon
745            .retain(|key, _| active_keys.contains(key));
746    }
747
748    /// Reconciles a mass snapshot, applying order events before evaluating positions.
749    ///
750    /// Publishes raw reports before cache mutation and verifies each historical fill after dispatch.
751    /// Returns processed events, external orders for client registration, and diagnostics for
752    /// in-scope nonzero venue positions that remain inconsistent with the cache.
753    pub fn reconcile_execution_mass_status(
754        &mut self,
755        mass_status: &ExecutionMassStatus,
756        exec_engine: &RefCell<ExecutionEngine>,
757    ) -> ReconciliationResult {
758        if exec_engine
759            .borrow()
760            .get_client(&mass_status.client_id)
761            .is_none()
762        {
763            log::error!(
764                "Cannot reconcile ExecutionMassStatus from unknown client {}",
765                mass_status.client_id
766            );
767            return ReconciliationResult::default();
768        }
769
770        self.validate_mass_status_order_sources(mass_status);
771
772        // Publish raw reports before any state mutation (including fill adjustment
773        // below, which can synthesize replacement order/fill reports). The
774        // execution engine's per-report `reconcile_*` entry points are bypassed by
775        // this path, so the capture seam lives here.
776        let raw_order_status_topic =
777            MessagingSwitchboard::reconciliation_raw_order_status_report_topic();
778
779        for report in mass_status.order_reports().values() {
780            msgbus::publish_any(raw_order_status_topic, report);
781        }
782
783        let raw_fill_topic = MessagingSwitchboard::reconciliation_raw_fill_report_topic();
784
785        for fills in mass_status.fill_reports().values() {
786            for fill in fills {
787                msgbus::publish_any(raw_fill_topic, fill);
788            }
789        }
790
791        let raw_position_topic =
792            MessagingSwitchboard::reconciliation_raw_position_status_report_topic();
793
794        for reports in mass_status.position_reports().values() {
795            for report in reports {
796                msgbus::publish_any(raw_position_topic, report);
797            }
798        }
799
800        if exec_engine
801            .borrow()
802            .get_client(&mass_status.client_id)
803            .is_none()
804        {
805            log::error!(
806                "Execution client {} disappeared while publishing raw mass status reports",
807                mass_status.client_id
808            );
809            return ReconciliationResult::default();
810        }
811
812        let venue = mass_status.venue;
813        let order_count = mass_status.order_reports().len();
814        let fill_count: usize = mass_status.fill_reports().values().map(Vec::len).sum();
815        let position_count: usize = mass_status.position_reports().values().map(Vec::len).sum();
816
817        log_info!(
818            "Reconciling ExecutionMassStatus for {venue}",
819            color = LogColor::Blue
820        );
821        log_info!(
822            "Received {order_count} order(s), {fill_count} fill(s), {position_count} position(s)",
823            color = LogColor::Blue
824        );
825
826        if mass_status.lookback_start().is_some() && !mass_status.reports_complete() {
827            log::warn!("Received incomplete bounded reconciliation reports for {venue}");
828        }
829
830        let retained_fill_state = self.retained_fill_state();
831
832        let reported_fill_keys: IndexSet<FillKey> = mass_status
833            .fill_reports()
834            .values()
835            .flatten()
836            .filter(|fill| !fill.last_qty.is_zero())
837            .map(|fill| (fill.account_id, fill.instrument_id, fill.trade_id))
838            .collect();
839
840        let order_venue_ids = exec_engine
841            .borrow()
842            .get_client(&mass_status.client_id)
843            .and_then(|client| client.venue_order_ids(mass_status));
844        let mut adjusted_reports = self.adjust_mass_status_fills(mass_status);
845        Self::preserve_external_order_history(
846            mass_status,
847            order_venue_ids.as_ref(),
848            &mut adjusted_reports,
849        );
850        let AdjustedReports {
851            orders: adjusted_order_reports,
852            fills: adjusted_fill_reports,
853            order_only_ids,
854            order_only_fill_keys,
855        } = adjusted_reports;
856
857        let bounded_order_only_ids =
858            self.order_only_ids(mass_status, &adjusted_order_reports, &adjusted_fill_reports);
859
860        let mut events = Vec::new();
861        let mut external_orders = Vec::new();
862        let mut orders_reconciled = 0usize;
863        let mut external_orders_created = 0usize;
864        let mut open_orders_initialized = 0usize;
865        let mut orders_skipped_no_instrument = 0usize;
866        let mut orders_skipped_duplicate = 0usize;
867        let mut fills_applied = 0usize;
868        let mut fill_queue = ReconciliationFillQueue::default();
869
870        let fill_reports = &adjusted_fill_reports;
871        let mut seen_fill_keys: IndexSet<FillKey> = IndexSet::new();
872
873        for fills in fill_reports.values() {
874            for fill in fills {
875                let fill_key = (fill.account_id, fill.instrument_id, fill.trade_id);
876                if !seen_fill_keys.insert(fill_key) {
877                    log::warn!(
878                        "Duplicate trade_id {} for {} in mass status",
879                        fill.trade_id,
880                        fill.instrument_id
881                    );
882                }
883            }
884        }
885
886        let order_reports = &adjusted_order_reports;
887        let mut orders_skipped_filtered = 0usize;
888        let mut orders_projected: IndexMap<ClientOrderId, OrderAny> = IndexMap::new();
889
890        for report in order_reports.values().filter(|report| {
891            order_venue_ids
892                .as_ref()
893                .and_then(|histories| report.client_order_id.and_then(|id| histories.get(&id)))
894                .is_none_or(|ids| ids.last() == Some(&report.venue_order_id))
895        }) {
896            if self.should_skip_order_report(report) {
897                orders_skipped_filtered += 1;
898                continue;
899            }
900
901            let order = report
902                .client_order_id
903                .and_then(|id| {
904                    orders_projected
905                        .get(&id)
906                        .cloned()
907                        .or_else(|| self.get_order(id))
908                })
909                .or_else(|| {
910                    self.get_order_by_venue_order_id(report.venue_order_id)
911                        .map(|order| {
912                            orders_projected
913                                .get(&order.client_order_id())
914                                .cloned()
915                                .unwrap_or(order)
916                        })
917                });
918
919            let order_client = order
920                .as_ref()
921                .filter(|order| Some(order.client_order_id()) == report.client_order_id);
922            let events_start = events.len();
923
924            if let Some(client_order_id) = &report.client_order_id {
925                if let Some(cached_order) = order_client
926                    && is_exact_order_match(cached_order, report)
927                {
928                    log::debug!("Skipping order {client_order_id}: already in sync with venue");
929                    orders_skipped_duplicate += 1;
930
931                    // Still ensure venue_order_id is indexed even when skipping
932                    if let Err(e) = self
933                        .cache
934                        .borrow_mut()
935                        .index_venue_order_id(client_order_id, &report.venue_order_id)
936                    {
937                        log::warn!("Failed to index venue order ID: {e}");
938                    }
939
940                    continue;
941                }
942
943                // Skip closed reconciliation orders to prevent duplicate inferred fills on restart
944                if let Some(cached_order) = order_client
945                    && cached_order.is_closed()
946                    && cached_order
947                        .tags()
948                        .is_some_and(|tags| tags.contains(&*TAG_RECONCILIATION))
949                {
950                    log::debug!(
951                        "Skipping closed reconciliation order {client_order_id}: \
952                         synthetic position adjustment from previous session",
953                    );
954                    orders_skipped_duplicate += 1;
955                    continue;
956                }
957            }
958
959            if let Some(order) = order.as_ref() {
960                let instrument = self.get_instrument(&report.instrument_id);
961
962                if order_client.is_some() {
963                    log::info!(
964                        color = LogColor::Blue as u8;
965                        "Reconciling {} {} {} [{}] -> [{}]",
966                        order.client_order_id(),
967                        report.venue_order_id,
968                        report.instrument_id,
969                        order.status(),
970                        report.order_status,
971                    );
972                } else {
973                    // Fallback: match by venue_order_id
974                    log::info!(
975                        color = LogColor::Blue as u8;
976                        "Reconciling {} (matched by venue_order_id {}) {} [{}] -> [{}]",
977                        order.client_order_id(),
978                        report.venue_order_id,
979                        report.instrument_id,
980                        order.status(),
981                        report.order_status,
982                    );
983                }
984
985                let order_fills: Vec<&FillReport> = fill_reports
986                    .get(&report.venue_order_id)
987                    .map_or_default(|f| f.iter().collect());
988                let engine_ref = exec_engine.borrow();
989                let commission_client = engine_ref.get_client(&mass_status.client_id);
990
991                let order_events = self.reconcile_order_with_fills(
992                    true,
993                    order,
994                    report,
995                    &order_fills,
996                    instrument.as_ref(),
997                    &mut fill_queue,
998                    commission_client,
999                );
1000
1001                drop(engine_ref);
1002
1003                orders_reconciled += usize::from(!order_events.is_empty());
1004                fills_applied += order_events
1005                    .iter()
1006                    .filter(|e| matches!(e, OrderEventAny::Filled(_)))
1007                    .count();
1008                events.extend(order_events);
1009
1010                // Always ensure venue_order_id is indexed after reconciliation
1011                if let Err(e) = self
1012                    .cache
1013                    .borrow_mut()
1014                    .index_venue_order_id(&order.client_order_id(), &report.venue_order_id)
1015                {
1016                    log::warn!("Failed to index venue order ID: {e}");
1017                }
1018            } else if let Some(instrument) = self.get_instrument(&report.instrument_id) {
1019                // Synthetic orders (S- prefix) are generated by reconciliation logic
1020                let is_synthetic = report.client_order_id.is_none()
1021                    && report.venue_order_id.as_str().starts_with("S-");
1022
1023                let venue_order_ids = report.client_order_id.and_then(|client_order_id| {
1024                    order_venue_ids
1025                        .as_ref()
1026                        .and_then(|histories| histories.get(&client_order_id))
1027                });
1028
1029                let order_fills: Vec<&FillReport> = venue_order_ids
1030                    .map_or(std::slice::from_ref(&report.venue_order_id), Vec::as_slice)
1031                    .iter()
1032                    .filter_map(|id| fill_reports.get(id))
1033                    .flatten()
1034                    .collect();
1035                let engine_ref = exec_engine.borrow();
1036                let commission_client = engine_ref.get_client(&mass_status.client_id);
1037
1038                let (mut external_events, metadata) = self.handle_external_order(
1039                    report,
1040                    mass_status.account_id,
1041                    &instrument,
1042                    &order_fills,
1043                    is_synthetic,
1044                    Some(&mut fill_queue),
1045                    commission_client,
1046                );
1047
1048                drop(engine_ref);
1049
1050                self.restore_external_order_venue_ids(
1051                    report,
1052                    venue_order_ids.map(Vec::as_slice),
1053                    &mut external_events,
1054                );
1055
1056                if !external_events.is_empty() {
1057                    external_orders_created += 1;
1058                    fills_applied += external_events
1059                        .iter()
1060                        .filter(|e| matches!(e, OrderEventAny::Filled(_)))
1061                        .count();
1062
1063                    if report.order_status.is_open() {
1064                        open_orders_initialized += 1;
1065                    }
1066
1067                    events.extend(external_events);
1068
1069                    if let Some(m) = metadata {
1070                        external_orders.push(m);
1071                    }
1072                }
1073            } else {
1074                orders_skipped_no_instrument += 1;
1075            }
1076
1077            if events.len() > events_start
1078                && let Some(mut order) = order
1079            {
1080                for event in &events[events_start..] {
1081                    if event.client_order_id() == order.client_order_id()
1082                        && let Err(e) = order.apply(event.clone())
1083                    {
1084                        log::warn!("Cannot project queued reconciliation event: {e}");
1085                    }
1086                }
1087
1088                orders_projected.insert(order.client_order_id(), order);
1089            }
1090        }
1091
1092        // Process orphan fills (fills without matching order reports)
1093        let mut dropped_fill_groups: Vec<(VenueOrderId, InstrumentId, usize)> = Vec::new();
1094
1095        for (venue_order_id, fills) in fill_reports {
1096            if order_reports.contains_key(venue_order_id) {
1097                continue;
1098            }
1099
1100            let Some(first_fill) = fills.first() else {
1101                continue;
1102            };
1103
1104            if !self.should_reconcile_instrument(&first_fill.instrument_id) {
1105                log::debug!(
1106                    "Skipping orphan fills for {}: not in reconciliation_instrument_ids",
1107                    first_fill.instrument_id
1108                );
1109                continue;
1110            }
1111
1112            // Skip if fill's client_order_id is in filtered list
1113            if let Some(client_order_id) = &first_fill.client_order_id
1114                && self
1115                    .config
1116                    .filtered_client_order_ids
1117                    .contains(client_order_id)
1118            {
1119                log::debug!(
1120                    "Skipping orphan fills for {client_order_id}: in filtered_client_order_ids"
1121                );
1122                continue;
1123            }
1124
1125            let order = first_fill
1126                .client_order_id
1127                .as_ref()
1128                .and_then(|id| self.get_order(*id))
1129                .or_else(|| self.get_order_by_venue_order_id(*venue_order_id));
1130
1131            // Skip if resolved order's client_order_id is filtered (venue_order_id lookup path)
1132            if let Some(ref order) = order
1133                && self
1134                    .config
1135                    .filtered_client_order_ids
1136                    .contains(&order.client_order_id())
1137            {
1138                log::debug!(
1139                    "Skipping orphan fills for {}: in filtered_client_order_ids",
1140                    order.client_order_id()
1141                );
1142                continue;
1143            }
1144
1145            if let Some(order) = order {
1146                let instrument_id = order.instrument_id();
1147                if let Some(instrument) = self.get_instrument(&instrument_id) {
1148                    let mut sorted_fills: Vec<&FillReport> = fills.iter().collect();
1149                    sorted_fills.sort_by_key(|f| f.ts_event);
1150
1151                    for fill in sorted_fills {
1152                        if let Some((event, fill_key)) = self.create_order_fill(
1153                            &order,
1154                            fill,
1155                            &instrument,
1156                            &fill_queue.pending_fill_keys,
1157                        ) {
1158                            fills_applied += 1;
1159                            fill_queue.push(&mut events, event, fill_key);
1160                        }
1161                    }
1162                } else {
1163                    orders_skipped_no_instrument += 1;
1164                }
1165            } else if fills.iter().any(FillReport::has_venue_position_id) {
1166                if !self.config.generate_missing_orders {
1167                    log::debug!(
1168                        "Skipping orphan fills for venue order {venue_order_id}: \
1169                         `generate_missing_orders` is disabled"
1170                    );
1171                    orders_skipped_filtered += 1;
1172                    continue;
1173                }
1174
1175                let Some(instrument) = self.get_instrument(&first_fill.instrument_id) else {
1176                    orders_skipped_no_instrument += 1;
1177                    continue;
1178                };
1179
1180                let mut sorted_fills: Vec<&FillReport> = fills.iter().collect();
1181                sorted_fills.sort_by_key(|fill| fill.ts_event);
1182
1183                let report = match create_orphan_fill_order_report(&sorted_fills, &instrument) {
1184                    Ok(report) => report,
1185                    Err(e) => {
1186                        log::error!(
1187                            "Cannot materialize orphan fills for venue order {venue_order_id}: {e}"
1188                        );
1189
1190                        continue;
1191                    }
1192                };
1193
1194                let engine_ref = exec_engine.borrow();
1195                let commission_client = engine_ref.get_client(&mass_status.client_id);
1196
1197                let (external_events, metadata) = self.handle_external_order(
1198                    &report,
1199                    mass_status.account_id,
1200                    &instrument,
1201                    &sorted_fills,
1202                    false,
1203                    Some(&mut fill_queue),
1204                    commission_client,
1205                );
1206
1207                drop(engine_ref);
1208
1209                if !external_events.is_empty() {
1210                    external_orders_created += 1;
1211                    fills_applied += external_events
1212                        .iter()
1213                        .filter(|event| matches!(event, OrderEventAny::Filled(_)))
1214                        .count();
1215
1216                    events.extend(external_events);
1217
1218                    if let Some(metadata) = metadata {
1219                        external_orders.push(metadata);
1220                    }
1221                }
1222            } else {
1223                log::debug!(
1224                    "Dropping {} fill(s) for venue order {venue_order_id} ({}): \
1225                     no order report or cached order",
1226                    fills.len(),
1227                    first_fill.instrument_id,
1228                );
1229                dropped_fill_groups.push((*venue_order_id, first_fill.instrument_id, fills.len()));
1230            }
1231        }
1232
1233        sort_reconciliation_events(&mut events);
1234
1235        let recover_closing_fills = mass_status.lookback_start().is_some()
1236            && mass_status.reports_complete()
1237            && !self.config.filter_position_reports;
1238        let mut uncovered_instruments: IndexMap<InstrumentId, bool> = IndexMap::new();
1239        let mut withheld_fills: IndexMap<_, Vec<_>> = IndexMap::new();
1240        let mut unapplied_fill_position_ids = IndexSet::new();
1241
1242        for event in &events {
1243            let OrderEventAny::Filled(fill) = event else {
1244                exec_engine.borrow_mut().process(event);
1245                continue;
1246            };
1247
1248            let fill_key = (fill.account_id, fill.instrument_id, fill.trade_id);
1249            let queued_fill_key = fill_queue.event_fill_keys.get(&fill.event_id).copied();
1250            let historical = should_project_fill(
1251                fill,
1252                &retained_fill_state,
1253                &reported_fill_keys,
1254                &order_only_ids,
1255                &order_only_fill_keys,
1256            );
1257            let bounded = !historical && bounded_order_only_ids.contains(&fill.venue_order_id);
1258
1259            let uncovered = bounded
1260                && *uncovered_instruments
1261                    .entry(fill.instrument_id)
1262                    .or_insert_with(|| {
1263                        exec_engine
1264                            .borrow()
1265                            .get_client(&mass_status.client_id)
1266                            .is_some_and(|client| {
1267                                !client.provides_bulk_position_coverage(fill.instrument_id)
1268                            })
1269                    });
1270
1271            let recovered = uncovered
1272                && recover_closing_fills
1273                && queued_fill_key == Some(fill_key)
1274                && self.fill_reduces_position(fill, &exec_engine.borrow());
1275
1276            // Warn only for fills this projection adds to their order, so a restart that
1277            // replays a fill the cached order already holds stays silent
1278            let withheld_position_id =
1279                (uncovered && !recovered && self.applied_fill_key(fill) != Some(fill_key))
1280                    .then(|| exec_engine.borrow().reconciliation_position_id(fill));
1281            if historical || bounded && !recovered {
1282                exec_engine.borrow_mut().project_reconciliation_fill(fill);
1283            } else {
1284                exec_engine.borrow_mut().process(event);
1285            }
1286
1287            let applied_fill_key = self.applied_fill_key(fill);
1288
1289            if let Some(position_id) = withheld_position_id
1290                && applied_fill_key == Some(fill_key)
1291            {
1292                withheld_fills
1293                    .entry((fill.account_id, fill.instrument_id, position_id))
1294                    .or_default()
1295                    .push((fill.trade_id, fill.client_order_id));
1296            }
1297
1298            if let Some(fill_key) = queued_fill_key {
1299                if applied_fill_key == Some(fill_key) {
1300                    self.fills_processed.mark(fill_key);
1301                } else if let Some(venue_position_id) = fill.position_id {
1302                    log::error!(
1303                        "Skipping reconciliation for venue position {venue_position_id}: historical fill {} was not applied",
1304                        fill.trade_id,
1305                    );
1306
1307                    unapplied_fill_position_ids.insert(venue_position_id);
1308                }
1309            }
1310        }
1311
1312        let mut positions_created = 0usize;
1313
1314        if !self.config.filter_position_reports {
1315            // Collect instruments with fills that lack venue_position_id (can't attribute to
1316            // specific hedge position, so must skip all hedge reports for that instrument)
1317            let instruments_with_unattributed_fills: IndexSet<InstrumentId> = mass_status
1318                .fill_reports()
1319                .values()
1320                .flatten()
1321                .filter(|f| !f.last_qty.is_zero() && f.venue_position_id.is_none())
1322                .map(|f| f.instrument_id)
1323                .chain(
1324                    mass_status
1325                        .order_reports()
1326                        .values()
1327                        .filter(|r| !r.filled_qty.is_zero() && r.venue_position_id.is_none())
1328                        .map(|r| r.instrument_id),
1329                )
1330                .collect();
1331
1332            for (instrument_id, reports) in mass_status.position_reports() {
1333                if !self.should_reconcile_instrument(&instrument_id) {
1334                    log::debug!(
1335                        "Skipping position reports for {instrument_id}: not in reconciliation_instrument_ids"
1336                    );
1337                    continue;
1338                }
1339
1340                for report in reports {
1341                    if report.venue_position_id.is_some_and(|venue_position_id| {
1342                        unapplied_fill_position_ids.contains(&venue_position_id)
1343                    }) {
1344                        continue;
1345                    }
1346
1347                    if let Some(position_events) = self.reconcile_position_report(
1348                        &report,
1349                        mass_status.account_id,
1350                        &instruments_with_unattributed_fills,
1351                    ) {
1352                        for event in position_events {
1353                            exec_engine.borrow_mut().process(&event);
1354                            events.push(event);
1355                        }
1356
1357                        positions_created += 1;
1358                    }
1359                }
1360            }
1361        }
1362
1363        if orders_skipped_no_instrument > 0 {
1364            log::warn!("{orders_skipped_no_instrument} orders skipped (instrument not in cache)");
1365        }
1366
1367        if !dropped_fill_groups.is_empty() {
1368            let dropped_fill_count: usize =
1369                dropped_fill_groups.iter().map(|(_, _, count)| count).sum();
1370
1371            let samples = dropped_fill_groups
1372                .iter()
1373                .take(LOG_SAMPLES_MAX)
1374                .map(|(venue_order_id, instrument_id, _)| {
1375                    format!("{venue_order_id} ({instrument_id})")
1376                })
1377                .collect::<Vec<_>>()
1378                .join(", ");
1379
1380            log::warn!(
1381                "Dropped {dropped_fill_count} fill(s) in {} fill group(s) without an order report \
1382                 or cached order ({samples})",
1383                dropped_fill_groups.len(),
1384            );
1385        }
1386
1387        for ((account_id, instrument_id, position_id), fills) in &withheld_fills {
1388            let target = position_id.map_or_else(
1389                || "with no resolvable position".to_string(),
1390                |position_id| format!("not to position {position_id}"),
1391            );
1392            let samples = fills
1393                .iter()
1394                .take(LOG_SAMPLES_MAX)
1395                .map(|(trade_id, client_order_id)| format!("{trade_id} ({client_order_id})"))
1396                .collect::<Vec<_>>()
1397                .join(", ");
1398
1399            log::warn!(
1400                "Applied {} bounded fill(s) for {instrument_id} on {account_id} to order state \
1401                 only, {target} ({samples}): exposure and PnL may need manual reconciliation",
1402                fills.len(),
1403            );
1404        }
1405
1406        if orders_skipped_duplicate > 0 {
1407            log::debug!("{orders_skipped_duplicate} orders skipped (already in sync)");
1408        }
1409
1410        if orders_skipped_filtered > 0 {
1411            log::debug!("{orders_skipped_filtered} orders skipped (filtered by config)");
1412        }
1413
1414        log::info!(
1415            color = LogColor::Blue as u8;
1416            "Reconciliation complete for {venue}: reconciled={orders_reconciled}, external={external_orders_created}, external_open={open_orders_initialized}, fills={fills_applied}, positions={positions_created}, in_sync={orders_skipped_duplicate}, filtered={orders_skipped_filtered}",
1417        );
1418
1419        ReconciliationResult {
1420            events,
1421            external_orders,
1422            unresolved_positions: self.unresolved_mass_status_positions(mass_status),
1423        }
1424    }
1425
1426    fn preserve_external_order_history(
1427        mass_status: &ExecutionMassStatus,
1428        order_venue_ids: Option<&IndexMap<ClientOrderId, Vec<VenueOrderId>>>,
1429        adjusted: &mut AdjustedReports,
1430    ) {
1431        let Some(order_venue_ids) = order_venue_ids else {
1432            return;
1433        };
1434
1435        let reports = mass_status.order_reports();
1436        let fills = mass_status.fill_reports();
1437
1438        for id in order_venue_ids.values().flatten() {
1439            if let Some(report) = reports.get(id) {
1440                adjusted.orders.entry(*id).or_insert_with(|| report.clone());
1441            }
1442
1443            let retained = adjusted.fills.entry(*id).or_default();
1444            for fill in fills.get(id).into_iter().flatten() {
1445                if !fill.last_qty.is_zero()
1446                    && !retained
1447                        .iter()
1448                        .any(|existing| existing.trade_id == fill.trade_id)
1449                {
1450                    // Restore filtered native history to the order without reopening old exposure
1451                    adjusted.order_only_fill_keys.insert((
1452                        fill.account_id,
1453                        fill.instrument_id,
1454                        fill.trade_id,
1455                    ));
1456                    retained.push(fill.clone());
1457                }
1458            }
1459        }
1460    }
1461
1462    fn restore_external_order_venue_ids(
1463        &self,
1464        report: &OrderStatusReport,
1465        venue_order_ids: Option<&[VenueOrderId]>,
1466        events: &mut Vec<OrderEventAny>,
1467    ) {
1468        let Some((first, remaining)) = venue_order_ids.and_then(|ids| ids.split_first()) else {
1469            return;
1470        };
1471
1472        let Some(OrderEventAny::Accepted(mut accepted)) = events.first().cloned() else {
1473            return;
1474        };
1475
1476        let Some(order) = report.client_order_id.and_then(|id| self.get_order(id)) else {
1477            return;
1478        };
1479
1480        accepted.venue_order_id = *first;
1481        let mut lifecycle = vec![OrderEventAny::Accepted(accepted)];
1482
1483        // Restore ID history at acceptance time, before native fills are applied
1484        for venue_order_id in remaining {
1485            lifecycle.push(OrderEventAny::Updated(OrderUpdated::new(
1486                order.trader_id(),
1487                order.strategy_id(),
1488                order.instrument_id(),
1489                order.client_order_id(),
1490                order.quantity(),
1491                UUID4::new(),
1492                report.ts_accepted,
1493                self.clock.borrow().timestamp_ns(),
1494                true,
1495                Some(*venue_order_id),
1496                Some(accepted.account_id),
1497                order.price(),
1498                order.trigger_price(),
1499                None,
1500                order.is_quote_quantity(),
1501            )));
1502        }
1503
1504        if let Err(e) =
1505            self.cache
1506                .borrow_mut()
1507                .add_venue_order_id(&order.client_order_id(), first, true)
1508        {
1509            log::error!("Cannot initialize venue order ID history: {e}");
1510            return;
1511        }
1512
1513        events.splice(..1, lifecycle);
1514    }
1515
1516    fn unresolved_mass_status_positions(&self, mass_status: &ExecutionMassStatus) -> Vec<String> {
1517        if self.config.filter_position_reports {
1518            return Vec::new();
1519        }
1520
1521        let mut unresolved = Vec::new();
1522
1523        for (instrument_id, reports) in mass_status.position_reports() {
1524            if !self.should_reconcile_instrument(&instrument_id) {
1525                continue;
1526            }
1527
1528            let reports = distinct_position_reports(reports);
1529
1530            if self
1531                .netting_position_reports_match((instrument_id, mass_status.account_id), &reports)
1532            {
1533                continue;
1534            }
1535
1536            for report in &reports {
1537                if let Some(reason) =
1538                    self.unresolved_position_report(report, mass_status.account_id, &reports)
1539                {
1540                    unresolved.push(reason);
1541                }
1542            }
1543        }
1544
1545        unresolved
1546    }
1547
1548    fn netting_position_reports_match(
1549        &self,
1550        key: InstrumentAccountKey,
1551        reports: &[PositionStatusReport],
1552    ) -> bool {
1553        let comparison = self.position_quantity_comparison(key, reports);
1554        let cache = self.cache.borrow();
1555        !comparison.cached_positions.is_empty()
1556            && comparison
1557                .cached_positions
1558                .iter()
1559                .all(|position| cache.oms_type(&position.id) == Some(OmsType::Netting))
1560            && comparison.quantities_match(self.position_reconciliation_tolerance(key.1))
1561            && self.position_report_prices_match(&comparison.cached_positions, reports)
1562    }
1563
1564    fn unresolved_position_report(
1565        &self,
1566        report: &PositionStatusReport,
1567        account_id: AccountId,
1568        reports: &[PositionStatusReport],
1569    ) -> Option<String> {
1570        let cache = self.cache.borrow();
1571        let instrument_id = report.instrument_id;
1572
1573        let open_positions =
1574            cache.positions_open(None, Some(&instrument_id), None, Some(&account_id), None);
1575        let is_netting = !open_positions.is_empty()
1576            && open_positions
1577                .iter()
1578                .all(|position| cache.oms_type(&position.id) == Some(OmsType::Netting));
1579
1580        let venue_position_id = report.venue_position_id.filter(|_| !is_netting);
1581        let venue_qty = report.signed_decimal_qty;
1582
1583        let cached_positions: Vec<Position> = if let Some(position_id) = venue_position_id {
1584            cache
1585                .position(&position_id)
1586                .filter(|p| p.account_id == account_id && p.instrument_id == instrument_id)
1587                .into_iter()
1588                .map(|p| (*p).clone())
1589                .collect()
1590        } else {
1591            open_positions.into_iter().map(|p| (*p).clone()).collect()
1592        };
1593
1594        let cached_qty: Decimal = cached_positions
1595            .iter()
1596            .map(Position::signed_decimal_qty)
1597            .sum();
1598
1599        let quantities_match = if is_netting {
1600            self.position_quantity_comparison((instrument_id, account_id), reports)
1601                .quantities_match(self.position_reconciliation_tolerance(account_id))
1602        } else if venue_position_id.is_some() {
1603            cached_qty == venue_qty
1604        } else {
1605            (cached_qty - venue_qty).abs() <= self.position_reconciliation_tolerance(account_id)
1606        };
1607
1608        let price_reports = if is_netting {
1609            reports
1610        } else {
1611            std::slice::from_ref(report)
1612        };
1613
1614        let prices_match = self.position_report_prices_match(&cached_positions, price_reports);
1615
1616        if quantities_match && prices_match {
1617            return None;
1618        }
1619
1620        let reason = if cache.instrument(&instrument_id).is_none() {
1621            "instrument missing from cache"
1622        } else if cache.account(&account_id).is_none() {
1623            "account missing from cache"
1624        } else if !self.config.generate_missing_orders {
1625            "generate_missing_orders is disabled"
1626        } else if report.avg_px_open.is_none() && cached_qty == Decimal::ZERO {
1627            "missing avg_px_open for position recovery"
1628        } else if quantities_match {
1629            "position recovery did not restore the reported average entry price"
1630        } else {
1631            "position recovery did not restore the reported quantity"
1632        };
1633
1634        Some(format!(
1635            "account={account_id}, instrument={instrument_id}, venue_position_id={:?}, venue_quantity={venue_qty}: {reason}",
1636            report.venue_position_id,
1637        ))
1638    }
1639
1640    fn position_report_prices_match(
1641        &self,
1642        cached_positions: &[Position],
1643        reports: &[PositionStatusReport],
1644    ) -> bool {
1645        for negative in [false, true] {
1646            let reports: Vec<_> = reports
1647                .iter()
1648                .filter(|report| {
1649                    !report.signed_decimal_qty.is_zero()
1650                        && report.signed_decimal_qty.is_sign_negative() == negative
1651                })
1652                .collect();
1653
1654            if !reports.iter().any(|report| report.avg_px_open.is_some())
1655                || reports.iter().any(|report| {
1656                    report.avg_px_open_reconciliation == AvgPxReconciliation::OpeningOnly
1657                })
1658            {
1659                continue;
1660            }
1661
1662            let Some((venue_value, venue_qty)) = reports.iter().try_fold(
1663                (Decimal::ZERO, Decimal::ZERO),
1664                |(value, quantity), report| {
1665                    let price = report.avg_px_open.filter(|price| *price > Decimal::ZERO)?;
1666                    let qty = report.signed_decimal_qty.abs();
1667                    Some((value + price * qty, quantity + qty))
1668                },
1669            ) else {
1670                return false;
1671            };
1672
1673            let positions: Vec<&Position> = cached_positions
1674                .iter()
1675                .filter(|position| {
1676                    !position.quantity.is_zero()
1677                        && position.signed_decimal_qty().is_sign_negative() == negative
1678                })
1679                .collect();
1680
1681            if positions
1682                .iter()
1683                .any(|position| position.avg_px_open <= Decimal::ZERO)
1684            {
1685                return false;
1686            }
1687
1688            if positions.is_empty()
1689                && venue_qty <= self.position_reconciliation_tolerance(reports[0].account_id)
1690            {
1691                continue;
1692            }
1693
1694            let Some(cached_avg_px) = position_avg_px(positions) else {
1695                return false;
1696            };
1697
1698            // The coarsest reported precision bounds the rounding in the side's weighted average
1699            let venue_precision = reports
1700                .iter()
1701                .filter_map(|report| report.avg_px_open_precision)
1702                .min();
1703
1704            if !position_prices_match(
1705                cached_avg_px,
1706                venue_value / venue_qty,
1707                None,
1708                venue_precision,
1709            ) {
1710                return false;
1711            }
1712        }
1713
1714        true
1715    }
1716
1717    fn retained_fill_state(&self) -> RetainedFillState {
1718        let cache = self.cache.borrow();
1719        let positions = cache.positions(None, None, None, None, None);
1720        let mut fill_keys = IndexSet::new();
1721        let mut missing_order_ids = IndexSet::new();
1722        let mut missing_venue_order_ids = IndexSet::new();
1723        let mut netting_lifecycle_starts = IndexMap::new();
1724
1725        for position in positions {
1726            for fill in &position.events {
1727                fill_keys.insert((position.account_id, position.instrument_id, fill.trade_id));
1728                if cache.order(&fill.client_order_id).is_none() {
1729                    missing_order_ids.insert((
1730                        position.account_id,
1731                        position.instrument_id,
1732                        fill.client_order_id,
1733                    ));
1734                    missing_venue_order_ids.insert((
1735                        position.account_id,
1736                        position.instrument_id,
1737                        fill.venue_order_id,
1738                    ));
1739                }
1740            }
1741
1742            if cache.oms_type(&position.id) == Some(OmsType::Netting) {
1743                netting_lifecycle_starts.insert(
1744                    (
1745                        position.account_id,
1746                        position.instrument_id,
1747                        position.strategy_id,
1748                    ),
1749                    position.ts_opened,
1750                );
1751            }
1752        }
1753
1754        RetainedFillState {
1755            fill_keys,
1756            missing_order_ids,
1757            missing_venue_order_ids,
1758            netting_lifecycle_starts,
1759        }
1760    }
1761
1762    fn order_only_ids(
1763        &self,
1764        mass_status: &ExecutionMassStatus,
1765        order_reports: &IndexMap<VenueOrderId, OrderStatusReport>,
1766        fill_reports: &IndexMap<VenueOrderId, Vec<FillReport>>,
1767    ) -> IndexSet<VenueOrderId> {
1768        if mass_status.lookback_start().is_none() {
1769            return IndexSet::new();
1770        }
1771
1772        let reported_instruments: IndexSet<InstrumentId> = if self.config.filter_position_reports {
1773            IndexSet::new()
1774        } else {
1775            mass_status
1776                .position_reports()
1777                .into_iter()
1778                .filter(|(instrument_id, reports)| {
1779                    !reports.is_empty() && self.should_reconcile_instrument(instrument_id)
1780                })
1781                .map(|(instrument_id, _)| instrument_id)
1782                .collect()
1783        };
1784
1785        let mut venue_order_ids = IndexSet::new();
1786
1787        for (venue_order_id, report) in order_reports {
1788            if report.filled_qty.is_zero() || reported_instruments.contains(&report.instrument_id) {
1789                continue;
1790            }
1791
1792            venue_order_ids.insert(*venue_order_id);
1793        }
1794
1795        for (venue_order_id, fills) in fill_reports {
1796            let Some(fill) = fills.first() else {
1797                continue;
1798            };
1799
1800            if reported_instruments.contains(&fill.instrument_id) {
1801                continue;
1802            }
1803
1804            venue_order_ids.insert(*venue_order_id);
1805        }
1806
1807        venue_order_ids
1808    }
1809
1810    fn fill_reduces_position(&self, fill: &OrderFilled, engine: &ExecutionEngine) -> bool {
1811        let Some(position_id) = engine.reconciliation_position_id(fill) else {
1812            return false;
1813        };
1814
1815        let cache = self.cache.borrow();
1816
1817        let Some(order) = cache.order(&fill.client_order_id) else {
1818            return false;
1819        };
1820
1821        if order.order_side() != fill.order_side
1822            || !matches!(has_active_inferred_fill(&order), Ok(false))
1823        {
1824            return false;
1825        }
1826
1827        cache.position_ref(&position_id).is_some_and(|position| {
1828            position.is_open()
1829                && !position.is_settled()
1830                && position.instrument_id == fill.instrument_id
1831                && position.account_id == fill.account_id
1832                && position.closing_order_side() == Some(fill.order_side)
1833                && fill.last_qty <= position.quantity
1834                && fill.ts_event >= position.ts_opened
1835                && !position.trade_ids.contains(&fill.trade_id)
1836        })
1837    }
1838
1839    /// Validates cached order origins against the mass status client, logging a warning for each
1840    /// kind of violation. Never fails: orders persisted before origin tracking or materialized at
1841    /// runtime lack origins legitimately, so reconciliation proceeds regardless.
1842    fn validate_mass_status_order_sources(&self, mass_status: &ExecutionMassStatus) {
1843        let cache = self.cache.borrow();
1844        let mut checked_client_order_ids = IndexSet::new();
1845        let mut missing_origins: Vec<ClientOrderId> = Vec::new();
1846        let mut mismatched_origins: Vec<(ClientOrderId, ClientId)> = Vec::new();
1847
1848        let mut validate_report_source =
1849            |direct_client_order_id: Option<ClientOrderId>, venue_order_id: VenueOrderId| {
1850                let direct_client_order_id = direct_client_order_id
1851                    .filter(|client_order_id| cache.order_exists(client_order_id));
1852                let indexed_client_order_id = cache
1853                    .client_order_id(&venue_order_id)
1854                    .copied()
1855                    .filter(|client_order_id| cache.order_exists(client_order_id));
1856                for client_order_id in [direct_client_order_id, indexed_client_order_id]
1857                    .into_iter()
1858                    .flatten()
1859                    .filter(|client_order_id| checked_client_order_ids.insert(*client_order_id))
1860                {
1861                    match cache.client_id(&client_order_id) {
1862                        Some(cached_client_id) if *cached_client_id == mass_status.client_id => {}
1863                        Some(cached_client_id) => {
1864                            mismatched_origins.push((client_order_id, *cached_client_id));
1865                        }
1866                        None => missing_origins.push(client_order_id),
1867                    }
1868                }
1869            };
1870
1871        for report in mass_status.order_reports().values() {
1872            validate_report_source(report.client_order_id, report.venue_order_id);
1873        }
1874
1875        for fills in mass_status.fill_reports().values() {
1876            for fill in fills {
1877                validate_report_source(fill.client_order_id, fill.venue_order_id);
1878            }
1879        }
1880
1881        if !missing_origins.is_empty() {
1882            let samples = missing_origins
1883                .iter()
1884                .take(LOG_SAMPLES_MAX)
1885                .map(ToString::to_string)
1886                .collect::<Vec<_>>()
1887                .join(", ");
1888
1889            log::warn!(
1890                "Found {} cached order(s) without an execution client origin ({}): \
1891                 continuing reconciliation against mass status client {} for compatibility \
1892                 with existing cache data",
1893                missing_origins.len(),
1894                samples,
1895                mass_status.client_id,
1896            );
1897        }
1898
1899        if !mismatched_origins.is_empty() {
1900            let samples = mismatched_origins
1901                .iter()
1902                .take(LOG_SAMPLES_MAX)
1903                .map(|(client_order_id, cached)| format!("{client_order_id} -> {cached}"))
1904                .collect::<Vec<_>>()
1905                .join(", ");
1906
1907            log::warn!(
1908                "Found {} cached order(s) with an execution client origin conflicting with \
1909                 mass status client {} ({}): continuing reconciliation for compatibility; \
1910                 this conflict will become a startup error in a future release, verify cached \
1911                 order ownership and execution client configuration",
1912                mismatched_origins.len(),
1913                mass_status.client_id,
1914                samples,
1915            );
1916        }
1917    }
1918
1919    /// Checks inflight orders and returns resolution events and intermediate venue queries.
1920    ///
1921    /// For retries below `inflight_max_retries`, generates `QueryOrder` commands to poll
1922    /// the venue for the order's current status. At max retries, generates terminal events
1923    /// (rejection or cancellation) based on the order's status. Orders never accepted are
1924    /// retained when the recovery policy or their client requires definitive venue evidence.
1925    /// Under `RetainUnresolved`, a pending cancel or update on an accepted order generates
1926    /// command rejections which restore its prior status.
1927    pub fn check_inflight_orders(&mut self) -> InflightCheckResult {
1928        let mut result = InflightCheckResult::default();
1929        let now = dst::time::Instant::now();
1930        let threshold = Duration::from_millis(self.config().inflight_threshold_ms);
1931
1932        let mut to_check = Vec::new();
1933
1934        for (client_order_id, check) in &self.order_inflight_checks {
1935            if now
1936                .checked_duration_since(check.submitted_at)
1937                .is_some_and(|elapsed| elapsed > threshold)
1938            {
1939                to_check.push(*client_order_id);
1940            }
1941        }
1942
1943        for client_order_id in to_check {
1944            self.confirm_submission_outcome(&client_order_id);
1945            if self
1946                .config
1947                .filtered_client_order_ids
1948                .contains(&client_order_id)
1949            {
1950                self.clear_recon_tracking(&client_order_id, true);
1951                continue;
1952            }
1953
1954            if self.order_query_pending.contains(&client_order_id) {
1955                continue;
1956            }
1957
1958            let Some(check) = self.order_inflight_checks.get_mut(&client_order_id) else {
1959                continue;
1960            };
1961
1962            if let Some(last_query_at) = check.last_query_at
1963                && now
1964                    .checked_duration_since(last_query_at)
1965                    .is_none_or(|elapsed| elapsed < threshold)
1966            {
1967                continue;
1968            }
1969
1970            check.retry_count += 1;
1971            check.last_query_at = Some(now);
1972            self.order_query_recency.mark(client_order_id);
1973            self.order_recon_retries
1974                .insert(client_order_id, check.retry_count);
1975            if check.retry_count >= self.config.inflight_max_retries {
1976                let retry_count = check.retry_count;
1977
1978                if self.exhaust_submission(
1979                    client_order_id,
1980                    SubmissionRecoverySource::Inflight,
1981                    retry_count,
1982                ) {
1983                    continue;
1984                }
1985
1986                let ts_now = self.clock.borrow().timestamp_ns();
1987                if let Some(order) = self.get_order(client_order_id) {
1988                    let events = self.resolve_inflight_timeout(&order, ts_now);
1989                    result.events.extend(events);
1990                }
1991
1992                self.clear_recon_tracking(&client_order_id, true);
1993            } else if let Some(order) = self.get_order(client_order_id) {
1994                // Intermediate retry: query the venue for current order status
1995                let ts_now = self.clock.borrow().timestamp_ns();
1996                let client_id = self.cache.borrow().client_id(&client_order_id).copied();
1997                let query = TradingCommand::QueryOrder(QueryOrder::new(
1998                    order.trader_id(),
1999                    client_id,
2000                    order.strategy_id(),
2001                    order.instrument_id(),
2002                    order.client_order_id(),
2003                    order.venue_order_id(),
2004                    UUID4::new(),
2005                    ts_now,
2006                    None,
2007                    None, // correlation_id
2008                ));
2009                result.queries.push(query);
2010            }
2011        }
2012
2013        result
2014    }
2015
2016    fn resolve_inflight_timeout(&self, order: &OrderAny, ts_now: UnixNanos) -> Vec<OrderEventAny> {
2017        match order.status() {
2018            // Generate rejection for submitted orders that never got accepted
2019            OrderStatus::Submitted => {
2020                create_reconciliation_rejected(order, Some(INFLIGHT_TIMEOUT_REASON), ts_now)
2021                    .into_iter()
2022                    .collect()
2023            }
2024            OrderStatus::PendingUpdate | OrderStatus::PendingCancel => {
2025                if self.config.submission_recovery_policy
2026                    == SubmissionRecoveryPolicy::RetainUnresolved
2027                {
2028                    // Retention restores the pre-command status for later venue evidence
2029                    create_reconciliation_command_rejections(order, INFLIGHT_TIMEOUT_REASON, ts_now)
2030                } else {
2031                    // Generate cancellation for orders stuck in pending modify/cancel
2032                    let canceled = create_reconciliation_canceled(
2033                        order,
2034                        Some(INFLIGHT_TIMEOUT_REASON),
2035                        ts_now,
2036                    );
2037                    vec![canceled]
2038                }
2039            }
2040            // Order already resolved
2041            _ => Vec::new(),
2042        }
2043    }
2044
2045    pub(crate) fn register_submission_retention(&mut self, client: &dyn ExecutionClient) {
2046        if client.retain_unresolved_submissions() {
2047            self.submission_retention
2048                .insert(client.client_id(), client.account_id());
2049        }
2050    }
2051
2052    fn submission_retention_enabled(
2053        &self,
2054        client_order_id: ClientOrderId,
2055        client_id: Option<ClientId>,
2056    ) -> bool {
2057        if self.config.submission_recovery_policy == SubmissionRecoveryPolicy::RetainUnresolved {
2058            return true;
2059        }
2060
2061        if self.submission_retention.is_empty() {
2062            return false;
2063        }
2064
2065        let cache = self.cache.borrow();
2066
2067        if let Some(client_id) = client_id.or_else(|| cache.client_id(&client_order_id).copied()) {
2068            return self.submission_retention.contains_key(&client_id);
2069        }
2070
2071        cache
2072            .order_ref(&client_order_id)
2073            .and_then(|order| order.account_id())
2074            .is_some_and(|account_id| {
2075                self.submission_retention
2076                    .values()
2077                    .any(|id| *id == account_id)
2078            })
2079    }
2080
2081    fn submission_is_retained(&self, client_order_id: ClientOrderId) -> bool {
2082        self.submissions
2083            .get(&client_order_id)
2084            .is_some_and(|submission| submission.exhausted)
2085            && self.submission_recovery_pending(client_order_id)
2086    }
2087
2088    fn filtered_open_orders_for_reconciliation(&self) -> Vec<OrderAny> {
2089        let cache = self.cache.borrow();
2090        let mut orders = cache.orders_open(None, None, None, None, None);
2091        orders.extend(cache.orders_inflight(None, None, None, None, None));
2092        let mut seen_client_order_ids = IndexSet::new();
2093        orders
2094            .into_iter()
2095            .filter(|order| {
2096                seen_client_order_ids.insert(order.client_order_id())
2097                    && !self.submission_is_retained(order.client_order_id())
2098                    && !self
2099                        .config
2100                        .filtered_client_order_ids
2101                        .contains(&order.client_order_id())
2102                    && self.should_reconcile_instrument(&order.instrument_id())
2103            })
2104            .map(|order| order.clone())
2105            .collect()
2106    }
2107
2108    fn open_position_keys_for_reconciliation(&self) -> IndexSet<InstrumentAccountKey> {
2109        let cache = self.cache.borrow();
2110        let positions = cache.positions_open(None, None, None, None, None);
2111        let mut position_keys = IndexSet::new();
2112
2113        for position in positions {
2114            if !self.should_reconcile_instrument(&position.instrument_id) {
2115                continue;
2116            }
2117
2118            position_keys.insert((position.instrument_id, position.account_id));
2119        }
2120
2121        position_keys
2122    }
2123
2124    /// Collects open-order reports and targeted follow-ups, returning reconciliation events.
2125    ///
2126    /// The caller applies the returned events to its execution engine.
2127    pub async fn check_open_orders(
2128        &mut self,
2129        clients: &[&dyn ExecutionClient],
2130    ) -> Vec<OrderEventAny> {
2131        log::debug!("Checking order consistency between cached-state and venues");
2132
2133        let check = self.prepare_open_order_report_check(UUID4::new(), clients);
2134        let mut all_reports = Vec::new();
2135        let mut queried_clients = IndexSet::new();
2136        let mut failed_clients = IndexSet::new();
2137
2138        for client in clients {
2139            let client_id = client.client_id();
2140            queried_clients.insert(client_id);
2141
2142            match client.generate_order_status_reports(&check.command).await {
2143                Ok(reports) => {
2144                    all_reports.extend(
2145                        reports
2146                            .into_iter()
2147                            .map(|report| SourcedOrderStatusReport { client_id, report }),
2148                    );
2149                }
2150                Err(e) => {
2151                    failed_clients.insert(client_id);
2152                    log::warn!("Failed to query order reports from {client_id}: {e}");
2153                }
2154            }
2155        }
2156
2157        let result = self.reconcile_open_order_reports(
2158            &check,
2159            all_reports,
2160            &queried_clients,
2161            &failed_clients,
2162            clients,
2163        );
2164
2165        let mut events = result.events;
2166
2167        if !result.targeted_queries.is_empty() {
2168            let query_delay =
2169                Duration::from_millis(u64::from(self.config.single_order_query_delay_ms));
2170            let query_results =
2171                request_targeted_order_reports(result.targeted_queries, clients, query_delay).await;
2172            events.extend(self.reconcile_targeted_order_reports(query_results, clients));
2173        }
2174
2175        events
2176    }
2177
2178    /// Prepares a bulk open-order report request and snapshots cached open orders.
2179    pub(crate) fn prepare_open_order_report_check(
2180        &mut self,
2181        command_id: UUID4,
2182        clients: &[&dyn ExecutionClient],
2183    ) -> OpenOrderReportCheck {
2184        for client in clients {
2185            self.register_submission_retention(*client);
2186        }
2187
2188        let filtered_orders = self.filtered_open_orders_for_reconciliation();
2189        let active_order_ids: IndexSet<ClientOrderId> =
2190            filtered_orders.iter().map(Order::client_order_id).collect();
2191        self.order_coverage_warnings
2192            .retain(|client_order_id| active_order_ids.contains(client_order_id));
2193        self.order_lookback_warnings
2194            .retain(|client_order_id| active_order_ids.contains(client_order_id));
2195        self.order_coverage_unresolved
2196            .retain(|client_order_id| active_order_ids.contains(client_order_id));
2197
2198        let mut client_coverage = IndexMap::new();
2199
2200        for order in &filtered_orders {
2201            let client_order_id = order.client_order_id();
2202            let coverage = self.resolve_order_report_client_coverage(order, clients);
2203
2204            match &coverage {
2205                ReportClientCoverage::Resolved(_) => {
2206                    if self
2207                        .order_coverage_unresolved
2208                        .shift_remove(&client_order_id)
2209                    {
2210                        self.order_coverage_warnings.shift_remove(&client_order_id);
2211                    }
2212                }
2213                ReportClientCoverage::Unavailable(_) | ReportClientCoverage::Unresolved => {
2214                    self.order_coverage_unresolved.insert(client_order_id);
2215                }
2216            }
2217
2218            client_coverage.insert(client_order_id, coverage);
2219        }
2220
2221        log::debug!(
2222            "Found {} order{} open in cache",
2223            filtered_orders.len(),
2224            if filtered_orders.len() == 1 { "" } else { "s" }
2225        );
2226
2227        let ts_now = self.clock.borrow().timestamp_ns();
2228        let start = self
2229            .config
2230            .open_check_lookback_mins
2231            .map(DurationNanos::from_mins)
2232            .map(|lookback| ts_now.saturating_sub(lookback));
2233
2234        let mut command = GenerateOrderStatusReports::new(
2235            command_id,
2236            ts_now,
2237            self.config.open_check_open_only,
2238            None,
2239            start,
2240            None,
2241            None,
2242            None,
2243        );
2244        command.log_receipt_level = LogLevel::Debug;
2245
2246        OpenOrderReportCheck {
2247            command,
2248            filtered_orders,
2249            client_coverage,
2250        }
2251    }
2252
2253    fn resolve_order_report_client_coverage(
2254        &self,
2255        order: &OrderAny,
2256        clients: &[&dyn ExecutionClient],
2257    ) -> ReportClientCoverage {
2258        if let Some(client_id) = self.cache.borrow().client_id(&order.client_order_id()) {
2259            return ReportClientCoverage::Resolved(IndexSet::from([*client_id]));
2260        }
2261
2262        let client_ids =
2263            responsible_client_ids(order.account_id(), order.instrument_id().venue, clients);
2264
2265        if client_ids.is_empty() {
2266            ReportClientCoverage::Unresolved
2267        } else {
2268            ReportClientCoverage::Resolved(client_ids)
2269        }
2270    }
2271
2272    /// Builds throttled per-order venue queries for fallback open-order reconciliation.
2273    pub fn check_open_order_queries(&mut self) -> Vec<TradingCommand> {
2274        let now = dst::time::Instant::now();
2275        let query_delay = Duration::from_millis(u64::from(self.config.single_order_query_delay_ms));
2276        let query_limit = self.config.max_single_order_queries_per_cycle as usize;
2277
2278        if query_limit == 0 {
2279            return Vec::new();
2280        }
2281
2282        let mut filtered_orders = self.filtered_open_orders_for_reconciliation();
2283        filtered_orders.sort_by_key(|order| {
2284            let client_order_id = order.client_order_id();
2285            (
2286                self.order_query_recency.last_marked(&client_order_id),
2287                client_order_id,
2288            )
2289        });
2290
2291        let mut queries = Vec::new();
2292        for order in filtered_orders {
2293            if queries.len() >= query_limit {
2294                break;
2295            }
2296
2297            let client_order_id = order.client_order_id();
2298            let threshold = Duration::from(self.config.open_check_threshold_ns);
2299
2300            if let Some(elapsed) = self.order_activity.elapsed_at(&client_order_id, now)
2301                && elapsed < threshold
2302            {
2303                let elapsed_ms = elapsed.as_millis();
2304                let threshold_ms = threshold.as_millis();
2305                log::debug!(
2306                    "Deferring open order query for {client_order_id}: recent local activity \
2307                     ({elapsed_ms}ms < threshold={threshold_ms}ms)",
2308                );
2309                continue;
2310            }
2311
2312            if self
2313                .order_query_recency
2314                .within_at(&client_order_id, now, query_delay)
2315            {
2316                continue;
2317            }
2318
2319            self.order_query_recency.mark(client_order_id);
2320            let client_id = self.cache.borrow().client_id(&client_order_id).copied();
2321            let ts_now = self.clock.borrow().timestamp_ns();
2322
2323            let cmd = TradingCommand::QueryOrder(QueryOrder::new(
2324                order.trader_id(),
2325                client_id,
2326                order.strategy_id(),
2327                order.instrument_id(),
2328                client_order_id,
2329                order.venue_order_id(),
2330                UUID4::new(),
2331                ts_now,
2332                None,
2333                None,
2334            ));
2335            queries.push(cmd);
2336        }
2337
2338        queries
2339    }
2340
2341    /// Reconciles bulk open-order report responses against a cached order snapshot.
2342    pub(crate) fn reconcile_open_order_reports(
2343        &mut self,
2344        check: &OpenOrderReportCheck,
2345        mut all_reports: Vec<SourcedOrderStatusReport>,
2346        queried_clients: &IndexSet<ClientId>,
2347        failed_clients: &IndexSet<ClientId>,
2348        clients: &[&dyn ExecutionClient],
2349    ) -> OpenOrderReconciliationResult {
2350        all_reports.retain(|sourced| !self.should_skip_order_report(&sourced.report));
2351        let mut venue_reported_ids = IndexSet::new();
2352
2353        for sourced in &all_reports {
2354            let report = &sourced.report;
2355
2356            let client_order_id = report.client_order_id.or_else(|| {
2357                self.cache
2358                    .borrow()
2359                    .client_order_id(&report.venue_order_id)
2360                    .copied()
2361            });
2362
2363            let Some(client_order_id) = client_order_id else {
2364                continue;
2365            };
2366
2367            venue_reported_ids.insert(client_order_id);
2368            self.order_coverage_warnings.shift_remove(&client_order_id);
2369            self.order_lookback_warnings.shift_remove(&client_order_id);
2370
2371            // A positive report, including one mapped by venue order ID, is proof the venue
2372            // still knows the order: reset the missing-order ladder so only consecutive misses
2373            // accumulate (mirrors the Python engine's per-report clear).
2374            self.order_recon_retries.shift_remove(&client_order_id);
2375        }
2376
2377        let mut events = Vec::new();
2378        let mut targeted_candidates = Vec::new();
2379
2380        for sourced in all_reports {
2381            let report = sourced.report;
2382
2383            let order = match report.client_order_id {
2384                Some(client_order_id) => self.get_order(client_order_id),
2385                None => self.get_order_by_venue_order_id(report.venue_order_id),
2386            };
2387
2388            let Some(order) = order else {
2389                continue;
2390            };
2391
2392            let client_order_id = order.client_order_id();
2393
2394            // Check for recent local activity to avoid race conditions with in-flight fills
2395            let threshold = Duration::from(self.config.open_check_threshold_ns);
2396            let activity_elapsed = self.order_activity.elapsed(&client_order_id);
2397            self.confirm_submitted_report(&report);
2398
2399            if let Some(elapsed) = activity_elapsed
2400                && elapsed < threshold
2401            {
2402                let elapsed_ms = elapsed.as_millis();
2403                let threshold_ms = threshold.as_millis();
2404                log::debug!(
2405                    "Deferring reconciliation for {client_order_id}: recent local activity ({elapsed_ms}ms < threshold={threshold_ms}ms)",
2406                );
2407                continue;
2408            }
2409
2410            let instrument = self.get_instrument(&report.instrument_id);
2411
2412            let commission_client = clients
2413                .iter()
2414                .find(|client| client.client_id() == sourced.client_id)
2415                .copied();
2416
2417            if order_report_has_missing_fills(
2418                &report,
2419                order.filled_qty(),
2420                commission_client.is_some_and(ExecutionClient::requires_authoritative_fills),
2421            ) {
2422                targeted_candidates.push((
2423                    order,
2424                    IndexSet::from([sourced.client_id]),
2425                    Some(report),
2426                ));
2427                continue;
2428            }
2429
2430            match self.reconcile_order_report(
2431                &order,
2432                &report,
2433                instrument.as_ref(),
2434                commission_client,
2435            ) {
2436                Ok(order_events) => events.extend(order_events),
2437                Err(e) => log::error!(
2438                    "Deferring reconciliation for {client_order_id}: order reconciliation failed: {e}"
2439                ),
2440            }
2441        }
2442
2443        let candidates: Vec<&OrderAny> = if let Some(cutoff) = check.command.start {
2444            let mut candidates = Vec::new();
2445
2446            for order in &check.filtered_orders {
2447                let client_order_id = order.client_order_id();
2448                if order.ts_last() >= cutoff {
2449                    self.order_lookback_warnings.shift_remove(&client_order_id);
2450                    candidates.push(order);
2451                } else if !venue_reported_ids.contains(&client_order_id)
2452                    && self.order_lookback_warnings.insert(client_order_id)
2453                {
2454                    log::warn!(
2455                        "Skipping missing-order reconciliation for {client_order_id}: last update predates open-check lookback"
2456                    );
2457                }
2458            }
2459
2460            candidates
2461        } else {
2462            check.filtered_orders.iter().collect()
2463        };
2464
2465        for order in candidates {
2466            let client_order_id = order.client_order_id();
2467            if venue_reported_ids.contains(&client_order_id) {
2468                continue;
2469            }
2470
2471            let responsible_clients = match check.client_coverage.get(&client_order_id) {
2472                Some(ReportClientCoverage::Resolved(responsible_clients))
2473                    if !responsible_clients.is_empty() =>
2474                {
2475                    responsible_clients
2476                }
2477                _ => {
2478                    if self.order_coverage_warnings.insert(client_order_id) {
2479                        log::warn!(
2480                            "Skipping order reconciliation for {client_order_id}: responsible execution client coverage is unresolved"
2481                        );
2482                    }
2483
2484                    continue;
2485                }
2486            };
2487
2488            let missing_clients = responsible_clients
2489                .difference(queried_clients)
2490                .copied()
2491                .collect::<IndexSet<_>>();
2492
2493            if !missing_clients.is_empty() {
2494                if self.order_coverage_warnings.insert(client_order_id) {
2495                    log::warn!(
2496                        "Skipping order reconciliation for {client_order_id}: responsible execution clients were not queried: {missing_clients:?}"
2497                    );
2498                }
2499
2500                continue;
2501            }
2502
2503            let failed_responsible_clients = responsible_clients
2504                .intersection(failed_clients)
2505                .copied()
2506                .collect::<IndexSet<_>>();
2507
2508            if !failed_responsible_clients.is_empty() {
2509                if !self.config.open_check_open_only
2510                    || self.order_coverage_warnings.insert(client_order_id)
2511                {
2512                    log::warn!(
2513                        "Skipping order reconciliation for {client_order_id}: failed to query responsible execution clients: {failed_responsible_clients:?}"
2514                    );
2515                }
2516
2517                continue;
2518            }
2519
2520            self.order_coverage_warnings.shift_remove(&client_order_id);
2521            if let Some(order) = self.prepare_missing_order_query(client_order_id) {
2522                targeted_candidates.push((order, responsible_clients.clone(), None));
2523            }
2524        }
2525
2526        targeted_candidates.sort_by_key(|(order, _, _)| {
2527            let client_order_id = order.client_order_id();
2528            (
2529                self.order_query_recency.last_marked(&client_order_id),
2530                client_order_id,
2531            )
2532        });
2533
2534        let query_limit = self.config.max_single_order_queries_per_cycle as usize;
2535        let mut planned_queries = 0usize;
2536        let mut cap_deferred_orders = 0usize;
2537        let mut targeted_queries = Vec::new();
2538
2539        for (order, responsible_clients, report) in targeted_candidates {
2540            let client_order_id = order.client_order_id();
2541
2542            let required_queries = responsible_clients.len();
2543            let exceeds_query_limit = planned_queries + required_queries > query_limit;
2544            let can_run_oversized_group = planned_queries == 0 && query_limit > 0;
2545            if required_queries == 0 || (exceeds_query_limit && !can_run_oversized_group) {
2546                cap_deferred_orders += 1;
2547                continue;
2548            }
2549
2550            if required_queries > query_limit {
2551                log::warn!(
2552                    "Targeted order query for {client_order_id} requires {required_queries} responsible clients, exceeding the per-cycle limit {query_limit} to avoid indefinite deferral"
2553                );
2554            }
2555
2556            planned_queries += required_queries;
2557
2558            if self.config.open_check_open_only && report.is_none() {
2559                self.order_recon_retries.shift_remove(&client_order_id);
2560            }
2561
2562            self.order_query_recency.mark(client_order_id);
2563            self.order_query_pending.insert(client_order_id);
2564            let command_id = UUID4::new();
2565            let ts_now = self.clock.borrow().timestamp_ns();
2566
2567            let command = GenerateOrderStatusReport::new(
2568                command_id,
2569                ts_now,
2570                Some(order.instrument_id()),
2571                Some(client_order_id),
2572                order.venue_order_id(),
2573                None,
2574                None,
2575            );
2576            targeted_queries.push(TargetedOrderQuery {
2577                client_order_id,
2578                responsible_clients,
2579                report,
2580                filled_qty: order.filled_qty(),
2581                command,
2582            });
2583        }
2584
2585        if cap_deferred_orders > 0 {
2586            log::warn!(
2587                "Reached max single-order queries ({query_limit}) this cycle, deferring {cap_deferred_orders} order(s)"
2588            );
2589        }
2590
2591        OpenOrderReconciliationResult {
2592            events,
2593            targeted_queries,
2594        }
2595    }
2596
2597    /// Reconciles targeted reports, using absence only in full-history mode.
2598    pub(crate) fn reconcile_targeted_order_reports(
2599        &mut self,
2600        results: Vec<TargetedOrderReportResult>,
2601        clients: &[&dyn ExecutionClient],
2602    ) -> Vec<OrderEventAny> {
2603        let mut events = Vec::new();
2604        let mut fill_queue = ReconciliationFillQueue::default();
2605
2606        for result in results {
2607            let client_order_id = result.client_order_id;
2608            self.remove_targeted_order_queries(&[client_order_id]);
2609            if let Some(report) = result.report {
2610                self.order_recon_retries.shift_remove(&client_order_id);
2611                self.order_coverage_warnings.shift_remove(&client_order_id);
2612
2613                let Some(order) = self.get_order(client_order_id) else {
2614                    continue;
2615                };
2616
2617                let instrument = self.get_instrument(&report.instrument_id);
2618
2619                let commission_client = result.client_id.and_then(|client_id| {
2620                    clients
2621                        .iter()
2622                        .find(|client| client.client_id() == client_id)
2623                        .copied()
2624                });
2625
2626                log::info!(
2627                    color = LogColor::Blue as u8;
2628                    "Found {client_order_id} via targeted order status query: {}",
2629                    report.order_status,
2630                );
2631
2632                let fills = result.fills.iter().collect::<Vec<_>>();
2633                events.extend(self.reconcile_order_with_fills(
2634                    false,
2635                    &order,
2636                    &report,
2637                    &fills,
2638                    instrument.as_ref(),
2639                    &mut fill_queue,
2640                    commission_client,
2641                ));
2642                continue;
2643            }
2644
2645            if self.config.open_check_open_only {
2646                if result.coverage_complete {
2647                    log::warn!(
2648                        "Keeping {client_order_id} open: targeted order status query found no report; absence is not terminal evidence in open-only mode"
2649                    );
2650                }
2651            } else if result.coverage_complete {
2652                events.extend(self.resolve_missing_order(client_order_id));
2653            } else {
2654                log::warn!(
2655                    "Deferring missing-order resolution for {client_order_id}: targeted order status coverage was incomplete"
2656                );
2657            }
2658        }
2659
2660        sort_reconciliation_events(&mut events);
2661        events
2662    }
2663
2664    /// Collects position reports and returns synthetic discrepancy events.
2665    ///
2666    /// Registers each client's tolerance before evaluating its reports. The caller applies the
2667    /// returned events; the live node separately queries authoritative fills before synthetic fallback.
2668    pub async fn check_positions_consistency(
2669        &mut self,
2670        clients: &[&dyn ExecutionClient],
2671    ) -> Vec<OrderEventAny> {
2672        let check = self.prepare_position_report_check(UUID4::new(), clients);
2673        let mut reports = Vec::new();
2674        let mut queried_clients = IndexSet::new();
2675        let mut failed_clients = IndexSet::new();
2676
2677        for client in clients {
2678            let client_id = client.client_id();
2679            queried_clients.insert(client_id);
2680            self.set_position_reconciliation_tolerance(
2681                client.account_id(),
2682                client.position_reconciliation_tolerance(),
2683            );
2684
2685            match client
2686                .generate_position_status_reports(&check.command)
2687                .await
2688            {
2689                Ok(client_reports) => {
2690                    reports.extend(client_reports);
2691                }
2692                Err(e) => {
2693                    failed_clients.insert(client_id);
2694                    log::warn!("Failed to query position reports from {client_id}: {e}");
2695                }
2696            }
2697        }
2698
2699        let active_keys = self
2700            .open_position_keys_for_reconciliation()
2701            .into_iter()
2702            .chain(reports.iter().filter_map(|report| {
2703                (self.should_reconcile_instrument(&report.instrument_id)
2704                    && report.signed_decimal_qty != Decimal::ZERO)
2705                    .then_some((report.instrument_id, report.account_id))
2706            }))
2707            .collect();
2708
2709        let events =
2710            self.reconcile_position_reports(&check, reports, &queried_clients, &failed_clients);
2711
2712        // Global pruning requires unfiltered reports; flat reports must not preserve stale retries
2713        self.retain_position_reconciliation(&active_keys);
2714
2715        events
2716    }
2717
2718    /// Prepares a bulk position report request and records client coverage.
2719    ///
2720    /// Snapshots all activity revisions, including keys without open cached positions, so venue-only
2721    /// positions can be checked against activity that predates the request.
2722    #[must_use]
2723    pub fn prepare_position_report_check(
2724        &self,
2725        command_id: UUID4,
2726        clients: &[&dyn ExecutionClient],
2727    ) -> PositionReportCheck {
2728        let position_keys = self.open_position_keys_for_reconciliation();
2729
2730        let client_coverage = position_keys
2731            .iter()
2732            .map(|key| (*key, resolve_position_report_client_coverage(*key, clients)))
2733            .collect();
2734
2735        let mut activity_revisions = self.position_activity_revisions.clone();
2736        for key in &position_keys {
2737            activity_revisions
2738                .entry(*key)
2739                .or_insert_with(|| self.position_activity_revision(key));
2740        }
2741
2742        log::debug!(
2743            "Found {} unique instrument/account combination{} with open positions",
2744            position_keys.len(),
2745            if position_keys.len() == 1 { "" } else { "s" }
2746        );
2747
2748        let ts_now = self.clock.borrow().timestamp_ns();
2749
2750        let mut command = GeneratePositionStatusReports::new(
2751            command_id, ts_now, None, // instrument_id - query all
2752            None, // start
2753            None, // end
2754            None, // params
2755            None, // correlation_id
2756        );
2757        command.log_receipt_level = LogLevel::Debug;
2758
2759        PositionReportCheck {
2760            command,
2761            client_coverage,
2762            activity_revisions,
2763        }
2764    }
2765
2766    /// Plans fill queries for settled position discrepancies with complete client coverage.
2767    ///
2768    /// Requires an unfiltered check and report snapshot for pruning. Coverage keys and nonflat
2769    /// venue reports retain retry state.
2770    pub fn plan_position_fill_reports(
2771        &mut self,
2772        check: &mut PositionReportCheck,
2773        reports: &[PositionStatusReport],
2774        queried_clients: &IndexSet<ClientId>,
2775        failed_clients: &IndexSet<ClientId>,
2776        clients: &[&dyn ExecutionClient],
2777    ) -> PositionFillReportPlan {
2778        let venue_positions = self.group_position_reports(reports.iter().cloned());
2779
2780        let keys = check
2781            .client_coverage
2782            .keys()
2783            .copied()
2784            .chain(venue_positions.iter().filter_map(|(key, reports)| {
2785                reports
2786                    .iter()
2787                    .any(|report| report.signed_decimal_qty != Decimal::ZERO)
2788                    .then_some(*key)
2789            }))
2790            .collect::<IndexSet<_>>();
2791
2792        let query_end = self.timestamp_ns();
2793        let lookback = DurationNanos::from_mins(self.config.position_check_lookback_mins);
2794        let query_start = query_end.saturating_sub(lookback);
2795        let mut discrepancy_keys = IndexSet::new();
2796        let mut queries = Vec::new();
2797
2798        for &key in &keys {
2799            let coverage = check
2800                .client_coverage
2801                .entry(key)
2802                .or_insert_with(|| resolve_position_report_client_coverage(key, clients));
2803            let prepared_revision = *check.activity_revisions.entry(key).or_default();
2804            let venue_reports = venue_positions.get(&key).map_or_default(Vec::as_slice);
2805            let comparison = self.position_quantity_comparison(key, venue_reports);
2806            let tolerance = self.position_reconciliation_tolerance(key.1);
2807            if comparison.quantities_match(tolerance) {
2808                self.clear_position_reconciliation(&key);
2809                continue;
2810            }
2811
2812            discrepancy_keys.insert(key);
2813
2814            if self.position_activity_revision(&key) > prepared_revision
2815                || self.position_activity_is_recent(&key)
2816            {
2817                continue;
2818            }
2819
2820            let report_shape = comparison.report_shape();
2821            let retries = self.position_reconciliation_retries(&key, report_shape);
2822            if retries >= self.config().position_check_retries {
2823                continue;
2824            }
2825
2826            let responsible_clients = match coverage {
2827                ReportClientCoverage::Resolved(responsible_clients) => responsible_clients,
2828
2829                // Coverage only decides whether an absent report proves a flat position
2830                ReportClientCoverage::Unavailable(responsible_clients)
2831                    if !venue_reports.is_empty() =>
2832                {
2833                    responsible_clients
2834                }
2835                ReportClientCoverage::Unavailable(_) => {
2836                    log::debug!(
2837                        "Skipping fill report query for {}/{}: responsible execution client coverage is unavailable",
2838                        key.0,
2839                        key.1,
2840                    );
2841                    continue;
2842                }
2843                ReportClientCoverage::Unresolved => {
2844                    log::warn!(
2845                        "Skipping fill report query for {}/{}: responsible execution client coverage is unresolved",
2846                        key.0,
2847                        key.1,
2848                    );
2849                    continue;
2850                }
2851            };
2852
2853            if responsible_clients.is_empty()
2854                || !responsible_clients.is_subset(queried_clients)
2855                || !responsible_clients.is_disjoint(failed_clients)
2856            {
2857                log::warn!(
2858                    "Skipping fill report query for {}/{}: responsible position report coverage is incomplete",
2859                    key.0,
2860                    key.1,
2861                );
2862                continue;
2863            }
2864
2865            for client_id in responsible_clients.iter() {
2866                let mut command = GenerateFillReports::new(
2867                    UUID4::new(),
2868                    query_end,
2869                    Some(key.0),
2870                    None,
2871                    Some(query_start),
2872                    Some(query_end),
2873                    None,
2874                    Some(check.command.command_id),
2875                );
2876                command.log_receipt_level = LogLevel::Debug;
2877                queries.push(PositionFillReportQuery {
2878                    key,
2879                    client_id: *client_id,
2880                    command,
2881                });
2882            }
2883        }
2884
2885        self.retain_position_reconciliation(&keys);
2886
2887        PositionFillReportPlan {
2888            queries,
2889            discrepancy_keys,
2890        }
2891    }
2892
2893    /// Checks whether position activity is unchanged since the check was prepared.
2894    #[must_use]
2895    pub fn position_report_check_is_current(
2896        &self,
2897        check: &PositionReportCheck,
2898        key: &InstrumentAccountKey,
2899    ) -> bool {
2900        check
2901            .activity_revisions
2902            .get(key)
2903            .is_some_and(|revision| self.position_activity_revision(key) == *revision)
2904    }
2905
2906    /// Validates fill attribution and supplies a cached position ID when unambiguous.
2907    ///
2908    /// # Errors
2909    ///
2910    /// Returns an error if cached order or position state conflicts with the fill,
2911    /// or inferred-fill history cannot be evaluated.
2912    pub fn prepare_position_fill_report(
2913        &self,
2914        report: &mut FillReport,
2915        venue_reports: &[PositionStatusReport],
2916    ) -> anyhow::Result<PositionFillReportPreparation> {
2917        let cache = self.cache();
2918        let venue_client_order_id = cache.client_order_id(&report.venue_order_id).copied();
2919
2920        if let (Some(report_client_order_id), Some(venue_client_order_id)) =
2921            (report.client_order_id, venue_client_order_id)
2922        {
2923            anyhow::ensure!(
2924                report_client_order_id == venue_client_order_id,
2925                "fill {} client order ID {report_client_order_id} conflicts with venue order mapping {venue_client_order_id}",
2926                report.trade_id,
2927            );
2928        }
2929
2930        let client_order_id = report.client_order_id.or(venue_client_order_id);
2931        let order = client_order_id.and_then(|id| cache.order(&id));
2932        if let Some(order) = &order {
2933            anyhow::ensure!(
2934                order.instrument_id() == report.instrument_id
2935                    && order.order_side() == report.order_side
2936                    && order
2937                        .account_id()
2938                        .is_none_or(|account_id| account_id == report.account_id)
2939                    && order
2940                        .venue_order_id()
2941                        .is_none_or(|venue_order_id| venue_order_id == report.venue_order_id),
2942                "fill {} conflicts with cached order {}",
2943                report.trade_id,
2944                order.client_order_id(),
2945            );
2946        }
2947
2948        let hedge_context = report.venue_position_id.is_some()
2949            || venue_reports
2950                .iter()
2951                .any(|venue_report| venue_report.venue_position_id.is_some());
2952        let flip = client_order_id
2953            .map(|id| cache.hedging_flip_position_ids(id))
2954            .transpose()?
2955            .flatten();
2956
2957        let mapped_position_id = flip.map(|ids| ids[1]).or_else(|| {
2958            client_order_id
2959                .and_then(|client_order_id| cache.position_id(&client_order_id))
2960                .copied()
2961        });
2962
2963        if hedge_context
2964            && let (Some(venue_position_id), Some(mapped_position_id)) =
2965                (report.venue_position_id, mapped_position_id)
2966        {
2967            anyhow::ensure!(
2968                venue_position_id == mapped_position_id
2969                    || flip.is_some_and(|ids| ids.contains(&venue_position_id)),
2970                "fill {} position ID {venue_position_id} conflicts with cached order position {mapped_position_id}",
2971                report.trade_id,
2972            );
2973        }
2974
2975        if let Some(order) = order
2976            && has_active_inferred_fill(&order)?
2977        {
2978            return Ok(PositionFillReportPreparation::InferredOverlap);
2979        }
2980
2981        if fill_precedes_snapshot_reconciled_position(&cache, report) {
2982            return Ok(PositionFillReportPreparation::SnapshotOverlap);
2983        }
2984
2985        if report.venue_position_id.is_none() && flip.is_some() {
2986            report.venue_position_id = mapped_position_id;
2987            return Ok(PositionFillReportPreparation::Ready);
2988        }
2989
2990        if !hedge_context {
2991            return Ok(PositionFillReportPreparation::Ready);
2992        }
2993
2994        if report.venue_position_id.is_some() {
2995            return Ok(PositionFillReportPreparation::Ready);
2996        }
2997
2998        let Some(position_id) = mapped_position_id else {
2999            return Ok(PositionFillReportPreparation::Unattributed);
3000        };
3001
3002        let position = cache.position(&position_id).ok_or_else(|| {
3003            anyhow::anyhow!(
3004                "fill {} maps to position {position_id}, which is not cached",
3005                report.trade_id,
3006            )
3007        })?;
3008
3009        anyhow::ensure!(
3010            position.account_id == report.account_id
3011                && position.instrument_id == report.instrument_id,
3012            "fill {} maps to position {position_id} with a different account or instrument",
3013            report.trade_id,
3014        );
3015        anyhow::ensure!(
3016            position.is_open(),
3017            "fill {} maps to non-open position {position_id}",
3018            report.trade_id,
3019        );
3020        anyhow::ensure!(
3021            !position.is_opposite_side(report.order_side) || report.last_qty <= position.quantity,
3022            "fill {} without a venue position ID would cross position {position_id}",
3023            report.trade_id,
3024        );
3025
3026        report.venue_position_id = Some(position_id);
3027        Ok(PositionFillReportPreparation::Ready)
3028    }
3029
3030    /// Records a position-check fill that failed to apply, keeping its first failure time.
3031    pub fn record_unapplied_fill_report(&mut self, report: &FillReport) {
3032        let fill_key = (report.account_id, report.instrument_id, report.trade_id);
3033        if !self.fills_unapplied.contains_key(&fill_key) {
3034            self.fills_unapplied.mark(fill_key);
3035        }
3036
3037        let ttl = Duration::from_mins(self.config.position_check_lookback_mins)
3038            .max(Duration::from_mins(1));
3039        self.fills_unapplied.prune_older_than(ttl);
3040    }
3041
3042    /// Checks whether a fill has stayed unapplied past the position check threshold.
3043    ///
3044    /// Such a fill no longer holds back synthetic position reconciliation.
3045    #[must_use]
3046    pub fn is_unapplied_fill_report_expired(&self, report: &FillReport) -> bool {
3047        let fill_key = (report.account_id, report.instrument_id, report.trade_id);
3048        self.fills_unapplied.contains_key(&fill_key)
3049            && !self.fills_unapplied.within(
3050                &fill_key,
3051                Duration::from(self.config.position_check_threshold_ns),
3052            )
3053    }
3054
3055    /// Checks whether cached position fills match the report, including quantity and commission.
3056    #[must_use]
3057    pub fn position_contains_fill_report(&self, report: &FillReport) -> bool {
3058        let cache = self.cache();
3059        let positions = cache.positions_refs(
3060            None,
3061            Some(&report.instrument_id),
3062            None,
3063            Some(&report.account_id),
3064            None,
3065        );
3066        position_fill_report_matches(
3067            &cache,
3068            report,
3069            &positions,
3070            |id| cache.hedging_flip_position_ids(id),
3071            None,
3072        )
3073    }
3074
3075    /// Counts leading reports already matched by the current immutable cache snapshot.
3076    ///
3077    /// Stops at the first mismatch or account/instrument change. Reuse ends before dispatch.
3078    #[cfg(feature = "node")]
3079    pub(crate) fn position_fill_reports_contained_prefix(&self, reports: &[FillReport]) -> usize {
3080        let Some(first) = reports.first() else {
3081            return 0;
3082        };
3083
3084        if reports.len() == 1 {
3085            return usize::from(self.position_contains_fill_report(first));
3086        }
3087
3088        let cache = self.cache();
3089        let positions = cache.positions_refs(
3090            None,
3091            Some(&first.instrument_id),
3092            None,
3093            Some(&first.account_id),
3094            None,
3095        );
3096        let mut replay = IndexMap::new();
3097
3098        // Reuse is confined to this immutable borrow and ends before any fill dispatch
3099        let mut flips = IndexMap::new();
3100        reports
3101            .iter()
3102            .take_while(|report| {
3103                report.instrument_id == first.instrument_id
3104                    && report.account_id == first.account_id
3105                    && position_fill_report_matches(
3106                        &cache,
3107                        report,
3108                        &positions,
3109                        |id| {
3110                            if let Some(flip) = flips.get(&id) {
3111                                return Ok(*flip);
3112                            }
3113
3114                            let flip = cache.hedging_flip_position_ids(id)?;
3115                            flips.insert(id, flip);
3116                            Ok(flip)
3117                        },
3118                        Some(&mut replay),
3119                    )
3120            })
3121            .count()
3122    }
3123
3124    /// Reconciles cached positions against venue position reports.
3125    ///
3126    /// Callers may supply a filtered check and reports without pruning retry state for other positions.
3127    /// Global pruning is handled by [`Self::plan_position_fill_reports`] and
3128    /// [`Self::check_positions_consistency`].
3129    #[must_use]
3130    pub fn reconcile_position_reports(
3131        &mut self,
3132        check: &PositionReportCheck,
3133        reports: Vec<PositionStatusReport>,
3134        queried_clients: &IndexSet<ClientId>,
3135        failed_clients: &IndexSet<ClientId>,
3136    ) -> Vec<OrderEventAny> {
3137        log::debug!("Checking position consistency between cached-state and venues");
3138
3139        let venue_positions = self.group_position_reports(reports);
3140        let mut events = Vec::new();
3141
3142        for (key, coverage) in &check.client_coverage {
3143            let prepared_revision = check
3144                .activity_revisions
3145                .get(key)
3146                .copied()
3147                .unwrap_or_default();
3148
3149            if self.position_activity_revision(key) > prepared_revision {
3150                log::debug!(
3151                    "Deferring position reconciliation for {}/{}: local activity recorded during report request",
3152                    key.0,
3153                    key.1,
3154                );
3155                continue;
3156            }
3157
3158            let venue_reports = venue_positions.get(key).map_or_default(Vec::as_slice);
3159
3160            if venue_reports.is_empty() {
3161                match coverage {
3162                    ReportClientCoverage::Resolved(responsible_clients)
3163                        if responsible_clients.is_empty() =>
3164                    {
3165                        log::warn!(
3166                            "Skipping position reconciliation for {}/{}: responsible execution client coverage is unresolved",
3167                            key.0,
3168                            key.1,
3169                        );
3170                        continue;
3171                    }
3172                    ReportClientCoverage::Resolved(responsible_clients)
3173                        if !responsible_clients.is_subset(queried_clients) =>
3174                    {
3175                        log::warn!(
3176                            "Skipping position reconciliation for {}/{}: responsible execution clients were not all queried",
3177                            key.0,
3178                            key.1,
3179                        );
3180                        continue;
3181                    }
3182                    ReportClientCoverage::Resolved(responsible_clients)
3183                        if !responsible_clients.is_disjoint(failed_clients) =>
3184                    {
3185                        let failed_responsible_clients = responsible_clients
3186                            .intersection(failed_clients)
3187                            .copied()
3188                            .collect::<IndexSet<_>>();
3189                        log::warn!(
3190                            "Skipping position reconciliation for {}/{}: failed to query responsible execution clients: {failed_responsible_clients:?}",
3191                            key.0,
3192                            key.1,
3193                        );
3194                        continue;
3195                    }
3196                    ReportClientCoverage::Resolved(_) => {}
3197                    ReportClientCoverage::Unavailable(responsible_clients) => {
3198                        log::debug!(
3199                            "Skipping position reconciliation for {}/{}: complete bulk position coverage is unavailable from responsible execution clients: {responsible_clients:?}",
3200                            key.0,
3201                            key.1,
3202                        );
3203                        continue;
3204                    }
3205                    ReportClientCoverage::Unresolved => {
3206                        log::warn!(
3207                            "Skipping position reconciliation for {}/{}: responsible execution client coverage is unresolved",
3208                            key.0,
3209                            key.1,
3210                        );
3211                        continue;
3212                    }
3213                }
3214            }
3215
3216            if let Some(discrepancy_events) = self.check_position_discrepancy(*key, venue_reports) {
3217                events.extend(discrepancy_events);
3218            }
3219        }
3220
3221        let current_position_keys = self.open_position_keys_for_reconciliation();
3222
3223        for (key, venue_reports) in &venue_positions {
3224            if check.client_coverage.contains_key(key)
3225                || venue_reports
3226                    .iter()
3227                    .all(|report| report.signed_decimal_qty == Decimal::ZERO)
3228            {
3229                continue;
3230            }
3231
3232            if current_position_keys.contains(key) {
3233                log::debug!(
3234                    "Deferring position reconciliation for {}/{}: position opened after client coverage was recorded",
3235                    key.0,
3236                    key.1,
3237                );
3238                continue;
3239            }
3240
3241            if let Some(discrepancy_events) = self.check_position_discrepancy(*key, venue_reports) {
3242                events.extend(discrepancy_events);
3243            }
3244        }
3245
3246        events
3247    }
3248
3249    fn group_position_reports(
3250        &self,
3251        reports: impl IntoIterator<Item = PositionStatusReport>,
3252    ) -> IndexMap<InstrumentAccountKey, Vec<PositionStatusReport>> {
3253        let mut venue_positions: IndexMap<InstrumentAccountKey, Vec<PositionStatusReport>> =
3254            IndexMap::new();
3255
3256        for report in reports {
3257            if !self.should_reconcile_instrument(&report.instrument_id) {
3258                continue;
3259            }
3260
3261            venue_positions
3262                .entry((report.instrument_id, report.account_id))
3263                .or_default()
3264                .push(report);
3265        }
3266
3267        venue_positions
3268            .into_iter()
3269            .map(|(key, reports)| (key, distinct_position_reports(reports)))
3270            .collect()
3271    }
3272
3273    /// Returns any external order claim for the given instrument ID.
3274    #[must_use]
3275    pub fn get_external_order_claim(&self, instrument_id: &InstrumentId) -> Option<StrategyId> {
3276        self.cache.borrow().external_order_claim(instrument_id)
3277    }
3278
3279    /// Claims external orders for a specific strategy and instrument.
3280    ///
3281    /// # Errors
3282    ///
3283    /// Returns an error if the instrument already has a registered claim.
3284    pub fn claim_external_orders(
3285        &mut self,
3286        instrument_id: InstrumentId,
3287        strategy_id: StrategyId,
3288    ) -> anyhow::Result<()> {
3289        self.cache
3290            .borrow_mut()
3291            .register_external_order_claims(strategy_id, &[instrument_id])
3292    }
3293
3294    /// Observes a local order event and updates tracking state.
3295    ///
3296    /// This is the `LiveNode` dispatch path for order events: acknowledgement
3297    /// events clear reconciliation tracking, fills record position
3298    /// activity, and every event stamps local activity. The stamp must come
3299    /// AFTER any [`Self::clear_recon_tracking`] call - that call drops the
3300    /// local-activity mark, which is the sole grace gate protecting a
3301    /// just-acknowledged order from missing-order reconciliation while the
3302    /// venue report lags.
3303    pub fn observe_order_event(&mut self, event: &OrderEventAny) {
3304        match event {
3305            OrderEventAny::Filled(fill) => {
3306                self.record_position_activity(fill.instrument_id, fill.account_id);
3307            }
3308            OrderEventAny::ModifyDenied(event) => {
3309                self.clear_command_tracking(event.client_order_id, event.causation_id);
3310            }
3311            OrderEventAny::CancelDenied(event) => {
3312                self.clear_command_tracking(event.client_order_id, event.causation_id);
3313            }
3314            OrderEventAny::ModifyRejected(event) if event.causation_id.is_some() => {
3315                self.clear_command_tracking(event.client_order_id, event.causation_id);
3316            }
3317            OrderEventAny::CancelRejected(event) if event.causation_id.is_some() => {
3318                self.clear_command_tracking(event.client_order_id, event.causation_id);
3319            }
3320            OrderEventAny::Updated(event) if event.causation_id.is_some() => {
3321                self.clear_command_tracking(event.client_order_id, event.causation_id);
3322            }
3323            OrderEventAny::Accepted(_)
3324            | OrderEventAny::Rejected(_)
3325            | OrderEventAny::Canceled(_)
3326            | OrderEventAny::Expired(_)
3327            | OrderEventAny::Denied(_)
3328            | OrderEventAny::Updated(_)
3329            | OrderEventAny::ModifyRejected(_)
3330            | OrderEventAny::CancelRejected(_) => {
3331                self.clear_recon_tracking(&event.client_order_id(), true);
3332            }
3333            _ => {}
3334        }
3335
3336        self.record_local_activity(event.client_order_id());
3337    }
3338
3339    fn clear_command_tracking(
3340        &mut self,
3341        client_order_id: ClientOrderId,
3342        causation_id: Option<UUID4>,
3343    ) {
3344        let Some(command_id) = causation_id else {
3345            return;
3346        };
3347
3348        let Some(check) = self.order_inflight_checks.get_mut(&client_order_id) else {
3349            return;
3350        };
3351
3352        let Some(index) = check.command_ids.iter().position(|id| *id == command_id) else {
3353            return;
3354        };
3355
3356        check.command_ids.remove(index);
3357        if check.command_ids.is_empty() {
3358            self.clear_recon_tracking(&client_order_id, true);
3359        }
3360    }
3361
3362    /// Observes an incoming execution report and updates tracking state.
3363    ///
3364    /// This should be called **before** the report is dispatched to the execution
3365    /// engine, so that the manager's state is current when periodic checks run.
3366    ///
3367    /// Updates performed per report variant:
3368    /// - `Order`: updates reconciliation tracking based on order status
3369    /// - `Fill`: records order activity and advances the position revision once, without marking
3370    ///   the fill as processed; continuous fill recovery checks this increment after dispatch
3371    /// - `OrderWithFills`: updates order tracking and records position activity per fill
3372    /// - `Position`: records position activity
3373    /// - `MassStatus`: no-op (handled separately via startup reconciliation)
3374    pub fn observe_execution_report(&mut self, report: &ExecutionReport) {
3375        match report {
3376            ExecutionReport::Order(order_report) => {
3377                self.observe_order_report(order_report);
3378            }
3379            ExecutionReport::Fill(fill_report) => {
3380                let client_order_id = fill_report.client_order_id.or_else(|| {
3381                    self.cache
3382                        .borrow()
3383                        .client_order_id(&fill_report.venue_order_id)
3384                        .copied()
3385                });
3386
3387                if let Some(coid) = client_order_id {
3388                    self.record_local_activity(coid);
3389                }
3390
3391                self.record_position_activity(fill_report.instrument_id, fill_report.account_id);
3392            }
3393            ExecutionReport::OrderWithFills(order_report, fills) => {
3394                self.observe_order_report(order_report);
3395
3396                for fill_report in fills {
3397                    self.record_position_activity(
3398                        fill_report.instrument_id,
3399                        fill_report.account_id,
3400                    );
3401                }
3402            }
3403            ExecutionReport::Position(position_report) => {
3404                self.record_position_activity(
3405                    position_report.instrument_id,
3406                    position_report.account_id,
3407                );
3408            }
3409            ExecutionReport::MassStatus(_) => {
3410                // Handled separately via reconcile_execution_mass_status
3411            }
3412        }
3413    }
3414
3415    fn confirm_submitted_report(&mut self, report: &OrderStatusReport) -> bool {
3416        if report.order_status == OrderStatus::Submitted
3417            && let Some(client_order_id) = report.client_order_id
3418            && self.submission_retention_enabled(client_order_id, None)
3419            && let Some(order) = self.get_order(client_order_id)
3420            && self
3421                .submissions
3422                .get(&client_order_id)
3423                .is_none_or(|submission| {
3424                    submission.trader_id == order.trader_id()
3425                        && submission.strategy_id == order.strategy_id()
3426                        && submission.instrument_id == order.instrument_id()
3427                })
3428            && report.instrument_id == order.instrument_id()
3429            && order.account_id() == Some(report.account_id)
3430            && order
3431                .venue_order_id()
3432                .is_none_or(|id| id == report.venue_order_id)
3433            && self
3434                .cache
3435                .borrow()
3436                .client_order_id(&report.venue_order_id)
3437                .is_none_or(|id| *id == client_order_id)
3438        {
3439            if Self::submission_is_unacknowledged(&order) {
3440                let client_id = self.cache.borrow().client_id(&client_order_id).copied();
3441                self.track_submission(order.init_event(), client_id);
3442            }
3443
3444            if let Some(submission) = self.submissions.get_mut(&client_order_id) {
3445                submission.venue_confirmed = true;
3446            }
3447
3448            self.clear_recon_tracking(&client_order_id, false);
3449            self.record_local_activity(client_order_id);
3450            return true;
3451        }
3452
3453        false
3454    }
3455
3456    fn observe_order_report(&mut self, report: &OrderStatusReport) {
3457        let Some(client_order_id) = report.client_order_id else {
3458            return;
3459        };
3460
3461        if self.confirm_submitted_report(report) {
3462            return;
3463        }
3464
3465        let accepted_during_pending_command = report.order_status == OrderStatus::Accepted
3466            && self.get_order(client_order_id).is_some_and(|order| {
3467                matches!(
3468                    order.status(),
3469                    OrderStatus::PendingUpdate | OrderStatus::PendingCancel
3470                )
3471            });
3472
3473        if !matches!(
3474            report.order_status,
3475            OrderStatus::PendingUpdate | OrderStatus::PendingCancel
3476        ) && !accepted_during_pending_command
3477        {
3478            self.clear_recon_tracking(&client_order_id, report.order_status.is_closed());
3479        }
3480
3481        // Dispatch may suppress a terminal report, such as a stale cancel for the
3482        // old leg of a cancel-replace. Keep the settling grace until the node
3483        // confirms the cached order closed after dispatch.
3484        self.record_local_activity(client_order_id);
3485    }
3486
3487    /// Purges closed orders from the cache that are older than the configured buffer.
3488    pub fn purge_closed_orders(&mut self) {
3489        let Some(buffer_mins) = self.config.purge_closed_orders_buffer_mins else {
3490            return;
3491        };
3492
3493        let ts_now = self.timestamp_ns();
3494        let buffer_secs = mins_to_secs(u64::from(buffer_mins));
3495
3496        if let Err(e) = self.cache.borrow_mut().purge_closed_orders(
3497            ts_now,
3498            buffer_secs,
3499            self.config.purge_from_database,
3500        ) {
3501            log::error!("Failed to purge cached state: {e}");
3502        }
3503    }
3504
3505    /// Purges closed positions from the cache that are older than the configured buffer.
3506    pub fn purge_closed_positions(&mut self) {
3507        let Some(buffer_mins) = self.config.purge_closed_positions_buffer_mins else {
3508            return;
3509        };
3510
3511        let ts_now = self.clock.borrow().timestamp_ns();
3512        let buffer_secs = mins_to_secs(u64::from(buffer_mins));
3513
3514        if let Err(e) = self.cache.borrow_mut().purge_closed_positions(
3515            ts_now,
3516            buffer_secs,
3517            self.config.purge_from_database,
3518        ) {
3519            log::error!("Failed to purge cached state: {e}");
3520        }
3521    }
3522
3523    /// Purges old account events from the cache based on the configured lookback.
3524    pub fn purge_account_events(&mut self) {
3525        let Some(lookback_mins) = self.config.purge_account_events_lookback_mins else {
3526            return;
3527        };
3528
3529        let ts_now = self.clock.borrow().timestamp_ns();
3530        let lookback_secs = mins_to_secs(u64::from(lookback_mins));
3531
3532        if let Err(e) = self.cache.borrow_mut().purge_account_events(
3533            ts_now,
3534            lookback_secs,
3535            self.config.purge_from_database,
3536        ) {
3537            log::error!("Failed to purge cached state: {e}");
3538        }
3539    }
3540
3541    fn get_order(&self, client_order_id: ClientOrderId) -> Option<OrderAny> {
3542        self.cache().order(&client_order_id).map(|o| o.clone())
3543    }
3544
3545    fn get_order_by_venue_order_id(&self, venue_order_id: VenueOrderId) -> Option<OrderAny> {
3546        let cache = self.cache();
3547        cache
3548            .client_order_id(&venue_order_id)
3549            .and_then(|client_order_id| cache.order(client_order_id).map(|o| o.clone()))
3550    }
3551
3552    fn get_instrument(&self, instrument_id: &InstrumentId) -> Option<InstrumentAny> {
3553        self.cache().instrument(instrument_id).cloned()
3554    }
3555
3556    fn should_skip_order_report(&self, report: &OrderStatusReport) -> bool {
3557        let client_order_id = report.client_order_id.or_else(|| {
3558            self.cache
3559                .borrow()
3560                .client_order_id(&report.venue_order_id)
3561                .copied()
3562        });
3563
3564        if let Some(client_order_id) = client_order_id
3565            && self
3566                .config
3567                .filtered_client_order_ids
3568                .contains(&client_order_id)
3569        {
3570            log::debug!(
3571                "Skipping order report {client_order_id}: in filtered_client_order_ids list"
3572            );
3573            return true;
3574        }
3575
3576        if !self.should_reconcile_instrument(&report.instrument_id) {
3577            log::debug!(
3578                "Skipping order report for {}: not in reconciliation_instrument_ids",
3579                report.instrument_id
3580            );
3581            return true;
3582        }
3583
3584        false
3585    }
3586
3587    /// Checks whether the instrument passes the configured reconciliation filter.
3588    fn should_reconcile_instrument(&self, instrument_id: &InstrumentId) -> bool {
3589        self.config.reconciliation_instrument_ids.is_empty()
3590            || self
3591                .config
3592                .reconciliation_instrument_ids
3593                .contains(instrument_id)
3594    }
3595
3596    fn prepare_missing_order_query(&mut self, client_order_id: ClientOrderId) -> Option<OrderAny> {
3597        let order = self.get_order(client_order_id)?;
3598
3599        if self.submission_is_retained(client_order_id) {
3600            return None;
3601        }
3602
3603        // The order may have closed while the report request was in flight;
3604        // the check must come before the retry increment or the stale empty
3605        // response recreates tracking state that nothing prunes afterwards.
3606        if order.status().is_closed() {
3607            log::debug!(
3608                "Skipping missing-order resolution for {client_order_id}: already {}",
3609                order.status()
3610            );
3611            self.clear_recon_tracking(&client_order_id, true);
3612            return None;
3613        }
3614
3615        // Recent local activity is the real-time settling window for missing
3616        // orders. Venue/domain timestamps can be ahead of the trading clock and
3617        // must not stall reconciliation.
3618        if self.order_activity.within(
3619            &client_order_id,
3620            Duration::from(self.config.open_check_threshold_ns),
3621        ) {
3622            return None;
3623        }
3624
3625        if self.config.open_check_open_only
3626            && (order.is_inflight()
3627                || self.order_inflight_checks.contains_key(&client_order_id)
3628                || self.order_query_recency.within(
3629                    &client_order_id,
3630                    Duration::from_millis(u64::from(self.config.single_order_query_delay_ms)),
3631                ))
3632        {
3633            return None;
3634        }
3635
3636        if order.is_inflight() && Self::submission_is_unacknowledged(&order) {
3637            let client_id = self.cache.borrow().client_id(&client_order_id).copied();
3638            self.track_submission(order.init_event(), client_id);
3639        }
3640
3641        let retries = self.order_recon_retries.entry(client_order_id).or_insert(0);
3642        *retries = retries.saturating_add(1);
3643
3644        if *retries < self.config.open_check_missing_retries {
3645            log::debug!(
3646                "Order {} not found at venue, retry {}/{}",
3647                client_order_id,
3648                retries,
3649                self.config.open_check_missing_retries
3650            );
3651            return None;
3652        }
3653
3654        Some(order)
3655    }
3656
3657    fn resolve_missing_order(&mut self, client_order_id: ClientOrderId) -> Vec<OrderEventAny> {
3658        let mut events = Vec::new();
3659
3660        let Some(order) = self.get_order(client_order_id) else {
3661            return events;
3662        };
3663
3664        if order.status().is_closed() {
3665            log::debug!(
3666                "Skipping missing-order resolution for {client_order_id}: already {}",
3667                order.status()
3668            );
3669            self.clear_recon_tracking(&client_order_id, true);
3670            return events;
3671        }
3672
3673        if self.order_activity.within(
3674            &client_order_id,
3675            Duration::from(self.config.open_check_threshold_ns),
3676        ) {
3677            log::debug!(
3678                "Deferring missing-order resolution for {client_order_id}: recent local activity"
3679            );
3680            return events;
3681        }
3682
3683        let retries = self.recon_check_retry_count(&client_order_id);
3684        let ts_now = self.clock.borrow().timestamp_ns();
3685
3686        // The targeted query was scheduled only after the missing-order budget was reached.
3687        // An interleaved inflight check can subsequently overwrite the shared retry counter.
3688        let exhausted_retries = retries.max(self.config.open_check_missing_retries);
3689
3690        if self.submission_recovery_pending(client_order_id)
3691            && !self.order_inflight_checks.contains_key(&client_order_id)
3692        {
3693            self.exhaust_submission(
3694                client_order_id,
3695                SubmissionRecoverySource::MissingOrder,
3696                exhausted_retries,
3697            );
3698            return events;
3699        }
3700
3701        match order.status() {
3702            OrderStatus::Accepted | OrderStatus::Submitted => {
3703                if order.status() == OrderStatus::Submitted
3704                    && self.exhaust_submission(
3705                        client_order_id,
3706                        SubmissionRecoverySource::MissingOrder,
3707                        exhausted_retries,
3708                    )
3709                {
3710                    return events;
3711                }
3712
3713                log::warn!(
3714                    "Order {client_order_id} not found at venue after {retries} retries and a targeted query, marking as REJECTED"
3715                );
3716
3717                if let Some(rejected) =
3718                    create_reconciliation_rejected(&order, Some("NOT_FOUND_AT_VENUE"), ts_now)
3719                {
3720                    events.push(rejected);
3721                }
3722            }
3723            OrderStatus::PartiallyFilled => {
3724                log::warn!(
3725                    "Order {client_order_id} not found at venue after {retries} retries and a targeted query, marking as CANCELED"
3726                );
3727                events.push(create_reconciliation_canceled(&order, None, ts_now));
3728            }
3729            OrderStatus::PendingUpdate | OrderStatus::PendingCancel => {
3730                log::debug!(
3731                    "Deferring resolution for {client_order_id}: still inflight as {}",
3732                    order.status()
3733                );
3734
3735                if self.submission_recovery_pending(client_order_id) {
3736                    return events;
3737                }
3738
3739                // Narrow tracking reset mirroring the Python engine:
3740                // zero the retry ladder and stamp the query time so the
3741                // inflight checker first observes a full threshold delay
3742                // and then retries from scratch. The order must stay
3743                // registered in `order_inflight_checks` - the inflight checker
3744                // walks that map, unlike Python which rescans cached
3745                // inflight orders every cycle - and keeps its
3746                // local-activity mark.
3747                self.order_recon_retries.shift_remove(&client_order_id);
3748                if let Some(check) = self.order_inflight_checks.get_mut(&client_order_id) {
3749                    check.retry_count = 0;
3750                    check.last_query_at = Some(dst::time::Instant::now());
3751                }
3752
3753                self.order_query_recency.mark(client_order_id);
3754                return events;
3755            }
3756            status => {
3757                log::warn!(
3758                    "Skipping missing-order resolution for {client_order_id}: unexpected status {status}"
3759                );
3760            }
3761        }
3762
3763        self.clear_recon_tracking(&client_order_id, true);
3764        events
3765    }
3766
3767    /// Collects cached and venue net, long, and short quantities for comparison.
3768    fn position_quantity_comparison(
3769        &self,
3770        key: InstrumentAccountKey,
3771        venue_reports: &[PositionStatusReport],
3772    ) -> PositionQuantityComparison {
3773        let (instrument_id, account_id) = key;
3774
3775        let cached_positions = {
3776            let cache = self.cache.borrow();
3777            cache
3778                .positions_open(None, Some(&instrument_id), None, Some(&account_id), None)
3779                .into_iter()
3780                .map(|position| (*position).clone())
3781                .collect::<Vec<_>>()
3782        };
3783
3784        let (cached_signed_qty, cached_long_qty, cached_short_qty) =
3785            position_qty_aggregates(cached_positions.iter().map(Position::signed_decimal_qty));
3786        let (venue_signed_qty, venue_long_qty, venue_short_qty) =
3787            position_qty_aggregates(venue_reports.iter().map(|report| report.signed_decimal_qty));
3788        let nonflat_count = venue_reports
3789            .iter()
3790            .filter(|report| report.signed_decimal_qty != Decimal::ZERO)
3791            .count();
3792        let venue_report = venue_reports
3793            .iter()
3794            .find(|report| report.signed_decimal_qty != Decimal::ZERO)
3795            .or_else(|| venue_reports.last())
3796            .cloned();
3797        let venue_has_side_reports = venue_reports.iter().any(PositionStatusReport::is_long)
3798            && venue_reports.iter().any(PositionStatusReport::is_short);
3799
3800        PositionQuantityComparison {
3801            cached_positions,
3802            cached_signed_qty,
3803            cached_long_qty,
3804            cached_short_qty,
3805            venue_signed_qty,
3806            venue_long_qty,
3807            venue_short_qty,
3808            nonflat_count,
3809            venue_report,
3810            venue_has_side_reports,
3811        }
3812    }
3813
3814    fn check_position_discrepancy(
3815        &mut self,
3816        key: InstrumentAccountKey,
3817        venue_reports: &[PositionStatusReport],
3818    ) -> Option<Vec<OrderEventAny>> {
3819        let (instrument_id, account_id) = key;
3820        let comparison = self.position_quantity_comparison(key, venue_reports);
3821        let tolerance = self.position_reconciliation_tolerance(account_id);
3822        let quantities_match = comparison.quantities_match(tolerance);
3823        let report_shape = comparison.report_shape();
3824        let PositionQuantityComparison {
3825            cached_positions,
3826            cached_signed_qty,
3827            cached_long_qty,
3828            cached_short_qty,
3829            venue_signed_qty,
3830            venue_long_qty,
3831            venue_short_qty,
3832            venue_report,
3833            ..
3834        } = comparison;
3835
3836        if quantities_match {
3837            self.clear_position_reconciliation(&key);
3838            return None;
3839        }
3840
3841        if !self.config.generate_missing_orders {
3842            log::debug!(
3843                "Discrepancy for {instrument_id} position when `generate_missing_orders` disabled, skipping"
3844            );
3845            return None;
3846        }
3847
3848        let ts_now = self.clock.borrow().timestamp_ns();
3849
3850        // Grace window measured on the monotonic `dst::time` clock; see `record_position_activity`
3851        if self.position_activity_is_recent(&key) {
3852            log::debug!(
3853                "Skipping position reconciliation for {instrument_id}: recent activity within threshold"
3854            );
3855            return None;
3856        }
3857
3858        let retries = self.position_reconciliation_retries(&key, report_shape);
3859
3860        if retries >= self.config.position_check_retries {
3861            return None;
3862        }
3863
3864        if report_shape == PositionReportShape::MultiLeg {
3865            let new_retries = retries + 1;
3866            self.set_position_reconciliation_retries(key, report_shape, new_retries);
3867            log::warn!(
3868                "Deferring position reconciliation for {instrument_id}/{account_id}: venue reports have ambiguous side aggregates (cached net={cached_signed_qty}, long={cached_long_qty}, short={cached_short_qty}; venue net={venue_signed_qty}, long={venue_long_qty}, short={venue_short_qty})"
3869            );
3870
3871            if new_retries >= self.config.position_check_retries {
3872                log::error!(
3873                    "Position discrepancy for {instrument_id}/{account_id} unresolved after {} attempts; no further reconciliation attempts will be made for the current report shape",
3874                    self.config.position_check_retries,
3875                );
3876            }
3877
3878            return None;
3879        }
3880
3881        log::warn!(
3882            "Position discrepancy detected for {instrument_id}: cached_signed_qty={cached_signed_qty}, venue_signed_qty={venue_signed_qty}"
3883        );
3884
3885        let Some(instrument) = self.get_instrument(&instrument_id) else {
3886            log::debug!("Cannot reconcile position for {instrument_id}: instrument not in cache");
3887            let new_retries = retries + 1;
3888            self.set_position_reconciliation_retries(key, report_shape, new_retries);
3889            if new_retries >= self.config.position_check_retries {
3890                log::error!(
3891                    "Position discrepancy for {instrument_id} unresolved after {} attempts \
3892                     (cached_qty={cached_signed_qty}, venue_qty={venue_signed_qty}); \
3893                     no further reconciliation attempts will be made for the current report shape",
3894                    self.config.position_check_retries,
3895                );
3896            }
3897
3898            return None;
3899        };
3900
3901        let cached_avg_px = position_avg_px(&cached_positions);
3902        let venue_avg_px = venue_report.as_ref().and_then(|r| r.avg_px_open);
3903        let venue_position_id = venue_report
3904            .as_ref()
3905            .and_then(|report| report.venue_position_id);
3906        let venue_ts_last = venue_report.as_ref().map_or(ts_now, |r| r.ts_last);
3907
3908        let crosses_zero = (cached_signed_qty > Decimal::ZERO && venue_signed_qty < Decimal::ZERO)
3909            || (cached_signed_qty < Decimal::ZERO && venue_signed_qty > Decimal::ZERO);
3910
3911        let result = if crosses_zero {
3912            let position_ids = match venue_position_id {
3913                Some(open_position_id) => match cached_positions.as_slice() {
3914                    [position] => Some((Some(position.id), Some(open_position_id))),
3915                    _ => {
3916                        log::warn!(
3917                            "Deferring hedge cross-zero reconciliation for {instrument_id}/{account_id}: cached and venue position identities are ambiguous"
3918                        );
3919                        None
3920                    }
3921                },
3922                None => Some((None, None)),
3923            };
3924
3925            position_ids.and_then(|(close_position_id, open_position_id)| {
3926                self.reconcile_cross_zero_position(
3927                    &instrument,
3928                    account_id,
3929                    cached_signed_qty,
3930                    cached_avg_px,
3931                    venue_signed_qty,
3932                    venue_avg_px,
3933                    close_position_id,
3934                    open_position_id,
3935                    ts_now,
3936                    venue_ts_last,
3937                )
3938            })
3939        } else {
3940            let qty_diff = venue_signed_qty - cached_signed_qty;
3941
3942            let order_side = if qty_diff > Decimal::ZERO {
3943                OrderSide::Buy
3944            } else {
3945                OrderSide::Sell
3946            };
3947
3948            let reconciliation_px = calculate_reconciliation_price(
3949                cached_signed_qty,
3950                cached_avg_px,
3951                venue_signed_qty,
3952                venue_avg_px,
3953                venue_report
3954                    .as_ref()
3955                    .map_or_default(|report| report.avg_px_open_reconciliation),
3956                venue_report
3957                    .as_ref()
3958                    .and_then(|report| report.avg_px_open_precision),
3959            );
3960
3961            reconciliation_px
3962                .or(venue_avg_px)
3963                .or(cached_avg_px)
3964                .and_then(|fill_px| {
3965                    let quantity =
3966                        Quantity::from_decimal_dp(qty_diff.abs(), instrument.size_precision())
3967                            .ok()?;
3968                    let order_report = create_position_reconciliation_report(
3969                        &instrument,
3970                        account_id,
3971                        order_side,
3972                        quantity,
3973                        fill_px,
3974                        venue_position_id,
3975                        None,
3976                        ts_now,
3977                        venue_ts_last,
3978                    );
3979
3980                    log::info!(
3981                        color = LogColor::Blue as u8;
3982                        "Generating synthetic fill for position reconciliation {instrument_id}: side={order_side:?}, qty={}, px={fill_px}", qty_diff.abs(),
3983                    );
3984
3985                    let (events, _) = self.handle_external_order(
3986                        &order_report,
3987                        account_id,
3988                        &instrument,
3989                        &[],
3990                        true,
3991                        None,
3992                        None,
3993                    );
3994                    Some(events)
3995                })
3996        };
3997
3998        // Track retries when reconciliation didn't produce events
3999        if result.as_ref().is_none_or(Vec::is_empty) {
4000            let new_retries = retries + 1;
4001            self.set_position_reconciliation_retries(key, report_shape, new_retries);
4002            if new_retries >= self.config.position_check_retries {
4003                log::error!(
4004                    "Position discrepancy for {} unresolved after {} attempts \
4005                     (cached_qty={}, venue_qty={}); \
4006                     no further reconciliation attempts will be made for the current report shape",
4007                    instrument_id,
4008                    self.config.position_check_retries,
4009                    cached_signed_qty,
4010                    venue_signed_qty,
4011                );
4012            }
4013        } else {
4014            self.clear_position_reconciliation(&key);
4015        }
4016
4017        result
4018    }
4019
4020    /// Handles position reconciliation when position flips sign, splitting into two
4021    /// fills: close existing position then open new position in opposite direction.
4022    #[expect(clippy::too_many_arguments)]
4023    fn reconcile_cross_zero_position(
4024        &self,
4025        instrument: &InstrumentAny,
4026        account_id: AccountId,
4027        cached_signed_qty: Decimal,
4028        cached_avg_px: Option<Decimal>,
4029        venue_signed_qty: Decimal,
4030        venue_avg_px: Option<Decimal>,
4031        close_position_id: Option<PositionId>,
4032        open_position_id: Option<PositionId>,
4033        ts_now: UnixNanos,
4034        venue_ts_last: UnixNanos,
4035    ) -> Option<Vec<OrderEventAny>> {
4036        let instrument_id = instrument.id();
4037
4038        log::info!(
4039            color = LogColor::Blue as u8;
4040            "Position crosses zero for {instrument_id}: cached={cached_signed_qty}, venue={venue_signed_qty}. Splitting into two fills",
4041        );
4042
4043        let close_qty = cached_signed_qty.abs();
4044
4045        let close_side = if cached_signed_qty < Decimal::ZERO {
4046            OrderSide::Buy // Close short by buying
4047        } else {
4048            OrderSide::Sell // Close long by selling
4049        };
4050
4051        let open_qty = venue_signed_qty.abs();
4052
4053        let open_side = if venue_signed_qty > Decimal::ZERO {
4054            OrderSide::Buy // Open long
4055        } else {
4056            OrderSide::Sell // Open short
4057        };
4058
4059        let Some(close_px) = cached_avg_px else {
4060            log::warn!("Cannot close position for {instrument_id}: no cached average price");
4061            return None;
4062        };
4063
4064        let open_report = match venue_avg_px {
4065            Some(open_px) => {
4066                let quantity =
4067                    Quantity::from_decimal_dp(open_qty, instrument.size_precision()).ok()?;
4068                let report = create_position_reconciliation_report(
4069                    instrument,
4070                    account_id,
4071                    open_side,
4072                    quantity,
4073                    open_px,
4074                    open_position_id,
4075                    Some("OPEN"),
4076                    ts_now,
4077                    venue_ts_last,
4078                );
4079                Some((report, open_px))
4080            }
4081            None => None,
4082        };
4083
4084        let quantity = Quantity::from_decimal_dp(close_qty, instrument.size_precision()).ok()?;
4085        let close_report = create_position_reconciliation_report(
4086            instrument,
4087            account_id,
4088            close_side,
4089            quantity,
4090            close_px,
4091            close_position_id,
4092            Some("CLOSE"),
4093            ts_now,
4094            venue_ts_last,
4095        );
4096
4097        log::info!(
4098            color = LogColor::Blue as u8;
4099            "Generating close fill for cross-zero {instrument_id}: side={close_side:?}, qty={close_qty}, px={close_px}",
4100        );
4101
4102        let (close_events, _) = self.handle_external_order(
4103            &close_report,
4104            account_id,
4105            instrument,
4106            &[],
4107            true,
4108            None,
4109            None,
4110        );
4111        let mut all_events = close_events;
4112
4113        if let Some((open_report, open_px)) = open_report {
4114            log::info!(
4115                color = LogColor::Blue as u8;
4116                "Generating open fill for cross-zero {instrument_id}: side={open_side:?}, qty={open_qty}, px={open_px}",
4117            );
4118
4119            let (open_events, _) = self.handle_external_order(
4120                &open_report,
4121                account_id,
4122                instrument,
4123                &[],
4124                true,
4125                None,
4126                None,
4127            );
4128            all_events.extend(open_events);
4129        } else {
4130            log::warn!("Cannot open new position for {instrument_id}: no venue average price");
4131        }
4132
4133        Some(all_events)
4134    }
4135
4136    fn reconcile_position_report(
4137        &self,
4138        report: &PositionStatusReport,
4139        account_id: AccountId,
4140        instruments_with_unattributed_fills: &IndexSet<InstrumentId>,
4141    ) -> Option<Vec<OrderEventAny>> {
4142        match report.venue_position_id {
4143            Some(venue_position_id) => self.reconcile_position_report_hedging(
4144                report,
4145                venue_position_id,
4146                account_id,
4147                instruments_with_unattributed_fills,
4148            ),
4149            None => self.reconcile_position_report_netting(report, account_id),
4150        }
4151    }
4152
4153    fn reconcile_position_report_hedging(
4154        &self,
4155        report: &PositionStatusReport,
4156        venue_position_id: PositionId,
4157        account_id: AccountId,
4158        instruments_with_unattributed_fills: &IndexSet<InstrumentId>,
4159    ) -> Option<Vec<OrderEventAny>> {
4160        // Skip if fills exist for this instrument but lack venue_position_id
4161        // (can't determine which hedge position they belong to)
4162        if instruments_with_unattributed_fills.contains(&report.instrument_id) {
4163            log::debug!(
4164                "Skipping hedge position {venue_position_id} reconciliation: unattributed fills in batch"
4165            );
4166            return None;
4167        }
4168
4169        log::debug!(
4170            "Reconciling HEDGE position for {}, venue_position_id={}",
4171            report.instrument_id,
4172            venue_position_id
4173        );
4174
4175        let position = {
4176            let cache = self.cache.borrow();
4177            cache.position_owned(&venue_position_id)
4178        };
4179
4180        match position {
4181            Some(position) => {
4182                let cached_signed_qty = position.signed_decimal_qty();
4183                let venue_signed_qty = report.signed_decimal_qty;
4184
4185                if cached_signed_qty == venue_signed_qty {
4186                    log::debug!(
4187                        "Hedge position {venue_position_id} matches venue: qty={cached_signed_qty}"
4188                    );
4189                    return None;
4190                }
4191
4192                if !self.config.generate_missing_orders {
4193                    log::error!(
4194                        "Cannot reconcile {} {}: position net qty {} != reported net qty {} \
4195                         and `generate_missing_orders` is disabled",
4196                        report.instrument_id,
4197                        venue_position_id,
4198                        cached_signed_qty,
4199                        venue_signed_qty
4200                    );
4201                    return None;
4202                }
4203
4204                self.reconcile_hedge_position_discrepancy(
4205                    report,
4206                    venue_position_id,
4207                    account_id,
4208                    &position,
4209                    cached_signed_qty,
4210                )
4211            }
4212            None => {
4213                if report.signed_decimal_qty == Decimal::ZERO {
4214                    return None;
4215                }
4216
4217                if !self.config.generate_missing_orders {
4218                    log::error!(
4219                        "Cannot reconcile position: {venue_position_id} not found and `generate_missing_orders` is disabled"
4220                    );
4221                    return None;
4222                }
4223
4224                self.reconcile_missing_hedge_position(report, venue_position_id, account_id)
4225            }
4226        }
4227    }
4228
4229    fn reconcile_hedge_position_discrepancy(
4230        &self,
4231        report: &PositionStatusReport,
4232        venue_position_id: PositionId,
4233        account_id: AccountId,
4234        position: &Position,
4235        cached_signed_qty: Decimal,
4236    ) -> Option<Vec<OrderEventAny>> {
4237        let instrument = self.get_instrument(&report.instrument_id)?;
4238        let venue_signed_qty = report.signed_decimal_qty;
4239
4240        let diff = (cached_signed_qty - venue_signed_qty).abs();
4241        let diff_qty = Quantity::from_decimal_dp(diff, instrument.size_precision()).ok()?;
4242
4243        if diff_qty.is_zero() {
4244            log::debug!(
4245                "Difference quantity rounds to zero for {}, skipping",
4246                instrument.id()
4247            );
4248            return None;
4249        }
4250
4251        log::warn!(
4252            "Hedge position discrepancy for {} {}: cached={}, venue={}, generating reconciliation order",
4253            report.instrument_id,
4254            venue_position_id,
4255            cached_signed_qty,
4256            venue_signed_qty
4257        );
4258
4259        let current_avg_px = if position.avg_px_open > Decimal::ZERO {
4260            Some(position.avg_px_open)
4261        } else {
4262            None
4263        };
4264
4265        self.create_position_reconciliation_order(
4266            report,
4267            account_id,
4268            &instrument,
4269            cached_signed_qty,
4270            diff_qty,
4271            current_avg_px,
4272        )
4273    }
4274
4275    fn reconcile_missing_hedge_position(
4276        &self,
4277        report: &PositionStatusReport,
4278        venue_position_id: PositionId,
4279        account_id: AccountId,
4280    ) -> Option<Vec<OrderEventAny>> {
4281        let instrument = self.get_instrument(&report.instrument_id)?;
4282        let venue_signed_qty = report.signed_decimal_qty;
4283
4284        let qty = venue_signed_qty.abs();
4285        let diff_qty = Quantity::from_decimal_dp(qty, instrument.size_precision()).ok()?;
4286
4287        if diff_qty.is_zero() {
4288            return None;
4289        }
4290
4291        log::warn!(
4292            "Missing hedge position for {} {}: venue reports {}, generating reconciliation order",
4293            report.instrument_id,
4294            venue_position_id,
4295            venue_signed_qty
4296        );
4297
4298        self.create_position_reconciliation_order(
4299            report,
4300            account_id,
4301            &instrument,
4302            Decimal::ZERO,
4303            diff_qty,
4304            None,
4305        )
4306    }
4307
4308    fn reconcile_position_report_netting(
4309        &self,
4310        report: &PositionStatusReport,
4311        account_id: AccountId,
4312    ) -> Option<Vec<OrderEventAny>> {
4313        let instrument_id = report.instrument_id;
4314
4315        log::debug!("Reconciling NET position for {instrument_id}");
4316
4317        let instrument = self.get_instrument(&instrument_id)?;
4318
4319        let (cached_signed_qty, cached_avg_px) = {
4320            let cache = self.cache.borrow();
4321            let positions =
4322                cache.positions_open(None, Some(&instrument_id), None, Some(&account_id), None);
4323            let cached_signed_qty = positions
4324                .iter()
4325                .map(|position| position.signed_decimal_qty())
4326                .sum::<Decimal>();
4327            let cached_avg_px = position_avg_px(positions.iter().map(|position| &**position));
4328
4329            (cached_signed_qty, cached_avg_px)
4330        };
4331
4332        let venue_signed_qty = report.signed_decimal_qty;
4333
4334        log::debug!("venue_signed_qty={venue_signed_qty}, cached_signed_qty={cached_signed_qty}");
4335
4336        let diff = (cached_signed_qty - venue_signed_qty).abs();
4337        let tolerance = self.position_reconciliation_tolerance(account_id);
4338        if diff <= tolerance {
4339            log::debug!("Position quantities match for {instrument_id}, no reconciliation needed");
4340            return None;
4341        }
4342
4343        if !self.config.generate_missing_orders {
4344            log::debug!(
4345                "Discrepancy for {instrument_id} position when `generate_missing_orders` disabled, skipping"
4346            );
4347            return None;
4348        }
4349
4350        let diff_qty = Quantity::from_decimal_dp(diff, instrument.size_precision()).ok()?;
4351
4352        if diff_qty.is_zero() {
4353            log::debug!(
4354                "Difference quantity rounds to zero for {instrument_id}, skipping order generation"
4355            );
4356            return None;
4357        }
4358
4359        let crosses_zero = (cached_signed_qty > Decimal::ZERO && venue_signed_qty < Decimal::ZERO)
4360            || (cached_signed_qty < Decimal::ZERO && venue_signed_qty > Decimal::ZERO);
4361
4362        if crosses_zero {
4363            let ts_now = self.clock.borrow().timestamp_ns();
4364            return self.reconcile_cross_zero_position(
4365                &instrument,
4366                account_id,
4367                cached_signed_qty,
4368                cached_avg_px,
4369                venue_signed_qty,
4370                report.avg_px_open,
4371                None,
4372                None,
4373                ts_now,
4374                report.ts_last,
4375            );
4376        }
4377
4378        if cached_signed_qty == Decimal::ZERO {
4379            return self.create_position_from_report(report, account_id, &instrument);
4380        }
4381
4382        self.create_position_reconciliation_order(
4383            report,
4384            account_id,
4385            &instrument,
4386            cached_signed_qty,
4387            diff_qty,
4388            cached_avg_px,
4389        )
4390    }
4391
4392    /// Creates a position from a venue position report when no orders/fills exist.
4393    ///
4394    /// This handles the case where the venue reports an open position but there are
4395    /// no order or fill reports to create it from (e.g., orders are already closed).
4396    fn create_position_from_report(
4397        &self,
4398        report: &PositionStatusReport,
4399        account_id: AccountId,
4400        instrument: &InstrumentAny,
4401    ) -> Option<Vec<OrderEventAny>> {
4402        let instrument_id = report.instrument_id;
4403        let venue_signed_qty = report.signed_decimal_qty;
4404
4405        if venue_signed_qty == Decimal::ZERO {
4406            return None;
4407        }
4408
4409        let order_side = if venue_signed_qty > Decimal::ZERO {
4410            OrderSide::Buy
4411        } else {
4412            OrderSide::Sell
4413        };
4414
4415        let qty_abs = venue_signed_qty.abs();
4416        let venue_avg_px = report.avg_px_open?;
4417
4418        let ts_now = self.clock.borrow().timestamp_ns();
4419        let order_qty = Quantity::from_decimal_dp(qty_abs, instrument.size_precision()).ok()?;
4420        let order_report = create_position_reconciliation_report(
4421            instrument,
4422            account_id,
4423            order_side,
4424            order_qty,
4425            venue_avg_px,
4426            report.venue_position_id,
4427            None,
4428            ts_now,
4429            report.ts_last,
4430        );
4431
4432        log::info!(
4433            color = LogColor::Blue as u8;
4434            "Creating position from venue report for {instrument_id}: side={order_side:?}, qty={qty_abs}, avg_px={venue_avg_px}",
4435        );
4436
4437        let (events, _) = self.handle_external_order(
4438            &order_report,
4439            account_id,
4440            instrument,
4441            &[],
4442            true,
4443            None,
4444            None,
4445        );
4446        Some(events)
4447    }
4448
4449    fn create_position_reconciliation_order(
4450        &self,
4451        report: &PositionStatusReport,
4452        account_id: AccountId,
4453        instrument: &InstrumentAny,
4454        cached_signed_qty: Decimal,
4455        diff_qty: Quantity,
4456        current_avg_px: Option<Decimal>,
4457    ) -> Option<Vec<OrderEventAny>> {
4458        let venue_signed_qty = report.signed_decimal_qty;
4459        let instrument_id = report.instrument_id;
4460
4461        let order_side = if venue_signed_qty > cached_signed_qty {
4462            OrderSide::Buy
4463        } else {
4464            OrderSide::Sell
4465        };
4466
4467        let reconciliation_px = calculate_reconciliation_price(
4468            cached_signed_qty,
4469            current_avg_px,
4470            venue_signed_qty,
4471            report.avg_px_open,
4472            report.avg_px_open_reconciliation,
4473            report.avg_px_open_precision,
4474        );
4475
4476        let fill_px = reconciliation_px
4477            .or(report.avg_px_open)
4478            .or(current_avg_px)?;
4479
4480        let ts_now = self.clock.borrow().timestamp_ns();
4481        let order_report = create_position_reconciliation_report(
4482            instrument,
4483            account_id,
4484            order_side,
4485            diff_qty,
4486            fill_px,
4487            report.venue_position_id,
4488            None,
4489            ts_now,
4490            report.ts_last,
4491        );
4492
4493        log::info!(
4494            color = LogColor::Blue as u8;
4495            "Generating reconciliation order for {instrument_id}: side={order_side:?}, qty={diff_qty}, px={fill_px}",
4496        );
4497
4498        let (events, _) = self.handle_external_order(
4499            &order_report,
4500            account_id,
4501            instrument,
4502            &[],
4503            true,
4504            None,
4505            None,
4506        );
4507        Some(events)
4508    }
4509
4510    fn reconcile_order_report(
4511        &self,
4512        order: &OrderAny,
4513        report: &OrderStatusReport,
4514        instrument: Option<&InstrumentAny>,
4515        commission_client: Option<&dyn ExecutionClient>,
4516    ) -> anyhow::Result<Vec<OrderEventAny>> {
4517        let requires_authoritative_fills =
4518            commission_client.is_some_and(ExecutionClient::requires_authoritative_fills);
4519        let current_report = preserve_order_amendment(order, report, requires_authoritative_fills);
4520        let report = current_report.as_ref();
4521        let has_missing_fills = order_report_has_missing_fills(
4522            report,
4523            order.filled_qty(),
4524            requires_authoritative_fills,
4525        );
4526
4527        if has_missing_fills
4528            && requires_authoritative_fills
4529            && order.status() == OrderStatus::Submitted
4530        {
4531            let ts_now = self.clock.borrow().timestamp_ns();
4532            let events = generate_reconciliation_order_pre_fill_events(order, report, ts_now);
4533            return Ok(events);
4534        }
4535
4536        anyhow::ensure!(
4537            !has_missing_fills,
4538            "order report for {} has unaccounted fills; waiting for fill reports",
4539            order.client_order_id(),
4540        );
4541        let ts_now = self.clock.borrow().timestamp_ns();
4542
4543        let mut events = Vec::new();
4544        let mut amended = None;
4545
4546        if order.status() == OrderStatus::PendingUpdate
4547            && matches!(
4548                report.order_status,
4549                OrderStatus::Accepted | OrderStatus::Triggered | OrderStatus::PartiallyFilled
4550            )
4551            && should_reconciliation_update(order, report)
4552        {
4553            events = generate_reconciliation_order_pre_fill_events(order, report, ts_now);
4554            let mut working = order.clone();
4555            for event in &events {
4556                working
4557                    .apply(event.clone())
4558                    .context("failed to project reconciled amendment")?;
4559            }
4560
4561            amended = Some(working);
4562        }
4563
4564        let order = amended.as_ref().unwrap_or(order);
4565        let commission = if matches!(
4566            report.order_status,
4567            OrderStatus::PartiallyFilled | OrderStatus::Filled
4568        ) && report.filled_qty > order.filled_qty()
4569            && let Some(instrument) = instrument
4570        {
4571            let fill_qty = report.filled_qty - order.filled_qty();
4572            let price_and_liquidity =
4573                incremental_inferred_fill_price_and_liquidity(order, report, instrument);
4574
4575            resolve_inferred_fill_commission(
4576                fill_qty,
4577                price_and_liquidity,
4578                instrument,
4579                commission_client,
4580            )?
4581        } else {
4582            None
4583        };
4584
4585        if matches!(
4586            report.order_status,
4587            OrderStatus::Canceled | OrderStatus::Expired
4588        ) && order.status() == OrderStatus::Filled
4589            && report.filled_qty == order.filled_qty()
4590        {
4591            return Ok(Vec::new());
4592        }
4593
4594        events.extend(reconcile_order_report_with_commission(
4595            order, report, instrument, ts_now, commission,
4596        ));
4597        Ok(events)
4598    }
4599
4600    /// Reconciles an order with its associated fills atomically.
4601    #[expect(
4602        clippy::too_many_arguments,
4603        reason = "Snapshot and continuous reports share fill projection"
4604    )]
4605    fn reconcile_order_with_fills(
4606        &mut self,
4607        is_snapshot: bool,
4608        order: &OrderAny,
4609        report: &OrderStatusReport,
4610        fills: &[&FillReport],
4611        instrument: Option<&InstrumentAny>,
4612        fill_queue: &mut ReconciliationFillQueue,
4613        commission_client: Option<&dyn ExecutionClient>,
4614    ) -> Vec<OrderEventAny> {
4615        let requires_authoritative_fills =
4616            commission_client.is_some_and(ExecutionClient::requires_authoritative_fills);
4617        let current_report = preserve_order_amendment(order, report, requires_authoritative_fills);
4618        let report = current_report.as_ref();
4619        self.confirm_submitted_report(report);
4620        let mut events = Vec::new();
4621        let mut working = order.clone();
4622        let mut sorted_fills: Vec<&FillReport> = fills.to_vec();
4623        sorted_fills.sort_by_key(|f| f.ts_event);
4624
4625        let ts_now = self.clock.borrow().timestamp_ns();
4626        if matches!(
4627            report.order_status,
4628            OrderStatus::Canceled | OrderStatus::Expired
4629        ) && report.ts_triggered.is_some()
4630            && working.status() != OrderStatus::Triggered
4631            && TRIGGERABLE_ORDER_TYPES.contains(&working.order_type())
4632        {
4633            let triggered = create_reconciliation_triggered(&working, report, ts_now);
4634            if working.apply(triggered.clone()).is_ok() {
4635                events.push(triggered);
4636            }
4637        }
4638
4639        let requires_snapshot_projection = !sorted_fills.is_empty()
4640            || is_snapshot
4641                && (report.order_status == OrderStatus::Voided
4642                    || report.filled_qty < working.filled_qty()
4643                    || report.order_status == OrderStatus::Filled
4644                        && report.quantity < working.quantity());
4645        if !requires_snapshot_projection {
4646            match self.reconcile_order_report(&working, report, instrument, commission_client) {
4647                Ok(order_events) => events.extend(order_events),
4648                Err(e) => log::error!(
4649                    "Deferring order reconciliation for {}: {e}",
4650                    order.client_order_id(),
4651                ),
4652            }
4653
4654            return events;
4655        }
4656
4657        for event in generate_reconciliation_order_pre_fill_events(&working, report, ts_now) {
4658            if let Err(e) = working.apply(event.clone()) {
4659                log::warn!(
4660                    "Cannot project reconciliation event for {}: {e}",
4661                    order.client_order_id()
4662                );
4663                return events;
4664            }
4665
4666            events.push(event);
4667        }
4668
4669        if let Some(inst) = instrument {
4670            for fill in sorted_fills {
4671                let Some((event, fill_key)) =
4672                    self.create_order_fill(&working, fill, inst, &fill_queue.pending_fill_keys)
4673                else {
4674                    continue;
4675                };
4676
4677                if let Err(e) = working.apply(OrderEventAny::Filled(event.clone())) {
4678                    if self.applied_fill_key(&event) == Some(fill_key) {
4679                        self.fills_processed.mark(fill_key);
4680                        continue;
4681                    }
4682
4683                    log::warn!(
4684                        "Cannot project reconciliation fill for {}: {e}",
4685                        order.client_order_id()
4686                    );
4687                    return events;
4688                }
4689
4690                fill_queue.push(&mut events, event, fill_key);
4691            }
4692        }
4693
4694        // Continuous reports can precede streamed fills; only snapshots can reverse fills
4695        if !is_snapshot {
4696            match self.reconcile_order_report(&working, report, instrument, commission_client) {
4697                Ok(order_events) => events.extend(order_events),
4698                Err(e) => log::warn!("Deferring order reconciliation: {e}"),
4699            }
4700
4701            return events;
4702        }
4703
4704        if order_report_has_missing_fills(
4705            report,
4706            working.filled_qty(),
4707            requires_authoritative_fills,
4708        ) {
4709            log::warn!(
4710                "Deferring terminal reconciliation for {}: fill reports are incomplete",
4711                order.client_order_id(),
4712            );
4713            return events;
4714        }
4715
4716        let commission = if report.filled_qty > working.filled_qty()
4717            && let Some(instrument) = instrument
4718        {
4719            let fill_qty = report.filled_qty - working.filled_qty();
4720
4721            let price_and_liquidity =
4722                incremental_inferred_fill_price_and_liquidity(&working, report, instrument);
4723
4724            match resolve_inferred_fill_commission(
4725                fill_qty,
4726                price_and_liquidity,
4727                instrument,
4728                commission_client,
4729            ) {
4730                Ok(commission) => commission,
4731                Err(e) => {
4732                    log::error!(
4733                        "Deferring inferred fill for {}: venue commission calculation failed: {e}",
4734                        order.client_order_id(),
4735                    );
4736                    return events;
4737                }
4738            }
4739        } else {
4740            None
4741        };
4742
4743        for event in generate_reconciliation_order_snapshot_events_with_commission(
4744            &working, report, instrument, ts_now, commission,
4745        ) {
4746            if let Err(e) = working.apply(event.clone()) {
4747                log::warn!(
4748                    "Cannot project reconciliation snapshot event for {}: {e}",
4749                    order.client_order_id()
4750                );
4751                break;
4752            }
4753
4754            events.push(event);
4755        }
4756
4757        events
4758    }
4759
4760    #[expect(clippy::too_many_arguments)]
4761    fn handle_external_order(
4762        &self,
4763        report: &OrderStatusReport,
4764        account_id: AccountId,
4765        instrument: &InstrumentAny,
4766        fills: &[&FillReport],
4767        is_synthetic: bool,
4768        fill_queue: Option<&mut ReconciliationFillQueue>,
4769        commission_client: Option<&dyn ExecutionClient>,
4770    ) -> (Vec<OrderEventAny>, Option<ExternalOrderMetadata>) {
4771        let claimed_strategy = self
4772            .cache
4773            .borrow()
4774            .external_order_claim(&report.instrument_id);
4775        let (strategy_id, tags) = if let Some(claimed_strategy) = claimed_strategy {
4776            let order_id = report
4777                .client_order_id
4778                .map_or_else(|| report.venue_order_id.to_string(), |id| id.to_string());
4779            log::info!(
4780                color = LogColor::Blue as u8;
4781                "External order {} for {} claimed by strategy {}",
4782                order_id,
4783                report.instrument_id,
4784                claimed_strategy,
4785            );
4786
4787            // Keep the synthetic tag so the engine can recognize a position it opened
4788            (
4789                claimed_strategy,
4790                is_synthetic.then(|| vec![*TAG_RECONCILIATION]),
4791            )
4792        } else {
4793            // Unclaimed orders use EXTERNAL strategy ID with tag distinguishing source
4794            let tag = if is_synthetic {
4795                *TAG_RECONCILIATION
4796            } else {
4797                *TAG_VENUE
4798            };
4799
4800            (StrategyId::from("EXTERNAL"), Some(vec![tag]))
4801        };
4802
4803        // Filter unclaimed venue orders (but not synthetic reconciliation orders)
4804        if self.config.filter_unclaimed_external && claimed_strategy.is_none() && !is_synthetic {
4805            return (Vec::new(), None);
4806        }
4807
4808        let client_order_id = report
4809            .client_order_id
4810            .unwrap_or_else(|| ClientOrderId::from(report.venue_order_id.as_str()));
4811
4812        if !report.quantity.is_positive() {
4813            log::error!(
4814                "Skipping external order {} ({}) for {}: non-positive quantity in report {:?}",
4815                client_order_id,
4816                report.venue_order_id,
4817                report.instrument_id,
4818                report,
4819            );
4820            return (Vec::new(), None);
4821        }
4822
4823        let ts_now = self.clock.borrow().timestamp_ns();
4824
4825        let Some(order_side) = report.order_side else {
4826            log::error!(
4827                "Skipping external order {} ({}) for {}: order side is not specified",
4828                client_order_id,
4829                report.venue_order_id,
4830                report.instrument_id,
4831            );
4832            return (Vec::new(), None);
4833        };
4834
4835        let initialized = match OrderInitialized::new_checked(
4836            self.config.trader_id,
4837            strategy_id,
4838            report.instrument_id,
4839            client_order_id,
4840            order_side,
4841            report.order_type,
4842            report.quantity,
4843            report.time_in_force,
4844            report.post_only,
4845            report.reduce_only,
4846            false, // quote_quantity
4847            true,  // reconciliation
4848            UUID4::new(),
4849            ts_now,
4850            ts_now,
4851            report.price,
4852            report.activation_price,
4853            report.trigger_price,
4854            report.trigger_type,
4855            report.limit_offset,
4856            report.trailing_offset,
4857            report.trailing_offset_type,
4858            report.expire_time,
4859            report.display_qty,
4860            None, // emulation_trigger
4861            None, // trigger_instrument_id
4862            report.contingency_type,
4863            report.order_list_id,
4864            report.linked_order_ids.clone(),
4865            report.parent_order_id,
4866            None, // exec_algorithm_id
4867            None, // exec_algorithm_params
4868            None, // exec_spawn_id
4869            tags,
4870        ) {
4871            Ok(initialized) => initialized,
4872            Err(e) => {
4873                log::error!("Failed to create order from report: {e}");
4874                return (Vec::new(), None);
4875            }
4876        };
4877
4878        let initialized = OrderEventAny::Initialized(initialized);
4879
4880        let order = match OrderAny::from_events(vec![initialized.clone()]) {
4881            Ok(order) => order,
4882            Err(e) => {
4883                log::error!("Failed to create order from report: {e}");
4884                return (Vec::new(), None);
4885            }
4886        };
4887
4888        let replace_inferred_fill = !fills.is_empty()
4889            && matches!(
4890                report.order_status,
4891                OrderStatus::Accepted
4892                    | OrderStatus::Canceled
4893                    | OrderStatus::Expired
4894                    | OrderStatus::Filled
4895                    | OrderStatus::PartiallyFilled
4896                    | OrderStatus::Triggered
4897            );
4898        let mut prepared_fills = Vec::new();
4899        let mut prepared_fill_keys = fill_queue
4900            .as_deref()
4901            .map_or_default(|queue| queue.pending_fill_keys.clone());
4902
4903        if replace_inferred_fill {
4904            let mut sorted_fills: Vec<&FillReport> = fills.to_vec();
4905            sorted_fills.sort_by_key(|fill| fill.ts_event);
4906
4907            if fill_queue.is_none() {
4908                log::error!(
4909                    "Cannot reconcile external order {client_order_id}: fill queue is unavailable"
4910                );
4911                return (Vec::new(), None);
4912            }
4913
4914            for fill in sorted_fills {
4915                if let Some((fill_event, fill_key)) =
4916                    self.create_order_fill(&order, fill, instrument, &prepared_fill_keys)
4917                {
4918                    prepared_fill_keys.insert(fill_key);
4919                    prepared_fills.push((fill_event, fill_key));
4920                }
4921            }
4922        }
4923
4924        let real_fill_total: Decimal = prepared_fills
4925            .iter()
4926            .map(|(fill, _)| fill.last_qty.as_decimal())
4927            .sum();
4928        let report_filled = report.filled_qty.as_decimal();
4929
4930        let inferred_qty = if report_filled.is_zero()
4931            || matches!(
4932                report.order_status,
4933                OrderStatus::Accepted | OrderStatus::Triggered
4934            ) {
4935            None
4936        } else if replace_inferred_fill {
4937            if real_fill_total < report_filled {
4938                match Quantity::from_decimal_dp(
4939                    report_filled - real_fill_total,
4940                    instrument.size_precision(),
4941                ) {
4942                    Ok(quantity) => Some(quantity),
4943                    Err(e) => {
4944                        log::error!(
4945                            "Cannot reconcile external order {client_order_id}: residual fill quantity is invalid: {e}"
4946                        );
4947                        return (Vec::new(), None);
4948                    }
4949                }
4950            } else {
4951                None
4952            }
4953        } else if matches!(
4954            report.order_status,
4955            OrderStatus::PartiallyFilled
4956                | OrderStatus::Filled
4957                | OrderStatus::Canceled
4958                | OrderStatus::Expired
4959                | OrderStatus::Voided
4960        ) {
4961            Some(report.filled_qty)
4962        } else {
4963            None
4964        };
4965
4966        let requires_authoritative_fills =
4967            commission_client.is_some_and(ExecutionClient::requires_authoritative_fills);
4968        let defer_terminal = !is_synthetic
4969            && inferred_qty.is_some()
4970            && (requires_authoritative_fills
4971                || claimed_strategy.is_some()
4972                    && matches!(
4973                        report.order_status,
4974                        OrderStatus::Canceled | OrderStatus::Expired
4975                    ));
4976
4977        if defer_terminal && !requires_authoritative_fills && prepared_fills.is_empty() {
4978            log::warn!(
4979                "Deferring terminal reconciliation for claimed order {client_order_id}: fill reports are incomplete"
4980            );
4981            return (Vec::new(), None);
4982        }
4983
4984        if defer_terminal {
4985            log::warn!(
4986                "Deferring external order status for {client_order_id}: fill reports are incomplete"
4987            );
4988        }
4989
4990        let inferred_commission = if is_synthetic || defer_terminal {
4991            None
4992        } else if let Some(inferred_qty) = inferred_qty {
4993            let price_and_liquidity = inferred_fill_price_and_liquidity(&order, report, instrument);
4994
4995            match resolve_inferred_fill_commission(
4996                inferred_qty,
4997                price_and_liquidity,
4998                instrument,
4999                commission_client,
5000            ) {
5001                Ok(commission) => commission,
5002                Err(e) => {
5003                    log::error!(
5004                        "Deferring external order {client_order_id}: venue commission calculation failed: {e}"
5005                    );
5006                    return (Vec::new(), None);
5007                }
5008            }
5009        } else {
5010            None
5011        };
5012
5013        {
5014            let mut cache = self.cache.borrow_mut();
5015
5016            let source_client_id = if is_synthetic {
5017                None
5018            } else {
5019                commission_client.map(ExecutionClient::client_id)
5020            };
5021
5022            if let Err(e) = cache.add_order(order.clone(), None, source_client_id, false) {
5023                // Deterministic synthetic reconciliation IDs hash the same logical event
5024                // to the same client_order_id, so a restart replay can legitimately collide
5025                // with a cached order. Differentiate expected dedup from stuck state.
5026                match cache.order(&client_order_id) {
5027                    Some(existing) if is_synthetic && existing.is_closed() => {
5028                        log::debug!(
5029                            "Skipping synthetic reconciliation order {client_order_id} for {}: \
5030                             replay deduped (cached status={:?})",
5031                            report.instrument_id,
5032                            existing.status(),
5033                        );
5034                    }
5035                    Some(existing) if is_synthetic => {
5036                        log::warn!(
5037                            "Synthetic reconciliation order {client_order_id} for {} exists in \
5038                             cache in non-terminal state {:?}; fill not regenerated",
5039                            report.instrument_id,
5040                            existing.status(),
5041                        );
5042                    }
5043                    _ => {
5044                        log::error!("Failed to add external order to cache: {e}");
5045                    }
5046                }
5047
5048                return (Vec::new(), None);
5049            }
5050
5051            if let Err(e) = cache.index_venue_order_id(&client_order_id, &report.venue_order_id) {
5052                log::warn!("Failed to index venue order ID: {e}");
5053            }
5054        }
5055
5056        Self::publish_order_event(&initialized);
5057
5058        log::info!(
5059            color = LogColor::Blue as u8;
5060            "Created external order {} ({}) for {} [{}]",
5061            client_order_id,
5062            report.venue_order_id,
5063            report.instrument_id,
5064            report.order_status,
5065        );
5066
5067        let ts_now = self.clock.borrow().timestamp_ns();
5068        let mut order_events = generate_external_order_status_events_with_commission(
5069            &order,
5070            report,
5071            &account_id,
5072            instrument,
5073            ts_now,
5074            inferred_commission,
5075        );
5076
5077        if defer_terminal && requires_authoritative_fills {
5078            order_events.retain(|event| matches!(event, OrderEventAny::Accepted(_)));
5079        }
5080
5081        if replace_inferred_fill {
5082            let terminal_event = order_events.pop_if(|event| {
5083                matches!(
5084                    event,
5085                    OrderEventAny::Canceled(_) | OrderEventAny::Expired(_),
5086                )
5087            });
5088
5089            order_events.pop_if(|event| matches!(event, OrderEventAny::Filled(_)));
5090
5091            let fill_queue =
5092                fill_queue.expect("fill queue availability was checked before cache mutation");
5093            for (fill_event, fill_key) in prepared_fills {
5094                fill_queue.push(&mut order_events, fill_event, fill_key);
5095            }
5096
5097            if !defer_terminal
5098                && let Some(inferred_qty) = inferred_qty
5099                && let Some(inferred_fill) = create_inferred_fill_for_qty(
5100                    &order,
5101                    report,
5102                    &account_id,
5103                    instrument,
5104                    inferred_qty,
5105                    ts_now,
5106                    inferred_commission,
5107                )
5108            {
5109                order_events.push(inferred_fill);
5110            }
5111
5112            if !defer_terminal && let Some(event) = terminal_event {
5113                order_events.push(event);
5114            }
5115        }
5116
5117        let metadata = ExternalOrderMetadata {
5118            client_order_id,
5119            venue_order_id: report.venue_order_id,
5120            instrument_id: report.instrument_id,
5121            strategy_id,
5122            ts_init: ts_now,
5123        };
5124
5125        (order_events, Some(metadata))
5126    }
5127
5128    fn publish_order_event(event: &OrderEventAny) {
5129        let topic = switchboard::get_event_order_topic(event.strategy_id());
5130        msgbus::publish_order_event(topic, event);
5131    }
5132
5133    /// Adjusts fills for instruments with incomplete first lifecycle (partial window).
5134    ///
5135    /// When historical fills don't fully explain the current position (e.g., lookback window
5136    /// started mid-position), this creates synthetic fills to align with the venue position.
5137    fn adjust_mass_status_fills(&self, mass_status: &ExecutionMassStatus) -> AdjustedReports {
5138        let mut final_orders: IndexMap<VenueOrderId, OrderStatusReport> =
5139            mass_status.order_reports();
5140        let mut final_fills: IndexMap<VenueOrderId, Vec<FillReport>> = mass_status.fill_reports();
5141        let mut order_only_ids = IndexSet::new();
5142        let mut order_only_fill_keys = IndexSet::new();
5143
5144        final_fills.retain(|_, fills| {
5145            fills.retain(|fill| {
5146                if fill.last_qty.is_zero() {
5147                    log::warn!("Skipping zero-quantity fill report: {fill}");
5148                    return false;
5149                }
5150
5151                true
5152            });
5153
5154            !fills.is_empty()
5155        });
5156
5157        if self.config.filter_position_reports {
5158            return AdjustedReports {
5159                orders: final_orders,
5160                fills: final_fills,
5161                order_only_ids,
5162                order_only_fill_keys,
5163            };
5164        }
5165
5166        let mut instruments_to_adjust = Vec::new();
5167
5168        for (instrument_id, position_reports) in mass_status.position_reports() {
5169            if !self.should_reconcile_instrument(&instrument_id) {
5170                log::debug!(
5171                    "Skipping fill adjustment for {instrument_id}: not in reconciliation_instrument_ids"
5172                );
5173                continue;
5174            }
5175
5176            // Skip hedge mode instruments (have venue_position_id) as partial-window
5177            // adjustment assumes a single net position per instrument
5178            let is_hedge_mode = position_reports
5179                .iter()
5180                .any(|r| r.venue_position_id.is_some());
5181
5182            if is_hedge_mode {
5183                log::debug!(
5184                    "Skipping fill adjustment for {instrument_id}: hedge mode (has venue_position_id)"
5185                );
5186                continue;
5187            }
5188
5189            let has_retained_position = {
5190                let cache = self.cache.borrow();
5191                !cache
5192                    .positions_open(
5193                        None,
5194                        Some(&instrument_id),
5195                        None,
5196                        Some(&mass_status.account_id),
5197                        None,
5198                    )
5199                    .is_empty()
5200            };
5201
5202            if has_retained_position {
5203                log::debug!(
5204                    "Skipping fill adjustment for {instrument_id}: retained open position in cache"
5205                );
5206                continue;
5207            }
5208
5209            if let Some(instrument) = self.get_instrument(&instrument_id) {
5210                instruments_to_adjust.push(instrument);
5211            } else {
5212                log::debug!(
5213                    "Skipping fill adjustment for {instrument_id}: instrument not found in cache"
5214                );
5215            }
5216        }
5217
5218        if instruments_to_adjust.is_empty() {
5219            return AdjustedReports {
5220                orders: final_orders,
5221                fills: final_fills,
5222                order_only_ids,
5223                order_only_fill_keys,
5224            };
5225        }
5226
5227        log_info!(
5228            "Adjusting fills for {} instrument(s) with position reports",
5229            instruments_to_adjust.len(),
5230            color = LogColor::Blue
5231        );
5232
5233        for instrument in &instruments_to_adjust {
5234            let instrument_id = instrument.id();
5235            let result = if self.config.generate_missing_orders {
5236                process_mass_status_for_reconciliation(mass_status, instrument, None)
5237            } else {
5238                process_mass_status_for_reconciliation_without_synthetic_reports(
5239                    mass_status,
5240                    instrument,
5241                    None,
5242                )
5243            };
5244
5245            match result {
5246                Ok(result) => {
5247                    order_only_ids.extend(result.order_only_ids);
5248                    order_only_fill_keys.extend(result.order_only_fill_keys);
5249                    final_orders.retain(|_, order| order.instrument_id != instrument_id);
5250                    final_fills.retain(|_, fills| {
5251                        fills
5252                            .first()
5253                            .is_none_or(|f| f.instrument_id != instrument_id)
5254                    });
5255
5256                    final_orders.extend(result.orders);
5257                    final_fills.extend(result.fills);
5258                }
5259                Err(e) => {
5260                    log::warn!("Failed to adjust fills for {instrument_id}: {e}");
5261                }
5262            }
5263        }
5264
5265        log_info!(
5266            "After adjustment: {} order(s), {} fill group(s)",
5267            final_orders.len(),
5268            final_fills.len(),
5269            color = LogColor::Blue
5270        );
5271
5272        AdjustedReports {
5273            orders: final_orders,
5274            fills: final_fills,
5275            order_only_ids,
5276            order_only_fill_keys,
5277        }
5278    }
5279
5280    fn applied_fill_key(&self, fill: &OrderFilled) -> Option<FillKey> {
5281        if fill.last_qty.is_zero() {
5282            return None;
5283        }
5284
5285        let cache = self.cache();
5286        let order = cache.order(&fill.client_order_id).or_else(|| {
5287            cache
5288                .client_order_id(&fill.venue_order_id)
5289                .and_then(|client_order_id| cache.order(client_order_id))
5290        })?;
5291
5292        order.trade_ids().contains(&&fill.trade_id).then_some((
5293            order.account_id()?,
5294            order.instrument_id(),
5295            fill.trade_id,
5296        ))
5297    }
5298
5299    fn create_order_fill(
5300        &self,
5301        order: &OrderAny,
5302        fill: &FillReport,
5303        instrument: &InstrumentAny,
5304        pending_fill_keys: &IndexSet<FillKey>,
5305    ) -> Option<(OrderFilled, FillKey)> {
5306        if order.is_fill_report_order() && fill.instrument_id != order.instrument_id() {
5307            log::warn!(
5308                "Skipping fill report with mismatched instrument for {}",
5309                order.client_order_id()
5310            );
5311            return None;
5312        }
5313
5314        if fill.last_qty.is_zero() {
5315            log::warn!("Skipping zero-quantity fill report: {fill}");
5316            return None;
5317        }
5318
5319        let fill_key = (fill.account_id, fill.instrument_id, fill.trade_id);
5320        if self.fills_processed.contains_key(&fill_key) || pending_fill_keys.contains(&fill_key) {
5321            return None;
5322        }
5323
5324        let order_side = order.order_side();
5325        if fill.order_side != order_side {
5326            log::warn!(
5327                "Fill side mismatch for {}: cached={:?}, venue={:?}",
5328                order.client_order_id(),
5329                order_side,
5330                fill.order_side,
5331            );
5332        }
5333
5334        let ts_now = self.clock.borrow().timestamp_ns();
5335
5336        let event = OrderFilled::new(
5337            order.trader_id(),
5338            order.strategy_id(),
5339            order.instrument_id(),
5340            order.client_order_id(),
5341            fill.venue_order_id,
5342            fill.account_id,
5343            fill.trade_id,
5344            fill.order_side,
5345            order.order_type(),
5346            fill.last_qty,
5347            fill.last_px,
5348            instrument.quote_currency(),
5349            fill.liquidity_side,
5350            fill.report_id,
5351            fill.ts_event,
5352            ts_now,
5353            true, // reconciliation
5354            fill.venue_position_id,
5355            Some(fill.commission),
5356            None,
5357        );
5358
5359        Some((event, fill_key))
5360    }
5361}
5362
5363fn position_fill_report_matches(
5364    cache: &Cache,
5365    report: &FillReport,
5366    positions: &[PositionRef<'_>],
5367    mut flip_for_order: impl FnMut(ClientOrderId) -> anyhow::Result<Option<[PositionId; 2]>>,
5368    mut replay: Option<&mut IndexMap<PositionId, IndexMap<TradeId, Vec<usize>>>>,
5369) -> bool {
5370    let client_order_id = report
5371        .client_order_id
5372        .or_else(|| cache.client_order_id(&report.venue_order_id).copied());
5373
5374    let flip = match client_order_id.map(&mut flip_for_order).transpose() {
5375        Ok(flip) => flip.flatten(),
5376        Err(_) => return false,
5377    };
5378
5379    if let (Some(ids), Some(id)) = (flip, report.venue_position_id)
5380        && !ids.contains(&id)
5381    {
5382        return false;
5383    }
5384
5385    let mut matched = false;
5386    let mut quantity = Quantity::zero(report.last_qty.precision);
5387    let mut commission = Money::zero(report.commission.currency);
5388
5389    for position in positions {
5390        if flip.map_or_else(
5391            || report.venue_position_id.is_some_and(|id| position.id != id),
5392            |ids| !ids.contains(&position.id),
5393        ) {
5394            continue;
5395        }
5396
5397        let totals = if let Some(replay) = replay.as_deref_mut() {
5398            let indexes = replay
5399                .entry(position.id)
5400                .or_insert_with(|| position_fill_report_indexes(position))
5401                .get(&report.trade_id);
5402            position_fill_report_totals(
5403                position,
5404                report,
5405                client_order_id,
5406                flip.is_some(),
5407                indexes
5408                    .into_iter()
5409                    .flatten()
5410                    .map(|&index| &position.replay_events[index]),
5411            )
5412        } else {
5413            position_fill_report_totals(
5414                position,
5415                report,
5416                client_order_id,
5417                flip.is_some(),
5418                position.replay_events.iter(),
5419            )
5420        };
5421
5422        let Some((position_quantity, position_commission)) = totals else {
5423            return false;
5424        };
5425
5426        let Some(next_quantity) = quantity.checked_add(position_quantity) else {
5427            return false;
5428        };
5429
5430        let Some(next_commission) = commission.checked_add(position_commission) else {
5431            return false;
5432        };
5433
5434        matched |= position_quantity.non_zero();
5435        quantity = next_quantity;
5436        commission = next_commission;
5437    }
5438
5439    matched && quantity == report.last_qty && commission == report.commission
5440}
5441
5442fn position_fill_report_indexes(position: &Position) -> IndexMap<TradeId, Vec<usize>> {
5443    let mut replay = IndexMap::<_, Vec<usize>>::new();
5444
5445    for (index, event) in position.replay_events.iter().enumerate() {
5446        if let PositionReplayEvent::Filled(fill) = event {
5447            replay.entry(fill.trade_id).or_default().push(index);
5448        }
5449    }
5450
5451    replay
5452}
5453
5454fn position_fill_report_totals<'a>(
5455    position: &Position,
5456    report: &FillReport,
5457    client_order_id: Option<ClientOrderId>,
5458    apply_voids: bool,
5459    replay: impl Iterator<Item = &'a PositionReplayEvent>,
5460) -> Option<(Quantity, Money)> {
5461    let mut fills = replay.filter_map(|event| match event {
5462        PositionReplayEvent::Filled(fill)
5463            if fill.position_id == Some(position.id)
5464                && fill.account_id == report.account_id
5465                && fill.instrument_id == report.instrument_id
5466                && fill.venue_order_id == report.venue_order_id
5467                && fill.trade_id == report.trade_id
5468                && fill.order_side == report.order_side
5469                && fill.last_px == report.last_px
5470                && fill.liquidity_side == report.liquidity_side
5471                && client_order_id.is_none_or(|id| fill.client_order_id == id) =>
5472        {
5473            Some(fill)
5474        }
5475        _ => None,
5476    });
5477
5478    let (mut position_quantity, mut position_commission) = fills.try_fold(
5479        (
5480            Quantity::zero(report.last_qty.precision),
5481            Money::zero(report.commission.currency),
5482        ),
5483        |(quantity, commission), fill| {
5484            let fill_commission = fill.commission?;
5485            if fill_commission.currency != report.commission.currency {
5486                return None;
5487            }
5488
5489            Some((
5490                quantity.checked_add(fill.last_qty)?,
5491                commission.checked_add(fill_commission)?,
5492            ))
5493        },
5494    )?;
5495
5496    if apply_voids
5497        && let Some(correction) = position.fill_voids.iter().rev().find(|correction| {
5498            correction.event.trade_id == report.trade_id
5499                && correction.event.venue_order_id == report.venue_order_id
5500                && client_order_id.is_none_or(|id| correction.event.client_order_id == id)
5501        })
5502    {
5503        let corrected_quantity = position_quantity.checked_sub(correction.voided_qty)?;
5504        let corrected_commission = position_commission.checked_sub(
5505            correction
5506                .commission_voided
5507                .unwrap_or(Money::zero(report.commission.currency)),
5508        )?;
5509        position_quantity = corrected_quantity;
5510        position_commission = corrected_commission;
5511    }
5512
5513    Some((position_quantity, position_commission))
5514}
5515
5516#[cfg(test)]
5517mod tests {
5518    use nautilus_common::{clock::VirtualClock, config::ConfigError};
5519    use nautilus_core::{DurationNanos, Params};
5520    use nautilus_execution::reconciliation::generate_reconciliation_order_events;
5521    use nautilus_model::{
5522        accounts::AccountAny,
5523        enums::{LiquiditySide, OmsType, OrderType, PositionSide, TimeInForce},
5524        events::order::spec::{
5525            OrderAcceptedSpec, OrderCancelDeniedSpec, OrderInitializedSpec, OrderModifyDeniedSpec,
5526            OrderPendingCancelSpec, OrderPendingUpdateSpec, OrderUpdatedSpec,
5527        },
5528        identifiers::{Symbol, Venue},
5529        instruments::{
5530            CurrencyPair, Instrument,
5531            stubs::{btcusd_bybit, crypto_perpetual_ethusdt},
5532        },
5533        orders::{FILL_REPORT_ORDER_TAG, OrderTestBuilder, stubs::TestOrderEventStubs},
5534        types::{AccountBalance, Currency, MarginBalance, Money, Price, fixed::FIXED_PRECISION},
5535    };
5536    use rstest::rstest;
5537    use rust_decimal_macros::dec;
5538
5539    use super::{
5540        super::reconciliation::tests::{CommissionOutcome, CommissionStubClient},
5541        *,
5542    };
5543
5544    #[rstest]
5545    fn test_create_fill_report_order_fill_rejects_source_instrument_mismatch() {
5546        let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
5547        let (_, mut fill) = external_report_with_partial_fill(&instrument);
5548        let init = OrderInitializedSpec::builder()
5549            .instrument_id(instrument.id())
5550            .quantity(fill.last_qty)
5551            .reconciliation(true)
5552            .tags(vec![Ustr::from(FILL_REPORT_ORDER_TAG)])
5553            .build();
5554        let mut order = OrderAny::try_from(init).unwrap();
5555        order
5556            .apply(OrderEventAny::Accepted(
5557                OrderAcceptedSpec::builder()
5558                    .account_id(fill.account_id)
5559                    .venue_order_id(fill.venue_order_id)
5560                    .build(),
5561            ))
5562            .unwrap();
5563        let manager = ExecutionManager::new(
5564            Rc::new(RefCell::new(VirtualClock::new())),
5565            Rc::new(RefCell::new(Cache::default())),
5566            ExecutionManagerConfig::default(),
5567        )
5568        .unwrap();
5569        manager
5570            .create_order_fill(&order, &fill, &instrument, &IndexSet::new())
5571            .expect("matching source instrument produces a fill");
5572        fill.instrument_id = btcusd_bybit().id();
5573
5574        let result = manager.create_order_fill(&order, &fill, &instrument, &IndexSet::new());
5575
5576        assert_eq!(result, None);
5577    }
5578
5579    #[rstest]
5580    fn test_new_validates_open_check_lookback_mins_boundaries() {
5581        let create_manager = |mins| {
5582            ExecutionManager::new(
5583                Rc::new(RefCell::new(VirtualClock::new())),
5584                Rc::new(RefCell::new(Cache::default())),
5585                ExecutionManagerConfig {
5586                    open_check_lookback_mins: Some(mins),
5587                    ..Default::default()
5588                },
5589            )
5590        };
5591
5592        assert!(create_manager(307_445_734).is_ok());
5593        assert!(matches!(
5594            create_manager(307_445_735),
5595            Err(ConfigError::Range { field, .. })
5596                if field == "ExecutionManagerConfig.open_check_lookback_mins"
5597        ));
5598    }
5599
5600    #[rstest]
5601    fn test_new_validates_reconciliation_lookback_mins_boundaries() {
5602        let create_manager = |mins| {
5603            ExecutionManager::new(
5604                Rc::new(RefCell::new(VirtualClock::new())),
5605                Rc::new(RefCell::new(Cache::default())),
5606                ExecutionManagerConfig {
5607                    lookback_mins: Some(mins),
5608                    ..Default::default()
5609                },
5610            )
5611        };
5612
5613        assert!(create_manager(307_445_734_561_825_860).is_ok());
5614        assert!(matches!(
5615            create_manager(307_445_734_561_825_861),
5616            Err(ConfigError::Range { field, .. })
5617                if field == "ExecutionManagerConfig.lookback_mins"
5618        ));
5619    }
5620
5621    #[rstest]
5622    fn test_new_reports_every_invalid_lookback_field() {
5623        let error = ExecutionManager::new(
5624            Rc::new(RefCell::new(VirtualClock::new())),
5625            Rc::new(RefCell::new(Cache::default())),
5626            ExecutionManagerConfig {
5627                lookback_mins: Some(307_445_734_561_825_861),
5628                open_check_lookback_mins: Some(307_445_735),
5629                position_check_lookback_mins: 307_445_735,
5630                ..Default::default()
5631            },
5632        )
5633        .expect_err("all lookback fields are out of range");
5634
5635        let ConfigError::Multiple { errors } = error else {
5636            panic!("expected a `Multiple` error, was {error:?}");
5637        };
5638
5639        let fields = errors
5640            .iter()
5641            .map(|e| match e {
5642                ConfigError::Range { field, .. } => field.as_str(),
5643                other => panic!("expected a `Range` error, was {other:?}"),
5644            })
5645            .collect::<Vec<_>>();
5646
5647        assert_eq!(
5648            fields,
5649            [
5650                "ExecutionManagerConfig.lookback_mins",
5651                "ExecutionManagerConfig.open_check_lookback_mins",
5652                "ExecutionManagerConfig.position_check_lookback_mins",
5653            ]
5654        );
5655    }
5656
5657    struct PositionCoverageStubClient;
5658
5659    #[async_trait::async_trait(?Send)]
5660    impl ExecutionClient for PositionCoverageStubClient {
5661        fn is_connected(&self) -> bool {
5662            true
5663        }
5664
5665        fn client_id(&self) -> ClientId {
5666            ClientId::from("BYBIT")
5667        }
5668
5669        fn account_id(&self) -> AccountId {
5670            AccountId::from("TEST-001")
5671        }
5672
5673        fn venue(&self) -> Venue {
5674            Venue::from("BYBIT")
5675        }
5676
5677        fn oms_type(&self) -> OmsType {
5678            OmsType::Netting
5679        }
5680
5681        fn get_account(&self) -> Option<AccountAny> {
5682            None
5683        }
5684
5685        fn provides_bulk_position_coverage(&self, instrument_id: InstrumentId) -> bool {
5686            !instrument_id.symbol.as_str().ends_with("-SPOT")
5687        }
5688
5689        fn generate_account_state(
5690            &self,
5691            _balances: Vec<AccountBalance>,
5692            _margins: Vec<MarginBalance>,
5693            _reported: bool,
5694            _ts_event: UnixNanos,
5695            _info: Option<Params>,
5696        ) -> anyhow::Result<()> {
5697            Ok(())
5698        }
5699
5700        fn start(&mut self) -> anyhow::Result<()> {
5701            Ok(())
5702        }
5703
5704        fn stop(&mut self) -> anyhow::Result<()> {
5705            Ok(())
5706        }
5707    }
5708
5709    fn cached_commission_fixtures() -> (
5710        ExecutionManager,
5711        Rc<RefCell<Cache>>,
5712        OrderAny,
5713        OrderStatusReport,
5714        InstrumentAny,
5715    ) {
5716        let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
5717        let clock = Rc::new(RefCell::new(VirtualClock::new()));
5718        let cache = Rc::new(RefCell::new(Cache::default()));
5719        cache
5720            .borrow_mut()
5721            .add_instrument(instrument.clone())
5722            .expect("instrument is cacheable");
5723        let client_order_id = ClientOrderId::from("O-COMMISSION-CACHED");
5724        let venue_order_id = VenueOrderId::from("V-COMMISSION-CACHED");
5725        insert_accepted_limit_order(
5726            &cache,
5727            client_order_id,
5728            venue_order_id,
5729            instrument.id(),
5730            ClientId::from("STUB"),
5731        );
5732        let order = cache
5733            .borrow()
5734            .order_owned(&client_order_id)
5735            .expect("accepted order is cached");
5736        let report = OrderStatusReport::new(
5737            AccountId::from("TEST-001"),
5738            instrument.id(),
5739            Some(client_order_id),
5740            venue_order_id,
5741            OrderSide::Buy.into(),
5742            OrderType::Limit,
5743            TimeInForce::Gtc,
5744            OrderStatus::Filled,
5745            Quantity::from("10.0"),
5746            Quantity::from("10.0"),
5747            UnixNanos::from(1),
5748            UnixNanos::from(1),
5749            UnixNanos::from(1),
5750            None,
5751        )
5752        .with_avg_px(dec!(100.0));
5753        let manager =
5754            ExecutionManager::new(clock, cache.clone(), ExecutionManagerConfig::default())
5755                .expect("valid config");
5756
5757        (manager, cache, order, report, instrument)
5758    }
5759
5760    fn external_report_with_partial_fill(
5761        instrument: &InstrumentAny,
5762    ) -> (OrderStatusReport, FillReport) {
5763        let account_id = AccountId::from("STUB-001");
5764        let venue_order_id = VenueOrderId::from("V-EXT-1");
5765        let report = OrderStatusReport::new(
5766            account_id,
5767            instrument.id(),
5768            None,
5769            venue_order_id,
5770            OrderSide::Buy.into(),
5771            OrderType::Limit,
5772            TimeInForce::Gtc,
5773            OrderStatus::Filled,
5774            Quantity::from("10.0"),
5775            Quantity::from("10.0"),
5776            UnixNanos::from(1),
5777            UnixNanos::from(1),
5778            UnixNanos::from(1),
5779            None,
5780        )
5781        .with_price(Price::from("100.00"))
5782        .with_avg_px(dec!(100.0));
5783
5784        let fill = FillReport::new(
5785            account_id,
5786            instrument.id(),
5787            venue_order_id,
5788            TradeId::from("T-EXT-1"),
5789            OrderSide::Buy,
5790            Quantity::from("4.0"),
5791            Price::from("100.00"),
5792            Money::new(0.1, Currency::USDT()),
5793            LiquiditySide::Taker,
5794            None,
5795            None,
5796            UnixNanos::from(1),
5797            UnixNanos::from(1),
5798            None,
5799        );
5800
5801        (report, fill)
5802    }
5803
5804    fn inferred_fills(events: &[OrderEventAny]) -> Vec<OrderFilled> {
5805        events
5806            .iter()
5807            .filter_map(|event| match event {
5808                OrderEventAny::Filled(filled) if filled.last_qty == Quantity::from("6.0") => {
5809                    Some(filled.clone())
5810                }
5811                _ => None,
5812            })
5813            .collect()
5814    }
5815
5816    #[rstest]
5817    fn test_handle_external_order_applies_venue_commission_to_inferred_fill() {
5818        let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
5819        let clock = Rc::new(RefCell::new(VirtualClock::new()));
5820        let cache = Rc::new(RefCell::new(Cache::default()));
5821        cache
5822            .borrow_mut()
5823            .add_instrument(instrument.clone())
5824            .expect("instrument is cacheable");
5825        let manager = ExecutionManager::new(clock, cache, ExecutionManagerConfig::default())
5826            .expect("valid config");
5827        let (report, fill) = external_report_with_partial_fill(&instrument);
5828        let expected = Money::new(2.5, Currency::USDT());
5829        let client = CommissionStubClient::new(CommissionOutcome::Value(expected));
5830        let mut fill_queue = ReconciliationFillQueue::default();
5831
5832        let (events, _) = manager.handle_external_order(
5833            &report,
5834            AccountId::from("STUB-001"),
5835            &instrument,
5836            &[&fill],
5837            false,
5838            Some(&mut fill_queue),
5839            Some(&client),
5840        );
5841
5842        let inferred = inferred_fills(&events);
5843        assert_eq!(inferred.len(), 1, "one inferred fill covers the 6.0 gap");
5844        assert_eq!(inferred[0].commission, Some(expected));
5845    }
5846
5847    #[rstest]
5848    fn test_submitted_order_accepts_status_without_authoritative_fills(
5849        #[values(false, true)] is_snapshot: bool,
5850    ) {
5851        let (mut manager, _cache, order, report, instrument) = cached_commission_fixtures();
5852        let mut submitted =
5853            OrderAny::from_events(order.events().into_iter().take(2).cloned().collect()).unwrap();
5854        assert_eq!(submitted.status(), OrderStatus::Submitted);
5855        let mut client = CommissionStubClient::new(CommissionOutcome::Failure);
5856        client.requires_authoritative_fills = true;
5857        let mut queue = ReconciliationFillQueue::default();
5858
5859        let events = manager.reconcile_order_with_fills(
5860            is_snapshot,
5861            &submitted,
5862            &report,
5863            &[],
5864            Some(&instrument),
5865            &mut queue,
5866            Some(&client),
5867        );
5868
5869        assert_eq!(events.len(), 1);
5870        assert!(matches!(events[0], OrderEventAny::Accepted(_)));
5871        submitted.apply(events[0].clone()).unwrap();
5872        assert_eq!(submitted.status(), OrderStatus::Accepted);
5873        assert_eq!(submitted.quantity(), report.quantity);
5874        assert_eq!(submitted.filled_qty(), Quantity::from("0.0"));
5875        assert_eq!(submitted.venue_order_id(), Some(report.venue_order_id));
5876        assert!(submitted.trade_ids().is_empty());
5877        assert!(submitted.commissions().is_empty());
5878        assert_eq!(client.seen(), None);
5879    }
5880
5881    #[rstest]
5882    fn test_external_order_defers_missing_authoritative_fills(
5883        #[values(0, 4, 10)] recovered_qty: u32,
5884        #[values(
5885            OrderStatus::PartiallyFilled,
5886            OrderStatus::Filled,
5887            OrderStatus::Canceled
5888        )]
5889        status: OrderStatus,
5890    ) {
5891        let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
5892        let cache = Rc::new(RefCell::new(Cache::default()));
5893        cache
5894            .borrow_mut()
5895            .add_instrument(instrument.clone())
5896            .unwrap();
5897        let manager = ExecutionManager::new(
5898            Rc::new(RefCell::new(VirtualClock::new())),
5899            Rc::clone(&cache),
5900            ExecutionManagerConfig::default(),
5901        )
5902        .unwrap();
5903        let (mut report, mut fill) = external_report_with_partial_fill(&instrument);
5904        report.order_status = status;
5905        if status != OrderStatus::Filled {
5906            report.quantity = Quantity::from("20.0");
5907        }
5908
5909        fill.last_qty = Quantity::from_decimal_dp(Decimal::from(recovered_qty), 1).unwrap();
5910
5911        let reports = if recovered_qty == 0 {
5912            vec![]
5913        } else {
5914            vec![&fill]
5915        };
5916
5917        let mut client =
5918            CommissionStubClient::new(CommissionOutcome::Value(Money::from("2.5 USDT")));
5919        client.requires_authoritative_fills = true;
5920        let mut queue = ReconciliationFillQueue::default();
5921        let (events, metadata) = manager.handle_external_order(
5922            &report,
5923            report.account_id,
5924            &instrument,
5925            &reports,
5926            false,
5927            Some(&mut queue),
5928            Some(&client),
5929        );
5930
5931        let fills = events
5932            .iter()
5933            .filter_map(|event| {
5934                if let OrderEventAny::Filled(fill) = event {
5935                    Some(fill)
5936                } else {
5937                    None
5938                }
5939            })
5940            .collect::<Vec<_>>();
5941
5942        assert_eq!(client.seen(), None);
5943
5944        assert_eq!(fills.len(), usize::from(recovered_qty != 0));
5945
5946        if recovered_qty != 0 {
5947            assert_eq!(fills[0].trade_id, fill.trade_id);
5948            assert_eq!(fills[0].last_qty, fill.last_qty);
5949            assert_eq!(fills[0].last_px, fill.last_px);
5950            assert_eq!(fills[0].commission, Some(fill.commission));
5951        }
5952
5953        let metadata = metadata.unwrap();
5954        assert_eq!(metadata.venue_order_id, report.venue_order_id);
5955        assert_eq!(events[0].client_order_id(), metadata.client_order_id);
5956        assert!(matches!(events[0], OrderEventAny::Accepted(_)));
5957
5958        for event in &events {
5959            cache.borrow_mut().update_order(event).unwrap();
5960        }
5961
5962        let cache = cache.borrow();
5963        let order = cache.order(&metadata.client_order_id).unwrap();
5964        assert_eq!(order.quantity(), report.quantity);
5965        assert_eq!(order.filled_qty(), fill.last_qty);
5966        assert_eq!(order.order_side(), report.order_side.unwrap());
5967        assert_eq!(order.order_type(), report.order_type);
5968        assert_eq!(order.price(), report.price);
5969        assert_eq!(order.venue_order_id(), Some(report.venue_order_id));
5970        assert_eq!(order.account_id(), Some(report.account_id));
5971        assert_eq!(
5972            order.status(),
5973            if recovered_qty == 0 {
5974                OrderStatus::Accepted
5975            } else if recovered_qty == 10 {
5976                status
5977            } else {
5978                OrderStatus::PartiallyFilled
5979            },
5980        );
5981        assert_eq!(
5982            order.commissions().get(&fill.commission.currency),
5983            if recovered_qty == 0 {
5984                None
5985            } else {
5986                Some(&fill.commission)
5987            },
5988        );
5989        assert_eq!(
5990            order.trade_ids(),
5991            if recovered_qty == 0 {
5992                vec![]
5993            } else {
5994                vec![&fill.trade_id]
5995            },
5996        );
5997    }
5998
5999    #[rstest]
6000    fn test_handle_external_order_skips_inferred_fill_when_commission_fails() {
6001        let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
6002        let clock = Rc::new(RefCell::new(VirtualClock::new()));
6003        let cache = Rc::new(RefCell::new(Cache::default()));
6004        cache
6005            .borrow_mut()
6006            .add_instrument(instrument.clone())
6007            .expect("instrument is cacheable");
6008        let manager =
6009            ExecutionManager::new(clock, cache.clone(), ExecutionManagerConfig::default())
6010                .expect("valid config");
6011        let (report, fill) = external_report_with_partial_fill(&instrument);
6012        let client = CommissionStubClient::new(CommissionOutcome::Failure);
6013        let mut fill_queue = ReconciliationFillQueue::default();
6014
6015        let (events, metadata) = manager.handle_external_order(
6016            &report,
6017            AccountId::from("STUB-001"),
6018            &instrument,
6019            &[&fill],
6020            false,
6021            Some(&mut fill_queue),
6022            Some(&client),
6023        );
6024
6025        assert!(events.is_empty());
6026        assert!(metadata.is_none());
6027        assert!(fill_queue.pending_fill_keys.is_empty());
6028        assert!(
6029            cache
6030                .borrow()
6031                .order(&ClientOrderId::from(report.venue_order_id.as_str()))
6032                .is_none(),
6033            "commission failure must precede external order cache mutation"
6034        );
6035
6036        let expected = Money::new(2.5, Currency::USDT());
6037        let retry_client = CommissionStubClient::new(CommissionOutcome::Value(expected));
6038        let (retry_events, retry_metadata) = manager.handle_external_order(
6039            &report,
6040            AccountId::from("STUB-001"),
6041            &instrument,
6042            &[&fill],
6043            false,
6044            Some(&mut fill_queue),
6045            Some(&retry_client),
6046        );
6047        let inferred = inferred_fills(&retry_events);
6048
6049        assert!(retry_metadata.is_some());
6050        assert_eq!(inferred.len(), 1);
6051        assert_eq!(inferred[0].commission, Some(expected));
6052        assert_eq!(fill_queue.pending_fill_keys.len(), 1);
6053        assert!(
6054            cache
6055                .borrow()
6056                .order(&ClientOrderId::from(report.venue_order_id.as_str()))
6057                .is_some()
6058        );
6059    }
6060
6061    #[rstest]
6062    fn test_handle_external_order_without_explicit_fills_resolves_commission_before_cache() {
6063        let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
6064        let clock = Rc::new(RefCell::new(VirtualClock::new()));
6065        let cache = Rc::new(RefCell::new(Cache::default()));
6066        cache
6067            .borrow_mut()
6068            .add_instrument(instrument.clone())
6069            .expect("instrument is cacheable");
6070        let manager =
6071            ExecutionManager::new(clock, cache.clone(), ExecutionManagerConfig::default())
6072                .expect("valid config");
6073        let (report, _) = external_report_with_partial_fill(&instrument);
6074        let failing_client = CommissionStubClient::new(CommissionOutcome::Failure);
6075
6076        let (failed_events, failed_metadata) = manager.handle_external_order(
6077            &report,
6078            AccountId::from("STUB-001"),
6079            &instrument,
6080            &[],
6081            false,
6082            None,
6083            Some(&failing_client),
6084        );
6085
6086        assert!(failed_events.is_empty());
6087        assert!(failed_metadata.is_none());
6088        assert!(
6089            cache
6090                .borrow()
6091                .order(&ClientOrderId::from(report.venue_order_id.as_str()))
6092                .is_none()
6093        );
6094
6095        let expected = Money::new(4.0, Currency::USDT());
6096        let retry_client = CommissionStubClient::new(CommissionOutcome::Value(expected));
6097        let (retry_events, retry_metadata) = manager.handle_external_order(
6098            &report,
6099            AccountId::from("STUB-001"),
6100            &instrument,
6101            &[],
6102            false,
6103            None,
6104            Some(&retry_client),
6105        );
6106
6107        let fills: Vec<_> = retry_events
6108            .iter()
6109            .filter_map(|event| match event {
6110                OrderEventAny::Filled(fill) => Some(fill),
6111                _ => None,
6112            })
6113            .collect();
6114
6115        assert!(retry_metadata.is_some());
6116        assert_eq!(fills.len(), 1);
6117        assert_eq!(fills[0].last_qty, Quantity::from("10.0"));
6118        assert_eq!(fills[0].commission, Some(expected));
6119    }
6120
6121    #[rstest]
6122    fn test_handle_external_order_with_no_override_emits_fill_without_commission() {
6123        let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
6124        let clock = Rc::new(RefCell::new(VirtualClock::new()));
6125        let cache = Rc::new(RefCell::new(Cache::default()));
6126        cache
6127            .borrow_mut()
6128            .add_instrument(instrument.clone())
6129            .expect("instrument is cacheable");
6130        let manager = ExecutionManager::new(clock, cache, ExecutionManagerConfig::default())
6131            .expect("valid config");
6132        let (report, fill) = external_report_with_partial_fill(&instrument);
6133        let client = CommissionStubClient::new(CommissionOutcome::NoOverride);
6134        let mut fill_queue = ReconciliationFillQueue::default();
6135
6136        let (events, _) = manager.handle_external_order(
6137            &report,
6138            AccountId::from("STUB-001"),
6139            &instrument,
6140            &[&fill],
6141            false,
6142            Some(&mut fill_queue),
6143            Some(&client),
6144        );
6145
6146        let inferred = inferred_fills(&events);
6147        assert_eq!(inferred.len(), 1);
6148        assert_eq!(inferred[0].commission, None);
6149    }
6150
6151    #[rstest]
6152    #[case::filled(
6153        OrderStatus::Filled,
6154        "10.0",
6155        "6.0",
6156        Price::from_decimal_dp(dec!(33.3333333333333333), FIXED_PRECISION).unwrap(),
6157        1
6158    )]
6159    #[case::canceled(OrderStatus::Canceled, "8.0", "4.0", "20.00", 2)]
6160    #[case::expired(OrderStatus::Expired, "8.0", "4.0", "20.00", 2)]
6161    fn test_cached_reconciliation_applies_explicit_fill_and_defers_failed_residual(
6162        #[case] status: OrderStatus,
6163        #[case] filled_qty: Quantity,
6164        #[case] residual_qty: Quantity,
6165        #[case] residual_px: Price,
6166        #[case] event_count: usize,
6167    ) {
6168        let (mut manager, _cache, order, mut report, instrument) = cached_commission_fixtures();
6169        report.order_status = status;
6170        report.filled_qty = filled_qty;
6171        report.avg_px = Some(dec!(60.0));
6172
6173        let explicit_fill = FillReport::new(
6174            report.account_id,
6175            report.instrument_id,
6176            report.venue_order_id,
6177            TradeId::from("T-COMMISSION-EXPLICIT"),
6178            OrderSide::Buy,
6179            Quantity::from("4.0"),
6180            Price::from("100.0"),
6181            Money::new(0.25, Currency::USDT()),
6182            LiquiditySide::Taker,
6183            report.client_order_id,
6184            None,
6185            UnixNanos::from(1),
6186            UnixNanos::from(1),
6187            None,
6188        );
6189        let failing_client = CommissionStubClient::new(CommissionOutcome::Failure);
6190        let mut fill_queue = ReconciliationFillQueue::default();
6191
6192        let first_events = manager.reconcile_order_with_fills(
6193            true,
6194            &order,
6195            &report,
6196            &[&explicit_fill],
6197            Some(&instrument),
6198            &mut fill_queue,
6199            Some(&failing_client),
6200        );
6201        let mut working = order;
6202        for event in &first_events {
6203            working
6204                .apply(event.clone())
6205                .expect("explicit fill projects cleanly");
6206        }
6207
6208        assert_eq!(first_events.len(), 1);
6209
6210        let OrderEventAny::Filled(explicit) = &first_events[0] else {
6211            panic!("expected the valid explicit fill");
6212        };
6213
6214        assert_eq!(explicit.last_qty, Quantity::from("4.0"));
6215        assert_eq!(
6216            explicit.commission,
6217            Some(Money::new(0.25, Currency::USDT()))
6218        );
6219        assert_eq!(working.status(), OrderStatus::PartiallyFilled);
6220
6221        let expected = Money::new(1.5, Currency::USDT());
6222        let retry_client = CommissionStubClient::new(CommissionOutcome::Value(expected));
6223        let mut reported_residual = explicit_fill.clone();
6224        reported_residual.trade_id = TradeId::from("T-COMMISSION-RESIDUAL");
6225        reported_residual.last_qty = residual_qty;
6226        reported_residual.last_px = residual_px;
6227        reported_residual.commission = expected;
6228
6229        let residual_reports = if status == OrderStatus::Filled {
6230            Vec::new()
6231        } else {
6232            vec![&reported_residual]
6233        };
6234
6235        let retry_events = manager.reconcile_order_with_fills(
6236            true,
6237            &working,
6238            &report,
6239            &residual_reports,
6240            Some(&instrument),
6241            &mut fill_queue,
6242            Some(&retry_client),
6243        );
6244
6245        assert_eq!(retry_events.len(), event_count);
6246
6247        let OrderEventAny::Filled(residual) = &retry_events[0] else {
6248            panic!("expected the residual fill");
6249        };
6250
6251        assert_eq!(residual.last_qty, residual_qty);
6252        assert_eq!(residual.last_px, residual_px);
6253        assert_eq!(residual.commission, Some(expected));
6254        assert_eq!(
6255            retry_client.seen(),
6256            (status == OrderStatus::Filled).then_some((
6257                residual_qty,
6258                residual.last_px,
6259                residual.liquidity_side
6260            )),
6261            "commission must use the exact price and liquidity carried by the residual fill"
6262        );
6263
6264        for event in &retry_events {
6265            working
6266                .apply(event.clone())
6267                .expect("residual precedes terminal status");
6268        }
6269
6270        retry_client.clear_seen();
6271        let replay = manager.reconcile_order_with_fills(
6272            true,
6273            &working,
6274            &report,
6275            &[],
6276            Some(&instrument),
6277            &mut fill_queue,
6278            Some(&retry_client),
6279        );
6280
6281        assert_eq!(working.status(), status);
6282        assert_eq!(working.filled_qty(), filled_qty);
6283        assert_eq!(
6284            working.commissions().get(&Currency::USDT()),
6285            Some(&Money::from("1.75 USDT"))
6286        );
6287        assert!(replay.is_empty());
6288        assert_eq!(retry_client.seen(), None);
6289    }
6290
6291    #[rstest]
6292    fn test_cached_reconciliation_preserves_explicit_fill_side() {
6293        let (mut manager, _cache, order, mut report, instrument) = cached_commission_fixtures();
6294        report.order_status = OrderStatus::PartiallyFilled;
6295        report.filled_qty = Quantity::from("4.0");
6296        let trade_id = TradeId::from("T-CONFLICTING-SIDE");
6297
6298        let explicit_fill = FillReport::new(
6299            report.account_id,
6300            report.instrument_id,
6301            report.venue_order_id,
6302            trade_id,
6303            OrderSide::Sell,
6304            Quantity::from("4.0"),
6305            Price::from("100.0"),
6306            Money::new(0.25, Currency::USDT()),
6307            LiquiditySide::Taker,
6308            report.client_order_id,
6309            None,
6310            UnixNanos::from(1),
6311            UnixNanos::from(1),
6312            None,
6313        );
6314        let mut fill_queue = ReconciliationFillQueue::default();
6315
6316        let events = manager.reconcile_order_with_fills(
6317            true,
6318            &order,
6319            &report,
6320            &[&explicit_fill],
6321            Some(&instrument),
6322            &mut fill_queue,
6323            None,
6324        );
6325
6326        assert_eq!(events.len(), 1);
6327
6328        let OrderEventAny::Filled(fill) = &events[0] else {
6329            panic!("expected the explicit fill");
6330        };
6331
6332        assert_eq!(fill.trade_id, trade_id);
6333        assert_eq!(fill.order_side, OrderSide::Sell);
6334        assert_eq!(fill.last_qty, Quantity::from("4.0"));
6335        assert_eq!(fill.last_px, Price::from("100.0"));
6336    }
6337
6338    #[rstest]
6339    fn test_continuous_report_preserves_newer_fills() {
6340        let (mut manager, _cache, mut order, mut report, instrument) = cached_commission_fixtures();
6341        let fill = TestOrderEventStubs::filled(
6342            &order,
6343            &instrument,
6344            Some(TradeId::from("T-NEWER-STREAM")),
6345            None,
6346            Some(Price::from("100.00")),
6347            Some(Quantity::from("2.0")),
6348            Some(LiquiditySide::Maker),
6349            None,
6350            None,
6351            Some(AccountId::from("TEST-001")),
6352        );
6353        order.apply(fill).unwrap();
6354        report.order_status = OrderStatus::PartiallyFilled;
6355        report.filled_qty = Quantity::from("1.0");
6356        let mut fill_queue = ReconciliationFillQueue::default();
6357
6358        let events = manager.reconcile_order_with_fills(
6359            false,
6360            &order,
6361            &report,
6362            &[],
6363            Some(&instrument),
6364            &mut fill_queue,
6365            None,
6366        );
6367
6368        assert!(events.is_empty());
6369        assert!(fill_queue.pending_fill_keys.is_empty());
6370    }
6371
6372    #[rstest]
6373    #[case::with_fills(true)]
6374    #[case::without_fills(false)]
6375    fn test_cached_snapshot_without_instrument_defers_unaccounted_fills(#[case] has_fills: bool) {
6376        let (mut manager, _cache, order, mut report, _instrument) = cached_commission_fixtures();
6377        report.order_status = OrderStatus::Canceled;
6378
6379        let explicit_fill = FillReport::new(
6380            report.account_id,
6381            report.instrument_id,
6382            report.venue_order_id,
6383            TradeId::from("T-MISSING-INSTRUMENT"),
6384            OrderSide::Buy,
6385            Quantity::from("4.0"),
6386            Price::from("100.0"),
6387            Money::new(0.25, Currency::USDT()),
6388            LiquiditySide::Taker,
6389            report.client_order_id,
6390            None,
6391            UnixNanos::from(1),
6392            UnixNanos::from(1),
6393            None,
6394        );
6395        let mut fill_queue = ReconciliationFillQueue::default();
6396
6397        let fills = if has_fills {
6398            vec![&explicit_fill]
6399        } else {
6400            Vec::new()
6401        };
6402
6403        let events = manager.reconcile_order_with_fills(
6404            true,
6405            &order,
6406            &report,
6407            &fills,
6408            None,
6409            &mut fill_queue,
6410            None,
6411        );
6412
6413        assert!(events.is_empty());
6414        assert_eq!(order.status(), OrderStatus::Accepted);
6415        assert_eq!(order.filled_qty(), Quantity::from("0.0"));
6416        assert!(fill_queue.pending_fill_keys.is_empty());
6417    }
6418
6419    #[rstest]
6420    #[case::stale_authoritative(1, true, false)]
6421    #[case::newer_authoritative(3, true, true)]
6422    #[case::stale_other_client(1, false, true)]
6423    fn test_reconcile_order_report_scopes_amendment_freshness(
6424        #[values(false, true)] bundled: bool,
6425        #[case] report_ts: u64,
6426        #[case] requires_authoritative_fills: bool,
6427        #[case] expected_update: bool,
6428    ) {
6429        let (mut manager, _cache, mut order, mut report, instrument) = cached_commission_fixtures();
6430        let amended_price = Price::from("101.0");
6431        let updated = OrderUpdatedSpec::builder()
6432            .trader_id(order.trader_id())
6433            .strategy_id(order.strategy_id())
6434            .instrument_id(order.instrument_id())
6435            .client_order_id(order.client_order_id())
6436            .quantity(order.quantity())
6437            .price(amended_price)
6438            .ts_event(UnixNanos::from(2))
6439            .ts_init(UnixNanos::from(2))
6440            .build();
6441        order.apply(OrderEventAny::Updated(updated)).unwrap();
6442        report.order_status = OrderStatus::Accepted;
6443        report.filled_qty = Quantity::from("0.0");
6444        report.price = Some(Price::from("102.0"));
6445        report.ts_last = UnixNanos::from(report_ts);
6446        let mut client = CommissionStubClient::new(CommissionOutcome::Failure);
6447        client.requires_authoritative_fills = requires_authoritative_fills;
6448
6449        let events = if bundled {
6450            let fill = FillReport::new(
6451                report.account_id,
6452                report.instrument_id,
6453                report.venue_order_id,
6454                TradeId::from("T-AMENDMENT"),
6455                OrderSide::Buy,
6456                Quantity::from("4.0"),
6457                Price::from("100.0"),
6458                Money::from("0.25 USDT"),
6459                LiquiditySide::Taker,
6460                report.client_order_id,
6461                None,
6462                UnixNanos::from(1),
6463                UnixNanos::from(1),
6464                None,
6465            );
6466
6467            let mut queue = ReconciliationFillQueue::default();
6468            manager.reconcile_order_with_fills(
6469                false,
6470                &order,
6471                &report,
6472                &[&fill],
6473                Some(&instrument),
6474                &mut queue,
6475                Some(&client),
6476            )
6477        } else {
6478            manager
6479                .reconcile_order_report(&order, &report, Some(&instrument), Some(&client))
6480                .unwrap()
6481        };
6482
6483        assert_eq!(
6484            events.len(),
6485            usize::from(expected_update) + usize::from(bundled),
6486        );
6487
6488        if expected_update {
6489            assert!(matches!(events[0], OrderEventAny::Updated(_)));
6490        }
6491
6492        for event in &events {
6493            order.apply(event.clone()).unwrap();
6494        }
6495
6496        let expected_price = if expected_update {
6497            Price::from("102.0")
6498        } else {
6499            amended_price
6500        };
6501
6502        assert_eq!(order.price(), Some(expected_price));
6503
6504        let expected_filled_qty = if bundled {
6505            Quantity::from(4)
6506        } else {
6507            Quantity::from(0)
6508        };
6509
6510        assert_eq!(order.filled_qty(), expected_filled_qty);
6511    }
6512
6513    #[rstest]
6514    #[case::canceled(OrderStatus::Canceled)]
6515    #[case::expired(OrderStatus::Expired)]
6516    fn test_terminal_order_report_does_not_void_cached_fills(#[case] status: OrderStatus) {
6517        let (manager, _cache, mut order, mut report, instrument) = cached_commission_fixtures();
6518        let fill = create_inferred_fill_for_qty(
6519            &order,
6520            &report,
6521            &report.account_id,
6522            &instrument,
6523            Quantity::from("4.0"),
6524            UnixNanos::from(1),
6525            None,
6526        )
6527        .unwrap();
6528        order.apply(fill).unwrap();
6529        report.order_status = status;
6530        report.filled_qty = Quantity::from("2.0");
6531        let client = CommissionStubClient::new(CommissionOutcome::Failure);
6532
6533        let events = manager
6534            .reconcile_order_report(&order, &report, Some(&instrument), Some(&client))
6535            .unwrap();
6536
6537        for event in &events {
6538            order.apply(event.clone()).unwrap();
6539        }
6540
6541        assert_eq!(events.len(), 1);
6542        assert_eq!(order.status(), status);
6543        assert_eq!(order.filled_qty(), Quantity::from("4.0"));
6544        assert_eq!(client.seen(), None);
6545    }
6546
6547    #[rstest]
6548    fn test_filled_order_ignores_superseded_cancel_report() {
6549        let (manager, cache, order, mut report, instrument) = cached_commission_fixtures();
6550        let venue_order_id = VenueOrderId::from("V-REPLACEMENT");
6551        let updated = OrderUpdatedSpec::builder()
6552            .trader_id(order.trader_id())
6553            .strategy_id(order.strategy_id())
6554            .instrument_id(order.instrument_id())
6555            .client_order_id(order.client_order_id())
6556            .account_id(report.account_id)
6557            .venue_order_id(venue_order_id)
6558            .quantity(order.quantity())
6559            .build();
6560        let order = cache
6561            .borrow_mut()
6562            .update_order(&OrderEventAny::Updated(updated))
6563            .unwrap();
6564        let mut fill_report = report.clone();
6565        fill_report.venue_order_id = venue_order_id;
6566        let commission = Money::from("1.25 USDT");
6567        let fill = create_inferred_fill_for_qty(
6568            &order,
6569            &fill_report,
6570            &report.account_id,
6571            &instrument,
6572            Quantity::from("10.0"),
6573            UnixNanos::from(2),
6574            Some(commission),
6575        )
6576        .unwrap();
6577        let order = cache.borrow_mut().update_order(&fill).unwrap();
6578        report.order_status = OrderStatus::Canceled;
6579        report.filled_qty = Quantity::from("0.0");
6580        report.avg_px = None;
6581        let client = CommissionStubClient::new(CommissionOutcome::Failure);
6582
6583        let events = manager
6584            .reconcile_order_report(&order, &report, Some(&instrument), Some(&client))
6585            .unwrap();
6586
6587        assert!(events.is_empty());
6588        assert_eq!(order.status(), OrderStatus::Filled);
6589        assert_eq!(order.venue_order_id(), Some(venue_order_id));
6590        assert_eq!(order.filled_qty(), Quantity::from("10.0"));
6591        assert_eq!(order.avg_px(), Some(dec!(100.0)));
6592        assert_eq!(
6593            order.commissions().get(&Currency::USDT()),
6594            Some(&commission)
6595        );
6596        assert_eq!(client.seen(), None);
6597    }
6598
6599    #[rstest]
6600    fn test_continuous_reconciliation_uses_source_client_and_retries_commission() {
6601        let (mut manager, _cache, order, report, _instrument) = cached_commission_fixtures();
6602        let client_id = ClientId::from("STUB");
6603
6604        let check = OpenOrderReportCheck {
6605            command: GenerateOrderStatusReports::new(
6606                UUID4::new(),
6607                UnixNanos::from(1),
6608                true,
6609                None,
6610                None,
6611                None,
6612                None,
6613                None,
6614            ),
6615            filtered_orders: vec![order],
6616            client_coverage: IndexMap::from([(
6617                report.client_order_id.unwrap(),
6618                ReportClientCoverage::Resolved(IndexSet::from([client_id])),
6619            )]),
6620        };
6621
6622        let queried_clients = IndexSet::from([client_id]);
6623        let failed_clients = IndexSet::new();
6624        let failing_client = CommissionStubClient::new(CommissionOutcome::Failure);
6625
6626        let failed = manager.reconcile_open_order_reports(
6627            &check,
6628            vec![SourcedOrderStatusReport {
6629                client_id,
6630                report: report.clone(),
6631            }],
6632            &queried_clients,
6633            &failed_clients,
6634            &[&failing_client],
6635        );
6636
6637        assert!(failed.events.is_empty());
6638
6639        let expected = Money::new(1.5, Currency::USDT());
6640        let retry_client = CommissionStubClient::new(CommissionOutcome::Value(expected));
6641        let retry = manager.reconcile_open_order_reports(
6642            &check,
6643            vec![SourcedOrderStatusReport { client_id, report }],
6644            &queried_clients,
6645            &failed_clients,
6646            &[&retry_client],
6647        );
6648
6649        assert_eq!(retry.events.len(), 1);
6650
6651        let OrderEventAny::Filled(fill) = &retry.events[0] else {
6652            panic!("expected inferred fill on valid retry");
6653        };
6654
6655        assert_eq!(fill.last_qty, Quantity::from("10.0"));
6656        assert_eq!(fill.commission, Some(expected));
6657    }
6658
6659    #[rstest]
6660    fn test_open_check_lookback_exclusion_warns_once_without_reconciliation_actions() {
6661        let client_order_id = ClientOrderId::from("O-LOOKBACK-OLD");
6662        let venue_order_id = VenueOrderId::from("V-LOOKBACK-OLD");
6663        let client_id = ClientId::from("BINANCE");
6664        let instrument_id = crypto_perpetual_ethusdt().id();
6665        let clock = Rc::new(RefCell::new(VirtualClock::new()));
6666        let cache = Rc::new(RefCell::new(Cache::default()));
6667        insert_accepted_limit_order(
6668            &cache,
6669            client_order_id,
6670            venue_order_id,
6671            instrument_id,
6672            client_id,
6673        );
6674        let order = cache.borrow().order_owned(&client_order_id).unwrap();
6675        let cutoff = order.ts_last().saturating_add(DurationNanos::new(1));
6676
6677        let check = OpenOrderReportCheck {
6678            command: GenerateOrderStatusReports::new(
6679                UUID4::new(),
6680                UnixNanos::from(1),
6681                false,
6682                None,
6683                Some(cutoff),
6684                None,
6685                None,
6686                None,
6687            ),
6688            filtered_orders: vec![order],
6689            client_coverage: IndexMap::from([(
6690                client_order_id,
6691                ReportClientCoverage::Resolved(IndexSet::from([client_id])),
6692            )]),
6693        };
6694
6695        let queried_clients = IndexSet::from([client_id]);
6696
6697        let mut manager = ExecutionManager::new(
6698            clock,
6699            cache.clone(),
6700            ExecutionManagerConfig {
6701                open_check_open_only: false,
6702                ..Default::default()
6703            },
6704        )
6705        .expect("valid config");
6706
6707        for _ in 0..2 {
6708            let result = manager.reconcile_open_order_reports(
6709                &check,
6710                Vec::new(),
6711                &queried_clients,
6712                &IndexSet::new(),
6713                &[],
6714            );
6715
6716            assert!(result.events.is_empty());
6717            assert!(result.targeted_queries.is_empty());
6718            assert_eq!(
6719                cache.borrow().order(&client_order_id).unwrap().status(),
6720                OrderStatus::Accepted
6721            );
6722            assert!(!manager.order_recon_retries.contains_key(&client_order_id));
6723            assert!(!manager.order_query_recency.contains_key(&client_order_id));
6724            assert!(!manager.order_query_pending.contains(&client_order_id));
6725            assert_eq!(
6726                manager.order_lookback_warnings,
6727                IndexSet::from([client_order_id])
6728            );
6729            assert_eq!(manager.order_lookback_warnings.len(), 1);
6730        }
6731    }
6732
6733    #[rstest]
6734    fn test_open_check_lookback_warning_clears_at_boundary_and_rearms() {
6735        let client_order_id = ClientOrderId::from("O-LOOKBACK-REARM");
6736        let client_id = ClientId::from("BINANCE");
6737        let cache = Rc::new(RefCell::new(Cache::default()));
6738        insert_accepted_limit_order(
6739            &cache,
6740            client_order_id,
6741            VenueOrderId::from("V-LOOKBACK-REARM"),
6742            crypto_perpetual_ethusdt().id(),
6743            client_id,
6744        );
6745        let order = cache.borrow().order_owned(&client_order_id).unwrap();
6746        let old_cutoff = order.ts_last().saturating_add(DurationNanos::new(1));
6747
6748        let make_check = |start| OpenOrderReportCheck {
6749            command: GenerateOrderStatusReports::new(
6750                UUID4::new(),
6751                UnixNanos::from(1),
6752                false,
6753                None,
6754                Some(start),
6755                None,
6756                None,
6757                None,
6758            ),
6759            filtered_orders: vec![order.clone()],
6760            client_coverage: IndexMap::from([(
6761                client_order_id,
6762                ReportClientCoverage::Resolved(IndexSet::from([client_id])),
6763            )]),
6764        };
6765
6766        let queried_clients = IndexSet::new();
6767
6768        let mut manager = ExecutionManager::new(
6769            Rc::new(RefCell::new(VirtualClock::new())),
6770            cache,
6771            ExecutionManagerConfig {
6772                open_check_open_only: false,
6773                ..Default::default()
6774            },
6775        )
6776        .expect("valid config");
6777
6778        manager.reconcile_open_order_reports(
6779            &make_check(old_cutoff),
6780            Vec::new(),
6781            &queried_clients,
6782            &IndexSet::new(),
6783            &[],
6784        );
6785        assert!(manager.order_lookback_warnings.contains(&client_order_id));
6786
6787        let boundary = order.ts_last();
6788        let boundary_result = manager.reconcile_open_order_reports(
6789            &make_check(boundary),
6790            Vec::new(),
6791            &queried_clients,
6792            &IndexSet::new(),
6793            &[],
6794        );
6795        assert!(boundary_result.targeted_queries.is_empty());
6796        assert!(!manager.order_lookback_warnings.contains(&client_order_id));
6797        assert!(manager.order_coverage_warnings.contains(&client_order_id));
6798
6799        manager.reconcile_open_order_reports(
6800            &make_check(old_cutoff),
6801            Vec::new(),
6802            &queried_clients,
6803            &IndexSet::new(),
6804            &[],
6805        );
6806        assert_eq!(
6807            manager.order_lookback_warnings,
6808            IndexSet::from([client_order_id])
6809        );
6810    }
6811
6812    #[rstest]
6813    fn test_venue_order_id_mapped_report_clears_old_order_lookback_warning() {
6814        let client_order_id = ClientOrderId::from("O-LOOKBACK-MAPPED");
6815        let venue_order_id = VenueOrderId::from("V-LOOKBACK-MAPPED");
6816        let client_id = ClientId::from("BINANCE");
6817        let instrument_id = crypto_perpetual_ethusdt().id();
6818        let cache = Rc::new(RefCell::new(Cache::default()));
6819        insert_accepted_limit_order(
6820            &cache,
6821            client_order_id,
6822            venue_order_id,
6823            instrument_id,
6824            client_id,
6825        );
6826        let order = cache.borrow().order_owned(&client_order_id).unwrap();
6827        let cutoff = order.ts_last().saturating_add(DurationNanos::new(1));
6828
6829        let check = OpenOrderReportCheck {
6830            command: GenerateOrderStatusReports::new(
6831                UUID4::new(),
6832                UnixNanos::from(1),
6833                false,
6834                None,
6835                Some(cutoff),
6836                None,
6837                None,
6838                None,
6839            ),
6840            filtered_orders: vec![order],
6841            client_coverage: IndexMap::from([(
6842                client_order_id,
6843                ReportClientCoverage::Resolved(IndexSet::from([client_id])),
6844            )]),
6845        };
6846
6847        let mut manager = ExecutionManager::new(
6848            Rc::new(RefCell::new(VirtualClock::new())),
6849            cache,
6850            ExecutionManagerConfig {
6851                open_check_open_only: false,
6852                ..Default::default()
6853            },
6854        )
6855        .expect("valid config");
6856
6857        manager.order_lookback_warnings.insert(client_order_id);
6858
6859        // The report carries NO client_order_id, so it resolves through the
6860        // cache's venue_order_id mapping.
6861        let report = OrderStatusReport::new(
6862            AccountId::from("TEST-001"),
6863            instrument_id,
6864            None,
6865            venue_order_id,
6866            OrderSide::Buy.into(),
6867            OrderType::Limit,
6868            TimeInForce::Gtc,
6869            OrderStatus::Accepted,
6870            Quantity::from("10.0"),
6871            Quantity::from("0.0"),
6872            UnixNanos::from(0),
6873            UnixNanos::from(0),
6874            UnixNanos::from(0),
6875            None,
6876        );
6877
6878        let result = manager.reconcile_open_order_reports(
6879            &check,
6880            vec![SourcedOrderStatusReport { client_id, report }],
6881            &IndexSet::from([client_id]),
6882            &IndexSet::new(),
6883            &[],
6884        );
6885
6886        assert!(result.targeted_queries.is_empty());
6887        assert!(!manager.order_lookback_warnings.contains(&client_order_id));
6888    }
6889
6890    #[rstest]
6891    fn test_positive_report_clears_old_order_lookback_warning_without_reinserting_it() {
6892        let client_order_id = ClientOrderId::from("O-LOOKBACK-REPORTED");
6893        let venue_order_id = VenueOrderId::from("V-LOOKBACK-REPORTED");
6894        let client_id = ClientId::from("BINANCE");
6895        let instrument_id = crypto_perpetual_ethusdt().id();
6896        let cache = Rc::new(RefCell::new(Cache::default()));
6897        insert_accepted_limit_order(
6898            &cache,
6899            client_order_id,
6900            venue_order_id,
6901            instrument_id,
6902            client_id,
6903        );
6904        let order = cache.borrow().order_owned(&client_order_id).unwrap();
6905        let cutoff = order.ts_last().saturating_add(DurationNanos::new(1));
6906
6907        let check = OpenOrderReportCheck {
6908            command: GenerateOrderStatusReports::new(
6909                UUID4::new(),
6910                UnixNanos::from(1),
6911                false,
6912                None,
6913                Some(cutoff),
6914                None,
6915                None,
6916                None,
6917            ),
6918            filtered_orders: vec![order],
6919            client_coverage: IndexMap::from([(
6920                client_order_id,
6921                ReportClientCoverage::Resolved(IndexSet::from([client_id])),
6922            )]),
6923        };
6924
6925        let mut manager = ExecutionManager::new(
6926            Rc::new(RefCell::new(VirtualClock::new())),
6927            cache,
6928            ExecutionManagerConfig {
6929                open_check_open_only: false,
6930                ..Default::default()
6931            },
6932        )
6933        .expect("valid config");
6934
6935        manager.order_lookback_warnings.insert(client_order_id);
6936
6937        let report = OrderStatusReport::new(
6938            AccountId::from("TEST-001"),
6939            instrument_id,
6940            Some(client_order_id),
6941            venue_order_id,
6942            OrderSide::Buy.into(),
6943            OrderType::Limit,
6944            TimeInForce::Gtc,
6945            OrderStatus::Accepted,
6946            Quantity::from("10.0"),
6947            Quantity::from("0.0"),
6948            UnixNanos::from(0),
6949            UnixNanos::from(0),
6950            UnixNanos::from(0),
6951            None,
6952        );
6953
6954        let result = manager.reconcile_open_order_reports(
6955            &check,
6956            vec![SourcedOrderStatusReport { client_id, report }],
6957            &IndexSet::from([client_id]),
6958            &IndexSet::new(),
6959            &[],
6960        );
6961
6962        assert!(result.targeted_queries.is_empty());
6963        assert!(!manager.order_lookback_warnings.contains(&client_order_id));
6964    }
6965
6966    #[rstest]
6967    fn test_targeted_reconciliation_orders_interleaved_fills(
6968        #[values(false, true)] requires_authoritative_fills: bool,
6969    ) {
6970        let (mut manager, cache, opening, mut opening_report, instrument) =
6971            cached_commission_fixtures();
6972        let account_id = opening_report.account_id;
6973        let client_id = ClientId::from("STUB");
6974        let closing_id = ClientOrderId::from("O-CLOSING");
6975        let closing_venue_id = VenueOrderId::from("V-CLOSING");
6976        let closing = OrderTestBuilder::new(OrderType::Limit)
6977            .client_order_id(closing_id)
6978            .instrument_id(instrument.id())
6979            .side(OrderSide::Sell)
6980            .quantity(Quantity::from("10.0"))
6981            .price(Price::from("101.0"))
6982            .reduce_only(true)
6983            .build();
6984        let submitted = TestOrderEventStubs::submitted(&closing, account_id);
6985        cache
6986            .borrow_mut()
6987            .add_order(closing, None, Some(client_id), false)
6988            .unwrap();
6989        let closing = cache.borrow_mut().update_order(&submitted).unwrap();
6990        let accepted = TestOrderEventStubs::accepted(&closing, account_id, closing_venue_id);
6991        cache.borrow_mut().update_order(&accepted).unwrap();
6992        opening_report.avg_px = Some(dec!(99));
6993        opening_report.ts_last = UnixNanos::from(300);
6994        let mut closing_report = opening_report.clone();
6995        closing_report.client_order_id = Some(closing_id);
6996        closing_report.venue_order_id = closing_venue_id;
6997        closing_report.order_side = Some(OrderSide::Sell);
6998        closing_report.avg_px = Some(dec!(102));
6999        closing_report.ts_last = UnixNanos::from(400);
7000        let opening_id = opening.client_order_id();
7001
7002        let results = [
7003            (
7004                closing_report,
7005                [
7006                    ("T-CLOSE-2", "103.0", "0.04 USDT", 400),
7007                    ("T-CLOSE-1", "101.0", "0.02 USDT", 200),
7008                ],
7009            ),
7010            (
7011                opening_report,
7012                [
7013                    ("T-OPEN-2", "100.0", "0.03 USDT", 300),
7014                    ("T-OPEN-1", "98.0", "0.01 USDT", 100),
7015                ],
7016            ),
7017        ]
7018        .into_iter()
7019        .map(|(report, fills)| TargetedOrderReportResult {
7020            client_order_id: report.client_order_id.unwrap(),
7021            client_id: Some(client_id),
7022            fills: fills
7023                .into_iter()
7024                .map(|(trade_id, price, commission, timestamp)| {
7025                    FillReport::new(
7026                        account_id,
7027                        instrument.id(),
7028                        report.venue_order_id,
7029                        TradeId::from(trade_id),
7030                        report.order_side.unwrap(),
7031                        Quantity::from("5.0"),
7032                        Price::from(price),
7033                        Money::from(commission),
7034                        LiquiditySide::Taker,
7035                        report.client_order_id,
7036                        None,
7037                        UnixNanos::from(timestamp),
7038                        UnixNanos::from(timestamp + 1),
7039                        None,
7040                    )
7041                })
7042                .collect(),
7043            report: Some(report),
7044            coverage_complete: true,
7045        })
7046        .collect();
7047
7048        let mut client = CommissionStubClient::new(CommissionOutcome::Failure);
7049        client.requires_authoritative_fills = requires_authoritative_fills;
7050        let events = manager.reconcile_targeted_order_reports(results, &[&client]);
7051
7052        let fills = events
7053            .iter()
7054            .map(|event| {
7055                let OrderEventAny::Filled(fill) = event else {
7056                    panic!("expected only authoritative fills");
7057                };
7058
7059                assert_eq!(fill.account_id, account_id);
7060                assert_eq!(fill.instrument_id, instrument.id());
7061                assert_eq!(fill.last_qty, Quantity::from("5.0"));
7062                assert_eq!(fill.liquidity_side, LiquiditySide::Taker);
7063                (
7064                    fill.trade_id,
7065                    fill.client_order_id,
7066                    fill.order_side,
7067                    fill.last_px,
7068                    fill.commission,
7069                    fill.ts_event,
7070                )
7071            })
7072            .collect::<Vec<_>>();
7073
7074        assert_eq!(client.seen(), None);
7075        assert_eq!(
7076            fills,
7077            vec![
7078                (
7079                    TradeId::from("T-OPEN-1"),
7080                    opening_id,
7081                    OrderSide::Buy,
7082                    Price::from("98.0"),
7083                    Some(Money::from("0.01 USDT")),
7084                    UnixNanos::from(100)
7085                ),
7086                (
7087                    TradeId::from("T-CLOSE-1"),
7088                    closing_id,
7089                    OrderSide::Sell,
7090                    Price::from("101.0"),
7091                    Some(Money::from("0.02 USDT")),
7092                    UnixNanos::from(200)
7093                ),
7094                (
7095                    TradeId::from("T-OPEN-2"),
7096                    opening_id,
7097                    OrderSide::Buy,
7098                    Price::from("100.0"),
7099                    Some(Money::from("0.03 USDT")),
7100                    UnixNanos::from(300)
7101                ),
7102                (
7103                    TradeId::from("T-CLOSE-2"),
7104                    closing_id,
7105                    OrderSide::Sell,
7106                    Price::from("103.0"),
7107                    Some(Money::from("0.04 USDT")),
7108                    UnixNanos::from(400)
7109                ),
7110            ],
7111        );
7112    }
7113
7114    #[rstest]
7115    fn test_targeted_reconciliation_uses_source_client_and_retries_commission() {
7116        let (mut manager, _cache, _order, report, _instrument) = cached_commission_fixtures();
7117        let client_order_id = report.client_order_id.unwrap();
7118        let client_id = ClientId::from("STUB");
7119        let failing_client = CommissionStubClient::new(CommissionOutcome::Failure);
7120
7121        let failed = manager.reconcile_targeted_order_reports(
7122            vec![TargetedOrderReportResult {
7123                client_order_id,
7124                client_id: Some(client_id),
7125                report: Some(report.clone()),
7126                fills: Vec::new(),
7127                coverage_complete: true,
7128            }],
7129            &[&failing_client],
7130        );
7131
7132        assert!(failed.is_empty());
7133
7134        let expected = Money::new(1.5, Currency::USDT());
7135        let retry_client = CommissionStubClient::new(CommissionOutcome::Value(expected));
7136        let retry = manager.reconcile_targeted_order_reports(
7137            vec![TargetedOrderReportResult {
7138                client_order_id,
7139                client_id: Some(client_id),
7140                report: Some(report),
7141                fills: Vec::new(),
7142                coverage_complete: true,
7143            }],
7144            &[&retry_client],
7145        );
7146
7147        assert_eq!(retry.len(), 1);
7148
7149        let OrderEventAny::Filled(fill) = &retry[0] else {
7150            panic!("expected inferred fill on valid targeted retry");
7151        };
7152
7153        assert_eq!(fill.last_qty, Quantity::from("10.0"));
7154        assert_eq!(fill.commission, Some(expected));
7155    }
7156
7157    #[rstest]
7158    fn test_clear_recon_tracking_removes_targeted_query() {
7159        let clock = Rc::new(RefCell::new(VirtualClock::new()));
7160        let cache = Rc::new(RefCell::new(Cache::default()));
7161        let mut manager = ExecutionManager::new(clock, cache, ExecutionManagerConfig::default())
7162            .expect("valid config");
7163        let client_order_id = ClientOrderId::from("O-TARGETED-CLEAR");
7164        manager.order_query_pending.insert(client_order_id);
7165        manager.order_lookback_warnings.insert(client_order_id);
7166
7167        manager.clear_recon_tracking(&client_order_id, true);
7168
7169        assert!(manager.order_query_pending.is_empty());
7170        assert!(manager.order_lookback_warnings.is_empty());
7171    }
7172
7173    #[rstest]
7174    fn test_submission_confirmation_skips_untracked_order_cache(
7175        #[values(false, true)] previously_registered: bool,
7176    ) {
7177        let clock = Rc::new(RefCell::new(VirtualClock::new()));
7178        let cache = Rc::new(RefCell::new(Cache::default()));
7179
7180        let mut manager = ExecutionManager::new(
7181            clock,
7182            cache.clone(),
7183            ExecutionManagerConfig {
7184                submission_recovery_policy: SubmissionRecoveryPolicy::RetainUnresolved,
7185                ..Default::default()
7186            },
7187        )
7188        .expect("valid config");
7189
7190        let order = OrderTestBuilder::new(OrderType::Limit)
7191            .instrument_id(InstrumentId::from("ETHUSDT.BYBIT"))
7192            .quantity(Quantity::from("10.0"))
7193            .price(Price::from("100.0"))
7194            .build();
7195        let client_order_id = order.client_order_id();
7196        let account_id = AccountId::from("TEST-001");
7197        let submitted = TestOrderEventStubs::submitted(&order, account_id);
7198        if previously_registered {
7199            manager.register_submission(order.init_event(), None);
7200        }
7201
7202        cache
7203            .borrow_mut()
7204            .add_order(order, None, None, false)
7205            .unwrap();
7206        let order = cache.borrow_mut().update_order(&submitted).unwrap();
7207        let accepted =
7208            TestOrderEventStubs::accepted(&order, account_id, VenueOrderId::from("V-UNTRACKED"));
7209        cache.borrow_mut().update_order(&accepted).unwrap();
7210
7211        if previously_registered {
7212            manager.confirm_submission_outcome(&client_order_id);
7213        }
7214
7215        assert!(!manager.submissions.contains_key(&client_order_id));
7216        assert!(!manager.order_inflight_checks.contains_key(&client_order_id));
7217
7218        // Any cache access would fail while the mutable borrow is held
7219        let cached = cache.borrow_mut();
7220        manager.confirm_submission_outcome(&client_order_id);
7221
7222        assert_eq!(
7223            cached.order(&client_order_id).unwrap().status(),
7224            OrderStatus::Accepted,
7225        );
7226    }
7227
7228    #[rstest]
7229    #[case(false)]
7230    #[case(true)]
7231    fn test_denial_resolves_only_matching_inflight_commands(#[case] reverse: bool) {
7232        let client_order_id = ClientOrderId::from("O-DENIAL-TRACKING");
7233        let clock = Rc::new(RefCell::new(VirtualClock::new()));
7234        let cache = Rc::new(RefCell::new(Cache::default()));
7235        let mut manager =
7236            ExecutionManager::new(clock, cache, ExecutionManagerConfig::default()).unwrap();
7237        let first = UUID4::new();
7238        let second = UUID4::new();
7239        manager.register_inflight(client_order_id, first);
7240        manager.register_inflight(client_order_id, second);
7241        let (resolved, remaining) = if reverse {
7242            (second, first)
7243        } else {
7244            (first, second)
7245        };
7246
7247        for cause in [None, Some(UUID4::new()), Some(resolved), Some(resolved)] {
7248            let event = OrderEventAny::ModifyDenied(
7249                OrderModifyDeniedSpec::builder()
7250                    .client_order_id(client_order_id)
7251                    .maybe_causation_id(cause)
7252                    .build(),
7253            );
7254            manager.observe_order_event(&event);
7255            assert!(manager.order_inflight_checks.contains_key(&client_order_id));
7256        }
7257
7258        let event = OrderEventAny::CancelDenied(
7259            OrderCancelDeniedSpec::builder()
7260                .client_order_id(client_order_id)
7261                .causation_id(remaining)
7262                .build(),
7263        );
7264        manager.observe_order_event(&event);
7265        assert!(!manager.order_inflight_checks.contains_key(&client_order_id));
7266    }
7267
7268    #[rstest]
7269    fn test_register_inflight_skips_filtered_order() {
7270        let client_order_id = ClientOrderId::from("O-FILTERED-REGISTER");
7271        let clock = Rc::new(RefCell::new(VirtualClock::new()));
7272        let cache = Rc::new(RefCell::new(Cache::default()));
7273
7274        let mut manager = ExecutionManager::new(
7275            clock,
7276            cache,
7277            ExecutionManagerConfig {
7278                filtered_client_order_ids: IndexSet::from([client_order_id]),
7279                ..Default::default()
7280            },
7281        )
7282        .expect("valid config");
7283
7284        manager.register_inflight(client_order_id, UUID4::new());
7285
7286        assert!(!manager.order_inflight_checks.contains_key(&client_order_id));
7287        assert!(!manager.order_recon_retries.contains_key(&client_order_id));
7288    }
7289
7290    #[rstest]
7291    #[cfg_attr(
7292        not(all(feature = "simulation", madsim)),
7293        tokio::test(start_paused = true)
7294    )]
7295    #[cfg_attr(all(feature = "simulation", madsim), madsim::test)]
7296    async fn test_inflight_check_retires_order_filtered_after_registration() {
7297        let client_order_id = ClientOrderId::from("O-FILTERED-LATE");
7298        let clock = Rc::new(RefCell::new(VirtualClock::new()));
7299        let cache = Rc::new(RefCell::new(Cache::default()));
7300
7301        let mut manager = ExecutionManager::new(
7302            clock,
7303            cache,
7304            ExecutionManagerConfig {
7305                inflight_threshold_ms: 100,
7306                ..Default::default()
7307            },
7308        )
7309        .expect("valid config");
7310
7311        manager.register_inflight(client_order_id, UUID4::new());
7312        manager
7313            .config
7314            .filtered_client_order_ids
7315            .insert(client_order_id);
7316        dst::time::sleep(Duration::from_millis(101)).await;
7317
7318        let first = manager.check_inflight_orders();
7319
7320        assert!(first.events.is_empty());
7321        assert!(first.queries.is_empty());
7322        assert!(!manager.order_inflight_checks.contains_key(&client_order_id));
7323        assert!(!manager.order_recon_retries.contains_key(&client_order_id));
7324
7325        dst::time::sleep(Duration::from_millis(101)).await;
7326        let second = manager.check_inflight_orders();
7327        assert!(second.events.is_empty());
7328        assert!(second.queries.is_empty());
7329        assert!(!manager.order_inflight_checks.contains_key(&client_order_id));
7330    }
7331
7332    #[rstest]
7333    #[case(false, OrderStatus::PendingUpdate, true, true, true)]
7334    #[case(false, OrderStatus::Accepted, false, true, true)]
7335    #[case(false, OrderStatus::Canceled, false, true, false)]
7336    #[case(true, OrderStatus::PendingCancel, true, true, true)]
7337    #[case(true, OrderStatus::Accepted, false, true, true)]
7338    #[case(true, OrderStatus::Filled, false, true, false)]
7339    fn test_observe_order_status_report_tracking_matrix(
7340        #[case] with_fills: bool,
7341        #[case] status: OrderStatus,
7342        #[case] expect_inflight: bool,
7343        #[case] expect_activity: bool,
7344        #[case] expect_last_query: bool,
7345    ) {
7346        let client_order_id = ClientOrderId::from("O-STATUS-MATRIX");
7347        let clock = Rc::new(RefCell::new(VirtualClock::new()));
7348        let cache = Rc::new(RefCell::new(Cache::default()));
7349        let mut manager = ExecutionManager::new(clock, cache, ExecutionManagerConfig::default())
7350            .expect("valid config");
7351        manager.register_inflight(client_order_id, UUID4::new());
7352        manager.order_query_recency.mark(client_order_id);
7353        manager.order_coverage_warnings.insert(client_order_id);
7354        manager.order_coverage_unresolved.insert(client_order_id);
7355        manager.order_query_pending.insert(client_order_id);
7356
7357        let order_report = OrderStatusReport::new(
7358            AccountId::from("TEST-001"),
7359            crypto_perpetual_ethusdt().id(),
7360            Some(client_order_id),
7361            VenueOrderId::from("V-STATUS-MATRIX"),
7362            OrderSide::Buy.into(),
7363            OrderType::Limit,
7364            TimeInForce::Gtc,
7365            status,
7366            Quantity::from("10.0"),
7367            Quantity::from("0.0"),
7368            UnixNanos::from(1_000),
7369            UnixNanos::from(1_000),
7370            UnixNanos::from(1_000),
7371            None,
7372        );
7373
7374        let report = if with_fills {
7375            ExecutionReport::OrderWithFills(Box::new(order_report), Vec::new())
7376        } else {
7377            ExecutionReport::Order(Box::new(order_report))
7378        };
7379
7380        manager.observe_execution_report(&report);
7381
7382        assert_eq!(
7383            manager.order_inflight_checks.contains_key(&client_order_id),
7384            expect_inflight,
7385        );
7386        assert_eq!(
7387            manager.order_recon_retries.contains_key(&client_order_id),
7388            expect_inflight,
7389        );
7390        assert_eq!(
7391            manager.order_activity.contains_key(&client_order_id),
7392            expect_activity,
7393        );
7394        assert_eq!(
7395            manager.order_query_recency.contains_key(&client_order_id),
7396            expect_last_query,
7397        );
7398        assert_eq!(
7399            manager.order_coverage_warnings.contains(&client_order_id),
7400            expect_inflight,
7401        );
7402        assert_eq!(
7403            manager.order_coverage_unresolved.contains(&client_order_id),
7404            expect_inflight,
7405        );
7406        assert_eq!(
7407            manager.order_query_pending.contains(&client_order_id),
7408            expect_inflight,
7409        );
7410    }
7411
7412    #[rstest]
7413    #[case(OrderStatus::PendingUpdate)]
7414    #[case(OrderStatus::PendingCancel)]
7415    fn test_accepted_report_during_pending_command_preserves_inflight_tracking(
7416        #[case] pending_status: OrderStatus,
7417    ) {
7418        let client_order_id = ClientOrderId::from("O-PENDING-COMMAND");
7419        let venue_order_id = VenueOrderId::from("V-PENDING-COMMAND");
7420        let account_id = AccountId::from("TEST-001");
7421        let client_id = ClientId::from("TEST");
7422        let instrument_id = crypto_perpetual_ethusdt().id();
7423        let clock = Rc::new(RefCell::new(VirtualClock::new()));
7424        let cache = Rc::new(RefCell::new(Cache::default()));
7425        insert_accepted_limit_order(
7426            &cache,
7427            client_order_id,
7428            venue_order_id,
7429            instrument_id,
7430            client_id,
7431        );
7432
7433        let order = cache.borrow().order_owned(&client_order_id).unwrap();
7434
7435        let event = match pending_status {
7436            OrderStatus::PendingUpdate => OrderEventAny::PendingUpdate(
7437                OrderPendingUpdateSpec::builder()
7438                    .trader_id(order.trader_id())
7439                    .strategy_id(order.strategy_id())
7440                    .instrument_id(instrument_id)
7441                    .client_order_id(client_order_id)
7442                    .account_id(account_id)
7443                    .venue_order_id(venue_order_id)
7444                    .build(),
7445            ),
7446            OrderStatus::PendingCancel => OrderEventAny::PendingCancel(
7447                OrderPendingCancelSpec::builder()
7448                    .trader_id(order.trader_id())
7449                    .strategy_id(order.strategy_id())
7450                    .instrument_id(instrument_id)
7451                    .client_order_id(client_order_id)
7452                    .account_id(account_id)
7453                    .venue_order_id(venue_order_id)
7454                    .build(),
7455            ),
7456            _ => unreachable!(),
7457        };
7458
7459        cache.borrow_mut().update_order(&event).unwrap();
7460
7461        let mut manager =
7462            ExecutionManager::new(clock, cache.clone(), ExecutionManagerConfig::default())
7463                .expect("valid config");
7464        manager.register_inflight(client_order_id, UUID4::new());
7465        manager.order_query_recency.mark(client_order_id);
7466        manager.order_coverage_warnings.insert(client_order_id);
7467        manager.order_coverage_unresolved.insert(client_order_id);
7468        manager.order_query_pending.insert(client_order_id);
7469        let report = OrderStatusReport::new(
7470            account_id,
7471            instrument_id,
7472            Some(client_order_id),
7473            venue_order_id,
7474            OrderSide::Buy.into(),
7475            OrderType::Limit,
7476            TimeInForce::Gtc,
7477            OrderStatus::Accepted,
7478            Quantity::from("10.0"),
7479            Quantity::from("0.0"),
7480            UnixNanos::from(1_000),
7481            UnixNanos::from(1_000),
7482            UnixNanos::from(1_000),
7483            None,
7484        )
7485        .with_price(Price::from("100.0"));
7486
7487        manager.observe_execution_report(&ExecutionReport::Order(Box::new(report.clone())));
7488        let order = cache.borrow().order_owned(&client_order_id).unwrap();
7489        let events =
7490            generate_reconciliation_order_events(&order, &report, None, UnixNanos::from(1_000));
7491
7492        assert!(events.is_empty());
7493        assert_eq!(order.status(), pending_status);
7494        assert!(manager.order_inflight_checks.contains_key(&client_order_id));
7495        assert!(manager.order_recon_retries.contains_key(&client_order_id));
7496        assert!(manager.order_query_recency.contains_key(&client_order_id));
7497        assert!(manager.order_activity.contains_key(&client_order_id));
7498        assert!(manager.order_coverage_warnings.contains(&client_order_id));
7499        assert!(manager.order_coverage_unresolved.contains(&client_order_id));
7500        assert!(manager.order_query_pending.contains(&client_order_id));
7501    }
7502
7503    #[rstest]
7504    fn test_superseded_cancel_report_preserves_missing_order_grace() {
7505        let client_order_id = ClientOrderId::from("O-CANCEL-REPLACE");
7506        let old_venue_order_id = VenueOrderId::from("V-CANCEL-REPLACE-OLD");
7507        let new_venue_order_id = VenueOrderId::from("V-CANCEL-REPLACE-NEW");
7508        let account_id = AccountId::from("TEST-001");
7509        let client_id = ClientId::from("TEST");
7510        let instrument_id = crypto_perpetual_ethusdt().id();
7511        let clock = Rc::new(RefCell::new(VirtualClock::new()));
7512        let cache = Rc::new(RefCell::new(Cache::default()));
7513        insert_accepted_limit_order(
7514            &cache,
7515            client_order_id,
7516            old_venue_order_id,
7517            instrument_id,
7518            client_id,
7519        );
7520
7521        let order = cache.borrow().order_owned(&client_order_id).unwrap();
7522        let pending_update = OrderPendingUpdateSpec::builder()
7523            .trader_id(order.trader_id())
7524            .strategy_id(order.strategy_id())
7525            .instrument_id(order.instrument_id())
7526            .client_order_id(client_order_id)
7527            .account_id(account_id)
7528            .venue_order_id(old_venue_order_id)
7529            .build();
7530        cache
7531            .borrow_mut()
7532            .update_order(&OrderEventAny::PendingUpdate(pending_update))
7533            .unwrap();
7534        let order = cache.borrow().order_owned(&client_order_id).unwrap();
7535        let updated = OrderUpdatedSpec::builder()
7536            .trader_id(order.trader_id())
7537            .strategy_id(order.strategy_id())
7538            .instrument_id(order.instrument_id())
7539            .client_order_id(client_order_id)
7540            .quantity(order.quantity())
7541            .venue_order_id(new_venue_order_id)
7542            .account_id(account_id)
7543            .build();
7544        cache
7545            .borrow_mut()
7546            .update_order(&OrderEventAny::Updated(updated))
7547            .unwrap();
7548
7549        let mut manager = ExecutionManager::new(
7550            clock,
7551            cache.clone(),
7552            ExecutionManagerConfig {
7553                open_check_missing_retries: 1,
7554                ..Default::default()
7555            },
7556        )
7557        .expect("valid config");
7558
7559        manager.record_local_activity(client_order_id);
7560        assert!(
7561            manager
7562                .prepare_missing_order_query(client_order_id)
7563                .is_none()
7564        );
7565
7566        let report = OrderStatusReport::new(
7567            account_id,
7568            instrument_id,
7569            Some(client_order_id),
7570            old_venue_order_id,
7571            OrderSide::Buy.into(),
7572            OrderType::Limit,
7573            TimeInForce::Gtc,
7574            OrderStatus::Canceled,
7575            Quantity::from("10.0"),
7576            Quantity::from("0.0"),
7577            UnixNanos::from(1_000),
7578            UnixNanos::from(2_000),
7579            UnixNanos::from(3_000),
7580            None,
7581        );
7582
7583        manager.observe_execution_report(&ExecutionReport::Order(Box::new(report.clone())));
7584        let order = cache.borrow().order_owned(&client_order_id).unwrap();
7585        let events =
7586            generate_reconciliation_order_events(&order, &report, None, UnixNanos::from(1_000));
7587
7588        assert!(events.is_empty());
7589        assert_eq!(order.status(), OrderStatus::Accepted);
7590        assert_eq!(order.venue_order_id(), Some(new_venue_order_id));
7591        assert!(manager.order_activity.contains_key(&client_order_id));
7592        assert!(
7593            manager
7594                .prepare_missing_order_query(client_order_id)
7595                .is_none()
7596        );
7597        assert_eq!(manager.recon_check_retry_count(&client_order_id), 0);
7598    }
7599
7600    #[rstest]
7601    #[cfg_attr(
7602        not(all(feature = "simulation", madsim)),
7603        tokio::test(start_paused = true)
7604    )]
7605    #[cfg_attr(all(feature = "simulation", madsim), madsim::test)]
7606    async fn test_prune_order_local_activity_uses_open_check_threshold() {
7607        let old_id = ClientOrderId::from("O-ACTIVITY-OLD");
7608        let fresh_id = ClientOrderId::from("O-ACTIVITY-FRESH");
7609        let clock = Rc::new(RefCell::new(VirtualClock::new()));
7610        let cache = Rc::new(RefCell::new(Cache::default()));
7611
7612        let mut manager = ExecutionManager::new(
7613            clock,
7614            cache,
7615            ExecutionManagerConfig {
7616                open_check_threshold_ns: DurationNanos::from_millis(100),
7617                ..Default::default()
7618            },
7619        )
7620        .expect("valid config");
7621
7622        manager.record_local_activity(old_id);
7623        dst::time::sleep(Duration::from_millis(101)).await;
7624        manager.record_local_activity(fresh_id);
7625
7626        manager.prune_order_local_activity();
7627
7628        assert!(!manager.order_activity.contains_key(&old_id));
7629        assert!(manager.order_activity.contains_key(&fresh_id));
7630    }
7631
7632    #[rstest]
7633    #[cfg_attr(
7634        not(all(feature = "simulation", madsim)),
7635        tokio::test(start_paused = true)
7636    )]
7637    #[cfg_attr(all(feature = "simulation", madsim), madsim::test)]
7638    async fn test_unapplied_fill_report_expires_after_position_check_threshold() {
7639        let clock = Rc::new(RefCell::new(VirtualClock::new()));
7640        let cache = Rc::new(RefCell::new(Cache::default()));
7641
7642        let mut manager = ExecutionManager::new(
7643            clock,
7644            cache,
7645            ExecutionManagerConfig {
7646                position_check_threshold_ns: DurationNanos::from_millis(100),
7647                ..Default::default()
7648            },
7649        )
7650        .expect("valid config");
7651
7652        let report = unapplied_fill_report("T-UNAPPLIED");
7653        let mut expired = vec![manager.is_unapplied_fill_report_expired(&report)];
7654
7655        manager.record_unapplied_fill_report(&report);
7656        dst::time::sleep(Duration::from_millis(60)).await;
7657        manager.record_unapplied_fill_report(&report);
7658        expired.push(manager.is_unapplied_fill_report_expired(&report));
7659        dst::time::sleep(Duration::from_millis(40)).await;
7660        expired.push(manager.is_unapplied_fill_report_expired(&report));
7661
7662        assert_eq!(expired, vec![false, false, true]);
7663    }
7664
7665    #[rstest]
7666    #[cfg_attr(
7667        not(all(feature = "simulation", madsim)),
7668        tokio::test(start_paused = true)
7669    )]
7670    #[cfg_attr(all(feature = "simulation", madsim), madsim::test)]
7671    async fn test_record_unapplied_fill_report_prunes_outside_position_check_lookback() {
7672        let clock = Rc::new(RefCell::new(VirtualClock::new()));
7673        let cache = Rc::new(RefCell::new(Cache::default()));
7674
7675        let mut manager = ExecutionManager::new(
7676            clock,
7677            cache,
7678            ExecutionManagerConfig {
7679                position_check_lookback_mins: 1,
7680                position_check_threshold_ns: DurationNanos::from_secs(5),
7681                ..Default::default()
7682            },
7683        )
7684        .expect("valid config");
7685
7686        let old_report = unapplied_fill_report("T-UNAPPLIED-OLD");
7687        let recent_report = unapplied_fill_report("T-UNAPPLIED-RECENT");
7688        let fresh_report = unapplied_fill_report("T-UNAPPLIED-FRESH");
7689
7690        manager.record_unapplied_fill_report(&old_report);
7691        dst::time::sleep(Duration::from_secs(30)).await;
7692        manager.record_unapplied_fill_report(&recent_report);
7693        dst::time::sleep(Duration::from_secs(31)).await;
7694        manager.record_unapplied_fill_report(&fresh_report);
7695
7696        assert!(!manager.fills_unapplied.contains_key(&(
7697            old_report.account_id,
7698            old_report.instrument_id,
7699            old_report.trade_id,
7700        )));
7701        assert!(manager.fills_unapplied.contains_key(&(
7702            recent_report.account_id,
7703            recent_report.instrument_id,
7704            recent_report.trade_id,
7705        )));
7706        assert!(manager.fills_unapplied.contains_key(&(
7707            fresh_report.account_id,
7708            fresh_report.instrument_id,
7709            fresh_report.trade_id,
7710        )));
7711    }
7712
7713    fn unapplied_fill_report(trade_id: &str) -> FillReport {
7714        FillReport::new(
7715            AccountId::from("SIM-001"),
7716            InstrumentId::from("ETHUSDT-PERP.BINANCE"),
7717            VenueOrderId::from("V-UNAPPLIED"),
7718            TradeId::from(trade_id),
7719            OrderSide::Buy,
7720            Quantity::from("1.0"),
7721            Price::from("100.0"),
7722            Money::from("0.10 USDT"),
7723            LiquiditySide::Taker,
7724            None,
7725            None,
7726            UnixNanos::from(1),
7727            UnixNanos::from(1),
7728            None,
7729        )
7730    }
7731
7732    #[rstest]
7733    fn test_prepare_open_order_report_check_builds_bulk_command_with_config() {
7734        let lookback_mins = 5_u64;
7735        let lookback = DurationNanos::from_mins(lookback_mins);
7736        let clock = Rc::new(RefCell::new(VirtualClock::new()));
7737        let cache = Rc::new(RefCell::new(Cache::default()));
7738
7739        let mut manager = ExecutionManager::new(
7740            clock.clone(),
7741            cache.clone(),
7742            ExecutionManagerConfig {
7743                open_check_lookback_mins: Some(lookback_mins),
7744                open_check_open_only: false,
7745                reconciliation_instrument_ids: IndexSet::from([crypto_perpetual_ethusdt().id()]),
7746                ..Default::default()
7747            },
7748        )
7749        .expect("valid config");
7750
7751        let included_id = ClientOrderId::from("O-REPORT-001");
7752        let excluded_id = ClientOrderId::from("O-REPORT-002");
7753        let included_instrument_id = crypto_perpetual_ethusdt().id();
7754        let excluded_instrument_id = btcusd_bybit().id();
7755
7756        cache
7757            .borrow_mut()
7758            .add_instrument(InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt()))
7759            .unwrap();
7760        cache
7761            .borrow_mut()
7762            .add_instrument(InstrumentAny::CryptoPerpetual(btcusd_bybit()))
7763            .unwrap();
7764        insert_accepted_limit_order(
7765            &cache,
7766            included_id,
7767            VenueOrderId::from("V-REPORT-001"),
7768            included_instrument_id,
7769            ClientId::from("BINANCE"),
7770        );
7771        insert_accepted_limit_order(
7772            &cache,
7773            excluded_id,
7774            VenueOrderId::from("V-REPORT-002"),
7775            excluded_instrument_id,
7776            ClientId::from("BYBIT"),
7777        );
7778        clock
7779            .borrow_mut()
7780            .advance_time(UnixNanos::default().saturating_add(lookback * 2), true);
7781
7782        let ts_now = clock.borrow().timestamp_ns();
7783        let command_id = UUID4::new();
7784        let check = manager.prepare_open_order_report_check(command_id, &[]);
7785
7786        assert_eq!(check.command.command_id, command_id);
7787        assert_eq!(check.command.ts_init, ts_now);
7788        assert!(!check.command.open_only);
7789        assert_eq!(check.command.instrument_id, None);
7790        assert_eq!(check.command.start, Some(ts_now.saturating_sub(lookback)));
7791        assert_eq!(check.command.end, None);
7792        assert_eq!(check.command.log_receipt_level, LogLevel::Debug);
7793        assert_eq!(check.filtered_orders.len(), 1);
7794        assert_eq!(check.filtered_orders[0].client_order_id(), included_id);
7795    }
7796
7797    #[rstest]
7798    fn test_prepare_position_report_check_builds_bulk_command_with_coverage() {
7799        let clock = Rc::new(RefCell::new(VirtualClock::new()));
7800        let cache = Rc::new(RefCell::new(Cache::default()));
7801
7802        let manager = ExecutionManager::new(
7803            clock.clone(),
7804            cache.clone(),
7805            ExecutionManagerConfig {
7806                reconciliation_instrument_ids: IndexSet::from([crypto_perpetual_ethusdt().id()]),
7807                ..Default::default()
7808            },
7809        )
7810        .expect("valid config");
7811
7812        let included_instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
7813        let excluded_instrument = InstrumentAny::CryptoPerpetual(btcusd_bybit());
7814
7815        cache
7816            .borrow_mut()
7817            .add_instrument(included_instrument.clone())
7818            .unwrap();
7819        cache
7820            .borrow_mut()
7821            .add_instrument(excluded_instrument.clone())
7822            .unwrap();
7823        let included_position = insert_open_position(
7824            &cache,
7825            &included_instrument,
7826            PositionId::from("P-REPORT-001"),
7827            OrderSide::Buy,
7828            "5.0",
7829            "3000.00",
7830        );
7831        insert_open_position(
7832            &cache,
7833            &excluded_instrument,
7834            PositionId::from("P-REPORT-002"),
7835            OrderSide::Buy,
7836            "2.0",
7837            "40000.00",
7838        );
7839
7840        let ts_now = clock.borrow().timestamp_ns();
7841        let command_id = UUID4::new();
7842        let check = manager.prepare_position_report_check(command_id, &[]);
7843        let key = (
7844            included_position.instrument_id,
7845            included_position.account_id,
7846        );
7847
7848        assert_eq!(check.command.command_id, command_id);
7849        assert_eq!(check.command.ts_init, ts_now);
7850        assert_eq!(check.command.instrument_id, None);
7851        assert_eq!(check.command.start, None);
7852        assert_eq!(check.command.end, None);
7853        assert_eq!(check.command.log_receipt_level, LogLevel::Debug);
7854        assert_eq!(check.client_coverage.len(), 1);
7855        assert_eq!(
7856            check.client_coverage.get(&key),
7857            Some(&ReportClientCoverage::Unresolved)
7858        );
7859        assert_eq!(check.activity_revisions.get(&key), Some(&0));
7860    }
7861
7862    #[rstest]
7863    #[case::unresolved(ReportClientCoverage::Unresolved)]
7864    #[case::empty(ReportClientCoverage::Resolved(IndexSet::new()))]
7865    #[case::unqueried(ReportClientCoverage::Resolved(IndexSet::from([ClientId::from("BYBIT")])))]
7866    fn test_position_reconciliation_preserves_position_without_client_coverage(
7867        #[case] coverage: ReportClientCoverage,
7868    ) {
7869        let clock = Rc::new(RefCell::new(VirtualClock::new()));
7870        let cache = Rc::new(RefCell::new(Cache::default()));
7871
7872        let mut manager = ExecutionManager::new(
7873            clock,
7874            cache.clone(),
7875            ExecutionManagerConfig {
7876                position_check_threshold_ns: DurationNanos::ZERO,
7877                ..Default::default()
7878            },
7879        )
7880        .expect("valid config");
7881
7882        let instrument = test_bybit_spot_instrument();
7883        cache
7884            .borrow_mut()
7885            .add_instrument(instrument.clone())
7886            .unwrap();
7887        let position = insert_open_position(
7888            &cache,
7889            &instrument,
7890            PositionId::from("P-COVERAGE-PRESERVED"),
7891            OrderSide::Buy,
7892            "5.0",
7893            "3000.00",
7894        );
7895        let key = (position.instrument_id, position.account_id);
7896        let mut check = manager.prepare_position_report_check(UUID4::new(), &[]);
7897        check.client_coverage.insert(key, coverage);
7898        manager.set_position_reconciliation_retries(key, PositionReportShape::Unambiguous, 1);
7899
7900        let events = manager.reconcile_position_reports(
7901            &check,
7902            Vec::new(),
7903            &IndexSet::new(),
7904            &IndexSet::new(),
7905        );
7906
7907        assert!(events.is_empty());
7908        assert_eq!(manager.position_recon_retry_count(&key), 1);
7909    }
7910
7911    #[rstest]
7912    fn test_position_reconciliation_preserves_unavailable_spot_coverage() {
7913        let clock = Rc::new(RefCell::new(VirtualClock::new()));
7914        let cache = Rc::new(RefCell::new(Cache::default()));
7915        let mut manager =
7916            ExecutionManager::new(clock, cache.clone(), ExecutionManagerConfig::default())
7917                .expect("valid config");
7918        let derivative = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
7919        let spot = test_bybit_spot_instrument();
7920        cache
7921            .borrow_mut()
7922            .add_instrument(derivative.clone())
7923            .unwrap();
7924        cache.borrow_mut().add_instrument(spot.clone()).unwrap();
7925        let derivative_position = insert_open_position(
7926            &cache,
7927            &derivative,
7928            PositionId::from("P-DERIVATIVE-RECONCILE"),
7929            OrderSide::Buy,
7930            "5.0",
7931            "3000.00",
7932        );
7933        let spot_position = insert_open_position(
7934            &cache,
7935            &spot,
7936            PositionId::from("P-SPOT-PRESERVED"),
7937            OrderSide::Buy,
7938            "2.0",
7939            "2000.00",
7940        );
7941        let client = PositionCoverageStubClient;
7942        let check = manager.prepare_position_report_check(UUID4::new(), &[&client]);
7943        let queried_clients = IndexSet::from([client.client_id()]);
7944
7945        let events = manager.reconcile_position_reports(
7946            &check,
7947            Vec::new(),
7948            &queried_clients,
7949            &IndexSet::new(),
7950        );
7951
7952        assert!(events.iter().any(|event| {
7953            matches!(event, OrderEventAny::Filled(fill) if fill.instrument_id == derivative_position.instrument_id)
7954        }));
7955        assert!(!events.iter().any(|event| {
7956            matches!(event, OrderEventAny::Filled(fill) if fill.instrument_id == spot_position.instrument_id)
7957        }));
7958    }
7959
7960    #[rstest]
7961    fn test_position_reconciliation_preserves_spot_position_when_client_query_fails() {
7962        let clock = Rc::new(RefCell::new(VirtualClock::new()));
7963        let cache = Rc::new(RefCell::new(Cache::default()));
7964        let mut manager =
7965            ExecutionManager::new(clock, cache.clone(), ExecutionManagerConfig::default())
7966                .expect("valid config");
7967        let instrument = test_bybit_spot_instrument();
7968        cache
7969            .borrow_mut()
7970            .add_instrument(instrument.clone())
7971            .unwrap();
7972        let position = insert_open_position(
7973            &cache,
7974            &instrument,
7975            PositionId::from("P-SPOT-QUERY-FAILED"),
7976            OrderSide::Buy,
7977            "5.0",
7978            "3000.00",
7979        );
7980        let key = (position.instrument_id, position.account_id);
7981        let client_id = ClientId::from("BYBIT");
7982        let mut check = manager.prepare_position_report_check(UUID4::new(), &[]);
7983        check.client_coverage.insert(
7984            key,
7985            ReportClientCoverage::Resolved(IndexSet::from([client_id])),
7986        );
7987        let queried_clients = IndexSet::from([client_id]);
7988        let failed_clients = IndexSet::from([client_id]);
7989
7990        let events = manager.reconcile_position_reports(
7991            &check,
7992            Vec::new(),
7993            &queried_clients,
7994            &failed_clients,
7995        );
7996
7997        assert!(
7998            !events
7999                .iter()
8000                .any(|event| matches!(event, OrderEventAny::Filled(_))),
8001            "a failed bulk query must not generate a synthetic closing fill",
8002        );
8003        let cached_position = cache.borrow().position(&position.id).unwrap().clone();
8004        assert!(cached_position.is_open());
8005        assert_eq!(cached_position.quantity, Quantity::from("5.0"));
8006    }
8007
8008    #[rstest]
8009    #[cfg_attr(
8010        not(all(feature = "simulation", madsim)),
8011        tokio::test(start_paused = true)
8012    )]
8013    #[cfg_attr(all(feature = "simulation", madsim), madsim::test)]
8014    async fn test_position_report_check_defers_activity_recorded_during_delayed_request() {
8015        let clock = Rc::new(RefCell::new(VirtualClock::new()));
8016        let cache = Rc::new(RefCell::new(Cache::default()));
8017
8018        let mut manager = ExecutionManager::new(
8019            clock,
8020            cache.clone(),
8021            ExecutionManagerConfig {
8022                position_check_threshold_ns: DurationNanos::from_secs(5),
8023                ..Default::default()
8024            },
8025        )
8026        .expect("valid config");
8027
8028        let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
8029        let instrument_id = instrument.id();
8030        let position = insert_open_position(
8031            &cache,
8032            &instrument,
8033            PositionId::from("P-ACTIVITY-DURING-REQUEST"),
8034            OrderSide::Buy,
8035            "5.0",
8036            "3000.00",
8037        );
8038        cache
8039            .borrow_mut()
8040            .add_instrument(instrument.clone())
8041            .unwrap();
8042        let account_id = position.account_id;
8043        let check = manager.prepare_position_report_check(UUID4::new(), &[]);
8044
8045        let report = PositionStatusReport::new(
8046            account_id,
8047            instrument_id,
8048            PositionSide::Long,
8049            Quantity::from("5.0"),
8050            UnixNanos::from(1_000_000),
8051            UnixNanos::from(1_000_000),
8052            None,
8053            None,
8054            Some(Decimal::from(3000)),
8055        );
8056
8057        let closed_position = close_long_position(
8058            position,
8059            &instrument,
8060            TradeId::from("T-ACTIVITY-DURING-REQUEST"),
8061        );
8062        cache
8063            .borrow_mut()
8064            .update_position(&closed_position)
8065            .unwrap();
8066        manager.record_position_activity(instrument_id, account_id);
8067
8068        // Client A's report is already captured while client B holds the batch open.
8069        dst::time::sleep(Duration::from_secs(6)).await;
8070
8071        let events = manager.reconcile_position_reports(
8072            &check,
8073            vec![report],
8074            &IndexSet::new(),
8075            &IndexSet::new(),
8076        );
8077
8078        assert!(
8079            !events.iter().any(|event| {
8080                matches!(
8081                    event,
8082                    OrderEventAny::Filled(fill)
8083                        if fill.order_side == OrderSide::Buy
8084                            && fill.last_qty == Quantity::from("5.0")
8085                )
8086            }),
8087            "activity recorded after the request started must defer A's stale report",
8088        );
8089    }
8090
8091    #[rstest]
8092    fn test_position_report_check_does_not_defer_activity_recorded_before_request() {
8093        let clock = Rc::new(RefCell::new(VirtualClock::new()));
8094        let cache = Rc::new(RefCell::new(Cache::default()));
8095
8096        let mut manager = ExecutionManager::new(
8097            clock,
8098            cache.clone(),
8099            ExecutionManagerConfig {
8100                position_check_threshold_ns: DurationNanos::ZERO,
8101                ..Default::default()
8102            },
8103        )
8104        .expect("valid config");
8105
8106        let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
8107        let instrument_id = instrument.id();
8108        let position = insert_open_position(
8109            &cache,
8110            &instrument,
8111            PositionId::from("P-ACTIVITY-BEFORE-REQUEST"),
8112            OrderSide::Buy,
8113            "5.0",
8114            "3000.00",
8115        );
8116        cache.borrow_mut().add_instrument(instrument).unwrap();
8117        let account_id = position.account_id;
8118        manager.record_position_activity(instrument_id, account_id);
8119        let check = manager.prepare_position_report_check(UUID4::new(), &[]);
8120
8121        let report = PositionStatusReport::new(
8122            account_id,
8123            instrument_id,
8124            PositionSide::Long,
8125            Quantity::from("10.0"),
8126            UnixNanos::from(1_000_000),
8127            UnixNanos::from(1_000_000),
8128            None,
8129            None,
8130            Some(Decimal::from(3000)),
8131        );
8132
8133        let events = manager.reconcile_position_reports(
8134            &check,
8135            vec![report],
8136            &IndexSet::new(),
8137            &IndexSet::new(),
8138        );
8139
8140        let fills: Vec<_> = events
8141            .iter()
8142            .filter_map(|event| match event {
8143                OrderEventAny::Filled(fill) => Some(fill),
8144                _ => None,
8145            })
8146            .collect();
8147
8148        assert_eq!(fills.len(), 1);
8149        assert_eq!(fills[0].order_side, OrderSide::Buy);
8150        assert_eq!(fills[0].last_qty, Quantity::from("5.0"));
8151        assert_eq!(fills[0].commission, None);
8152    }
8153
8154    #[rstest]
8155    fn test_mass_status_projects_companion_fill_before_void_correction() {
8156        let clock = Rc::new(RefCell::new(VirtualClock::new()));
8157        let cache = Rc::new(RefCell::new(Cache::default()));
8158        let mut manager =
8159            ExecutionManager::new(clock, cache.clone(), ExecutionManagerConfig::default())
8160                .expect("valid config");
8161        let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
8162        let client_order_id = ClientOrderId::from("O-MASS-VOID-001");
8163        let venue_order_id = VenueOrderId::from("V-MASS-VOID-001");
8164        let account_id = AccountId::from("TEST-001");
8165        cache
8166            .borrow_mut()
8167            .add_instrument(instrument.clone())
8168            .unwrap();
8169        insert_accepted_limit_order(
8170            &cache,
8171            client_order_id,
8172            venue_order_id,
8173            instrument.id(),
8174            ClientId::from("BINANCE"),
8175        );
8176        let order = cache.borrow().order_owned(&client_order_id).unwrap();
8177        let initial_fill = TestOrderEventStubs::filled(
8178            &order,
8179            &instrument,
8180            Some(TradeId::from("T-MASS-VOID-INITIAL")),
8181            None,
8182            Some(Price::from("100.0")),
8183            Some(Quantity::from("6.0")),
8184            Some(LiquiditySide::Taker),
8185            None,
8186            None,
8187            Some(account_id),
8188        );
8189        cache.borrow_mut().update_order(&initial_fill).unwrap();
8190        let order = cache.borrow().order_owned(&client_order_id).unwrap();
8191
8192        let report = OrderStatusReport::new(
8193            account_id,
8194            instrument.id(),
8195            Some(client_order_id),
8196            venue_order_id,
8197            OrderSide::Buy.into(),
8198            OrderType::Limit,
8199            TimeInForce::Gtc,
8200            OrderStatus::Canceled,
8201            Quantity::from("10.0"),
8202            Quantity::from("5.0"),
8203            UnixNanos::from(1_000),
8204            UnixNanos::from(1_000),
8205            UnixNanos::from(1_000),
8206            None,
8207        );
8208
8209        let companion_fill = FillReport::new(
8210            account_id,
8211            instrument.id(),
8212            venue_order_id,
8213            TradeId::from("T-MASS-VOID-COMPANION"),
8214            OrderSide::Buy,
8215            Quantity::from("1.0"),
8216            Price::from("100.0"),
8217            Money::zero(instrument.quote_currency()),
8218            LiquiditySide::Taker,
8219            Some(client_order_id),
8220            None,
8221            UnixNanos::from(900),
8222            UnixNanos::from(1_000),
8223            None,
8224        );
8225
8226        let mut fill_queue = ReconciliationFillQueue::default();
8227        let events = manager.reconcile_order_with_fills(
8228            true,
8229            &order,
8230            &report,
8231            &[&companion_fill],
8232            Some(&instrument),
8233            &mut fill_queue,
8234            None,
8235        );
8236        let mut projected = order;
8237        for event in &events {
8238            projected.apply(event.clone()).unwrap();
8239        }
8240
8241        assert!(matches!(events[0], OrderEventAny::Filled(_)));
8242        assert_eq!(
8243            events
8244                .iter()
8245                .filter(|event| matches!(event, OrderEventAny::FillVoided(_)))
8246                .count(),
8247            2
8248        );
8249        assert_eq!(projected.status(), OrderStatus::Canceled);
8250        assert_eq!(projected.filled_qty(), Quantity::from("5.0"));
8251        assert_eq!(projected.voided_qty(), Quantity::from("2.0"));
8252    }
8253
8254    fn insert_accepted_limit_order(
8255        cache: &Rc<RefCell<Cache>>,
8256        client_order_id: ClientOrderId,
8257        venue_order_id: VenueOrderId,
8258        instrument_id: InstrumentId,
8259        client_id: ClientId,
8260    ) {
8261        let account_id = AccountId::from("TEST-001");
8262        let order = OrderTestBuilder::new(OrderType::Limit)
8263            .client_order_id(client_order_id)
8264            .instrument_id(instrument_id)
8265            .quantity(Quantity::from("10.0"))
8266            .price(Price::from("100.0"))
8267            .build();
8268        let submitted = TestOrderEventStubs::submitted(&order, account_id);
8269        cache
8270            .borrow_mut()
8271            .add_order(order, None, Some(client_id), false)
8272            .unwrap();
8273        let order = cache.borrow_mut().update_order(&submitted).unwrap();
8274        let accepted = TestOrderEventStubs::accepted(&order, account_id, venue_order_id);
8275        cache.borrow_mut().update_order(&accepted).unwrap();
8276    }
8277
8278    fn test_bybit_spot_instrument() -> InstrumentAny {
8279        InstrumentAny::CurrencyPair(
8280            CurrencyPair::builder()
8281                .instrument_id(InstrumentId::from("ETHUSDT-SPOT.BYBIT"))
8282                .raw_symbol(Symbol::from("ETHUSDT"))
8283                .base_currency(Currency::from("ETH"))
8284                .quote_currency(Currency::from("USDT"))
8285                .price_precision(2)
8286                .size_precision(5)
8287                .price_increment(Price::from("0.01"))
8288                .size_increment(Quantity::from("0.00001"))
8289                .ts_event(UnixNanos::default())
8290                .ts_init(UnixNanos::default())
8291                .build()
8292                .unwrap(),
8293        )
8294    }
8295
8296    fn insert_open_position(
8297        cache: &Rc<RefCell<Cache>>,
8298        instrument: &InstrumentAny,
8299        position_id: PositionId,
8300        side: OrderSide,
8301        quantity: &str,
8302        price: &str,
8303    ) -> Position {
8304        let order = OrderTestBuilder::new(OrderType::Market)
8305            .instrument_id(instrument.id())
8306            .side(side)
8307            .quantity(Quantity::from(quantity))
8308            .build();
8309        let fill = TestOrderEventStubs::filled(
8310            &order,
8311            instrument,
8312            Some(TradeId::new("T-REPORT-001")),
8313            Some(position_id),
8314            Some(Price::from(price)),
8315            Some(Quantity::from(quantity)),
8316            None,
8317            None,
8318            None,
8319            Some(AccountId::from("TEST-001")),
8320        );
8321        let order_filled: OrderFilled = fill.into();
8322        let position = Position::new(instrument, order_filled);
8323        cache
8324            .borrow_mut()
8325            .add_position(&position, OmsType::Hedging)
8326            .unwrap();
8327        position
8328    }
8329
8330    fn close_long_position(
8331        mut position: Position,
8332        instrument: &InstrumentAny,
8333        trade_id: TradeId,
8334    ) -> Position {
8335        let order = OrderTestBuilder::new(OrderType::Market)
8336            .instrument_id(instrument.id())
8337            .side(OrderSide::Sell)
8338            .quantity(position.quantity)
8339            .build();
8340        let fill = TestOrderEventStubs::filled(
8341            &order,
8342            instrument,
8343            Some(trade_id),
8344            Some(position.id),
8345            Some(Price::from("3000.00")),
8346            Some(position.quantity),
8347            None,
8348            None,
8349            None,
8350            Some(position.account_id),
8351        );
8352        let order_filled: OrderFilled = fill.into();
8353        position.apply(&order_filled);
8354        position
8355    }
8356
8357    #[cfg(feature = "node")]
8358    mod node {
8359        use nautilus_model::events::order::spec::OrderFillVoidedSpec;
8360
8361        use super::*;
8362        use crate::execution::client::LiveExecutionClient;
8363
8364        #[rstest]
8365        fn test_position_fill_reports_contained_prefix_matches_full_report(
8366            #[values(
8367                "account",
8368                "instrument",
8369                "venue_order",
8370                "client_order",
8371                "trade",
8372                "position",
8373                "side",
8374                "price",
8375                "liquidity",
8376                "quantity",
8377                "commission",
8378                "currency"
8379            )]
8380            field: &str,
8381        ) {
8382            let (manager, _, report) = position_history_fixture();
8383            let mut changed = report.clone();
8384            match field {
8385                "account" => changed.account_id = AccountId::from("OTHER-002"),
8386                "instrument" => changed.instrument_id = InstrumentId::from("OTHER.SIM"),
8387                "venue_order" => changed.venue_order_id = VenueOrderId::from("V-OTHER"),
8388                "client_order" => changed.client_order_id = Some(ClientOrderId::from("O-OTHER")),
8389                "trade" => changed.trade_id = TradeId::from("T-OTHER"),
8390                "position" => changed.venue_position_id = Some(PositionId::from("P-OTHER")),
8391                "side" => changed.order_side = OrderSide::Sell,
8392                "price" => changed.last_px = Price::from("3101.00"),
8393                "liquidity" => changed.liquidity_side = LiquiditySide::Maker,
8394                "quantity" => changed.last_qty = Quantity::from("3.000"),
8395                "commission" => changed.commission = Money::from("0.17 USDT"),
8396                "currency" => changed.commission = Money::from("0.13 USD"),
8397                _ => unreachable!(),
8398            }
8399
8400            let reports = [report.clone(), changed, report.clone()];
8401            let scalar: Vec<_> = reports
8402                .iter()
8403                .map(|report| manager.position_contains_fill_report(report))
8404                .collect();
8405            let prefix = manager.position_fill_reports_contained_prefix(&reports);
8406            let repeated =
8407                manager.position_fill_reports_contained_prefix(&[report.clone(), report]);
8408
8409            assert_eq!(scalar, vec![true, false, true]);
8410            assert_eq!(prefix, 1);
8411            assert_eq!(repeated, 2);
8412            assert_eq!(manager.position_fill_reports_contained_prefix(&[]), 0);
8413        }
8414
8415        #[rstest]
8416        fn test_position_fill_reports_contained_prefix_indexes_only_routed_positions(
8417            #[values(false, true)] closed: bool,
8418            #[values(false, true)] missing: bool,
8419        ) {
8420            let (manager, cache, mut report) = position_history_fixture();
8421            let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
8422            let position = insert_open_position(
8423                &cache,
8424                &instrument,
8425                PositionId::from("P-UNRELATED"),
8426                OrderSide::Buy,
8427                "4.000",
8428                "3101.00",
8429            );
8430
8431            if closed {
8432                let position =
8433                    close_long_position(position, &instrument, TradeId::from("T-UNRELATED-CLOSE"));
8434                cache.borrow_mut().update_position(&position).unwrap();
8435            }
8436
8437            let trade_id = report.trade_id;
8438            if missing {
8439                report.trade_id = TradeId::from("T-MISSING");
8440            }
8441
8442            let prefix =
8443                manager.position_fill_reports_contained_prefix(&[report.clone(), report.clone()]);
8444            let cache = cache.borrow();
8445            let positions = cache.positions_refs(
8446                None,
8447                Some(&report.instrument_id),
8448                None,
8449                Some(&report.account_id),
8450                None,
8451            );
8452            let mut replay = IndexMap::new();
8453            let contained = position_fill_report_matches(
8454                &cache,
8455                &report,
8456                &positions,
8457                |id| cache.hedging_flip_position_ids(id),
8458                Some(&mut replay),
8459            );
8460
8461            assert_eq!(positions.len(), 2);
8462            assert_eq!(contained, !missing);
8463            assert_eq!(prefix, if missing { 0 } else { 2 });
8464            assert_eq!(
8465                replay,
8466                IndexMap::from([(
8467                    report.venue_position_id.unwrap(),
8468                    IndexMap::from([(trade_id, vec![0])]),
8469                )]),
8470            );
8471        }
8472
8473        #[rstest]
8474        fn test_position_fill_reports_contained_prefix_resolves_client_order() {
8475            let (manager, cache, mut report) = position_history_fixture();
8476            let position_id = report.venue_position_id.unwrap();
8477            cache
8478                .borrow_mut()
8479                .add_venue_order_id(
8480                    &report.client_order_id.unwrap(),
8481                    &report.venue_order_id,
8482                    false,
8483                )
8484                .unwrap();
8485            report.client_order_id = None;
8486            let before =
8487                manager.position_fill_reports_contained_prefix(&[report.clone(), report.clone()]);
8488            {
8489                let mut cache = cache.borrow_mut();
8490                let mut position = cache.position_mut(&position_id).unwrap();
8491
8492                let PositionReplayEvent::Filled(fill) = &mut position.replay_events[0] else {
8493                    unreachable!()
8494                };
8495
8496                fill.client_order_id = ClientOrderId::from("O-OTHER");
8497            }
8498
8499            let after = manager.position_fill_reports_contained_prefix(&[report.clone(), report]);
8500
8501            assert_eq!(before, 2);
8502            assert_eq!(after, 0);
8503        }
8504
8505        #[rstest]
8506        fn test_position_fill_reports_contained_prefix_retains_reordered_fragments(
8507            #[values(false, true)] reverse: bool,
8508        ) {
8509            let (manager, cache, mut report) = position_history_fixture();
8510            let position_id = report.venue_position_id.unwrap();
8511            {
8512                let mut cache = cache.borrow_mut();
8513                let mut position = cache.position_mut(&position_id).unwrap();
8514
8515                let PositionReplayEvent::Filled(mut fragment) = position.replay_events[0].clone()
8516                else {
8517                    unreachable!()
8518                };
8519
8520                fragment.last_qty = Quantity::from("3.000");
8521                fragment.commission = Some(Money::from("0.29 USDT"));
8522                let mut unrelated = fragment.clone();
8523                unrelated.trade_id = TradeId::from("T-UNRELATED");
8524                position
8525                    .replay_events
8526                    .push(PositionReplayEvent::Filled(unrelated));
8527                position
8528                    .replay_events
8529                    .push(PositionReplayEvent::Filled(fragment));
8530
8531                if reverse {
8532                    position.replay_events.reverse();
8533                }
8534            }
8535
8536            let original =
8537                manager.position_fill_reports_contained_prefix(&[report.clone(), report.clone()]);
8538            report.last_qty = Quantity::from("5.000");
8539            report.commission = Money::from("0.42 USDT");
8540            let combined =
8541                manager.position_fill_reports_contained_prefix(&[report.clone(), report.clone()]);
8542            let scalar = manager.position_contains_fill_report(&report);
8543
8544            assert_eq!(original, 0);
8545            assert_eq!(combined, 2);
8546            assert!(scalar);
8547        }
8548
8549        #[rstest]
8550        fn test_position_fill_reports_contained_prefix_rechecks_after_applied_fill() {
8551            let (manager, cache, first) = position_history_fixture();
8552            let position_id = first.venue_position_id.unwrap();
8553            let mut second = first.clone();
8554            second.trade_id = TradeId::from("T-NEXT");
8555            second.last_qty = Quantity::from("1.500");
8556            second.last_px = Price::from("3110.00");
8557            second.commission = Money::from("0.29 USDT");
8558            let reports = [first, second.clone()];
8559            let before = manager.position_fill_reports_contained_prefix(&reports);
8560            {
8561                let mut cache = cache.borrow_mut();
8562                let mut position = cache.position_mut(&position_id).unwrap();
8563
8564                let PositionReplayEvent::Filled(mut fill) = position.replay_events[0].clone()
8565                else {
8566                    unreachable!()
8567                };
8568
8569                fill.trade_id = second.trade_id;
8570                fill.last_qty = second.last_qty;
8571                fill.last_px = second.last_px;
8572                fill.commission = Some(second.commission);
8573                fill.event_id = UUID4::new();
8574                position.apply(&fill);
8575            }
8576
8577            let after = manager.position_fill_reports_contained_prefix(&reports);
8578            let cache = cache.borrow();
8579            let position = cache.position_ref(&position_id).unwrap();
8580
8581            assert_eq!(before, 1);
8582            assert_eq!(after, 2);
8583            assert_eq!(position.quantity, Quantity::from("3.500"));
8584            assert_eq!(position.commissions(), vec![Money::from("0.42 USDT")]);
8585            assert_eq!(position.replay_events.len(), 2);
8586            assert_eq!(
8587                manager.position_activity_revision(&(second.instrument_id, second.account_id)),
8588                0
8589            );
8590        }
8591
8592        #[rstest]
8593        fn test_position_fill_reports_contained_prefix_rebuilds_after_history_changes(
8594            #[values("missing_commission", "currency", "payload", "removal")] mutation: &str,
8595        ) {
8596            let (manager, cache, report) = position_history_fixture();
8597            let reports = [report.clone(), report.clone()];
8598            let before = manager.position_fill_reports_contained_prefix(&reports);
8599            let revision =
8600                manager.position_activity_revision(&(report.instrument_id, report.account_id));
8601            {
8602                let mut cache = cache.borrow_mut();
8603
8604                if mutation == "removal" {
8605                    let position_id = report.venue_position_id.unwrap();
8606                    {
8607                        let mut position = cache.position_mut(&position_id).unwrap();
8608
8609                        let PositionReplayEvent::Filled(mut closing) =
8610                            position.replay_events[0].clone()
8611                        else {
8612                            unreachable!()
8613                        };
8614
8615                        closing.trade_id = TradeId::from("T-HISTORY-CLOSE");
8616                        closing.order_side = OrderSide::Sell;
8617                        closing.event_id = UUID4::new();
8618                        position.apply(&closing);
8619                    }
8620
8621                    cache.purge_position(position_id, false).unwrap();
8622                } else {
8623                    let mut position = cache
8624                        .position_mut(&report.venue_position_id.unwrap())
8625                        .unwrap();
8626
8627                    let PositionReplayEvent::Filled(fill) = &mut position.replay_events[0] else {
8628                        unreachable!()
8629                    };
8630
8631                    match mutation {
8632                        "missing_commission" => fill.commission = None,
8633                        "currency" => fill.commission = Some(Money::from("0.13 USD")),
8634                        "payload" => fill.last_px = Price::from("3101.00"),
8635                        _ => unreachable!(),
8636                    }
8637                }
8638            }
8639
8640            let after = manager.position_fill_reports_contained_prefix(&reports);
8641            let revision_after =
8642                manager.position_activity_revision(&(report.instrument_id, report.account_id));
8643
8644            assert_eq!(before, 2);
8645            assert_eq!(after, 0);
8646            assert_eq!(revision, 0);
8647            assert_eq!(revision_after, 0);
8648        }
8649
8650        #[rstest]
8651        fn test_position_fill_reports_contained_prefix_preserves_virtual_flip_proof(
8652            #[values(
8653                "unchanged",
8654                "missing_source",
8655                "conflicting_fragment",
8656                "opening_void",
8657                "closing_void"
8658            )]
8659            change: &str,
8660        ) {
8661            let (manager, cache, first) = position_history_fixture();
8662            let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
8663            let source_id = first.venue_position_id.unwrap();
8664            let destination_id = PositionId::from("P-HISTORY-DESTINATION");
8665            let mut order = OrderTestBuilder::new(OrderType::Market)
8666                .instrument_id(instrument.id())
8667                .client_order_id(ClientOrderId::from("O-HISTORY-FLIP"))
8668                .side(OrderSide::Sell)
8669                .quantity(Quantity::from("5.000"))
8670                .build();
8671            order
8672                .apply(TestOrderEventStubs::submitted(&order, first.account_id))
8673                .unwrap();
8674            order
8675                .apply(TestOrderEventStubs::accepted(
8676                    &order,
8677                    first.account_id,
8678                    VenueOrderId::from("V-HISTORY-FLIP"),
8679                ))
8680                .unwrap();
8681            let event = TestOrderEventStubs::filled(
8682                &order,
8683                &instrument,
8684                Some(TradeId::from("T-HISTORY-FLIP")),
8685                Some(source_id),
8686                Some(Price::from("3100.00")),
8687                Some(Quantity::from("3.000")),
8688                Some(LiquiditySide::Taker),
8689                Some(Money::from("0.75 USDT")),
8690                None,
8691                Some(first.account_id),
8692            );
8693
8694            let OrderEventAny::Filled(fill) = event.clone() else {
8695                unreachable!()
8696            };
8697
8698            order.apply(event).unwrap();
8699            let (closing, opening) = fill
8700                .split_for_position_flip(
8701                    Quantity::from("2.000"),
8702                    Some(destination_id),
8703                    UUID4::new(),
8704                )
8705                .unwrap();
8706            {
8707                let mut cache = cache.borrow_mut();
8708                cache.position_mut(&source_id).unwrap().apply(&closing);
8709                cache
8710                    .add_order(order, Some(source_id), None, false)
8711                    .unwrap();
8712                cache
8713                    .add_position(&Position::new(&instrument, opening), OmsType::Hedging)
8714                    .unwrap();
8715            }
8716
8717            let mut report = FillReport::new(
8718                fill.account_id,
8719                fill.instrument_id,
8720                fill.venue_order_id,
8721                fill.trade_id,
8722                fill.order_side,
8723                fill.last_qty,
8724                fill.last_px,
8725                fill.commission.unwrap(),
8726                fill.liquidity_side,
8727                Some(fill.client_order_id),
8728                Some(source_id),
8729                fill.ts_event,
8730                fill.ts_init,
8731                None,
8732            );
8733            let before =
8734                manager.position_fill_reports_contained_prefix(&[report.clone(), report.clone()]);
8735            {
8736                let mut cache = cache.borrow_mut();
8737
8738                match change {
8739                    "unchanged" => {}
8740                    "missing_source" => cache.purge_position(source_id, false).unwrap(),
8741                    "conflicting_fragment" => {
8742                        let mut position = cache.position_mut(&destination_id).unwrap();
8743
8744                        let PositionReplayEvent::Filled(fragment) = &mut position.replay_events[0]
8745                        else {
8746                            unreachable!()
8747                        };
8748
8749                        fragment.last_px = Price::from("3101.00");
8750                    }
8751                    "opening_void" | "closing_void" => void_position_history_flip(
8752                        &mut cache,
8753                        &fill,
8754                        source_id,
8755                        destination_id,
8756                        change == "closing_void",
8757                    ),
8758                    _ => unreachable!(),
8759                }
8760            }
8761
8762            let original_after =
8763                manager.position_fill_reports_contained_prefix(&[report.clone(), report.clone()]);
8764            if change == "missing_source" {
8765                report.venue_position_id = None;
8766                report.last_qty = Quantity::from("1.000");
8767                report.commission = Money::from("0.25 USDT");
8768            } else if change == "conflicting_fragment" {
8769                report.last_qty = Quantity::from("2.000");
8770                report.commission = Money::from("0.50 USDT");
8771            } else if change == "opening_void" {
8772                report.last_qty = Quantity::from("2.500");
8773                report.commission = Money::from("0.625 USDT");
8774            } else if change == "closing_void" {
8775                report.last_qty = Quantity::from("1.500");
8776                report.commission = Money::from("0.375 USDT");
8777            }
8778
8779            let after =
8780                manager.position_fill_reports_contained_prefix(&[report.clone(), report.clone()]);
8781            let scalar = manager.position_contains_fill_report(&report);
8782            let mixed = manager.position_fill_reports_contained_prefix(&[
8783                first,
8784                report.clone(),
8785                report.clone(),
8786            ]);
8787            let expected = !matches!(change, "missing_source" | "conflicting_fragment");
8788
8789            assert_eq!(before, 2);
8790            assert_eq!(original_after, if change == "unchanged" { 2 } else { 0 });
8791            assert_eq!(after, if expected { 2 } else { 0 });
8792            assert_eq!(scalar, expected);
8793
8794            let expected_mixed = match change {
8795                "missing_source" => 0,
8796                "conflicting_fragment" => 1,
8797                _ => 3,
8798            };
8799
8800            assert_eq!(mixed, expected_mixed);
8801            assert_eq!(
8802                manager.position_activity_revision(&(report.instrument_id, report.account_id)),
8803                0
8804            );
8805
8806            if expected {
8807                let cache = cache.borrow();
8808                let source = cache.position_ref(&source_id).unwrap();
8809                let destination = cache.position_ref(&destination_id).unwrap();
8810                assert_eq!(
8811                    source.quantity,
8812                    Quantity::from(if change == "closing_void" {
8813                        "0.500"
8814                    } else {
8815                        "0.000"
8816                    })
8817                );
8818                assert_eq!(
8819                    destination.quantity,
8820                    Quantity::from(match change {
8821                        "closing_void" => "0.000",
8822                        "opening_void" => "0.500",
8823                        _ => "1.000",
8824                    })
8825                );
8826                assert_eq!(
8827                    source.commissions(),
8828                    vec![Money::from(if change == "closing_void" {
8829                        "0.505 USDT"
8830                    } else {
8831                        "0.63 USDT"
8832                    })]
8833                );
8834
8835                let destination_commissions = if change == "closing_void" {
8836                    Vec::new()
8837                } else {
8838                    vec![Money::from(if change == "opening_void" {
8839                        "0.125 USDT"
8840                    } else {
8841                        "0.25 USDT"
8842                    })]
8843                };
8844
8845                assert_eq!(destination.commissions(), destination_commissions);
8846            }
8847        }
8848
8849        fn void_position_history_flip(
8850            cache: &mut Cache,
8851            fill: &OrderFilled,
8852            source_id: PositionId,
8853            destination_id: PositionId,
8854            closing_void: bool,
8855        ) {
8856            let correction = OrderFillVoidedSpec::builder()
8857                .trader_id(fill.trader_id)
8858                .strategy_id(fill.strategy_id)
8859                .instrument_id(fill.instrument_id)
8860                .client_order_id(fill.client_order_id)
8861                .venue_order_id(fill.venue_order_id)
8862                .account_id(fill.account_id)
8863                .trade_id(fill.trade_id)
8864                .voided_qty(Quantity::from(if closing_void { "1.500" } else { "0.500" }))
8865                .order_side(fill.order_side)
8866                .order_type(fill.order_type)
8867                .last_px(fill.last_px)
8868                .currency(fill.currency)
8869                .liquidity_side(fill.liquidity_side)
8870                .position_id(source_id)
8871                .commission_voided(Money::from(if closing_void {
8872                    "0.375 USDT"
8873                } else {
8874                    "0.125 USDT"
8875                }))
8876                .is_reopened(true)
8877                .build();
8878
8879            cache
8880                .position_mut(&destination_id)
8881                .unwrap()
8882                .apply_fill_void(
8883                    correction.clone(),
8884                    Quantity::from(if closing_void { "1.000" } else { "0.500" }),
8885                    Some(Money::from(if closing_void {
8886                        "0.25 USDT"
8887                    } else {
8888                        "0.125 USDT"
8889                    })),
8890                )
8891                .unwrap();
8892
8893            if closing_void {
8894                cache
8895                    .position_mut(&source_id)
8896                    .unwrap()
8897                    .apply_fill_void(
8898                        correction,
8899                        Quantity::from("0.500"),
8900                        Some(Money::from("0.125 USDT")),
8901                    )
8902                    .unwrap();
8903            }
8904        }
8905
8906        fn position_history_fixture() -> (ExecutionManager, Rc<RefCell<Cache>>, FillReport) {
8907            let cache = Rc::new(RefCell::new(Cache::default()));
8908            let manager = ExecutionManager::new(
8909                Rc::new(RefCell::new(VirtualClock::new())),
8910                cache.clone(),
8911                ExecutionManagerConfig::default(),
8912            )
8913            .unwrap();
8914            let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
8915            let order = OrderTestBuilder::new(OrderType::Market)
8916                .instrument_id(instrument.id())
8917                .client_order_id(ClientOrderId::from("O-HISTORY"))
8918                .side(OrderSide::Buy)
8919                .quantity(Quantity::from("10.000"))
8920                .build();
8921            let position_id = PositionId::from("P-HISTORY");
8922            let event = TestOrderEventStubs::filled(
8923                &order,
8924                &instrument,
8925                Some(TradeId::from("T-HISTORY")),
8926                Some(position_id),
8927                Some(Price::from("3100.00")),
8928                Some(Quantity::from("2.000")),
8929                Some(LiquiditySide::Taker),
8930                Some(Money::from("0.13 USDT")),
8931                None,
8932                Some(AccountId::from("TEST-001")),
8933            );
8934
8935            let OrderEventAny::Filled(fill) = event else {
8936                unreachable!()
8937            };
8938
8939            let report = FillReport::new(
8940                fill.account_id,
8941                fill.instrument_id,
8942                fill.venue_order_id,
8943                fill.trade_id,
8944                fill.order_side,
8945                fill.last_qty,
8946                fill.last_px,
8947                fill.commission.unwrap(),
8948                fill.liquidity_side,
8949                Some(fill.client_order_id),
8950                Some(position_id),
8951                fill.ts_event,
8952                fill.ts_init,
8953                None,
8954            );
8955            let position = Position::new(&instrument, fill);
8956            cache
8957                .borrow_mut()
8958                .add_position(&position, OmsType::Hedging)
8959                .unwrap();
8960            (manager, cache, report)
8961        }
8962
8963        #[rstest]
8964        fn test_plan_position_fill_reports_uses_configured_lookback() {
8965            let lookback_mins = 7_u64;
8966            let lookback = DurationNanos::from_mins(lookback_mins);
8967            let clock = Rc::new(RefCell::new(VirtualClock::new()));
8968            let cache = Rc::new(RefCell::new(Cache::default()));
8969
8970            let mut manager = ExecutionManager::new(
8971                clock.clone(),
8972                cache.clone(),
8973                ExecutionManagerConfig {
8974                    position_check_lookback_mins: lookback_mins,
8975                    position_check_threshold_ns: DurationNanos::ZERO,
8976                    ..Default::default()
8977                },
8978            )
8979            .expect("valid config");
8980
8981            let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
8982            cache
8983                .borrow_mut()
8984                .add_instrument(instrument.clone())
8985                .unwrap();
8986            let position = insert_open_position(
8987                &cache,
8988                &instrument,
8989                PositionId::from("P-FILL-LOOKBACK"),
8990                OrderSide::Buy,
8991                "1.0",
8992                "3000.00",
8993            );
8994            clock
8995                .borrow_mut()
8996                .advance_time(UnixNanos::default().saturating_add(lookback * 2), true);
8997            let client = PositionCoverageStubClient;
8998            let clients: [&dyn ExecutionClient; 1] = [&client];
8999            let mut check = manager.prepare_position_report_check(UUID4::new(), &clients);
9000            let query_end = clock.borrow().timestamp_ns();
9001
9002            let report = PositionStatusReport::new(
9003                position.account_id,
9004                position.instrument_id,
9005                PositionSide::Long,
9006                Quantity::from("2.0"),
9007                query_end,
9008                query_end,
9009                None,
9010                None,
9011                Some(dec!(3000.00)),
9012            );
9013            let queried_clients = IndexSet::from([client.client_id()]);
9014
9015            let plan = manager.plan_position_fill_reports(
9016                &mut check,
9017                &[report],
9018                &queried_clients,
9019                &IndexSet::new(),
9020                &clients,
9021            );
9022
9023            assert_eq!(
9024                plan.discrepancy_keys,
9025                IndexSet::from([(position.instrument_id, position.account_id)])
9026            );
9027            assert_eq!(plan.queries.len(), 1);
9028            let query = &plan.queries[0];
9029            assert_eq!(
9030                (query.key, query.client_id),
9031                (
9032                    (position.instrument_id, position.account_id),
9033                    client.client_id()
9034                )
9035            );
9036            assert_eq!(query.command.instrument_id, Some(position.instrument_id));
9037            assert_eq!(query.command.venue_order_id, None);
9038            assert_eq!(
9039                query.command.start,
9040                Some(query_end.saturating_sub(lookback))
9041            );
9042            assert_eq!(query.command.end, Some(query_end));
9043            assert_eq!(query.command.correlation_id, Some(check.command.command_id));
9044            assert_eq!(query.command.log_receipt_level, LogLevel::Debug);
9045        }
9046
9047        #[rstest]
9048        #[case::reported(Some("2.0"), true)]
9049        #[case::unreported(None, false)]
9050        fn test_plan_position_fill_reports_unavailable_coverage_requires_venue_report(
9051            #[case] venue_qty: Option<&str>,
9052            #[case] expect_query: bool,
9053        ) {
9054            let clock = Rc::new(RefCell::new(VirtualClock::new()));
9055            let cache = Rc::new(RefCell::new(Cache::default()));
9056
9057            let mut manager = ExecutionManager::new(
9058                clock.clone(),
9059                cache.clone(),
9060                ExecutionManagerConfig {
9061                    position_check_threshold_ns: DurationNanos::ZERO,
9062                    ..Default::default()
9063                },
9064            )
9065            .expect("valid config");
9066
9067            let spot = test_bybit_spot_instrument();
9068            cache.borrow_mut().add_instrument(spot.clone()).unwrap();
9069            let position = insert_open_position(
9070                &cache,
9071                &spot,
9072                PositionId::from("P-SPOT-UNAVAILABLE"),
9073                OrderSide::Buy,
9074                "1.0",
9075                "2000.00",
9076            );
9077            let key = (position.instrument_id, position.account_id);
9078            let client = PositionCoverageStubClient;
9079            let clients: [&dyn ExecutionClient; 1] = [&client];
9080            let mut check = manager.prepare_position_report_check(UUID4::new(), &clients);
9081            let ts_now = clock.borrow().timestamp_ns();
9082
9083            let reports: Vec<PositionStatusReport> = venue_qty
9084                .into_iter()
9085                .map(|qty| {
9086                    PositionStatusReport::new(
9087                        position.account_id,
9088                        position.instrument_id,
9089                        PositionSide::Long,
9090                        Quantity::from(qty),
9091                        ts_now,
9092                        ts_now,
9093                        None,
9094                        None,
9095                        Some(dec!(2000.00)),
9096                    )
9097                })
9098                .collect();
9099
9100            let queried_clients = IndexSet::from([client.client_id()]);
9101
9102            let plan = manager.plan_position_fill_reports(
9103                &mut check,
9104                &reports,
9105                &queried_clients,
9106                &IndexSet::new(),
9107                &clients,
9108            );
9109
9110            let expected_queries = if expect_query {
9111                vec![(key, client.client_id())]
9112            } else {
9113                Vec::new()
9114            };
9115
9116            assert_eq!(
9117                check.client_coverage.get(&key),
9118                Some(&ReportClientCoverage::Unavailable(IndexSet::from([
9119                    client.client_id()
9120                ])))
9121            );
9122            assert_eq!(plan.discrepancy_keys, IndexSet::from([key]));
9123            assert_eq!(
9124                plan.queries
9125                    .iter()
9126                    .map(|query| (query.key, query.client_id))
9127                    .collect::<Vec<_>>(),
9128                expected_queries
9129            );
9130        }
9131
9132        #[rstest]
9133        fn test_plan_position_fill_reports_defers_position_opened_during_request() {
9134            let clock = Rc::new(RefCell::new(VirtualClock::new()));
9135            let cache = Rc::new(RefCell::new(Cache::default()));
9136
9137            let mut manager = ExecutionManager::new(
9138                clock,
9139                cache.clone(),
9140                ExecutionManagerConfig {
9141                    position_check_threshold_ns: DurationNanos::ZERO,
9142                    ..Default::default()
9143                },
9144            )
9145            .expect("valid config");
9146
9147            let instrument = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
9148            cache
9149                .borrow_mut()
9150                .add_instrument(instrument.clone())
9151                .unwrap();
9152            let client = PositionCoverageStubClient;
9153            let clients: [&dyn ExecutionClient; 1] = [&client];
9154            let mut check = manager.prepare_position_report_check(UUID4::new(), &clients);
9155            let position = insert_open_position(
9156                &cache,
9157                &instrument,
9158                PositionId::from("P-FILL-DURING-REQUEST"),
9159                OrderSide::Buy,
9160                "1.0",
9161                "3000.00",
9162            );
9163            manager.record_position_activity(position.instrument_id, position.account_id);
9164
9165            let report = PositionStatusReport::new(
9166                position.account_id,
9167                position.instrument_id,
9168                PositionSide::Long,
9169                Quantity::from("2.0"),
9170                UnixNanos::from(1_000_000),
9171                UnixNanos::from(1_000_000),
9172                None,
9173                None,
9174                Some(dec!(3000.00)),
9175            );
9176
9177            let plan = manager.plan_position_fill_reports(
9178                &mut check,
9179                &[report],
9180                &IndexSet::from([client.client_id()]),
9181                &IndexSet::new(),
9182                &clients,
9183            );
9184
9185            assert_eq!(
9186                plan.discrepancy_keys,
9187                IndexSet::from([(position.instrument_id, position.account_id)])
9188            );
9189            assert!(plan.queries.is_empty());
9190            assert_eq!(
9191                check
9192                    .activity_revisions
9193                    .get(&(position.instrument_id, position.account_id)),
9194                Some(&0)
9195            );
9196        }
9197
9198        #[rstest]
9199        fn test_prepare_position_report_check_uses_live_client_bulk_coverage() {
9200            let clock = Rc::new(RefCell::new(VirtualClock::new()));
9201            let cache = Rc::new(RefCell::new(Cache::default()));
9202            let manager =
9203                ExecutionManager::new(clock, cache.clone(), ExecutionManagerConfig::default())
9204                    .expect("valid config");
9205            let derivative = InstrumentAny::CryptoPerpetual(crypto_perpetual_ethusdt());
9206            let spot = test_bybit_spot_instrument();
9207            cache
9208                .borrow_mut()
9209                .add_instrument(derivative.clone())
9210                .unwrap();
9211            cache.borrow_mut().add_instrument(spot.clone()).unwrap();
9212            let derivative_position = insert_open_position(
9213                &cache,
9214                &derivative,
9215                PositionId::from("P-DERIVATIVE-COVERAGE"),
9216                OrderSide::Buy,
9217                "5.0",
9218                "3000.00",
9219            );
9220            let spot_position = insert_open_position(
9221                &cache,
9222                &spot,
9223                PositionId::from("P-SPOT-COVERAGE"),
9224                OrderSide::Buy,
9225                "2.0",
9226                "2000.00",
9227            );
9228            let client = LiveExecutionClient::new(Box::new(PositionCoverageStubClient));
9229            let client: &dyn ExecutionClient = &client;
9230
9231            let check = manager.prepare_position_report_check(UUID4::new(), &[client]);
9232            let client_id = ClientId::from("BYBIT");
9233
9234            assert_eq!(
9235                check.client_coverage.get(&(
9236                    derivative_position.instrument_id,
9237                    derivative_position.account_id
9238                )),
9239                Some(&ReportClientCoverage::Resolved(IndexSet::from([client_id])))
9240            );
9241            assert_eq!(
9242                check
9243                    .client_coverage
9244                    .get(&(spot_position.instrument_id, spot_position.account_id)),
9245                Some(&ReportClientCoverage::Unavailable(IndexSet::from([
9246                    client_id
9247                ])))
9248            );
9249        }
9250    }
9251}