opencode-pyneruntime 6.8.5__tar.gz → 6.8.7__tar.gz

{opencode_pyneruntime-6.8.5 → opencode_pyneruntime-6.8.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opencode-pyneruntime
-Version: 6.8.5
+Version: 6.8.7
 Summary: PyneCore runtime (rubycell fork of PyneSys/pynecore) — Pine Script-like runtime and API
 Author-email: PYNESYS LLC <hello@pynesys.com>
 Maintainer: rubycell
@@ -224,15 +224,22 @@ auto-discovered through the `pyne.plugin` entry-point group:
 | **DNSE** — [`plugins/dnse`](plugins/dnse) | `dnse` (data) · `dnse_broker` (broker) | Vietnamese derivatives & stocks: OHLCV history + **native STOP/OCO conditional orders** on DNSE's OpenAPI, built on the vendored `openapi-sdk` 2.0.0. REST-only. |
 
 ```bash
-# historical / live data feed
-pyne run my_strategy.py dnse:VN30F1M@5 --from -500
+# historical / live data feed (no --from: it truncates the shared .ohlcv cache;
+# the built-in -500-real-bars default is both safe and deep enough)
+pyne run my_strategy.py dnse:VN30F1M@5
 
 # live broker — places REAL orders (implies --live)
 pyne run my_strategy.py dnse_broker:VN30F1M@5 --broker
 ```
 
-Unit tests: `pytest plugins/dnse/tests/`. The vendored SDK, a mirror of DNSE's
-OpenAPI docs (`docs/dnse-openapi-documentation/`) with a sync/verify tool, and the
+Testing: `pytest plugins/dnse/tests/` (unit + offline e2e against a fake venue that
+reproduces DNSE's measured quirks), plus a live-test suite — a session-independent
+venue-semantics gate and two staged live probes (no-fill place/amend/cancel/OCA cases
+and a fill matrix whose backtest mode doubles as the oracle). Procedures, safety rules
+and the measured venue facts: [`plugins/dnse/testing/live_test/README.md`](plugins/dnse/testing/live_test/README.md).
+
+The vendored SDK, a mirror of DNSE's OpenAPI docs
+(`docs/dnse-openapi-documentation/`) with a sync/verify tool, and the
 error-handling plan (`docs/plan/`) live alongside the plugin.
 
 **Reference plugins** — the DNSE plugin follows PyneSys's official broker-plugin

{opencode_pyneruntime-6.8.5 → opencode_pyneruntime-6.8.7}/README.md

@@ -179,15 +179,22 @@ auto-discovered through the `pyne.plugin` entry-point group:
 | **DNSE** — [`plugins/dnse`](plugins/dnse) | `dnse` (data) · `dnse_broker` (broker) | Vietnamese derivatives & stocks: OHLCV history + **native STOP/OCO conditional orders** on DNSE's OpenAPI, built on the vendored `openapi-sdk` 2.0.0. REST-only. |
 
 ```bash
-# historical / live data feed
-pyne run my_strategy.py dnse:VN30F1M@5 --from -500
+# historical / live data feed (no --from: it truncates the shared .ohlcv cache;
+# the built-in -500-real-bars default is both safe and deep enough)
+pyne run my_strategy.py dnse:VN30F1M@5
 
 # live broker — places REAL orders (implies --live)
 pyne run my_strategy.py dnse_broker:VN30F1M@5 --broker
 ```
 
-Unit tests: `pytest plugins/dnse/tests/`. The vendored SDK, a mirror of DNSE's
-OpenAPI docs (`docs/dnse-openapi-documentation/`) with a sync/verify tool, and the
+Testing: `pytest plugins/dnse/tests/` (unit + offline e2e against a fake venue that
+reproduces DNSE's measured quirks), plus a live-test suite — a session-independent
+venue-semantics gate and two staged live probes (no-fill place/amend/cancel/OCA cases
+and a fill matrix whose backtest mode doubles as the oracle). Procedures, safety rules
+and the measured venue facts: [`plugins/dnse/testing/live_test/README.md`](plugins/dnse/testing/live_test/README.md).
+
+The vendored SDK, a mirror of DNSE's OpenAPI docs
+(`docs/dnse-openapi-documentation/`) with a sync/verify tool, and the
 error-handling plan (`docs/plan/`) live alongside the plugin.
 
 **Reference plugins** — the DNSE plugin follows PyneSys's official broker-plugin

{opencode_pyneruntime-6.8.5 → opencode_pyneruntime-6.8.7}/pyproject.toml

@@ -20,7 +20,7 @@ egg_info.egg_base = "build"
 # `pynecore` so transpiler-generated code runs unchanged. Upstream authorship and
 # the Apache-2.0 NOTICE ("Powered by PyneSys") are retained per Section 4(d).
 name = "opencode-pyneruntime"
-version = "6.8.5" # PineVersion.Major.Minor — tracks upstream
+version = "6.8.7" # PineVersion.Major.Minor — tracks upstream
 description = "PyneCore runtime (rubycell fork of PyneSys/pynecore) — Pine Script-like runtime and API"
 authors = [{ name = "PYNESYS LLC", email = "hello@pynesys.com" }]
 maintainers = [{ name = "rubycell" }]

{opencode_pyneruntime-6.8.5 → opencode_pyneruntime-6.8.7}/src/pynecore/cli/commands/run.py

@@ -1005,8 +1005,12 @@ def _print_data_requirements(requirements: DataRequirements, script_name: str) -
         lines.append("")
         lines.append("Same symbol, other timeframe (resampled from the chart base data):")
         for r in requirements.same_symbol_other_tf:
-            suffix = (" [mapping present]" if r.has_security_mapping
-                      else f" [needs --security '{r.timeframe}=<base file>' in backtest]")
+            if r.has_security_mapping:
+                suffix = " [mapping present]"
+            elif r.derived_from_chart:
+                suffix = " [served from the chart data, nothing to supply]"
+            else:
+                suffix = f" [needs --security '{r.timeframe}=<base file>' in backtest]"
             lines.append(f"  -> {r.symbol} @ {r.timeframe}{_tags(r)}{suffix}")
 
     if requirements.cross_symbol:

{opencode_pyneruntime-6.8.5 → opencode_pyneruntime-6.8.7}/src/pynecore/core/broker/intent_builder.py

@@ -123,6 +123,11 @@ def build_entry_intent(order: Order, symbol: str) -> EntryIntent:
     exactly once per fresh intent — folding here would make a stale
     retained order's qty flap with the net position and re-trigger the
     diff (measured on the Capital.com demo E2E, 2026-07-10).
+
+    ``Order.skip_flip`` rides along so that fold can be suppressed for an entry
+    re-placed on its own bar: TV modifies the standing order with the raw
+    quantity and never recomputes the flip, so folding it at dispatch would
+    reverse a position the script only meant to reduce.
     """
     oca_name, oca_type_str = _coerce_oca(order)
     return EntryIntent(
@@ -138,6 +143,7 @@ def build_entry_intent(order: Order, symbol: str) -> EntryIntent:
         comment=_na_to_none(order.comment),
         alert_message=_na_to_none(order.alert_message),
         is_strategy_order=(order.order_type == _order_type_normal),
+        skip_flip=order.skip_flip,
     )
 
 

{opencode_pyneruntime-6.8.5 → opencode_pyneruntime-6.8.7}/src/pynecore/core/broker/models.py

@@ -546,6 +546,16 @@ class EntryIntent:
     # keeps it out of the diff equality: it is a dispatch route selector derived
     # by the engine, not Pine-level state the diff needs to sync.
     stop_fired_market: bool = field(default=False, compare=False)
+    # ``True`` when the Pine ``Order`` behind this intent re-placed an unfilled
+    # same-bar entry under the same id. TradingView modifies the standing order
+    # with the RAW quantity — the reversal flip the replaced order carried is not
+    # computed again — so the MARKET stop-and-reverse fold in
+    # :meth:`~pynecore.core.broker.sync_engine.OrderSyncEngine._dispatch_new`
+    # must be skipped for it, exactly as ``strategy.entry`` skips it in the
+    # simulator. ``compare=False`` for the same reason as above: it is a dispatch
+    # route selector, and letting it flip the diff would re-dispatch an entry the
+    # broker already holds.
+    skip_flip: bool = field(default=False, compare=False)
 
     @property
     def intent_key(self) -> str:
@@ -682,12 +692,45 @@ class CloseIntent:
     # Same invariant as :attr:`ExitIntent.reduce_only` — a close can never
     # flip the book to the other side in one-way Pine mode.
     reduce_only: bool = True
+    # Engine-owned routing provenance. ``None`` means a script close;
+    # synthetic close producers set this explicitly so broker plugins never
+    # infer authority from a Pine-controlled string prefix.
+    synthetic_kind: str | None = None
+    target_entry_id: str | None = None
+    target_position_coid: str | None = None
+    target_exchange_id: str | None = None
 
     def __post_init__(self) -> None:
         if not self.reduce_only:
             raise ValueError(
                 "CloseIntent.reduce_only must be True — one-way Pine semantics."
             )
+        if self.synthetic_kind is None:
+            if (self.target_entry_id is not None
+                    or self.target_position_coid is not None
+                    or self.target_exchange_id is not None):
+                raise ValueError(
+                    "CloseIntent synthetic targets require synthetic_kind."
+                )
+            return
+        if self.synthetic_kind not in {
+            'partial_trigger', 'marketable_exit', 'defensive_close',
+        }:
+            raise ValueError(
+                f"CloseIntent.synthetic_kind is invalid: {self.synthetic_kind!r}"
+            )
+        if self.synthetic_kind in {'partial_trigger', 'marketable_exit'}:
+            if (not self.target_entry_id
+                    or self.target_position_coid is not None
+                    or self.target_exchange_id is not None):
+                raise ValueError(
+                    f"CloseIntent {self.synthetic_kind} requires target_entry_id only."
+                )
+        elif (not self.target_position_coid
+              or self.target_entry_id is not None):
+            raise ValueError(
+                "CloseIntent defensive_close requires position COID and no entry target."
+            )
 
     @property
     def intent_key(self) -> str:
@@ -963,10 +1006,13 @@ class PendingDefensiveClose:
         qty (which would double-subtract the partial slices already
         accounted for).
     :ivar unapplied_partial_qty: Cumulative ``fill_qty`` from no-FIFO
-        defensive-close ``partial`` events that the engine could NOT
-        apply to :attr:`OrderSyncEngine._position.size` because the
-        parent ENTRY fill had not yet arrived (``_position.size ==
-        0.0``). Tracked separately from :attr:`partial_filled_qty` so
+        defensive-close events that the engine could NOT apply to
+        :attr:`OrderSyncEngine._position.size` because the parent ENTRY
+        fill had not yet arrived (``_position.size == 0.0``) — every
+        ``partial``, plus the terminal event of a leg that leaves a
+        fanned close INCOMPLETE (that parent is not neutralised, so its
+        fill still has to be booked and reduced).
+        Tracked separately from :attr:`partial_filled_qty` so
         the terminal computation does not believe the slice was
         already booked. When the parent ENTRY ``filled`` / ``partial``
         event finally routes through
@@ -1025,6 +1071,92 @@ class PendingDefensiveClose:
         produced no FIFO closures (no-FIFO / degenerate path) or when
         the marker is replayed from an older schema; the retry path
         falls back to ``marker.entry_id`` in that case.
+    :ivar expected_close_qty: Total quantity the close was actually
+        dispatched for when the one-way emulator fanned it across more
+        than one hedge leg, in PINE units (``CloseFanResult`` reports it
+        as ``dispatched_qty``; its ``legs`` volumes sit on the broker's
+        integer grid and are not comparable with fill quantities) and
+        already net of a broker-holds-less shortfall. Each leg is
+        a separate broker order with its own terminal event, so the
+        first leg FILL proves nothing about its siblings: while
+        :attr:`applied_close_qty` is short of this value the marker
+        stays armed (and the shared parent identities stay out of the
+        settled-duplicate caches) so a sibling that is later rejected
+        still escalates. ``None`` for a single-order close — the
+        marker then settles on its one terminal FILL as before.
+    :ivar applied_close_qty: Cumulative close quantity the broker has
+        reported against this marker — the single authoritative counter
+        for fan completion. Every booked slice is credited when it is
+        observed: ``partial`` events (which carry a leg's intermediate
+        segments), terminal ``filled`` events, and slices deferred on
+        :attr:`unapplied_partial_qty` while the parent entry fill is
+        still missing (the later drain does NOT credit them again). A
+        slice the engine drops without booking anything (the
+        ``record_fill`` gate of positive qty AND price on the FIFO path,
+        a zero-qty event on the no-FIFO path) is NOT credited, so a short
+        total keeps the marker armed.
+    :ivar settled_leg_order_ids: Broker-side ``order.id`` of every fan
+        leg whose FILL was already applied to this marker. Only
+        populated for a fanned close (``expected_close_qty is not
+        None``), where the shared parent identities must stay OUT of the
+        settled-duplicate caches until the last leg lands — so the only
+        durable per-leg dedup identity is the leg's own order id.
+        Startup replay seeds
+        :attr:`OrderSyncEngine._settled_defensive_close_order_refs` from
+        this tuple for an incomplete fan, keeping a delayed WS /
+        polled-orders replay of an already-applied leg out of
+        :meth:`BrokerPosition.record_fill` while the remaining legs are
+        still outstanding.
+    :ivar expected_leg_count: Number of legs the fan actually dispatched
+        (``len(CloseFanResult.legs)``), ``0`` for a single-order close.
+        A second, quantity-independent completion signal for
+        :attr:`expected_close_qty`: that value is the PINE-unit plan sum,
+        while the broker executes the plan snapped to its own integer
+        volume grid, so the fills can total slightly less than the plan
+        (a floor-style quantizer drops the sub-grid remainder). The
+        quantity check alone would then never be satisfied and the marker
+        would stay armed to the stale grace even though every dispatched
+        leg filled. Once :attr:`settled_leg_order_ids` reaches this count
+        every dispatched leg has reported its terminal FILL, so the fan is
+        complete regardless of the residual quantity difference.
+    :ivar booked_leg_count: How many fan legs have reported a terminal
+        event that actually BOOKED quantity against this marker. Compared
+        with :attr:`expected_leg_count` by
+        :meth:`OrderSyncEngine._is_defensive_close_fan_incomplete`. Legs
+        whose terminal event carried no quantity are deliberately NOT
+        counted: they say nothing about the outstanding sibling quantity
+        the marker exists to protect.
+    :ivar dropped_close_qty: Cumulative close quantity the broker reported
+        but the engine could NOT book — a ``partial`` slice with positive
+        ``fill_qty`` and a missing/zero ``fill_price``, which
+        :meth:`BrokerPosition.record_fill` discards. Such a slice makes the
+        local view short of the broker's real execution, and the leg-count
+        completion signal cannot see it (every leg may still report
+        terminally). While this is non-zero
+        :meth:`OrderSyncEngine._is_defensive_close_fan_incomplete` therefore
+        ignores :attr:`booked_leg_count` and falls back to the quantity
+        signal, keeping the marker armed so the stale grace or the next
+        reconcile escalates the divergence instead of silently retiring it.
+        Only STILL-UNRESOLVED drops are counted: a corrected redelivery of
+        the same execution subtracts its quantity again (see
+        :attr:`dropped_fill_slices`).
+    :ivar dropped_fill_slices: The still-unresolved drops behind
+        :attr:`dropped_close_qty`, as ``(fill_id, qty)`` pairs. A dropped
+        slice is NOT necessarily permanent: the engine deliberately keeps
+        an unbookable fill's id out of
+        :attr:`OrderSyncEngine._seen_fill_ids`
+        (:meth:`OrderSyncEngine._is_duplicate_fill`) so the broker can
+        redeliver the same execution with a corrected price, and that
+        redelivery books the quantity after all. When it arrives, the
+        matching pair is removed here and its quantity is subtracted from
+        :attr:`dropped_close_qty`, re-arming the leg-count completion
+        signal — without this the aggregate would stay positive forever
+        and keep a fully settled off-grid fan armed to the stale grace.
+        Slices dropped without a ``fill_id`` cannot be discharged (nothing
+        identifies their redelivery) and are counted in the aggregate
+        only, which stays conservative. The pairs also make the drop
+        bookkeeping idempotent: a redelivered price-less slice with an
+        already-recorded id is not counted twice.
     """
     entry_id: str
     close_intent_key: str
@@ -1039,6 +1171,13 @@ class PendingDefensiveClose:
     pre_close_position_size: float | None = None
     fifo_closed_entry_ids: tuple[str, ...] = ()
     unapplied_partial_qty: float = 0.0
+    expected_close_qty: float | None = None
+    applied_close_qty: float = 0.0
+    settled_leg_order_ids: tuple[str, ...] = ()
+    expected_leg_count: int = 0
+    booked_leg_count: int = 0
+    dropped_close_qty: float = 0.0
+    dropped_fill_slices: tuple[tuple[str, float], ...] = ()
 
     def to_extras_dict(self) -> dict:
         """Serialize to a JSON-compatible dict for ``extras`` storage."""
@@ -1056,6 +1195,15 @@ class PendingDefensiveClose:
             'pre_close_position_size': self.pre_close_position_size,
             'fifo_closed_entry_ids': list(self.fifo_closed_entry_ids),
             'unapplied_partial_qty': self.unapplied_partial_qty,
+            'expected_close_qty': self.expected_close_qty,
+            'applied_close_qty': self.applied_close_qty,
+            'settled_leg_order_ids': list(self.settled_leg_order_ids),
+            'expected_leg_count': self.expected_leg_count,
+            'booked_leg_count': self.booked_leg_count,
+            'dropped_close_qty': self.dropped_close_qty,
+            'dropped_fill_slices': [
+                [fill_id, qty] for fill_id, qty in self.dropped_fill_slices
+            ],
         }
 
     @classmethod
@@ -1162,6 +1310,118 @@ class PendingDefensiveClose:
                 f"PendingDefensiveClose.unapplied_partial_qty must be "
                 f"non-negative: {data!r}"
             )
+        expected_close_qty_raw = data.get('expected_close_qty')
+        if expected_close_qty_raw is None:
+            expected_close_qty: float | None = None
+        elif isinstance(expected_close_qty_raw, (int, float)):
+            expected_close_qty = float(expected_close_qty_raw)
+            if expected_close_qty <= 0.0:
+                raise ValueError(
+                    f"PendingDefensiveClose.expected_close_qty must be "
+                    f"positive or None: {data!r}"
+                )
+        else:
+            raise ValueError(
+                f"PendingDefensiveClose.expected_close_qty must be "
+                f"numeric or None: {data!r}"
+            )
+        applied_close_qty_raw = data.get('applied_close_qty', 0.0)
+        if not isinstance(applied_close_qty_raw, (int, float)):
+            raise ValueError(
+                f"PendingDefensiveClose.applied_close_qty must be "
+                f"numeric: {data!r}"
+            )
+        applied_close_qty = float(applied_close_qty_raw)
+        if applied_close_qty < 0.0:
+            raise ValueError(
+                f"PendingDefensiveClose.applied_close_qty must be "
+                f"non-negative: {data!r}"
+            )
+        settled_leg_order_ids_raw = data.get('settled_leg_order_ids', [])
+        if not isinstance(settled_leg_order_ids_raw, (list, tuple)):
+            raise ValueError(
+                f"PendingDefensiveClose.settled_leg_order_ids must be "
+                f"a list or tuple: {data!r}"
+            )
+        settled_leg_order_ids_list: list[str] = []
+        for leg_order_id in settled_leg_order_ids_raw:
+            if not isinstance(leg_order_id, str):
+                raise ValueError(
+                    f"PendingDefensiveClose.settled_leg_order_ids items "
+                    f"must be strings: {data!r}"
+                )
+            settled_leg_order_ids_list.append(leg_order_id)
+        expected_leg_count_raw = data.get('expected_leg_count', 0)
+        if isinstance(expected_leg_count_raw, bool) or not isinstance(
+                expected_leg_count_raw, int,
+        ):
+            raise ValueError(
+                f"PendingDefensiveClose.expected_leg_count must be "
+                f"an int: {data!r}"
+            )
+        if expected_leg_count_raw < 0:
+            raise ValueError(
+                f"PendingDefensiveClose.expected_leg_count must be "
+                f"non-negative: {data!r}"
+            )
+        booked_leg_count_raw = data.get('booked_leg_count', 0)
+        if isinstance(booked_leg_count_raw, bool) or not isinstance(
+                booked_leg_count_raw, int,
+        ):
+            raise ValueError(
+                f"PendingDefensiveClose.booked_leg_count must be "
+                f"an int: {data!r}"
+            )
+        if booked_leg_count_raw < 0:
+            raise ValueError(
+                f"PendingDefensiveClose.booked_leg_count must be "
+                f"non-negative: {data!r}"
+            )
+        dropped_close_qty_raw = data.get('dropped_close_qty', 0.0)
+        if not isinstance(dropped_close_qty_raw, (int, float)):
+            raise ValueError(
+                f"PendingDefensiveClose.dropped_close_qty must be "
+                f"numeric: {data!r}"
+            )
+        dropped_close_qty = float(dropped_close_qty_raw)
+        if dropped_close_qty < 0.0:
+            raise ValueError(
+                f"PendingDefensiveClose.dropped_close_qty must be "
+                f"non-negative: {data!r}"
+            )
+        dropped_fill_slices_raw = data.get('dropped_fill_slices', [])
+        if not isinstance(dropped_fill_slices_raw, (list, tuple)):
+            raise ValueError(
+                f"PendingDefensiveClose.dropped_fill_slices must be "
+                f"a list or tuple: {data!r}"
+            )
+        dropped_fill_slices_list: list[tuple[str, float]] = []
+        for slice_payload in dropped_fill_slices_raw:
+            if (not isinstance(slice_payload, (list, tuple))
+                    or len(slice_payload) != 2):
+                raise ValueError(
+                    f"PendingDefensiveClose.dropped_fill_slices items must "
+                    f"be (fill_id, qty) pairs: {data!r}"
+                )
+            slice_fill_id, slice_qty = slice_payload
+            if not isinstance(slice_fill_id, str):
+                raise ValueError(
+                    f"PendingDefensiveClose.dropped_fill_slices fill ids "
+                    f"must be strings: {data!r}"
+                )
+            if isinstance(slice_qty, bool) or not isinstance(
+                    slice_qty, (int, float),
+            ):
+                raise ValueError(
+                    f"PendingDefensiveClose.dropped_fill_slices quantities "
+                    f"must be numeric: {data!r}"
+                )
+            if slice_qty < 0.0:
+                raise ValueError(
+                    f"PendingDefensiveClose.dropped_fill_slices quantities "
+                    f"must be non-negative: {data!r}"
+                )
+            dropped_fill_slices_list.append((slice_fill_id, float(slice_qty)))
         return cls(
             entry_id=entry_id,
             close_intent_key=close_intent_key,
@@ -1176,6 +1436,13 @@ class PendingDefensiveClose:
             pre_close_position_size=pre_close_position_size,
             fifo_closed_entry_ids=tuple(fifo_closed_entry_ids_list),
             unapplied_partial_qty=unapplied_partial_qty,
+            expected_close_qty=expected_close_qty,
+            applied_close_qty=applied_close_qty,
+            settled_leg_order_ids=tuple(settled_leg_order_ids_list),
+            expected_leg_count=expected_leg_count_raw,
+            booked_leg_count=booked_leg_count_raw,
+            dropped_close_qty=dropped_close_qty,
+            dropped_fill_slices=tuple(dropped_fill_slices_list),
         )
 
 

{opencode_pyneruntime-6.8.5 → opencode_pyneruntime-6.8.7}/src/pynecore/core/broker/one_way_emulator.py

@@ -66,6 +66,7 @@ from pynecore.core.broker.store_helpers import (
     BRACKET_OWN_STATE_CLEARING,
     BRACKET_OWN_STATE_RELEASED,
     CLOSE_LEG_STATE_DISPATCHED,
+    ENTRY_KIND_POSITION,
     EXTRAS_KEY_BRACKET_OWN_ATTACH_COID,
     EXTRAS_KEY_BRACKET_OWN_CLEAR_COID,
     EXTRAS_KEY_BRACKET_OWN_LEG_ID,
@@ -111,7 +112,15 @@ class CloseFanResult:
     """Outcome of one fanned-out close, for the caller's return shaping / audit.
 
     :ivar legs: ``(leg_id, broker-grid volume)`` pairs actually dispatched, in
-        FIFO order. Empty when nothing was open or the close was skipped.
+        FIFO order. Empty when nothing was open or the close was skipped. The
+        volumes are BROKER-grid integers (cTrader centi-units, Capital.com
+        lot-step counts, ...) — never comparable with a Pine-unit fill
+        quantity; use ``dispatched_qty`` for that.
+    :ivar dispatched_qty: Pine-unit quantity the dispatched legs cover — the
+        summed FIFO plan slices, in the SAME unit as
+        :attr:`~pynecore.core.broker.models.OrderEvent.fill_qty`, so the
+        caller can compare it with the fills that come back. ``0.0`` when
+        nothing was dispatched.
     :ivar shortfall: Pine-unit quantity the open legs could not cover (the
         broker holds less than Pine believes). ``0.0`` in the normal case; a
         positive value is the caller's signal to log, not halt.
@@ -121,6 +130,7 @@ class CloseFanResult:
         ``skipped=False``, which means the symbol was already flat.
     """
     legs: tuple[tuple[str, int], ...]
+    dispatched_qty: float
     shortfall: float
     skipped: bool
 
@@ -146,11 +156,16 @@ class BracketFanResult:
     """Outcome of one exit-bracket replication across a position's legs.
 
     :ivar legs: Broker leg ids the bracket was replicated onto, in FIFO order.
-    :ivar skipped: ``True`` when the symbol was flat (no position-side legs to
-        protect) — a non-halting no-op; the caller re-evaluates next bar.
+    :ivar skipped: ``True`` when nothing was amended — the symbol was flat (no
+        position-side legs to protect) or the position book is incomplete (a
+        protected-side entry's fill is not yet journaled) — a non-halting
+        no-op; the caller re-evaluates next bar.
+    :ivar skip_reason: Human-readable cause for an incomplete-book skip, for
+        the caller's skip message; ``None`` for the flat / flipped-side skips.
     """
     legs: tuple[str, ...]
     skipped: bool
+    skip_reason: str | None = None
 
 
 @dataclass(frozen=True)
@@ -218,13 +233,18 @@ class OneWayEmulator:
         pos = aggregate_positions(intent.symbol, legs)
         if pos is None or pos.side == 'flat':
             # Nothing open, or offsetting legs net to flat — benign no-op.
-            return CloseFanResult(legs=(), shortfall=0.0, skipped=False)
+            return CloseFanResult(
+                legs=(), dispatched_qty=0.0, shortfall=0.0, skipped=False,
+            )
         # CloseIntent.side is the close direction ("sell" closes a long); the
         # legs to reduce sit on the opposite side of the book.
         leg_side = 'buy' if intent.side == 'sell' else 'sell'
         closes, shortfall = select_legs_for_close(intent.qty, legs, leg_side)
         if not closes:
-            return CloseFanResult(legs=(), shortfall=shortfall, skipped=False)
+            return CloseFanResult(
+                legs=(), dispatched_qty=0.0, shortfall=shortfall,
+                skipped=False,
+            )
         await self._reject_unsupported_partial_closes(
             closes, legs, symbol=intent.symbol,
             intent_key=intent.intent_key, port=port,
@@ -237,9 +257,16 @@ class OneWayEmulator:
         )
         if not dispatched:
             # Every slice rounded below the broker grid — skip, do not halt.
-            return CloseFanResult(legs=(), shortfall=shortfall, skipped=True)
+            return CloseFanResult(
+                legs=(), dispatched_qty=0.0, shortfall=shortfall, skipped=True,
+            )
         return CloseFanResult(
-            legs=tuple(dispatched), shortfall=shortfall, skipped=False,
+            legs=tuple(dispatched),
+            # Pine units, NOT the broker-grid volumes above: the caller
+            # compares this with the fill quantities the legs report back,
+            # and those arrive in Pine units on every venue.
+            dispatched_qty=round(sum(close.qty for close in closes), 12),
+            shortfall=shortfall, skipped=False,
         )
 
     async def run_reversal(
@@ -474,7 +501,8 @@ class OneWayEmulator:
         in the ownership index (keyed by the exit's ``intent_key``) BEFORE its
         amend, so :meth:`run_exit_bracket_clear` later clears ONLY the legs this
         exit owns and :meth:`restart_replay` can re-assert or release them. A flat
-        symbol is a non-halting skip.
+        symbol — or a book whose net side is the opposite of the one this exit
+        protects — is a non-halting skip.
 
         Re-running it (a modify, or a re-attach after pyramiding) upserts the
         same per-leg rows idempotently: the row key is STABLE per (exit
@@ -485,6 +513,11 @@ class OneWayEmulator:
         leg (the dispatch coid alone would collide — it encodes pine_id but not
         from_entry). Legs that have since closed are released by the restart /
         reconcile pass, not here.
+
+        The fan is also deferred (``skipped=True`` with a ``skip_reason``)
+        while any protected-side position entry's fill is still pending in the
+        journal — see :meth:`_pending_position_entry` — so it always runs over
+        a complete book and covers a same-sync pyramid entry's own leg.
         """
         intent = envelope.intent
         assert isinstance(intent, ExitIntent)
@@ -504,8 +537,43 @@ class OneWayEmulator:
             )
         legs = await port.fetch_raw_positions(intent.symbol)
         side, on_side = net_survivor_legs(legs)
-        if side == 'flat' or not on_side:
+        # The net side must be the one this exit protects: ``intent.side`` is
+        # the CLOSING direction, so a sell-side exit belongs to a long. When
+        # the book has flipped since the exit was placed — the parent entry was
+        # reversed away and the stale exit is re-dispatched against the new
+        # opposite position — the levels are upside down for that side (a
+        # long's take-profit sits ABOVE the price, a short's must sit below).
+        # Venues reject that outright, which escalates into a defensive close
+        # for a parent that no longer exists. The position this exit protects
+        # is simply not there, so it is the same non-halting skip as a flat
+        # book: no bracket, re-evaluated on the next bar.
+        protected_side = 'buy' if intent.side == 'sell' else 'sell'
+        if side == 'flat' or not on_side or side != protected_side:
             return BracketFanResult(legs=(), skipped=True)
+        # Incomplete-book gate: a protected-side position entry whose FILL is
+        # not yet journaled means the snapshot above cannot be tied to that
+        # entry's venue leg yet (the leg id is only learned from the fill, and
+        # on a same-sync pyramid the fill event has not been drained when this
+        # fan runs). Fanning now would attach the bracket onto the OLDER legs
+        # only, the intent would go active, and nothing ever re-fans — the
+        # newest leg of a pyramid round would stay permanently unprotected. A
+        # mixed book is worse: netting computed over the incomplete snapshot
+        # can mis-drop a true survivor and the clear below would strip its live
+        # bracket. Defer the WHOLE fan — the same non-halting skip as a flat
+        # book — until every position-opening dispatch on this side has its
+        # fill on the books; the re-run then covers all legs.
+        if self._store_ctx is not None:
+            pending_coid = self._pending_position_entry(
+                intent.symbol, protected_side,
+            )
+            if pending_coid is not None:
+                return BracketFanResult(
+                    legs=(), skipped=True,
+                    skip_reason=(
+                        f"position book incomplete — entry dispatch "
+                        f"{pending_coid!r} has not journaled its fill yet"
+                    ),
+                )
         survivors = {leg.leg_id for leg in on_side}
         # A re-attach can narrow the survivor set: a manual hedge or an
         # interrupted reversal opens an opposing leg that virtually FIFO-consumes
@@ -591,6 +659,32 @@ class OneWayEmulator:
             replicated.append(leg.leg_id)
         return BracketFanResult(legs=tuple(replicated), skipped=False)
 
+    def _pending_position_entry(self, symbol: str, protected_side: str) -> str | None:
+        """Client-order-id of a protected-side position entry awaiting its fill.
+
+        A live journal row with ``extras['kind'] == ENTRY_KIND_POSITION`` opens
+        a venue leg immediately (MARKET dispatch or an adopted position), so
+        while its cumulative ``filled_qty`` is short of ``qty`` the book
+        snapshot is incomplete for ``protected_side``. Working (LIMIT / STOP)
+        rows are excluded — they hold no leg until their fill promotes them to
+        ``ENTRY_KIND_POSITION`` — and so are entries opening the opposite side.
+
+        :param symbol: The exit's canonical broker symbol.
+        :param protected_side: Position side the exit protects (``'buy'`` /
+            ``'sell'``).
+        :return: The first pending row's ``client_order_id``, or ``None`` when
+            every protected-side position entry has its fill on the books.
+        """
+        assert self._store_ctx is not None
+        for row in self._store_ctx.iter_live_orders(symbol=symbol):
+            if (row.extras or {}).get('kind') != ENTRY_KIND_POSITION:
+                continue
+            if row.side != protected_side:
+                continue
+            if row.filled_qty < row.qty - 1e-9:
+                return row.client_order_id
+        return None
+
     async def _clear_dropped_survivor_legs(
             self, envelope: 'DispatchEnvelope', intent: ExitIntent, *,
             survivors: set[str], port: 'PositionPort',