powerquant-cli 0.2.6__py3-none-any.whl

quant_core/app/factor/service/selection_service.py

@@ -0,0 +1,234 @@
+"""纯函数式横截面筛选；身份精确、不补零、不联网。"""
+
+from decimal import Decimal, localcontext
+from statistics import median
+
+from quant_core.app.factor.constants import FactorStatus
+from quant_core.app.factor.schema.factor_contract import FactorIdentity, FactorSnapshot, FactorValue
+from quant_core.app.factor.schema.selection_types import (
+    ExcludedInstrument,
+    FactorTransform,
+    MissingPolicy,
+    NeutralizationMethod,
+    NormalizationMethod,
+    SelectedInstrument,
+    SelectionDefinition,
+    SelectionExposure,
+    SelectionResult,
+    SortDirection,
+    WinsorizationMethod,
+)
+
+
+class SelectionService:
+    def select(
+        self,
+        definition: SelectionDefinition,
+        universe: tuple[str, ...] | list[str],
+        snapshot: FactorSnapshot,
+        exposures: dict[str, SelectionExposure] | None = None,
+    ) -> SelectionResult:
+        cells: dict[tuple[tuple, str], FactorValue] = {}
+        for row in snapshot.values:
+            key = (row.identity.logical_key, row.instrument_id)
+            if key in cells:
+                raise ValueError(f"selection 截面单格存在多个 as_of：{key}")
+            cells[key] = row
+
+        needed = tuple(
+            dict.fromkeys(
+                [f.identity for f in definition.factors] + [f.identity for f in definition.filters]
+            )
+        )
+        eligible: dict[str, dict[tuple, Decimal]] = {}
+        excluded: list[ExcludedInstrument] = []
+        for iid in sorted(set(universe)):
+            values: dict[tuple, Decimal] = {}
+            failure: tuple[str, FactorIdentity] | None = None
+            for ident in needed:
+                row = cells.get((ident.logical_key, iid))
+                if row is None:
+                    failure = ("missing", ident)
+                    break
+                if row.status is not FactorStatus.AVAILABLE or row.value is None:
+                    failure = (row.status.value, ident)
+                    break
+                values[ident.logical_key] = row.value
+            if failure is not None:
+                if definition.missing_policy is MissingPolicy.ERROR:
+                    raise ValueError(f"selection {failure[0]}: {iid} / {failure[1].logical_key}")
+                excluded.append(ExcludedInstrument(iid, *failure))
+                continue
+            failed_filter = next(
+                (
+                    f
+                    for f in definition.filters
+                    if (f.minimum is not None and values[f.identity.logical_key] < f.minimum)
+                    or (f.maximum is not None and values[f.identity.logical_key] > f.maximum)
+                ),
+                None,
+            )
+            if failed_filter is not None:
+                excluded.append(ExcludedInstrument(iid, "filter", failed_filter.identity))
+                continue
+            eligible[iid] = values
+
+        if any(
+            factor.transform.neutralization is not NeutralizationMethod.NONE
+            for factor in definition.factors
+        ):
+            for instrument_id in eligible:
+                exposure = (exposures or {}).get(instrument_id)
+                if exposure is None or exposure.available_at is None:
+                    raise ValueError(f"neutralization 缺少有可见时间的 exposure: {instrument_id}")
+                if exposure.available_at > snapshot.decision_time:
+                    raise ValueError(f"neutralization exposure 在决策时点不可见: {instrument_id}")
+        processed: dict[tuple, dict[str, Decimal]] = {}
+        for factor in definition.factors:
+            raw = {iid: values[factor.identity.logical_key] for iid, values in eligible.items()}
+            transformed = _transform(raw, factor.transform)
+            processed[factor.identity.logical_key] = _neutralize(
+                transformed,
+                factor.transform.neutralization,
+                exposures or {},
+            )
+
+        ranked: list[SelectedInstrument] = []
+        for iid in eligible:
+            contributions = tuple(
+                (
+                    f.identity,
+                    f.weight
+                    * processed[f.identity.logical_key][iid]
+                    * (Decimal(-1) if f.direction is SortDirection.ASC else Decimal(1)),
+                )
+                for f in definition.factors
+            )
+            ranked.append(
+                SelectedInstrument(
+                    iid, sum((c for _, c in contributions), Decimal(0)), contributions, 0
+                )
+            )
+
+        ranked.sort(key=lambda r: (-r.score, r.instrument_id))
+        selected = tuple(
+            SelectedInstrument(r.instrument_id, r.score, r.contributions, rank)
+            for rank, r in enumerate(ranked[: definition.top_n], 1)
+        )
+        excluded.extend(
+            ExcludedInstrument(
+                r.instrument_id, "top_n", score=r.score, contributions=r.contributions
+            )
+            for r in ranked[definition.top_n :]
+        )
+        return SelectionResult(selected, tuple(sorted(excluded, key=lambda r: r.instrument_id)))
+
+
+def _transform(values: dict[str, Decimal], config: FactorTransform) -> dict[str, Decimal]:
+    result = dict(values)
+    if not result:
+        return result
+    ordered = sorted(result.values())
+    if config.winsorization is WinsorizationMethod.PERCENTILE:
+        low = _quantile(ordered, config.lower_quantile)
+        high = _quantile(ordered, config.upper_quantile)
+        result = {key: min(max(value, low), high) for key, value in result.items()}
+    elif config.winsorization is WinsorizationMethod.MAD:
+        center = Decimal(str(median(ordered)))
+        mad = Decimal(str(median([abs(value - center) for value in ordered])))
+        if mad:
+            radius = config.mad_scale * Decimal("1.4826") * mad
+            result = {
+                key: min(max(value, center - radius), center + radius)
+                for key, value in result.items()
+            }
+
+    if config.normalization is NormalizationMethod.RANK:
+        return _rank_percentile(result)
+    if config.normalization is NormalizationMethod.ZSCORE:
+        mean = sum(result.values(), Decimal(0)) / Decimal(len(result))
+        variance = sum(((value - mean) ** 2 for value in result.values()), Decimal(0)) / Decimal(
+            len(result)
+        )
+        if not variance:
+            return {key: Decimal(0) for key in result}
+        with localcontext() as context:
+            context.prec = 28
+            std = variance.sqrt()
+        return {key: (value - mean) / std for key, value in result.items()}
+    return result
+
+
+def _quantile(ordered: list[Decimal], quantile: Decimal) -> Decimal:
+    if len(ordered) == 1:
+        return ordered[0]
+    position = quantile * Decimal(len(ordered) - 1)
+    lower = int(position)
+    fraction = position - Decimal(lower)
+    return ordered[lower] + (ordered[min(lower + 1, len(ordered) - 1)] - ordered[lower]) * fraction
+
+
+def _rank_percentile(values: dict[str, Decimal]) -> dict[str, Decimal]:
+    """平均秩百分位；并列值获得相同分数，单元素截面取 0.5。"""
+    if len(values) == 1:
+        return {next(iter(values)): Decimal("0.5")}
+    groups: dict[Decimal, list[str]] = {}
+    for instrument_id, value in values.items():
+        groups.setdefault(value, []).append(instrument_id)
+    ranks: dict[str, Decimal] = {}
+    cursor = 1
+    denominator = Decimal(len(values) - 1)
+    for value in sorted(groups):
+        members = groups[value]
+        average_rank = (Decimal(cursor) + Decimal(cursor + len(members) - 1)) / Decimal(2)
+        percentile = (average_rank - Decimal(1)) / denominator
+        ranks.update({instrument_id: percentile for instrument_id in members})
+        cursor += len(members)
+    return ranks
+
+
+def _neutralize(
+    values: dict[str, Decimal],
+    method: NeutralizationMethod,
+    exposures: dict[str, SelectionExposure],
+) -> dict[str, Decimal]:
+    if method is NeutralizationMethod.NONE:
+        return values
+    missing = sorted(set(values) - exposures.keys())
+    if missing:
+        raise ValueError(f"neutralization 缺少 exposure: {missing[:5]}")
+    if not values:
+        return {}
+    # Frisch–Waugh–Lovell：行业+市值必须同时残差化 y 与 log(size)，
+    # 不能只去行业均值后再对原始市值回归，否则会重新引入行业暴露。
+    result = dict(values)
+    groups: dict[str, list[str]] = {}
+    if method in (NeutralizationMethod.INDUSTRY, NeutralizationMethod.INDUSTRY_SIZE):
+        for instrument_id in result:
+            industry = exposures[instrument_id].industry
+            if industry is None:
+                raise ValueError(f"industry exposure 缺失: {instrument_id}")
+            groups.setdefault(industry, []).append(instrument_id)
+    else:
+        groups["intercept"] = list(result)
+    sizes: dict[str, Decimal] = {}
+    if method in (NeutralizationMethod.SIZE, NeutralizationMethod.INDUSTRY_SIZE):
+        for instrument_id in result:
+            size = exposures[instrument_id].size
+            if size is None or not size.is_finite() or size <= 0:
+                raise ValueError(f"size exposure 必须大于 0: {instrument_id}")
+            sizes[instrument_id] = size.ln()
+    for members in groups.values():
+        mean = sum((result[key] for key in members), Decimal(0)) / Decimal(len(members))
+        for key in members:
+            result[key] -= mean
+        if sizes:
+            size_mean = sum((sizes[key] for key in members), Decimal(0)) / Decimal(len(members))
+            for key in members:
+                sizes[key] -= size_mean
+    if sizes:
+        variance = sum((size**2 for size in sizes.values()), Decimal(0))
+        if variance:
+            slope = sum((sizes[key] * result[key] for key in result), Decimal(0)) / variance
+            result = {key: result[key] - slope * sizes[key] for key in result}
+    return result

quant_core/app/factor/visibility.py

@@ -0,0 +1,22 @@
+"""因子可见时间计算（Q2=A：日频因子下一交易日开盘起可读）
+
+Provider 无关（Tushare mapper 与 Strategy 本地计算共用同一实现，不复制）：
+value_as_of 当日收盘后产生的因子值，最早可见时间 = 下一交易日 09:30
+（Asia/Shanghai）；无「下一交易日」证据（日历末端）时不臆造，返回 None
+由调用方降级 NOT_YET_PUBLISHED。
+"""
+
+from datetime import date, datetime, time
+from zoneinfo import ZoneInfo
+
+_CN = ZoneInfo("Asia/Shanghai")
+_NEXT_OPEN = time(9, 30)
+
+
+def next_trading_day_open(day: date, trading_days: list[date]) -> datetime | None:
+    """day 的下一交易日 09:30（CN）；day 不在日历或无下一交易日 → None"""
+    days = sorted(trading_days)
+    for d in days:
+        if d > day:
+            return datetime.combine(d, _NEXT_OPEN, tzinfo=_CN)
+    return None

quant_core/app/opportunity/SPEC.md

@@ -0,0 +1,45 @@
+# Opportunity SPEC
+
+## 1. Domain Purpose
+
+`opportunity` 负责把 Strategy 在离散市场时刻产生的观察维护成可跟踪的交易机会生命周期，统一支撑盘前观察池与盘中机会发现。
+
+## 2. Responsibilities
+
+- 识别同一 Strategy 与 Instrument 对应的机会身份。
+- 保存形成机会时可用的证据快照、触发条件、失效条件和有效期。
+- 根据 Strategy Observation 推进机会状态。
+- 提供当前机会及其历史变化的查询能力。
+- 形成盘前 Watchlist 等查询投影。
+
+## 3. Non-Responsibilities
+
+- 不重新计算 Strategy。
+- 不产生或执行 Order。
+- 不维护资金、持仓或收益。
+- 不直接调用消息渠道。
+- 不表示使用者是否接受某个机会。
+
+## 4. Main Concepts
+
+```text
+Strategy Observation
+         ↓
+Opportunity
+DETECTED → WATCHING → TRIGGERED
+              │            │
+              ├──> EXPIRED │
+              └────────────┴──> INVALIDATED
+```
+
+- `Opportunity`：某策略在某标的上的一个可跟踪机会实例。
+- `EvidenceSnapshot`：机会在该时刻实际可用且可追溯的证据。
+- `ValidityWindow`：机会允许继续存在或触发的时间范围。
+- `OpportunityChange`：创建、触发、失效或过期等状态事实。
+- `Watchlist`：对 WATCHING Opportunity 的查询投影，不拥有独立事实。
+
+## 5. Cross-Domain Dependencies
+
+- 只消费 Strategy 的稳定 Observation 契约；该契约尚未实现前不得用自由文本代替。
+- 时间判断使用 Market/Trading Runtime 提供的市场时间，不读取 wall clock 推断回测时间。
+- Notification 可以消费 OpportunityChange，本域不得直接调用渠道 SDK。

quant_core/app/opportunity/__init__.py

@@ -0,0 +1 @@
+"""Opportunity Domain - 交易机会生命周期。"""

quant_core/app/order_execution/SPEC.md

@@ -0,0 +1,64 @@
+# Order Execution SPEC
+
+## 1. Domain Purpose
+
+`order_execution` 负责把明确的 `OrderIntent` 转化为 Order，并维护订单从接受、等待、撮合到成交、撤销、拒绝或过期的生命周期。
+
+## 2. Responsibilities
+
+- 校验并接受或拒绝 OrderIntent。
+- 创建 Order 并维护 OrderStatus。
+- 根据 ExecutionPolicy 与后续市场事实撮合订单。
+- 计算模拟成交价格、费用和滑点。
+- 产生 OrderUpdate 与 Fill。
+- 为 Historical Backtest、Paper、Live 提供一致的订单语义。
+
+## 3. Non-Responsibilities
+
+- 不选择标的或产生 Signal。
+- 不负责仓位计算和组合资金分配。
+- 不维护最终现金、持仓与损益。
+- 不推进 Runtime Clock。
+- 不维护 Opportunity。
+
+## 4. Main Concepts
+
+```text
+OrderIntent
+    ↓
+ACCEPTED / REJECTED
+    ↓
+Order(PENDING)
+    ├──> PARTIALLY_FILLED ──> FILLED
+    ├──> CANCELLED
+    └──> EXPIRED
+```
+
+- `OrderIntent`：完成仓位计算、交易约束和下单前风险检查后的明确下单意图。
+- `Order`：已被订单执行领域接受并持续维护生命周期的订单。
+- `Fill`：一次已确认的实际成交记录，至少包含关联订单、标的、方向、数量、价格、费用和成交时间。
+
+一张 Order 可以没有 Fill，也可以因部分成交产生多条 Fill。创建或接受 Order 本身不能改变 Portfolio；只有 Fill 可以触发交易状态变化。
+
+## 5. Execution Implementations
+
+```text
+Order Execution Contract
+├── Simulated Order Execution   Historical Backtest / Paper Trading
+└── Broker Order Execution      Live Trading
+```
+
+实现可以不同，但 OrderIntent、Order、OrderStatus、OrderUpdate 与 Fill 的 Canonical 语义必须一致。
+
+## 6. Cross-Domain Dependencies
+
+- 消费 Order Planning 产生的 OrderIntent。
+- 撮合时只消费 Market 的 Canonical 市场事实。
+- 输出 Fill 给 Portfolio。
+- 由 Trading Runtime 编排，但不依赖其具体运行模式实现。
+
+## 7. Domain Boundary
+
+`Order` 是订单生命周期的唯一聚合根。`OrderIntent`、`OrderTransition`、`Fill`、`ExecutionAttempt`、`FeeBreakdown` 与决策结果是不可变值或领域事实；入口 Schema 只负责协议校验和投影。
+
+`app/order_execution/domain/` 不依赖 Pydantic、FastAPI、Typer、SQLAlchemy、Repository 实现或外部数据 SDK。模拟回测、Paper 与 Live Adapter 必须复用该领域语义，不得各自维护订单状态机。

quant_core/app/order_execution/__init__.py

@@ -0,0 +1 @@
+"""Order Execution Domain - 订单生命周期与成交。"""

quant_core/app/order_execution/bar_matcher.py

@@ -0,0 +1,55 @@
+"""Bar 撮合定价；Broker 管理订单，Matcher 解释行情成交价格。"""
+
+from decimal import Decimal
+
+from quant_core.app.data.schema.market_schema import BarResponse
+from quant_core.app.order_execution.constants import ExecutionPolicy, OrderSide, OrderType
+from quant_core.app.order_execution.domain.order_policy import SlippageModelProtocol
+from quant_core.app.order_execution.domain.order_value import OrderSnapshot
+
+
+class BarMatcher:
+    """当前收盘、下一开盘和日 VWAP 的统一定价实现。"""
+
+    def __init__(self, slippage_model: SlippageModelProtocol) -> None:
+        self._slippage_model = slippage_model
+
+    def execution_price(self, order: OrderSnapshot, bar: BarResponse) -> Decimal | None:
+        intent = order.intent
+        if intent.execution_policy is ExecutionPolicy.DAILY_VWAP:
+            if intent.order_type is not OrderType.MARKET:
+                return None
+            if bar.frequency != "1d" or bar.amount is None or bar.volume <= 0:
+                return None
+            vwap = bar.amount / Decimal(bar.volume)
+            if not vwap.is_finite() or vwap <= 0:
+                return None
+            if not (bar.low - Decimal("0.01") <= vwap <= bar.high + Decimal("0.01")):
+                return None
+            return self._slippage_model.apply(intent.side, vwap)
+        if intent.execution_policy is ExecutionPolicy.CURRENT_BAR_CLOSE:
+            if intent.limit_price is not None and (
+                (intent.side is OrderSide.BUY and bar.close > intent.limit_price)
+                or (intent.side is OrderSide.SELL and bar.close < intent.limit_price)
+            ):
+                return None
+            price = self._slippage_model.apply(intent.side, bar.close)
+            if intent.limit_price is not None:
+                return (
+                    min(price, intent.limit_price)
+                    if intent.side is OrderSide.BUY
+                    else max(price, intent.limit_price)
+                )
+            return price
+        if intent.order_type is OrderType.MARKET:
+            return self._slippage_model.apply(intent.side, bar.open)
+        assert intent.limit_price is not None
+        if intent.side is OrderSide.BUY:
+            if bar.low > intent.limit_price:
+                return None
+            reference = min(bar.open, intent.limit_price)
+            return min(self._slippage_model.apply(intent.side, reference), intent.limit_price)
+        if bar.high < intent.limit_price:
+            return None
+        reference = max(bar.open, intent.limit_price)
+        return max(self._slippage_model.apply(intent.side, reference), intent.limit_price)

quant_core/app/order_execution/constants.py

@@ -0,0 +1,142 @@
+"""
+Order Execution Domain 常量 - 订单生命周期枚举（Canonical 唯一定义点）
+
+语义 SSOT 见 `app/order_execution/SPEC.md` 与 DECISIONS.md 2026-09-04
+（Native Backtest 唯一权威路径 / 通用市场交易事实与可替换 Policy /
+短线 MVP 订单 DAY 有效期）。
+
+维度边界（不得混用）：
+- OrderType：订单价格形态（市价或限价）。
+- ExecutionPolicy：成交时点策略（当前 Bar、下一 Bar 或日 VWAP）。
+- TimeInForce：有效期（MVP 仅 DAY，不跨日执行）。
+"""
+
+from enum import Enum
+
+
+class OrderSide(str, Enum):
+    """订单方向（Order Execution 专用）
+
+    与 Strategy 的 SignalSide（LONG/NONE/SHORT）类型隔离；
+    策略通过交易 API 明确指定买卖方向。
+    """
+
+    BUY = "buy"
+    SELL = "sell"
+
+
+class OrderType(str, Enum):
+    """订单价格形态。"""
+
+    MARKET = "market"
+    LIMIT = "limit"
+
+
+class ExecutionPolicy(str, Enum):
+    """成交时点：当前 Bar 收盘、后续 Bar 开盘或日 VWAP。
+
+    CURRENT_BAR_CLOSE 在当前合法可见 Bar 上撮合；NEXT_BAR_OPEN 只使用后续 Bar。
+    """
+
+    CURRENT_BAR_CLOSE = "current_bar_close"
+    NEXT_BAR_OPEN = "next_bar_open"
+    DAILY_VWAP = "daily_vwap"
+
+
+class TimeInForce(str, Enum):
+    """订单有效期维度（MVP 仅 DAY）
+
+    DAY：市场约束解除后当日可继续尝试；所属 Exchange Session CLOSE 时
+    仍未成交则 EXPIRED；不跨日继续执行旧短线信号。实际扫描由 T5 实现。
+    """
+
+    DAY = "day"
+
+
+class OrderStatus(str, Enum):
+    """订单生命周期状态（REJECTED 不是订单状态：被拒 Intent 不创建 Order）
+
+    终态：FILLED / CANCELLED / EXPIRED；终态后禁止继续迁移。
+    """
+
+    PENDING = "pending"
+    PARTIALLY_FILLED = "partially_filled"
+    FILLED = "filled"
+    CANCELLED = "cancelled"
+    EXPIRED = "expired"
+
+
+class OrderAckStatus(str, Enum):
+    """submit 阶段结果（与 OrderStatus 分离）"""
+
+    ACCEPTED = "accepted"
+    REJECTED = "rejected"
+
+
+class TradabilityDecision(str, Enum):
+    """TradabilityPolicy 的市场决策（只表达「当前能否成交」）
+
+    REJECT 不属于本枚举：Intent 静态非法由 submit REJECT 表达，
+    执行阶段终止由 OrderUpdate(CANCELLED/EXPIRED) 表达。
+    """
+
+    ALLOW = "allow"
+    DEFER = "defer"
+
+
+class ExecutionAttemptOutcome(str, Enum):
+    """一次实际撮合检查的结果（FILLED 与 DEFERRED）"""
+
+    DEFERRED = "deferred"
+    FILLED = "filled"
+
+
+class ExecutionDeferReason(str, Enum):
+    """DEFER 的结构化原因（仅市场暂时限制；Order 保持 PENDING）
+
+    只允许「当日可能变化」的市场事实原因。账户条件不足（资金 /
+    可卖持仓）不会因等待自动恢复，属执行终止：
+    OrderUpdate(CANCELLED) + OrderUpdateReason.INSUFFICIENT_*_AT_EXECUTION。
+    """
+
+    NO_ELIGIBLE_BAR = "no_eligible_bar"
+    SUSPENDED = "suspended"
+    HALTED = "halted"
+    SESSION_NOT_TRADABLE = "session_not_tradable"
+    TRADING_STATE_UNKNOWN = "trading_state_unknown"
+    PRICE_LIMIT_BUY_BLOCKED = "price_limit_buy_blocked"
+    PRICE_LIMIT_SELL_BLOCKED = "price_limit_sell_blocked"
+    LIMIT_NOT_TOUCHED = "limit_not_touched"
+    INSUFFICIENT_BAR_LIQUIDITY = "insufficient_bar_liquidity"
+    INVALID_DAILY_VWAP = "invalid_daily_vwap"
+
+
+class OrderUpdateReason(str, Enum):
+    """OrderUpdate 的结构化原因码（终态迁移必填）"""
+
+    INSUFFICIENT_CASH_AT_EXECUTION = "insufficient_cash_at_execution"
+    INSUFFICIENT_AVAILABLE_POSITION_AT_EXECUTION = "insufficient_available_position_at_execution"
+    FILLED = "filled"
+    PARTIALLY_FILLED = "partially_filled"
+    CANCELLED = "cancelled"
+    EXPIRED_AT_SESSION_CLOSE = "expired_at_session_close"
+    # T4R R3 finding 2（方案 A+C）：粗粒度 DAY 生命周期结构化原因码
+    EXPIRED_AT_COARSE_SESSION_END = "expired_at_coarse_session_end"
+    EXPIRED_AT_BACKTEST_END = "expired_at_backtest_end"
+
+
+class OrderRejectReason(str, Enum):
+    """OrderAck(REJECTED) 的结构化拒绝原因（禁止任意字符串）"""
+
+    INVALID_INTENT = "invalid_intent"
+    INVALID_INSTRUMENT = "invalid_instrument"
+    INVALID_QUANTITY = "invalid_quantity"
+    UNSUPPORTED_ORDER_TYPE = "unsupported_order_type"
+    UNSUPPORTED_EXECUTION_POLICY = "unsupported_execution_policy"
+    UNSUPPORTED_TIME_IN_FORCE = "unsupported_time_in_force"
+    DUPLICATE_INTENT = "duplicate_intent"
+    # Exchange Session 已收盘期间收到的 Intent（DAY 不跨日执行；用户裁定
+    # 2026-09-06：submit 阶段结构化拒绝，不创建 Order，不复用 OrderUpdate 原因码）
+    SESSION_CLOSED = "session_closed"
+    RESERVATION_FAILED = "reservation_failed"
+    MISSING_REFERENCE_PRICE = "missing_reference_price"

quant_core/app/order_execution/domain/__init__.py

@@ -0,0 +1,45 @@
+"""Order Execution 纯领域模型。"""
+
+from quant_core.app.order_execution.domain.order_entity import (
+    ORDER_TRANSITIONS,
+    TERMINAL_ORDER_STATUSES,
+    Order,
+    is_terminal_order_status,
+    validate_order_transition,
+)
+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,
+    TradabilityDecision,
+)
+
+__all__ = [
+    "ORDER_TRANSITIONS",
+    "TERMINAL_ORDER_STATUSES",
+    "ExecutionAttempt",
+    "FeeBreakdown",
+    "Fill",
+    "FeeModelProtocol",
+    "Order",
+    "OrderAck",
+    "OrderIntent",
+    "OrderSnapshot",
+    "OrderTransition",
+    "SlippageModelProtocol",
+    "TradabilityDecision",
+    "TradabilityPolicyProtocol",
+    "is_terminal_order_status",
+    "validate_order_transition",
+]