powerquant-cli 0.2.6__py3-none-any.whl

quant_core/app/order_execution/simulation_broker.py

@@ -0,0 +1,883 @@
+"""模拟 Broker：同步接单、冻结事件、订单生命周期与 Bar 撮合。
+
+定价由 BarMatcher 完成；成交与终态事件交给账户监听器入账和释放冻结。
+NEXT_BAR_OPEN 严格使用后续 Bar，CURRENT_BAR_CLOSE 可在回调内撮合；
+同一 Bar 的成交量限制在多次下单之间共享。
+"""
+
+from collections.abc import Mapping
+from datetime import datetime
+from decimal import ROUND_FLOOR, Decimal
+from uuid import uuid4
+
+from quant_core.app.data.constants import INSTRUMENT_ID_SEPARATOR
+from quant_core.app.data.schema.event_schema import (
+    BarEvent,
+    CoarseBarExecutionContext,
+    MarketTimeSlice,
+)
+from quant_core.app.data.schema.exchange_operating_state import ExchangeOperatingState
+from quant_core.app.data.schema.exchange_state_schema import ExchangePhase
+from quant_core.app.data.schema.trading_state_schema import (
+    InstrumentMarketState,
+    TradingState,
+)
+from quant_core.app.order_execution.bar_matcher import BarMatcher
+from quant_core.app.order_execution.constants import (
+    ExecutionAttemptOutcome,
+    ExecutionDeferReason,
+    ExecutionPolicy,
+    OrderAckStatus,
+    OrderRejectReason,
+    OrderSide,
+    OrderStatus,
+    OrderType,
+    OrderUpdateReason,
+    TimeInForce,
+    TradabilityDecision,
+)
+from quant_core.app.order_execution.domain.execution_batch import MarketSliceProcessingResult
+from quant_core.app.order_execution.domain.order_entity import Order
+from quant_core.app.order_execution.domain.order_event import (
+    ExecutionAttempt,
+    Fill,
+    OrderTransition,
+)
+from quant_core.app.order_execution.domain.order_policy import (
+    FeeModelProtocol,
+    SlippageModelProtocol,
+    TradabilityPolicyProtocol,
+)
+from quant_core.app.order_execution.domain.order_value import (
+    FeeBreakdown,
+    OrderAck,
+    OrderIntent,
+    OrderSnapshot,
+)
+from quant_core.app.order_execution.domain.order_value import (
+    TradabilityDecision as TradabilityDecisionRecord,
+)
+from quant_core.app.order_execution.interface.public.execution_account import (
+    IExecutionAccountView,
+    IExecutionReservation,
+)
+from quant_core.app.order_execution.interface.public.order_events import IOrderEvents
+from quant_core.app.order_execution.validators import reject_float_amount
+
+
+def instrument_exchange(instrument_id: str) -> str:
+    """Canonical instrument_id 的 Exchange 归属（权威格式 {market}.{exchange}.{symbol}）
+
+    复用 market 域文档化分隔符契约；不猜测、不硬编码市场。
+    """
+    parts = instrument_id.split(INSTRUMENT_ID_SEPARATOR)
+    if len(parts) != 3 or not parts[1]:
+        raise ValueError(f"无法从 Canonical instrument_id 解析 exchange：{instrument_id!r}")
+    return parts[1]
+
+
+def _attempt_event_refs(bar_event_id: str, decision: TradabilityDecisionRecord) -> tuple[str, ...]:
+    """Attempt 引用 = eligible Bar + Policy 决策证据（合并、去重、字典序稳定）
+
+    Engine 只合并/透传，不解释状态事实、不根据原因码或 Policy 类型推断引用。
+    """
+    return tuple(sorted({bar_event_id, *decision.evidence_event_refs}))
+
+
+def _processing_sort_key(order: Order) -> tuple[datetime, int, str]:
+    """片内稳定业务排序键：creation_event_time → submission_sequence → instrument_id"""
+    return (order.intent.creation_event_time, order.submission_sequence, order.intent.instrument_id)
+
+
+def _extract_slice_bars(time_slice: MarketTimeSlice) -> dict[str, BarEvent]:
+    """从切片提取每标的一根 Bar（矛盾输入即报错）
+
+    T4R：切片内的 Session 事件不再由本引擎解释——交易所运行状态完全来自
+    Runtime 注入的 ExchangeStateResolver 投影（唯一 SSOT）。
+    """
+    bars: dict[str, BarEvent] = {}
+    for event in time_slice.events:
+        if isinstance(event, BarEvent):
+            bar = event.payload
+            if bar.instrument_id in bars:
+                raise ValueError(f"同一时间片出现多根 {bar.instrument_id} Bar，属矛盾输入")
+            bars[bar.instrument_id] = event
+    return bars
+
+
+class SimulationBroker:
+    """确定性模拟撮合引擎；结构化满足 IOrderExecution
+
+    构造注入：TradabilityPolicyProtocol + FeeModelProtocol + SlippageModelProtocol；
+    引擎不硬编码具体 Policy、费率、滑点、市场字符串或 Runtime mode。
+    """
+
+    def __init__(
+        self,
+        tradability_policy: TradabilityPolicyProtocol,
+        fee_model: FeeModelProtocol,
+        slippage_model: SlippageModelProtocol,
+        max_volume_participation: Decimal = Decimal("0.10"),
+        market_price_buffer_ratio: Decimal = Decimal("0"),
+        reservation_enabled: bool = True,
+        events: IOrderEvents | None = None,
+    ) -> None:
+        self._events = events
+        self._policy = tradability_policy
+        self._fee_model = fee_model
+        self._matcher = BarMatcher(slippage_model)
+        checked_participation = reject_float_amount(
+            max_volume_participation, "max_volume_participation"
+        )
+        self._max_volume_participation = Decimal(str(checked_participation))
+        if not Decimal("0") < self._max_volume_participation <= Decimal("1"):
+            raise ValueError("max_volume_participation 必须位于 (0, 1]")
+        checked_buffer = reject_float_amount(market_price_buffer_ratio, "market_price_buffer_ratio")
+        self._market_price_buffer_ratio = Decimal(str(checked_buffer))
+        if self._market_price_buffer_ratio < 0:
+            raise ValueError("market_price_buffer_ratio 必须 >= 0")
+        self._reservation_enabled = reservation_enabled
+        self._orders: dict[str, Order] = {}
+        self._intent_ids: set[str] = set()
+        self._next_sequence = 0
+        self._last_slice_time: datetime | None = None
+        # T4R R3/R4：粗粒度（coarse）生命周期簿记——只记 coarse 决策点接受的
+        # 订单 ID。机会消耗（R4 finding 3）改为片内局部集合确定性派生：
+        # 机会只影响当前片，不保留任何跨片可泄漏状态。
+        self._coarse_order_ids: set[str] = set()  # coarse 决策点提交的订单
+        self._charged_fees: dict[str, FeeBreakdown] = {}
+        self._bar_volume_used: dict[str, int] = {}
+        self._current_slice: MarketTimeSlice | None = None
+        self._current_market_states: Mapping[str, InstrumentMarketState] = {}
+        self._current_exchange_states: Mapping[str, ExchangeOperatingState] = {}
+
+    # ------------------------------------------------------------------
+    # IOrderExecution
+    # ------------------------------------------------------------------
+
+    def submit(
+        self,
+        intents: tuple[OrderIntent, ...],
+        exchange_states: Mapping[str, ExchangeOperatingState],
+        execution_context: CoarseBarExecutionContext | None = None,
+    ) -> tuple[OrderAck, ...]:
+        return self._submit(
+            intents,
+            exchange_states,
+            execution_context=execution_context,
+        )
+
+    def estimate_transaction_cost(self, side: OrderSide, quantity: int, price: Decimal) -> Decimal:
+        """费用估算与成交共用注入模型。"""
+        return self._fee_model.compute(side, quantity, price).total
+
+    def estimate_order_cash(self, intent: OrderIntent, reference_price: Decimal) -> Decimal:
+        """下单预算与冻结共用费用和价格口径。"""
+        if intent.side is OrderSide.SELL:
+            return Decimal(0)
+        price = (
+            intent.limit_price
+            if intent.limit_price is not None
+            else reference_price * (Decimal(1) + self._market_price_buffer_ratio)
+        )
+        return (
+            Decimal(intent.quantity) * price
+            + self._fee_model.compute(intent.side, intent.quantity, price).total
+        )
+
+    def submit_with_reservation(
+        self,
+        intents: tuple[OrderIntent, ...],
+        exchange_states: Mapping[str, ExchangeOperatingState],
+        account_view: IExecutionReservation,
+        reference_prices: Mapping[str, Decimal],
+        execution_context: CoarseBarExecutionContext | None = None,
+    ) -> tuple[OrderAck, ...]:
+        if not self._reservation_enabled:
+            return self.submit(intents, exchange_states, execution_context)
+        return self._submit(
+            intents,
+            exchange_states,
+            account_view=account_view,
+            reference_prices=reference_prices,
+            execution_context=execution_context,
+        )
+
+    def _submit(
+        self,
+        intents: tuple[OrderIntent, ...],
+        exchange_states: Mapping[str, ExchangeOperatingState],
+        account_view: IExecutionReservation | None = None,
+        reference_prices: Mapping[str, Decimal] | None = None,
+        execution_context: CoarseBarExecutionContext | None = None,
+    ) -> tuple[OrderAck, ...]:
+        """提交意图批次：保持输入顺序逐条处理（确定性），每条恰一个 Ack
+
+        execution_context（T4R R3 方案 A）：粗粒度 decision point 的**有界**
+        执行资格——Intent 的交易所必须落在 context.eligible_exchanges 内；
+        范围外与投影不放行一致走 SESSION_CLOSED 拒绝。它不是交易所运行
+        状态事实，不与 ExchangePhase 混用。
+        """
+        acks: list[OrderAck] = []
+        batch_seen: set[str] = set()
+        for intent in intents:
+            event_time = intent.creation_event_time
+            if intent.intent_id in self._intent_ids or intent.intent_id in batch_seen:
+                acks.append(
+                    OrderAck(
+                        intent_id=intent.intent_id,
+                        status=OrderAckStatus.REJECTED,
+                        rejection_reason=OrderRejectReason.DUPLICATE_INTENT,
+                        event_time=event_time,
+                    )
+                )
+                continue
+            reason = self._static_reject_reason(intent)
+            if reason is not None:
+                acks.append(
+                    OrderAck(
+                        intent_id=intent.intent_id,
+                        status=OrderAckStatus.REJECTED,
+                        rejection_reason=reason,
+                        event_time=event_time,
+                    )
+                )
+                continue
+            # 报单准入（T4R R4 finding 2：授权来源互斥，绝不混合）：
+            # - execution_context 存在（coarse 决策片）：只按 Context scope
+            #   判定——范围外即使注入 OPEN 投影也 REJECTED；
+            # - execution_context 为 None（日内片）：只按 ExchangeState 投影
+            #   判定——order_entry_allowed 不允许（BREAK/CLOSED/未初始化
+            #   安全默认）→ SESSION_CLOSED 拒绝。
+            # 与其他 REJECTED 一致不创建 Order、不登记 intent_id
+            # （同一 Intent 开市恢复后可重新提交）
+            exchange_state = exchange_states.get(instrument_exchange(intent.instrument_id))
+            if execution_context is not None:
+                in_coarse_scope = (
+                    instrument_exchange(intent.instrument_id)
+                    in execution_context.eligible_exchanges
+                )
+                allowed = in_coarse_scope
+            else:
+                in_coarse_scope = False
+                allowed = exchange_state is not None and exchange_state.order_entry_allowed
+            if not allowed:
+                acks.append(
+                    OrderAck(
+                        intent_id=intent.intent_id,
+                        status=OrderAckStatus.REJECTED,
+                        rejection_reason=OrderRejectReason.SESSION_CLOSED,
+                        event_time=event_time,
+                    )
+                )
+                continue
+            batch_seen.add(intent.intent_id)
+            order_id = f"order-{uuid4().hex}"
+            reference_price = (
+                reference_prices.get(intent.instrument_id) if reference_prices is not None else None
+            )
+            cash_amount = Decimal("0")
+            if account_view is not None and intent.side is OrderSide.BUY:
+                reservation_price = intent.limit_price or reference_price
+                if reservation_price is None:
+                    acks.append(
+                        OrderAck(
+                            intent_id=intent.intent_id,
+                            status=OrderAckStatus.REJECTED,
+                            rejection_reason=OrderRejectReason.MISSING_REFERENCE_PRICE,
+                            event_time=event_time,
+                        )
+                    )
+                    continue
+                cash_amount = self.estimate_order_cash(intent, reservation_price)
+            reserved = True
+            if self._events is not None:
+                reserved = self._events.publish_pending_new(order_id, intent, cash_amount)
+            elif account_view is not None:
+                reserved = account_view.reserve_order(
+                    order_id,
+                    intent.instrument_id,
+                    intent.side,
+                    intent.quantity,
+                    cash_amount,
+                    event_time,
+                )
+            if not reserved:
+                acks.append(
+                    OrderAck(
+                        intent_id=intent.intent_id,
+                        status=OrderAckStatus.REJECTED,
+                        rejection_reason=OrderRejectReason.RESERVATION_FAILED,
+                        event_time=event_time,
+                    )
+                )
+                continue
+            self._intent_ids.add(intent.intent_id)
+            order = Order(
+                order_id=order_id,
+                intent=intent,
+                # 冻结契约下唯一确定的确定性问题时间：created >= intent.creation_event_time
+                created_event_time=intent.creation_event_time,
+                submission_sequence=self._next_sequence,
+            )
+            self._next_sequence += 1
+            self._orders[order_id] = order
+            if in_coarse_scope:  # 仅真正通过 coarse scope 接受的订单为 coarse origin
+                self._coarse_order_ids.add(order_id)
+            acks.append(
+                OrderAck(
+                    intent_id=intent.intent_id,
+                    status=OrderAckStatus.ACCEPTED,
+                    order_id=order_id,
+                    event_time=event_time,
+                )
+            )
+        return tuple(acks)
+
+    def process_market_slice(
+        self,
+        time_slice: MarketTimeSlice,
+        market_states: Mapping[str, InstrumentMarketState],
+        exchange_states: Mapping[str, ExchangeOperatingState],
+        account_view: IExecutionAccountView,
+    ) -> MarketSliceProcessingResult:
+        """消费一个时间片：撮合此前已生效订单（新单本片绝不参与撮合）
+
+        粗粒度片（time_slice.execution_context 非空，方案 A）：matching
+        由 execution_context 显式放行；且不做 DAY 日内到期判定——日线片
+        无「日内收盘」语义，到期归属后续粗粒度到期语义（见报告剩余限制）。
+        """
+        self._check_slice_time(time_slice.event_time)
+        self._bar_volume_used.clear()
+        self._current_slice = time_slice
+        self._current_market_states = market_states
+        self._current_exchange_states = exchange_states
+        return self._match(time_slice, market_states, exchange_states, account_view)
+
+    def match_current_slice(
+        self, account_view: IExecutionAccountView
+    ) -> MarketSliceProcessingResult:
+        """当前 Bar 模式在下单调用内撮合，累计成交量限制跨多次下单共享。"""
+        if self._current_slice is None:
+            raise RuntimeError("撮合前必须注入当前时间片")
+        return self._match(
+            self._current_slice,
+            self._current_market_states,
+            self._current_exchange_states,
+            account_view,
+            immediate=True,
+        )
+
+    def _match(
+        self,
+        time_slice: MarketTimeSlice,
+        market_states: Mapping[str, InstrumentMarketState],
+        exchange_states: Mapping[str, ExchangeOperatingState],
+        account_view: IExecutionAccountView,
+        *,
+        immediate: bool = False,
+    ) -> MarketSliceProcessingResult:
+        bars = _extract_slice_bars(time_slice)
+        # R3 finding 1：有界资格——scope 内才放行，绝不全局旁路
+        context = time_slice.execution_context
+
+        def _in_coarse_scope(instrument_id: str) -> bool:
+            return context is not None and (
+                instrument_exchange(instrument_id) in context.eligible_exchanges
+            )
+
+        pending = sorted(
+            (
+                o
+                for o in self._orders.values()
+                if o.status in {OrderStatus.PENDING, OrderStatus.PARTIALLY_FILLED}
+            ),
+            key=_processing_sort_key,
+        )
+
+        fills: list[Fill] = []
+        attempts: list[ExecutionAttempt] = []
+        updates: list[OrderTransition] = []
+        # R4 finding 3：机会消耗为片内局部集合（成功末尾无需提交、失败即
+        # 随局部作用域丢弃）；只允许 coarse origin 订单进入
+        opportunity_used_now: set[str] = set()
+        # 片内预算（执行期临时，不修改 Portfolio）
+        remaining_cash = account_view.available_cash()
+        remaining_available: dict[str, int] = {}
+        remaining_volume: dict[str, int] = {}
+
+        # 先完成全部可失败计算（定价/费用/预算/Attempt/Fill 构造），
+        # 收集迁移指令；任何失败发生在任何 Order 聚合变更之前。
+        transitions: list[
+            tuple[Order, OrderStatus, OrderUpdateReason, int | None, Decimal | None]
+        ] = []
+        # 本片已被撮合/取消的订单（迁移在批末统一应用，聚合状态尚未变更）
+        matched_order_ids: set[str] = set()
+        staged_charged_fees: dict[str, FeeBreakdown] = {}
+        for order in pending:
+            intent = order.intent
+            bar_event = bars.get(intent.instrument_id)
+            if immediate and intent.execution_policy is not ExecutionPolicy.CURRENT_BAR_CLOSE:
+                continue
+            if (
+                bar_event is None
+                or bar_event.event_time < intent.creation_event_time
+                or (
+                    bar_event.event_time == intent.creation_event_time
+                    and intent.execution_policy is not ExecutionPolicy.CURRENT_BAR_CLOSE
+                )
+            ):
+                continue  # 无 Bar / 尚不 eligible：未发生实际检查，不产生 Attempt
+            # 撮合准入（R4 finding 2：授权来源互斥，同 submit）：
+            # - coarse 片：只按 Context scope 判定；
+            # - 日内片：只按注入投影 matching_allowed（BREAK/CLOSED/未初始化
+            #   安全默认）判定 → DEFERRED，Order 保持 PENDING，恢复后重试。
+            exchange_state = exchange_states.get(instrument_exchange(intent.instrument_id))
+            if context is not None:
+                matching_allowed = _in_coarse_scope(intent.instrument_id)
+            else:
+                matching_allowed = exchange_state is not None and exchange_state.matching_allowed
+            if not matching_allowed:
+                attempts.append(
+                    ExecutionAttempt(
+                        order_id=order.order_id,
+                        event_time=time_slice.event_time,
+                        outcome=ExecutionAttemptOutcome.DEFERRED,
+                        defer_reason=ExecutionDeferReason.SESSION_NOT_TRADABLE,
+                        market_event_refs=(bar_event.event_id,),
+                    )
+                )
+                continue
+            market_state = market_states.get(
+                intent.instrument_id,
+                InstrumentMarketState(
+                    instrument_id=intent.instrument_id,
+                    trading_state_as_of=None,
+                    trading_state=TradingState.UNKNOWN,
+                    price_limit=None,
+                ),
+            )
+            # coarse 机会标记（R3 方案 A / R4 finding 3 局部化）：有 eligible
+            # Bar 且通过 scope gate 的机会片已真实处理本 coarse origin 订单
+            # （无论后续 FILLED/DEFER/CANCEL）——机会即已消耗。只记片内局部
+            # 集合，且只允许 coarse origin（日内订单永不 coarse-expire）。
+            if (
+                context is not None
+                and intent.time_in_force is TimeInForce.DAY
+                and order.order_id in self._coarse_order_ids
+            ):
+                opportunity_used_now.add(order.order_id)
+            decision = self._policy.decide(order.snapshot(), market_state)
+            if decision.decision is TradabilityDecision.DEFER:
+                attempts.append(
+                    ExecutionAttempt(
+                        order_id=order.order_id,
+                        event_time=time_slice.event_time,
+                        outcome=ExecutionAttemptOutcome.DEFERRED,
+                        defer_reason=decision.defer_reason,
+                        market_event_refs=_attempt_event_refs(bar_event.event_id, decision),
+                    )
+                )
+                continue
+
+            bar = bar_event.payload
+            fill_price = self._matcher.execution_price(order.snapshot(), bar)
+            if fill_price is None:
+                attempts.append(
+                    ExecutionAttempt(
+                        order_id=order.order_id,
+                        event_time=time_slice.event_time,
+                        outcome=ExecutionAttemptOutcome.DEFERRED,
+                        defer_reason=(
+                            ExecutionDeferReason.INVALID_DAILY_VWAP
+                            if intent.execution_policy is ExecutionPolicy.DAILY_VWAP
+                            else ExecutionDeferReason.LIMIT_NOT_TOUCHED
+                        ),
+                        market_event_refs=_attempt_event_refs(bar_event.event_id, decision),
+                    )
+                )
+                continue
+            if intent.instrument_id not in remaining_volume:
+                remaining_volume[intent.instrument_id] = max(
+                    0,
+                    int(
+                        (Decimal(bar.volume) * self._max_volume_participation).to_integral_value(
+                            rounding=ROUND_FLOOR
+                        )
+                    )
+                    - self._bar_volume_used.get(intent.instrument_id, 0),
+                )
+            fill_quantity = min(order.remaining_quantity, remaining_volume[intent.instrument_id])
+            if fill_quantity == 0:
+                attempts.append(
+                    ExecutionAttempt(
+                        order_id=order.order_id,
+                        event_time=time_slice.event_time,
+                        outcome=ExecutionAttemptOutcome.DEFERRED,
+                        defer_reason=ExecutionDeferReason.INSUFFICIENT_BAR_LIQUIDITY,
+                        market_event_refs=_attempt_event_refs(bar_event.event_id, decision),
+                    )
+                )
+                continue
+            if intent.side is OrderSide.SELL:
+                reserved_quantity = getattr(account_view, "reserved_quantity", lambda _order_id: 0)(
+                    order.order_id
+                )
+                if reserved_quantity:
+                    executable_quantity = reserved_quantity
+                else:
+                    if intent.instrument_id not in remaining_available:
+                        remaining_available[intent.instrument_id] = account_view.available_quantity(
+                            intent.instrument_id
+                        )
+                    executable_quantity = remaining_available[intent.instrument_id]
+                if fill_quantity > executable_quantity:
+                    transitions.append(
+                        (
+                            order,
+                            OrderStatus.CANCELLED,
+                            OrderUpdateReason.INSUFFICIENT_AVAILABLE_POSITION_AT_EXECUTION,
+                            None,
+                            None,
+                        )
+                    )
+                    matched_order_ids.add(order.order_id)
+                    continue
+            fees, cumulative_fees = self._incremental_fees(order, fill_quantity, fill_price)
+            notional = Decimal(fill_quantity) * fill_price
+            if intent.side is OrderSide.BUY:
+                required = notional + fees.total
+                reserved_cash = getattr(
+                    account_view, "reserved_cash", lambda _order_id: Decimal("0")
+                )(order.order_id)
+                released_cash = (
+                    reserved_cash * Decimal(fill_quantity) / Decimal(order.remaining_quantity)
+                )
+                spendable_cash = released_cash + remaining_cash
+                if required > spendable_cash:
+                    transitions.append(
+                        (
+                            order,
+                            OrderStatus.CANCELLED,
+                            OrderUpdateReason.INSUFFICIENT_CASH_AT_EXECUTION,
+                            None,
+                            None,
+                        )
+                    )
+                    matched_order_ids.add(order.order_id)
+                    continue
+                remaining_cash += released_cash - required
+            else:
+                # 卖出净现金校验（先于 Fill / 状态迁移）：notional - fees.total
+                # 不得使片内现金预算为负（费用可能超过现金 + 成交额）
+                if remaining_cash + notional - fees.total < 0:
+                    transitions.append(
+                        (
+                            order,
+                            OrderStatus.CANCELLED,
+                            OrderUpdateReason.INSUFFICIENT_CASH_AT_EXECUTION,
+                            None,
+                            None,
+                        )
+                    )
+                    matched_order_ids.add(order.order_id)
+                    continue
+                if not reserved_quantity:
+                    remaining_available[intent.instrument_id] -= fill_quantity
+                remaining_cash += notional - fees.total
+
+            fill = Fill(
+                order_id=order.order_id,
+                instrument_id=intent.instrument_id,
+                side=intent.side,
+                quantity=fill_quantity,
+                price=fill_price,
+                fees=fees,
+                fill_time=time_slice.event_time,
+            )
+            attempts.append(
+                ExecutionAttempt(
+                    order_id=order.order_id,
+                    event_time=time_slice.event_time,
+                    outcome=ExecutionAttemptOutcome.FILLED,
+                    fill_id=fill.fill_id,
+                    market_event_refs=_attempt_event_refs(bar_event.event_id, decision),
+                )
+            )
+            fills.append(fill)
+            staged_charged_fees[order.order_id] = cumulative_fees
+            remaining_volume[intent.instrument_id] -= fill_quantity
+            self._bar_volume_used[intent.instrument_id] = (
+                self._bar_volume_used.get(intent.instrument_id, 0) + fill_quantity
+            )
+            cumulative_quantity = order.filled_quantity + fill_quantity
+            cumulative_notional = (order.average_fill_price or Decimal("0")) * Decimal(
+                order.filled_quantity
+            ) + fill_price * Decimal(fill_quantity)
+            cumulative_average = cumulative_notional / Decimal(cumulative_quantity)
+            target_status = (
+                OrderStatus.FILLED
+                if cumulative_quantity == intent.quantity
+                else OrderStatus.PARTIALLY_FILLED
+            )
+            transitions.append(
+                (
+                    order,
+                    target_status,
+                    (
+                        OrderUpdateReason.FILLED
+                        if target_status is OrderStatus.FILLED
+                        else OrderUpdateReason.PARTIALLY_FILLED
+                    ),
+                    cumulative_quantity,
+                    cumulative_average,
+                )
+            )
+            matched_order_ids.add(order.order_id)
+
+        # DAY 到期：投影 phase==CLOSED 的 Exchange 上仍 PENDING 的订单
+        # （matching 之后判定；本片已 FILLED/CANCELLED 的订单不再过期，
+        # 保证每单至多一条 Update）。状态来源是注入投影，不是切片事件解析。
+        # 粗粒度片跳过：日线 15:00 投影 CLOSED 是真实事实，但日片没有
+        # 「日内收盘」语义，不据此到期（方案 A：事实 ≠ 资格）。
+        expired_exchanges = (
+            {
+                exchange
+                for exchange, state in exchange_states.items()
+                if state.phase is ExchangePhase.CLOSED
+            }
+            if context is None and not immediate
+            else set()
+        )
+        for exchange in sorted(expired_exchanges):
+            for order in pending:
+                if order.order_id in matched_order_ids:
+                    continue
+                if order.status not in {OrderStatus.PENDING, OrderStatus.PARTIALLY_FILLED}:
+                    continue
+                if order.intent.time_in_force is not TimeInForce.DAY:
+                    continue
+                if instrument_exchange(order.intent.instrument_id) == exchange:
+                    transitions.append(
+                        (
+                            order,
+                            OrderStatus.EXPIRED,
+                            OrderUpdateReason.EXPIRED_AT_SESSION_CLOSE,
+                            None,
+                            None,
+                        )
+                    )
+
+        # coarse DAY 片级到期（R3 方案 A / R4 finding 3）：本片机会已消耗且
+        # 仍未成交的 coarse origin DAY 单 → 本机会片末结构化 EXPIRED
+        # （matching 先于 expiry；停牌日无 Bar 不消耗机会，恢复日先试撮合）。
+        # 不使用交易所投影——资格语义，非市场事实；日内 origin 订单即使
+        # 进入 coarse 片也绝不参与。机会集合为片内局部派生，无跨片状态。
+        if context is not None and not immediate:
+            for order in pending:
+                if order.order_id not in opportunity_used_now:
+                    continue  # 本片未获得机会（含日内 origin 订单）→ 不到期
+                if order.order_id in matched_order_ids:
+                    continue
+                if order.status not in {OrderStatus.PENDING, OrderStatus.PARTIALLY_FILLED}:
+                    continue
+                if order.intent.time_in_force is not TimeInForce.DAY:
+                    continue
+                transitions.append(
+                    (
+                        order,
+                        OrderStatus.EXPIRED,
+                        OrderUpdateReason.EXPIRED_AT_COARSE_SESSION_END,
+                        None,
+                        None,
+                    )
+                )
+
+        # 应用全部迁移（transition 先构造并校验 OrderUpdate，再变更聚合）
+        for order, status, reason, cumulative, avg_price in transitions:
+            updates.append(
+                order.transition(
+                    status,
+                    time_slice.event_time,
+                    reason,
+                    cumulative_filled_quantity=cumulative,
+                    average_fill_price=avg_price,
+                )
+            )
+            if status is OrderStatus.PARTIALLY_FILLED:
+                should_expire = (
+                    not immediate
+                    and (
+                        context is None
+                        and instrument_exchange(order.intent.instrument_id) in expired_exchanges
+                    )
+                    or (
+                        not immediate
+                        and context is not None
+                        and order.order_id in opportunity_used_now
+                    )
+                )
+                if should_expire:
+                    updates.append(
+                        order.transition(
+                            OrderStatus.EXPIRED,
+                            time_slice.event_time,
+                            (
+                                OrderUpdateReason.EXPIRED_AT_SESSION_CLOSE
+                                if context is None
+                                else OrderUpdateReason.EXPIRED_AT_COARSE_SESSION_END
+                            ),
+                        )
+                    )
+
+        result = MarketSliceProcessingResult(
+            slice_time=time_slice.event_time,
+            fills=tuple(fills),
+            execution_attempts=tuple(attempts),
+            order_updates=tuple(updates),
+        )
+        # 片处理成功（T4R：无内部会话状态需要提交）
+        self._charged_fees.update(staged_charged_fees)
+        self._last_slice_time = time_slice.event_time
+        if self._events is not None:
+            for fill in result.fills:
+                self._events.publish_trade(fill)
+            for update in result.order_updates:
+                self._events.publish_order_update(update)
+        return result
+
+    def finish_slice(self, time_slice: MarketTimeSlice) -> tuple[OrderTransition, ...]:
+        """当前 Bar 日线模式在策略回调结束后清理剩余 DAY 订单。"""
+        if time_slice.execution_context is None:
+            return ()
+        updates = []
+        for order in self._orders.values():
+            if order.intent.execution_policy is not ExecutionPolicy.CURRENT_BAR_CLOSE:
+                continue
+            if order.status not in {OrderStatus.PENDING, OrderStatus.PARTIALLY_FILLED}:
+                continue
+            update = order.transition(
+                OrderStatus.EXPIRED,
+                time_slice.event_time,
+                OrderUpdateReason.EXPIRED_AT_COARSE_SESSION_END,
+            )
+            updates.append(update)
+            if self._events is not None:
+                self._events.publish_order_update(update)
+        return tuple(updates)
+
+    def expire_pending_day_orders(self, event_time: datetime) -> tuple[OrderTransition, ...]:
+        """回测终止兜底（R3 方案 C）：coarse 决策点提交、至数据结束仍 PENDING
+        的 DAY 单批量结构化 EXPIRED（一次性终态，幂等：无粗粒度订单时为空）。
+
+        日内（非 coarse）提交的订单不参与——既有「数据结束时仍有效订单
+        如实保留」语义不变。只迁移订单状态，不修改 Portfolio。
+        """
+        updates: list[OrderTransition] = []
+        for order in sorted(self._orders.values(), key=lambda o: o.submission_sequence):
+            if order.order_id not in self._coarse_order_ids:
+                continue
+            if order.status not in {OrderStatus.PENDING, OrderStatus.PARTIALLY_FILLED}:
+                continue
+            if order.intent.time_in_force is not TimeInForce.DAY:
+                continue
+            updates.append(
+                order.transition(
+                    OrderStatus.EXPIRED,
+                    event_time,
+                    OrderUpdateReason.EXPIRED_AT_BACKTEST_END,
+                )
+            )
+        if self._events is not None:
+            for update in updates:
+                self._events.publish_order_update(update)
+        return tuple(updates)
+
+    def order_snapshots(self) -> tuple[OrderSnapshot, ...]:
+        """全部订单的不可变只读投影（按 submission_sequence 稳定排序）"""
+        return tuple(
+            order.snapshot()
+            for order in sorted(self._orders.values(), key=lambda o: o.submission_sequence)
+        )
+
+    def get_order(self, order_id: str) -> OrderSnapshot | None:
+        order = self._orders.get(order_id)
+        return order.snapshot() if order is not None else None
+
+    def open_order_snapshots(self, instrument_id: str | None = None) -> tuple[OrderSnapshot, ...]:
+        return tuple(
+            order.snapshot()
+            for order in sorted(self._orders.values(), key=lambda o: o.submission_sequence)
+            if order.status in {OrderStatus.PENDING, OrderStatus.PARTIALLY_FILLED}
+            and (instrument_id is None or order.intent.instrument_id == instrument_id)
+        )
+
+    def cancel_order(self, order_id: str, event_time: datetime) -> OrderTransition:
+        order = self._orders.get(order_id)
+        if order is None:
+            raise ValueError(f"订单 {order_id} 不存在")
+        if order.status not in {OrderStatus.PENDING, OrderStatus.PARTIALLY_FILLED}:
+            raise ValueError(f"订单 {order_id} 已处于终态 {order.status.value}，不能撤销")
+        update = order.transition(
+            OrderStatus.CANCELLED,
+            event_time,
+            OrderUpdateReason.CANCELLED,
+        )
+        if self._events is not None:
+            self._events.publish_order_update(update)
+        return update
+
+    # ------------------------------------------------------------------
+
+    def _check_slice_time(self, event_time: datetime) -> None:
+        """时间片必须严格前进：拒绝倒流与同片重复消费"""
+        if self._last_slice_time is not None and event_time <= self._last_slice_time:
+            raise ValueError(
+                f"时间片必须严格前进：{event_time} 不晚于已消费 {self._last_slice_time}"
+                f"（重复消费会造成重复 Fill）"
+            )
+
+    @staticmethod
+    def _static_reject_reason(intent: OrderIntent) -> OrderRejectReason | None:
+        """submit 静态校验（Policy 不参与；结构化原因码一一对应）"""
+        if not isinstance(intent.order_type, OrderType):
+            return OrderRejectReason.UNSUPPORTED_ORDER_TYPE
+        if intent.execution_policy not in {
+            ExecutionPolicy.CURRENT_BAR_CLOSE,
+            ExecutionPolicy.NEXT_BAR_OPEN,
+            ExecutionPolicy.DAILY_VWAP,
+        }:
+            return OrderRejectReason.UNSUPPORTED_EXECUTION_POLICY
+        if intent.time_in_force is not TimeInForce.DAY:
+            return OrderRejectReason.UNSUPPORTED_TIME_IN_FORCE
+        return None
+
+    def _incremental_fees(
+        self, order: Order, fill_quantity: int, fill_price: Decimal
+    ) -> tuple[FeeBreakdown, FeeBreakdown]:
+        cumulative_quantity = order.filled_quantity + fill_quantity
+        cumulative_notional = (order.average_fill_price or Decimal("0")) * Decimal(
+            order.filled_quantity
+        ) + fill_price * Decimal(fill_quantity)
+        cumulative_average = cumulative_notional / Decimal(cumulative_quantity)
+        cumulative = self._fee_model.compute(
+            order.intent.side, cumulative_quantity, cumulative_average
+        )
+        charged = self._charged_fees.get(
+            order.order_id,
+            FeeBreakdown(
+                commission=Decimal("0"),
+                stamp_tax=Decimal("0"),
+                transfer_fee=Decimal("0"),
+                other=Decimal("0"),
+                total=Decimal("0"),
+            ),
+        )
+        incremental = FeeBreakdown(
+            commission=cumulative.commission - charged.commission,
+            stamp_tax=cumulative.stamp_tax - charged.stamp_tax,
+            transfer_fee=cumulative.transfer_fee - charged.transfer_fee,
+            other=cumulative.other - charged.other,
+            total=cumulative.total - charged.total,
+        )
+        return incremental, cumulative