pine_adapter.cpp

Go to the documentation of this file.

#include <pineforge/source/pine_adapter.hpp>
#include <pineforge/source/pine_input_domain.hpp>
#include <pineforge/source/magnifier_intrabars.hpp>
#include <pineforge/source/pine_strategy_host.hpp>
#include <pineforge/compat/pine/market_admission.hpp>
#include <pineforge/pending_order_mirror.hpp>
#include "pine_cohort_exposure.hpp"
#include <pineforge/native_calendar.hpp>
#include <pineforge/timeframe.hpp>
 
#include "../engine_internal.hpp"
#include "../engine_value_invalid.hpp"
#include "../native_execution_consumer.hpp"
#include <pineforge/compat/pine/trail_ticks.hpp>
#include "../timezone.hpp"
#include "pine_host_reads.hpp"
#include "pine_quiet_bar.hpp"
#include "../compat/pine/callback_lifecycle_rules.hpp"
#include "pine_reissue_binding.hpp"
#include "pine_run_failure.hpp"
#include "pine_checked_arith.hpp"
#include "pine_command_scratch_production.hpp"
#include "../command_scratch_cache.hpp"
#include "pine_sequence_cache_observer.hpp"
#include "exit_scratch_versions_production.hpp"
#include "pine_value_admission.hpp"
#include "pine_position_tail.hpp"
#include "pine_position_tail_binding.hpp"
#include "pine_position_tail_summary.hpp"
#include "pine_source_key_test.hpp"
#include "roster_pass_work.hpp"
// Only an adapter TU using the existing observation seam selects the
// counting instantiations. Normal builds select the empty diagnostic tag.
#ifndef PINEFORGE_POSITION_TAIL_DIAGNOSTICS
#ifdef PINEFORGE_POSITION_TAIL_OBSERVE
#define PINEFORGE_POSITION_TAIL_DIAGNOSTICS \
    ::pineforge::source::detail::PositionTailDiagnostics
#else
#define PINEFORGE_POSITION_TAIL_DIAGNOSTICS \
    ::pineforge::source::detail::PositionTailNoDiagnostics
#endif
#endif
 
// Compile-time observation only, as for the position-tail seam above. No
// environment variable, strategy input or test population selects a path.
#ifndef PINEFORGE_TAIL_WORK
#define PINEFORGE_TAIL_WORK(site, count) ((void)0)
#endif
// Separate from the retirement-loop observer's fixed site vocabulary.
// Overrides observe lookup work only; the default has no storage or I/O.
#ifndef PINEFORGE_LOOKUP_INDEX_WORK
#define PINEFORGE_LOOKUP_INDEX_WORK(site, owner, run, count) ((void)0)
#endif
#ifndef PINEFORGE_RETIREMENT_OBSERVE
#define PINEFORGE_RETIREMENT_OBSERVE(rows, cycle, askable, roots, candidates, first) ((void)0)
#endif
#ifndef PINEFORGE_MARGIN_REVIVAL_OBSERVE
#define PINEFORGE_MARGIN_REVIVAL_OBSERVE(before, rows, event, context, units, cycle, selected) ((void)0)
#endif
 
#include <algorithm>
#include <atomic>
#include <array>
#include <cassert>
#include <cerrno>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <exception>
#include <limits>
#include <map>
#include <memory>
#include <new>
#include <stdexcept>
#include <string_view>
#include <type_traits>
#include <typeinfo>
#include <utility>
 
// A condition the per-bar path almost never meets: a narrow margin or
// admission scope. The hint lays its body out of the fall-through path; the
// condition is evaluated exactly as written (CMakeLists.txt,
// -falign-functions: the per-bar Pine path is front-end bound).
#define PF_RARE(condition) __builtin_expect(static_cast<bool>(condition), 0)
 
namespace pineforge::source {
#ifdef PINEFORGE_CR277_DIAGNOSTIC
namespace {
// Process totals: 0 = close(""), 1 = close_all(). Count successful transfers
// of a live, unpriced Entry placed on this script bar, including same-side
// entries. This does not count batch transfers or prove a later reissue.
std::atomic<std::uint64_t> cr277_pending_close_pushes[2]{};
}
extern "C" std::uint64_t pineforge_cr277_diagnostic_hits(int site) noexcept {
    return site >= 0 && site < 2
        ? cr277_pending_close_pushes[site].load(std::memory_order_relaxed) : 0;
}
#endif
#ifdef PINEFORGE_VALUE_INVALID_FIXTURES
namespace {
thread_local double (*adapter_execution_value_fixture)(const char*, double) = nullptr;
}
void fixture_adapter_execution_values(double (*fixture)(const char*, double)) noexcept {
    adapter_execution_value_fixture = fixture;
}
#endif
bool PineExecutionAdapter::modeled_input() const {
    if (input_scheduler_ && input_scheduler_->input_is_observed_ticks()) {
        return false;
    }
    const auto* point = host_ ? detail::callback_point(*host_) : nullptr;
    return modeled_pine_input(point
        ? point->decision.coordinate.provenance : NativePriceProvenance::Calculation);
}
 
namespace {
 
constexpr double kNaN = std::numeric_limits<double>::quiet_NaN();
 
void check_slippage_fill_price(double value, bool has_basis) {
    if (has_basis && !std::isfinite(value)) {
        engine_command_value_invalid_or_count("slippage.fill_price", EngineValueStage::slippage,
                                              EngineValueReason::numeric_overflow);
    }
}
 
#ifdef PINEFORGE_VALUE_INVALID_FIXTURES
double fixture_adapter_execution_value(const char* site, double value) {
    return adapter_execution_value_fixture ? adapter_execution_value_fixture(site, value) : value;
}
#endif
 
bool same_double_bits(double left, double right) noexcept {
    std::uint64_t left_bits = 0;
    std::uint64_t right_bits = 0;
    std::memcpy(&left_bits, &left, sizeof(left_bits));
    std::memcpy(&right_bits, &right, sizeof(right_bits));
    return left_bits == right_bits;
}
 
bool same_exit_levels(const PineExitLevels& left, const PineExitLevels& right) noexcept {
    return same_double_bits(left.limit, right.limit)
        && same_double_bits(left.stop, right.stop)
        && same_double_bits(left.trail_points, right.trail_points)
        && same_double_bits(left.trail_offset, right.trail_offset)
        && same_double_bits(left.trail_price, right.trail_price)
        && same_double_bits(left.profit_ticks, right.profit_ticks)
        && same_double_bits(left.loss_ticks, right.loss_ticks);
}
 
// Every leg of an exit's lifecycle retired: the script withdrew the exit
// (strategy.cancel / strategy.cancel_all, retire_cancelled_exits), a state no
// suspension produces (Suspend retires at most the trail leg). No margin call
// revives such an exit.
bool withdrawn(const exit_legs::Lifecycle& legs) noexcept {
    return legs.retired(exit_legs::Leg::Stop) && legs.retired(exit_legs::Leg::Limit)
        && legs.retired(exit_legs::Leg::Trail);
}
 
// A filled named origin-free limit has no consumed-origin reader. Even if a
// later reversal suspends it, margin revival cannot execute it: both the placed
// and inherited lifecycle definitions lack a stop (and every loss/trail input).
// Global rows must stay: the revival's supersession walk reads them, while K3
// only supplies witnesses for named exits. Do not infer safety from !live alone:
// cancelled stops and dormant replacements can still revive. K2/K3 may
// nevertheless need a named filled limit as another row's supersessor.
bool unbound_limit_without_revival(const PlacementSnapshot& row) noexcept {
    const auto& levels = row.exit_levels;
    const auto no_protection = [](const exit_legs::Prices& prices) {
        return std::isnan(prices.stop_price) && std::isnan(prices.loss_ticks)
            && std::isnan(prices.trail_points) && std::isnan(prices.trail_price)
            && std::isnan(prices.trail_offset);
    };
    const auto& suspension = row.legs.suspension();
    return row.family == PineOrderFamily::ExitLimit && !row.from_entry.empty()
        && row.bracket_origin.incarnation == 0 && row.per_entry_origin == 0
        && !row.pending_bound_exit && !row.legs.pending_replacement()
        && std::isnan(levels.stop) && std::isnan(levels.loss_ticks)
        && std::isnan(levels.trail_points) && std::isnan(levels.trail_price)
        && std::isnan(levels.trail_offset)
        && no_protection(row.legs.prices())
        && (!suspension || !suspension->revival_definition
            || no_protection(suspension->revival_definition->prices()));
}
 
bool filled_limit_without_revival(const PlacementSnapshot& row) noexcept {
    return row.filled_exit && unbound_limit_without_revival(row);
}
 
// Order-independent keyed fold: only immutable archive records enter it.
// XOR permits exact removal on restore/cancel without replaying history.
std::uint64_t settled_bracket_hash(std::uint64_t key, const BracketRoster::Settled& row) {
    BrokerStateHashSink f;
    f.u(key); f.u(row.last); f.u(row.count); f.u(row.digest);
    return f.h;
}
 
bool finite_positive(double value) noexcept {
    return std::isfinite(value) && value > 0.0;
}
 
bool finite_non_negative(double value) noexcept {
    return std::isfinite(value) && value >= 0.0;
}
 
// ab9714be pine_strategy_commands.cpp:533-537: a non-NaN limit/stop is a
// present price level, including 0.0.
bool price_present(double value) noexcept { return !std::isnan(value); }
 
bool pure_stop_entry_marketable_at(const PlacementSnapshot& snapshot, double open) noexcept {
    if (snapshot.family != PineOrderFamily::Entry) return false;
    if (!finite_positive(snapshot.exit_levels.stop)) return false;
    if (finite_positive(snapshot.exit_levels.limit)
        || finite_positive(snapshot.exit_levels.trail_points)
        || finite_positive(snapshot.exit_levels.trail_price)
        || finite_positive(snapshot.exit_levels.trail_offset)) {
        return false;
    }
    return snapshot.is_long ? open >= snapshot.exit_levels.stop
                            : open <= snapshot.exit_levels.stop;
}
 
// An order resting at a LIMIT level alone (no stop, no trail).
bool pure_limit_entry(const PlacementSnapshot& snapshot) noexcept {
    return finite_positive(snapshot.exit_levels.limit)
        && !finite_positive(snapshot.exit_levels.stop)
        && !finite_positive(snapshot.exit_levels.trail_points)
        && !finite_positive(snapshot.exit_levels.trail_price)
        && !finite_positive(snapshot.exit_levels.trail_offset);
}
 
double next_source_path_waypoint(const Bar& bar, NativePathPhase phase,
                                 double current, bool high_first,
                                 double tick = 0.0, int slippage = 0) noexcept {
    const double tol = (slippage > 0 && tick > 0.0) ? (slippage + 0.5) * tick : 1e-6;
    const auto at = [tol](double left, double right) {
        return std::abs(left - right) <= tol;
    };
    switch (phase) {
    case NativePathPhase::Open:
        return high_first ? bar.high : bar.low;
    case NativePathPhase::High:
        if (!at(current, bar.high) && current < bar.high - tol) return bar.high;
        return high_first ? bar.low : kNaN;
    case NativePathPhase::Low:
        if (!at(current, bar.low) && current > bar.low + tol) return bar.low;
        return high_first ? kNaN : bar.high;
    case NativePathPhase::Close:
        return kNaN;
    case NativePathPhase::None:
        return kNaN;
    }
    return kNaN;
}
 
std::uint64_t fnv_append(std::uint64_t value, const void* bytes, std::size_t size) noexcept {
    const auto* p = static_cast<const unsigned char*>(bytes);
    for (std::size_t i = 0; i < size; ++i) {
        value ^= p[i];
        value *= 1099511628211ULL;
    }
    return value;
}
 
std::uint64_t fnv_string(std::string_view value) noexcept {
    return fnv_append(1469598103934665603ULL, value.data(), value.size());
}
 
// java.lang.String.hashCode of a UTF-8 id: h = 31 * h + u over its UTF-16 code
// units, wrapping at 32 bits. False for a malformed UTF-8 sequence: a bad lead
// or continuation byte, an overlong form, an encoded surrogate or a code point
// past U+10FFFF (none of which a Pine string can hold).
bool java_string_hash(std::string_view text, std::uint32_t& hash) noexcept {
    std::uint32_t h = 0;
    for (std::size_t i = 0; i < text.size();) {
        const auto lead = static_cast<unsigned char>(text[i]);
        std::uint32_t point = 0;
        std::size_t width = 0;
        if (lead < 0x80) { point = lead; width = 1; }
        else if ((lead & 0xE0) == 0xC0) { point = lead & 0x1FU; width = 2; }
        else if ((lead & 0xF0) == 0xE0) { point = lead & 0x0FU; width = 3; }
        else if ((lead & 0xF8) == 0xF0) { point = lead & 0x07U; width = 4; }
        else return false;
        if (i + width > text.size()) return false;
        for (std::size_t k = 1; k < width; ++k) {
            const auto next = static_cast<unsigned char>(text[i + k]);
            if ((next & 0xC0) != 0x80) return false;
            point = (point << 6) | (next & 0x3FU);
        }
        if ((width == 2 && point < 0x80U) || (width == 3 && point < 0x800U)
            || (width == 4 && (point < 0x10000U || point > 0x10FFFFU))
            || (point >= 0xD800U && point <= 0xDFFFU)) {
            return false;
        }
        i += width;
        if (point >= 0x10000U) {
            point -= 0x10000U;
            h = 31U * h + (0xD800U + (point >> 10));
            h = 31U * h + (0xDC00U + (point & 0x3FFU));
        } else {
            h = 31U * h + point;
        }
    }
    hash = h;
    return true;
}
 
void copy_pending_string(std::string_view value, char* out, std::uint8_t* truncated,
                         std::uint64_t* hash) noexcept {
    *hash = fnv_string(value);
    const std::size_t size = std::min<std::size_t>(value.size(), 63U);
    if (size != 0) std::memcpy(out, value.data(), size);
    out[size] = '\0';
    *truncated = value.size() > size ? 1U : 0U;
}
 
void copy_pending_prefixed_string(std::string_view prefix, std::string_view value,
                                  char* out, std::uint8_t* truncated,
                                  std::uint64_t* hash) noexcept {
    // The public mirror is callable with allocation disabled. Hash and copy
    // the synthetic close prefix in-place instead of materializing a string.
    std::uint64_t digest = fnv_append(
        1469598103934665603ULL, prefix.data(), prefix.size());
    *hash = fnv_append(digest, value.data(), value.size());
    const std::size_t total = prefix.size() + value.size();
    const std::size_t prefix_size = std::min<std::size_t>(prefix.size(), 63U);
    if (prefix_size != 0) std::memcpy(out, prefix.data(), prefix_size);
    const std::size_t value_size = std::min<std::size_t>(
        value.size(), 63U - prefix_size);
    if (value_size != 0)
        std::memcpy(out + prefix_size, value.data(), value_size);
    out[prefix_size + value_size] = '\0';
    *truncated = total > prefix_size + value_size ? 1U : 0U;
}
 
int mirror_order_type(PineOrderFamily family) noexcept {
    switch (family) {
    case PineOrderFamily::Entry: return 1;
    case PineOrderFamily::Order: return 3;
    case PineOrderFamily::Close:
    case PineOrderFamily::CloseAll:
    case PineOrderFamily::ExitLimit:
    case PineOrderFamily::ExitStop:
    case PineOrderFamily::ExitTrail: return 2;
    case PineOrderFamily::Margin:
    case PineOrderFamily::Risk: return 0;
    }
    return 0;
}
 
std::uint64_t source_key(const SourceId& left, const SourceId& right) noexcept {
    std::uint64_t value = fnv_string(left);
    const char separator = '\0';
    value = fnv_append(value, &separator, sizeof(separator));
    return detail::source_key_test_mask(fnv_append(value, right.data(), right.size()));
}
 
double nearest_tick(double value, double tick) noexcept {
    if (!std::isfinite(value) || !finite_positive(tick)) return value;
    return std::floor(value / tick + 0.5) * tick;
}
 
// The grid index k = floor(p / mintick + 0.5) re-derived as the decimal
// quotient k / (1 / mintick), never the n * mintick product: a function of k
// alone, so two prints on one grid point compare equal and a limit level on
// the grid is never crossed by a ULP.
double source_decimal_tick(double value, double tick) noexcept {
    if (!std::isfinite(value) || !finite_positive(tick)) return value;
    const double k = std::floor(value / tick + 0.5);
    const double inverse = 1.0 / tick;
    const double integral_inverse = std::floor(inverse + 0.5);
    if (integral_inverse > 0.0
        && std::abs(inverse - integral_inverse) <= 1e-6 * integral_inverse) {
        return k / integral_inverse;
    }
    return k * tick;
}
 
double source_bar_fill_tick(double value, double tick) noexcept {
    if (!std::isfinite(value) || !finite_positive(tick)) return value;
    const double k = std::floor(value / tick + 0.5);
    // ab9714be include/pineforge/engine.hpp:1207-1210 and 1258-1266: the
    // legacy bar fill price is ``round_to_mintick`` = floor(p / mintick + 0.5)
    // * mintick, and it is IDEMPOTENT — a price that is already on the tick
    // grid comes back bit-identical (the comment there pins that the
    // downstream directional snap is an identity on such a result, because
    // n * mintick sits one binary64 ULP above the plain decimal quotient).
    // Re-deriving an already rounded price as k / (1 / tick) dropped that ULP,
    // so a same-bar reversal entry no longer booked on its own close's print.
    if (k * tick == value) return value;
    return source_decimal_tick(value, tick);
}
 
// ab9714be engine.hpp:1264-1266: a fill AT an on-grid raw print books
// bar_fill_price(print) = floor(p / mintick + 0.5) * mintick, which can sit
// one binary64 ULP off the print itself; both name the same path point.
bool source_same_point(double booked, double raw, double tick) noexcept {
    return booked == raw
        || (finite_positive(tick) && source_bar_fill_tick(raw, tick) == raw
            && nearest_tick(raw, tick) == booked);
}
 
// Only raw door callers supply a literal field. Derived prices retain the
// original arithmetic; no source ownership is inferred from their bits.
double source_arith_value(const std::optional<double>& value, const char* field) {
    if (!value)
        throw_strategy_value_invalid(field, StrategyValueReason::numeric_overflow);
    return *value;
}
 
double directional_tick(double value, double tick, bool upward,
                        const char* field = nullptr) {
    if (!std::isfinite(value) || !finite_positive(tick)) return value;
    if (field) {
        const double scaled = source_arith_value(checked_div(value, tick), field);
        return source_arith_value(checked_mul(
            upward ? std::ceil(scaled - 1e-9) : std::floor(scaled + 1e-9), tick), field);
    }
    const double scaled = value / tick;
    return (upward ? std::ceil(scaled - 1e-9) : std::floor(scaled + 1e-9)) * tick;
}
 
// A same-side default MARKET add as TradingView judges it when it is placed:
// the held units and its own, at the signal close's tick, against the
// placement equity (lane W5-ENG-MARGIN-V6; entry() and
// apply_open_market_admission), with no lot of slack: an add whose shortfall
// is under one lot's notional is dropped like any other (lab tv tapes
// tests/fixtures/margin_residual w5b-pa-f-market-p50 and -pooc-p50 on NYSE:F's
// whole shares; lane W5B-ENG-MARGIN-RESIDUAL).
bool add_margin_exceeds_equity(double held_units, const PineSizingSnapshot& sizing,
                               double margin_pct, double mintick, double pointvalue) noexcept {
    const double signal = nearest_tick(sizing.mark, mintick);
    const double unit_margin = signal * pointvalue * sizing.fx * margin_pct / 100.0;
    const double required = (held_units + sizing.frozen_units) * unit_margin;
    const double slack = std::max(1e-9, std::abs(sizing.equity) * 1e-12);
    return margin_pct > 0.0 && std::isfinite(required) && std::isfinite(sizing.equity)
        && required > sizing.equity + slack;
}
 
int price_grid_decimals(double tick) noexcept {
    if (!finite_positive(tick)) return -1;
    double scaled = tick;
    for (int digits = 0; digits <= 10; ++digits) {
        const double k = std::floor(scaled + 0.5);
        if (k >= 1.0 && std::abs(scaled - k) <= 1e-6 * k) return digits;
        scaled *= 10.0;
    }
    return -1;
}
 
double source_level_on_price_grid(double level, double tick,
                                 const char* field = nullptr) {
    if (!std::isfinite(level)) return level;
    const int digits = price_grid_decimals(tick);
    if (digits < 0) return level;
    double price_scale = 1.0;
    for (int i = 0; i < digits; ++i) price_scale *= 10.0;
    const double point_size = 1.0 / price_scale;
    const double points = field
        ? source_arith_value(checked_div(level, point_size), field)
        : level / point_size;
    const double grid = std::floor(points + 0.5);
    if (std::abs(points - grid) <= 0.01 / price_scale)
        return grid / price_scale;
    return level;
}
 
double source_trigger_threshold(double level, double tick,
                                bool is_buy, bool is_limit,
                                const char* field = nullptr) {
    if (!std::isfinite(level) || !finite_positive(tick)) return level;
    // ab9714be pine_strategy_commands.cpp:533-537: 0.0 is a valid stop level.
    // The native matcher's finite_non_negative trigger validator refuses negative
    // levels, so a non-positive trigger cannot be shifted half a tick lower.
    if (level <= 0.0) return 0.0;
    const bool upward = is_limit ? !is_buy : is_buy;
    double scaled = field ? source_arith_value(checked_div(level, tick), field) : level / tick;
    const double inverse = 1.0 / tick;
    const double integral_inverse = std::floor(inverse + 0.5);
    if (integral_inverse > 0.0
        && std::abs(inverse - integral_inverse) <= 1e-6 * integral_inverse) {
        scaled = field ? source_arith_value(checked_mul(level, integral_inverse), field)
                       : level * integral_inverse;
        const double nearest_index = std::floor(scaled + 0.5);
        if (source_bar_fill_tick(level, tick) == level)
            scaled = nearest_index;
    }
    const double target_index = upward
        ? std::ceil(scaled - 1e-12)
        : std::floor(scaled + 1e-12);
    const double grid = field ? source_arith_value(checked_mul(target_index, tick), field)
                             : target_index * tick;
    double threshold = field
        ? source_arith_value(checked_add(grid, (upward ? -0.5 : 0.5) * tick), field)
        : grid + (upward ? -0.5 : 0.5) * tick;
    // Materialize the exact binary64 boundary using the same half-up broker
    // projection as the legacy trigger bar. Decimal half ticks can land one
    // or two ULPs to either side depending on the literal and multiplication
    // order (11.805 and 13.775 are the two pinned opposite cases).
    const auto reaches_target = [&](double price) {
        const double rounded_index = field
            ? std::floor(source_arith_value(checked_div(price, tick), field) + 0.5)
            : std::floor(price / tick + 0.5);
        return upward ? rounded_index >= target_index
                      : rounded_index <= target_index;
    };
    for (int i = 0; i < 16 && !reaches_target(threshold); ++i) {
        threshold = std::nextafter(threshold, upward
            ? std::numeric_limits<double>::infinity()
            : -std::numeric_limits<double>::infinity());
    }
    // Walk to the outermost representable value which still projects to the
    // target grid. This handles literal half ticks whose binary value and the
    // multiply-built boundary lie one ULP apart.
    for (int i = 0; i < 16; ++i) {
        const double candidate = std::nextafter(threshold, upward
            ? -std::numeric_limits<double>::infinity()
            : std::numeric_limits<double>::infinity());
        if (!reaches_target(candidate)) break;
        threshold = candidate;
    }
    // An infinite outside candidate can be rejected by the walk. Only an
    // installed boundary derived from this finite raw level is an overflow.
    if (field && !std::isfinite(threshold))
        throw_strategy_value_invalid(field, StrategyValueReason::numeric_overflow);
    return threshold;
}
 
// A trailing exit's activation is reached on the tick-quantized path whatever
// its trailing offset: the one-shot's (test_trail_activation_tick_bar) and a
// trailing leg's arm alike. A measured TradingView run on NYSE:F 15m with
// trail_offset 1 (tests/fixtures/offset_trail_arm): synthetic lows 25.041 /
// 26.041 and highs 25.049 / 26.049 arm the activations their ticks
// equal, 6 of 6 exits on that bar. The generic Trail compares arm_price with
// the raw path, so the arm is the half-tick boundary where the quantized path
// first reaches the activation, the threshold a one-shot leg rests at; a
// sub-tick activation keeps its own level (the ETH tapes: never rounded onto
// the fill).
double source_trail_arm_level(double activation, double tick, bool exit_is_buy) noexcept {
    return source_trigger_threshold(activation, tick, exit_is_buy, true);
}
 
int legacy_volume_weighted_max_samples(int samples) noexcept {
    constexpr int kMaxSamples = 1 << 20;
    const int nonnegative = std::max(samples, 0);
    const int scaled = nonnegative > kMaxSamples / 4
        ? kMaxSamples : nonnegative * 4;
    return std::max(scaled, 8);
}
 
// The price a one-shot trail books when its activation is first reached
// inside a bar's path: the tick the quantized path reaches there. The one-shot
// rests as a generic Limit at that tick's half-tick boundary
// (one_shot_trail_trigger, source_trigger_threshold), so the tick is the
// resting level rounded AWAY from the position (a sell up, a buy down), a
// price the limit admits by construction. A measured TradingView run on
// BINANCE:ETHUSDT.P 15m (tests/fixtures/trail_activation_tick_reach): a long
// filled at synthetic 25.00 with trail_price 25.004 rests at 25.005 and books 25.01
// (5 of 5 exits); a synthetic short filled at 35.00 with 34.996 rests at 34.995 and
// books 34.99 (4 of 4); the stop-style snap toward the position (25.00,
// 35.00) is refused as InvalidTerms. On the grid it is the activation.
double source_one_shot_reach_tick(double resting_level, double tick, bool exit_is_buy) noexcept {
    return directional_tick(resting_level, tick, !exit_is_buy);
}
 
// Whether a print has reached a trail's activation: on the tick-quantized
// path, like every print the arm is tested on (source_trail_arm_level), the
// placement print included. A measured TradingView run on NYSE:F 15m
// (tests/fixtures/trail_activation_tick_reach): a placement close half a tick
// short of the activation whose tick IS the activation (synthetic 25.005 under 25.01,
// 35.035 over a short's 35.03) has reached it; 8 of 8 trades exit on the next
// bar, trail_offset 1 and 0 alike. On an on-grid feed no print lies in the
// half cell, so it admits what the raw compare did, save a print on the
// activation's own grid point that the raw compare missed by a binary64 ULP.
bool source_trail_reached_at(double price, double activation, double tick,
                             bool exit_is_buy) noexcept {
    const double arm = source_trail_arm_level(activation, tick, exit_is_buy);
    return exit_is_buy ? price <= arm : price >= arm;
}
 
double floor_quantity_grid(double units, const std::optional<double>& grid) noexcept {
    if (!std::isfinite(units) || units <= 0.0) return 0.0;
    if (!grid || !std::isfinite(*grid) || *grid <= 0.0) return units;
    const double floored = std::floor(units / *grid + 1e-6) * *grid;
    // Preserve the caller's exact representation when quantization is a
    // no-op.  Reconstructing an already-on-grid value can move it by one ULP
    // (ab9714be:engine.hpp:1547-1570).
    return floored < units ? floored : units;
}
 
double source_fifo_close_units(double units, const std::vector<NativeOpenLot>& lots) noexcept {
    if (!std::isfinite(units) || units <= 0.0) return units;
    const double lower = units - internal::kQtyEpsilon;
    const double upper = units + internal::kQtyEpsilon;
    double prefix = 0.0;
    for (const auto& lot : lots) {
        prefix += std::abs(lot.signed_units);
        if (prefix >= lower && prefix <= upper) return prefix;
        if (prefix > upper) break;
    }
    return units;
}
 
bool source_fifo_close_needs_resolution(double units,
                                        const std::vector<PyramidEntry>& lots,
                                        const std::vector<double>& preceding_closes) {
    if (!std::isfinite(units) || units <= 0.0) return false;
    std::vector<double> remaining;
    remaining.reserve(lots.size());
    for (const auto& lot : lots) remaining.push_back(lot.qty);
    const auto ambiguous_prefix = [&] {
        double prefix = 0.0;
        for (const double quantity : remaining) {
            prefix += quantity;
            if (prefix == units) return false;
            if (std::abs(prefix - units) <= internal::kQtyEpsilon)
                return true;
            if (prefix > units + internal::kQtyEpsilon) break;
        }
        return false;
    };
    if (ambiguous_prefix()) return true;
    for (const double quantity : preceding_closes) {
        if (!std::isfinite(quantity) || quantity <= 0.0) continue;
        double closed = 0.0;
        double left = quantity;
        for (auto& lot : remaining) {
            if (!(left > internal::kQtyEpsilon)) break;
            const double amount = std::min(lot, left);
            lot -= amount;
            closed += amount;
            left = quantity - closed;
        }
        remaining.erase(std::remove_if(remaining.begin(), remaining.end(), [](double lot) {
            return lot <= internal::kQtyEpsilon;
        }), remaining.end());
        if (ambiguous_prefix()) return true;
    }
    return false;
}
 
double source_money_round(double value) noexcept {
    if (!std::isfinite(value) || value == 0.0) return value;
    const double magnitude = std::floor(std::log10(std::abs(value)));
    const double scale = std::pow(10.0, 9.0 - magnitude);
    const double rounded = std::floor(std::abs(value) * scale + 0.5) / scale;
    return value < 0.0 ? -rounded : rounded;
}
 
// TV's market band is inclusive against its tick-index product, not a strict
// decimal-price test: band-{reversal,flat}-equal admits 3865.5, whereas
// fractional-fill-band and band-flat-residue refuse the 3386.68 tick product
// (tests/fixtures/source_buying_power). Rebuild that operand from the grid
// index rather than allowing an incidental resolved-price ULP to decide it.
bool source_price_band_affordable(double equity, double units,
                                  double fill_price, double tick) noexcept {
    if (!finite_positive(units) || !finite_positive(tick)) return false;
    const double affordable = source_money_round(source_money_round(equity) / units);
    return affordable >= nearest_tick(fill_price, tick);
}
 
// The power of ten `grid` is, as its exponent, or nullopt. The nineteen
// powers are formed once, by the same expressions, rather than at every
// call: the lot-grid scopes ask several times a bar.
std::optional<int> decimal_grid_exponent(double grid) noexcept {
    static const std::array<double, 19> powers = [] {
        std::array<double, 19> out{};
        for (int exponent = -12; exponent <= 6; ++exponent) {
            out[static_cast<std::size_t>(exponent + 12)] = exponent >= 0
                ? std::pow(10.0, exponent) : 1.0 / std::pow(10.0, -exponent);
        }
        return out;
    }();
    for (int exponent = -12; exponent <= 6; ++exponent) {
        if (powers[static_cast<std::size_t>(exponent + 12)] == grid) return exponent;
    }
    return std::nullopt;
}
 
// Margin rule 1: TradingView floors the SHORTEST round-trip decimal of the
// binary64 quotient to the lot, not the binary quotient, and keeps the
// nearest double of that decimal. Synthetic ETH quotient 0.0003 keeps 0.0003
// on a 0.0001 grid where a binary floor can take 0.0002; a quotient of
// 0.0002999999999999999 stays below 0.0003 and floors to 0.0002 (tests/fixtures/
// margin_call_rules sizing and boundary tapes). Nullopt off a power-of-ten
// lot grid, where the decimal floor is not pinned.
std::optional<double> decimal_floor_lot(double units, double grid) noexcept {
    const auto exponent = decimal_grid_exponent(grid);
    if (!exponent || !std::isfinite(units) || units <= 0.0) return std::nullopt;
    char text[40];
    int digits = 1;
    for (; digits <= 17; ++digits) {
        std::snprintf(text, sizeof text, "%.*e", digits - 1, units);
        if (std::strtod(text, nullptr) == units) break;
    }
    if (digits > 17) return std::nullopt;
    // text = d.ddd...e+XX: the integer of its digits and the power it scales.
    std::uint64_t mantissa = 0;
    const char* cursor = text;
    for (; *cursor != 'e' && *cursor != '\0'; ++cursor) {
        if (*cursor >= '0' && *cursor <= '9')
            mantissa = mantissa * 10 + static_cast<std::uint64_t>(*cursor - '0');
    }
    if (*cursor != 'e') return std::nullopt;
    const int shift = std::atoi(cursor + 1) - (digits - 1) - *exponent;
    std::uint64_t lots = mantissa;
    if (shift < 0) {
        for (int i = 0; i < -shift && lots > 0; ++i) lots /= 10;
    } else {
        for (int i = 0; i < shift; ++i) {
            if (lots > std::numeric_limits<std::uint64_t>::max() / 10) return std::nullopt;
            lots *= 10;
        }
    }
    std::snprintf(text, sizeof text, "%llue%d", static_cast<unsigned long long>(lots), *exponent);
    return std::strtod(text, nullptr);
}
 
// An explicit strategy.entry quantity on the lot grid. floor_quantity_grid's
// 1e-6 tolerance lifts a quotient just under a grid point to that point, finds
// it above the request and hands the raw, off-grid request back, which then
// never fills. TradingView floors the shortest decimal instead and never
// rounds up (a risk-sized (E/100)/0.3200000000000003 = 3124.9999999999973
// trades 3124, 1562 + 1562 after a 50% leg; literal 3124.9999995 trades 3124,
// 3125.0000000000005 trades 3125; tests/fixtures/explicit_qty_floor). Only that
// snap changes: an on-grid request, a floor below the request and a non-decimal
// grid keep the grid floor's result. No tape covers strategy.order's explicit
// quantity (order()) or a lot that is not a power of ten (0.5, 0.25): both keep
// the grid floor, snapped request included, as before.
double explicit_entry_quantity_floor(double units, const std::optional<double>& grid) noexcept {
    const double floored = floor_quantity_grid(units, grid);
    if (!detail::script_rule_switches().explicit_qty_decimal_floor || floored != units
        || !grid || !std::isfinite(*grid) || *grid <= 0.0 || !std::isfinite(units)
        || units <= 0.0) {
        return floored;
    }
    if (!(std::floor(units / *grid + 1e-6) > std::floor(units / *grid))) return floored;
    const auto decimal = decimal_floor_lot(units, *grid);
    return decimal && *decimal < units ? *decimal : floored;
}
 
double source_money_floor_lot(double units, const std::optional<double>& grid) noexcept {
    if (!grid || !std::isfinite(*grid) || *grid <= 0.0) return units;
    if (!std::isfinite(units) || units <= 0.0) return units;
    double floored = std::floor(units / *grid) * *grid;
    if (*grid == 0.01) {
        const double cent_candidate = std::floor(units * 100.0) * *grid;
        if (cent_candidate > floored && cent_candidate <= units) floored = cent_candidate;
    }
    return floored < units ? floored : units;
}
 
NativeFeeKind fee_kind_for(int commission_type) noexcept {
    switch (static_cast<CommissionType>(commission_type)) {
    case CommissionType::CASH_PER_CONTRACT: return NativeFeeKind::CashPerUnit;
    case CommissionType::CASH_PER_ORDER: return NativeFeeKind::CashPerExecution;
    case CommissionType::PERCENT:
    default: return NativeFeeKind::Percent;
    }
}
 
NativeOpenDirections directions_for(int direction) noexcept {
    if (direction > 0) return NativeOpenDirections::Long;
    if (direction < 0) return NativeOpenDirections::Short;
    return NativeOpenDirections::Both;
}
 
// R4-D L10z review fix 1: one throttled re-arm per refused source identity.
// A throttled opening can be refused at two driver points within the same bar;
// the bar-close re-arm must resubmit it exactly once, so the queue is deduped
// on the placement identity (source id + source sequence) of the refused row.
bool throttled_rearm_already_queued(
        const std::vector<PlacementSnapshot>& queue,
        const PlacementSnapshot& source) noexcept {
    for (const auto& queued : queue) {
        if (queued.source_id == source.source_id
            && queued.source_sequence == source.source_sequence) {
            return true;
        }
    }
    return false;
}
 
// An exit's place in TradingView's exit queue (lane W3-ENG-EXIT-ALLOC, F05).
// TradingView reserves an entry's quantity for its exits in the order they
// were created: re-issuing a strategy.exit modifies that order in place, it
// does not queue it again, and a later-created exit gets only what the
// earlier ones leave. Here a re-issue is a replacement chain, whose first
// row's source_sequence remember() keeps as chain_origin_sequence. A leg
// staged before remember() names its predecessor (still in the table while
// its retirement is pending) or carries the source_sequence it retained; one
// with neither is new, at the back of the queue. A call TradingView voided (its
// entry neither existed nor rested) holds no place: a re-issue made once the
// entry exists queues from that re-issue (lab tv w3f05-s12).
std::uint64_t exit_queue_rank(const PlacementTable& table,
                              const PlacementSnapshot& row) noexcept {
    if (row.chain_origin_sequence != 0) return row.chain_origin_sequence;
    if (row.projection_predecessor != 0 && table.contains(row.projection_predecessor)) {
        const auto& predecessor = table.at(row.projection_predecessor);
        const std::uint64_t origin = predecessor.chain_origin_sequence;
        if (origin != 0 && (!predecessor.void_issue || row.void_issue)) return origin;
    }
    if (row.source_sequence != 0) return row.source_sequence;
    return std::numeric_limits<std::uint64_t>::max();
}
 
 
// True when the placement row of some live handle satisfies `row`: the
// quiet-bar gates' scan (pine_quiet_bar.hpp). It reads and allocates nothing
// beyond the rows it visits.
template <class Row>
bool any_live_row(const std::vector<native_order::RequestHandle>& live,
                  const PlacementTable& placement, Row&& row) {
    for (const auto& handle : live) {
        const auto found = placement.find(handle.incarnation);
        if (found != placement.end() && row(found->second)) return true;
    }
    return false;
}
 
} // namespace
 
namespace detail {
namespace {
// The callback-lifecycle switches: process-wide like carry_bindings, and for the same reason.
std::atomic<bool> callback_lifecycle_rules[kPineCallbackLifecycleRuleCount] = {true, true, true, true, true};
} // namespace
void set_pine_callback_lifecycle_rule(PineCallbackLifecycleRule rule, bool on) noexcept {
    const int index = static_cast<int>(rule);
    if (index >= 0 && index < kPineCallbackLifecycleRuleCount)
        callback_lifecycle_rules[index].store(on, std::memory_order_relaxed);
}
bool pine_callback_lifecycle_rule(PineCallbackLifecycleRule rule) noexcept {
    const int index = static_cast<int>(rule);
    return index < 0 || index >= kPineCallbackLifecycleRuleCount
        || callback_lifecycle_rules[index].load(std::memory_order_relaxed);
}
MarginRuleSwitches& margin_rule_switches() noexcept {
    static MarginRuleSwitches switches;
    return switches;
}
 
MarginScheduleSwitches& margin_schedule_switches() noexcept {
    static MarginScheduleSwitches switches;
    return switches;
}
 
MarginOpeningSwitches& margin_opening_switches() noexcept {
    static MarginOpeningSwitches switches;
    return switches;
}
}  // namespace detail
 
namespace {
// trail_points as whole ticks (compat::pine::trail_points_to_ticks): with
// the mintick-scaled tolerance TradingView applies, or the constant one when
// the trail switch is off.
double source_trail_points_ticks(double trail_points, double mintick,
                                 const char* field = nullptr) {
    if (field && finite_positive(mintick)
        && detail::pine_callback_lifecycle_rule(detail::PineCallbackLifecycleRule::TrailPointsMintickTolerance)) {
        const double tolerance = source_arith_value(checked_mul(
            compat::pine::kTrailPointsCeilMintickScale, mintick), field);
        return std::ceil(source_arith_value(checked_add(trail_points, -tolerance), field));
    }
    return detail::pine_callback_lifecycle_rule(detail::PineCallbackLifecycleRule::TrailPointsMintickTolerance)
        ? compat::pine::trail_points_to_ticks(trail_points, mintick)
        : compat::pine::trail_points_to_ticks(trail_points);
}
} // namespace
 
#if PINEFORGE_PINE_QUIET_BAR_PROBE
namespace detail {
QuietBarCounts& quiet_bar_counts() noexcept {
    static QuietBarCounts counts;
    return counts;
}
}  // namespace detail
#endif
 
namespace detail {
ScriptRuleSwitches& script_rule_switches() noexcept {
    static ScriptRuleSwitches switches;
    return switches;
}
ExitBindingRuleSwitches& exit_binding_rule_switches() noexcept {
    static ExitBindingRuleSwitches switches;
    return switches;
}
PoocCloseFillViewSwitches& pooc_close_fill_view_switches() noexcept {
    static PoocCloseFillViewSwitches switches;
    return switches;
}
}  // namespace detail
 
// The retired-row compaction: the placement table's storage.
void PlacementTable::place(std::uint64_t incarnation, std::unique_ptr<PlacementSnapshot> node) { if (old_only_) return place_old(incarnation, std::move(node));
    if (window_rows_ == 0 && (old_.empty() || incarnation > old_.back().first)) {
        // An empty window restarts at the new row, above every older row.
        window_.clear();
        head_ = 0;
        base_ = incarnation;
    }
    if (incarnation < base_) {
        // Below the window (a request the core accepted before the rows the
        // window starts at, remembered only now): among the older rows.
        const auto at = std::lower_bound(old_.begin(), old_.end(), incarnation,
            [](const auto& entry, std::uint64_t key) { return entry.first < key; });
        placement_work_ += static_cast<std::uint64_t>(old_.end() - at) + 1U; old_.emplace(at, incarnation, std::move(node));
        return;
    }
    const auto index = head_ + static_cast<std::size_t>(incarnation - base_);
    if (index >= window_.size()) grow_window(index);
    ++placement_work_; window_[index] = std::move(node);
    ++window_rows_;
}
 
std::unique_ptr<PlacementSnapshot> PlacementTable::take(std::uint64_t incarnation) noexcept {
    if (!old_only_ && incarnation >= base_) {
        const std::uint64_t offset = incarnation - base_;
        if (offset >= window_.size() - head_) return nullptr;
        auto& slot = window_[head_ + static_cast<std::size_t>(offset)];
        if (slot) { --window_rows_; ++removal_work_; }
        return std::move(slot);
    }
    const auto found = std::lower_bound(old_.begin(), old_.end(), incarnation,
        [this](const auto& entry, std::uint64_t key) { ++lookup_work_; return entry.first < key; });
    if (found == old_.end() || found->first != incarnation) return nullptr;
    auto node = std::move(found->second);
    removal_work_ += static_cast<std::uint64_t>(old_.end() - found); old_.erase(found);
    return node;
}
 
void PlacementTable::remember_erased(const PlacementSnapshot& row) {
    if (row.family != PineOrderFamily::Margin && erased_foreign_ids_.size() < 3
        && std::find(erased_foreign_ids_.begin(), erased_foreign_ids_.end(), row.source_id)
            == erased_foreign_ids_.end()) {
        erased_foreign_ids_.push_back(row.source_id);
    }
    const auto family = static_cast<std::uint64_t>(row.family);
    erased_digest_ = fnv_append(erased_digest_, &family, sizeof family);
    const std::uint64_t id_size = row.source_id.size();
    erased_digest_ = fnv_append(erased_digest_, &id_size, sizeof id_size);
    erased_digest_ = fnv_append(erased_digest_, row.source_id.data(), row.source_id.size());
    const std::uint64_t from_size = row.from_entry.size();
    erased_digest_ = fnv_append(erased_digest_, &from_size, sizeof from_size);
    erased_digest_ = fnv_append(erased_digest_, row.from_entry.data(), row.from_entry.size());
    erased_digest_ = fnv_append(erased_digest_, &row.command_sequence,
                                sizeof row.command_sequence);
}
 
void PlacementTable::compact() { if (compact_old()) return;
    constexpr std::size_t kDenseFloor = 64;
    for (;;) {
        while (head_ < window_.size() && !window_[head_]) {
            ++head_;
            ++base_;
        }
        if (head_ == window_.size()) {
            window_.clear();
            head_ = 0;
            base_ = high_water_ + 1U;
            return;
        }
        if (head_ >= kDenseFloor && head_ >= window_.size() / 2) {
            window_.erase(window_.begin(), window_.begin() + static_cast<std::ptrdiff_t>(head_));
            head_ = 0;
        }
        const std::size_t span = window_.size() - head_;
        if (span <= kDenseFloor || span <= 4U * window_rows_) return;
        // Sparse: the older half's rows go below the window. They are above
        // every older row already there, so old_ stays ascending.
        const std::size_t half = head_ + span / 2U;
        for (std::size_t index = head_; index < half; ++index) {
            if (!window_[index]) continue;
            old_.emplace_back(base_ + static_cast<std::uint64_t>(index - head_),
                              std::move(window_[index]));
            --window_rows_;
        }
    }
}
 
std::uint64_t PlacementTable::command_sequence_for(const std::string& source_id,
                                                   const std::string& from_entry) const {
    constexpr auto absent = std::numeric_limits<std::uint64_t>::max();
    bool known = false;
    std::uint64_t any = absent;
    bool paired_known = false;
    std::uint64_t paired = absent;
    const auto retained = retained_sequences(source_id, from_entry);
    ++sequence_queries_;
    any = retained[0];
    paired = retained[1];
    known = any != absent;
    paired_known = paired != absent;
    // The backed index contains only current retained identities. Replacement
    // removes its predecessor rather than folding it into erased history.
    // Single and exact-pair domains remain distinct, including empty pairs.
    // Both minima still combine with the original erased evidence below.
    if (const auto minima = erased_minima_.lookup(source_id)) {
        known = true;
        any = std::min(any, *minima);
        if (const auto pair = erased_minima_.lookup(source_id, from_entry)) {
            paired_known = true;
            paired = std::min(paired, *pair);
        }
    }
    if (!known) return absent;
    if (paired_known && paired != absent) return paired;
    return any;
}
 
namespace detail {
namespace {
// The tombstone audit's state: every erased row, per table, and every read
// that reached one, per source line. One process-wide instance; the Pine
// adapter is single-threaded per host.
struct PlacementAudit {
    std::map<const PlacementTable*,
             std::map<std::uint64_t, std::unique_ptr<PlacementSnapshot>>> tombstones;
    std::map<std::pair<int, unsigned>, std::uint64_t> hits;
    std::vector<std::pair<std::uint64_t, const PlacementSnapshot*>> view;
    ~PlacementAudit() {
        const char* path = std::getenv("PINEFORGE_PLACEMENT_AUDIT_LOG");
        std::FILE* out = path ? std::fopen(path, "a") : nullptr;
        std::uint64_t rows = 0;
        for (const auto& table : tombstones) rows += table.second.size();
        std::fprintf(out ? out : stderr,
                     "placement-audit: %zu sites hit, %llu tombstones retained at exit\n",
                     hits.size(), static_cast<unsigned long long>(rows));
        for (const auto& hit : hits) {
            std::fprintf(out ? out : stderr, "placement-audit: %s pine_adapter line %u: %llu\n",
                         hit.first.first == 0 ? "lookup" : "scan", hit.first.second,
                         static_cast<unsigned long long>(hit.second));
        }
        if (out) std::fclose(out);
    }
};
PlacementAudit& placement_audit() {
    static PlacementAudit audit;
    return audit;
}
} // namespace
 
void placement_audit_erase(const PlacementTable* table, std::uint64_t incarnation,
                           PlacementSnapshot&& row) {
    placement_audit().tombstones[table][incarnation] =
        std::make_unique<PlacementSnapshot>(std::move(row));
}
 
void placement_audit_forget(const PlacementTable* table) noexcept {
    placement_audit().tombstones.erase(table);
}
 
void placement_audit_miss(const PlacementTable* table, std::uint64_t incarnation,
                          unsigned line) noexcept {
    auto& audit = placement_audit();
    const auto stones = audit.tombstones.find(table);
    if (stones == audit.tombstones.end() || stones->second.count(incarnation) == 0) return;
    ++audit.hits[{0, line}];
}
 
void placement_audit_scan_hit(const PlacementTable*, std::uint64_t, unsigned line) noexcept {
    ++placement_audit().hits[{1, line}];
}
 
const std::vector<std::pair<std::uint64_t, const PlacementSnapshot*>>*
placement_audit_tombstones(const PlacementTable* table) {
    auto& audit = placement_audit();
    const auto stones = audit.tombstones.find(table);
    if (stones == audit.tombstones.end()) return nullptr;
    audit.view.clear();
    for (const auto& stone : stones->second) audit.view.emplace_back(stone.first, stone.second.get());
    return &audit.view;
}
} // namespace detail
 
namespace {
// A whole-table scan's audit: the scan reads only the retained rows, and in a
// PINEFORGE_PLACEMENT_AUDIT build every erased row its predicate would also
// have accepted is recorded against the scan's line.
#if PINEFORGE_PLACEMENT_AUDIT
template <class Predicate>
void audit_placement_scan(const PlacementTable& table, unsigned line, Predicate&& predicate) {
    const auto* stones = detail::placement_audit_tombstones(&table);
    if (!stones) return;
    const auto copy = *stones;
    for (const auto& stone : copy) {
        if (predicate(stone.first, *stone.second))
            detail::placement_audit_scan_hit(&table, stone.first, line);
    }
}
#define PINEFORGE_AUDIT_PLACEMENT_SCAN(table, ...) \
    audit_placement_scan((table), __LINE__, __VA_ARGS__)
#else
#define PINEFORGE_AUDIT_PLACEMENT_SCAN(table, ...) ((void)0)
#endif
} // namespace
 
PineExecutionAdapter::PineExecutionAdapter(compat::pine::CapAttachment attachment)
    : cap(attachment) {
    pending_view_.owner_ = this;
    cohorts_by_id_.set_store(::pineforge::detail::ScratchStore::cohort);
    exit_rank_keys_.set_store(::pineforge::detail::ScratchStore::exit_rank);
}
 
PineExecutionAdapter::PineExecutionAdapter(NativeStrategyHost& host,
                                           compat::pine::CapAttachment attachment)
    : PineExecutionAdapter(attachment) {
    bind(host);
}
 
namespace detail {
// Share the production attached-arena/disk selection and per-run I/O policy.
struct CommandScratchRun {
    // Fixed geometry, independent of bars, handles and text widths.
    static constexpr std::size_t page_size = 512;
    std::unique_ptr<pineforge::detail::ScratchBacking> backing;
    CommandScratchStore store;
 
    CommandScratchRun(ScratchKeyOrder order, CacheCapacity capacity)
        : backing(make_command_scratch_backing(page_size, capacity)),
          store{{2, page_size, 1, 1, order,
                 pineforge::detail::ScratchOpenMode::create_empty}, backing.get()} {
        exit_scratch_check(store.status(), store);
    }
};
 
namespace {
struct ExitScratchRun {
    CommandScratchRun scratch;
    ExitScratchContext context;
    ExitScratchVersionsProduction versions{scratch.store};
 
    ExitScratchRun(const native_order::RunIdentity& run, CacheCapacity capacity)
        : scratch(exit_scratch_key_order(), capacity), context{scratch.store, run} {
        context.versions = &versions;
    }
};
 
std::shared_ptr<ExitScratchContext> make_exit_scratch(
        const native_order::RunIdentity& identity, CacheCapacity capacity) {
    auto run = std::make_shared<ExitScratchRun>(identity, capacity);
    return {run, &run->context};
}
} // namespace
 
ExitScratchContext& exit_scratch(const PineExecutionAdapter& adapter) {
    if (!adapter.exit_scratch_) exit_scratch_failure(ScratchStatus::programming_error);
    return *adapter.exit_scratch_;
}
ExitScratchError::ExitScratchError(ScratchStatus status)
    : coded<std::logic_error>(
          status == ScratchStatus::io_error ? RunFailureCode::scratch_io_failed
              : RunFailureCode::engine_invariant,
          {},
          "exit scratch operation failed"),
      status_(status) {}
 
[[noreturn]] void exit_scratch_failure(ScratchStatus status) {
    throw ExitScratchError(status);
}
} // namespace detail
 
void PineExecutionAdapter::bind_exit_scratch(detail::ExitScratchContext& context) {
    detail::exit_scratch_check(context.store.status(), context.store);
    if (context.store.transaction_active())
        detail::exit_scratch_failure(detail::ScratchStatus::programming_error);
    if (exit_scratch_.get() == &context) return;
    exit_scratch_ = std::shared_ptr<detail::ExitScratchContext>(
        &context, [](detail::ExitScratchContext*) {});
}
 
void PineExecutionAdapter::bind(NativeStrategyHost& host) noexcept {
    if (position_tail_summary_)
        position_tail_summary_->invalidate(PositionTailGuard::Rebind,
                                           PINEFORGE_POSITION_TAIL_DIAGNOSTICS{});
    host_ = &host;
    exit_scratch_ = nullptr;
    pine_view_host_ = nullptr;
    const auto* pine_host = pine_view_of(host_);
    input_scheduler_ = pine_host ? &pine_host->scheduler_ : nullptr;
}
 
// The bound host's PineStrategyHost view: dynamic_cast's answer, taken once
// per host instead of at every call site (several a bar), and again at every
// bind and run begin. The handle-preserving reissue change: an adapter member; it was a thread_local
// memo (keyed by the host, its object and its dynamic type), and a strategy
// module is dlopen'd, where every thread_local read is a dynamic TLS lookup.
// The adapter is its host's own member, bound to it at construction, and a
// host's dynamic type is fixed once the adapter can be asked.
PineStrategyHost* PineExecutionAdapter::pine_view_of(NativeStrategyHost* host) const noexcept {
    if (host != pine_view_host_) {
        pine_view_host_ = host;
        pine_view_ = host ? dynamic_cast<PineStrategyHost*>(host) : nullptr;
    }
    return pine_view_;
}
 
int PineExecutionAdapter::projection_bar_index(
        const NativeDecisionContext& context) const noexcept {
    // Pine's pending projection historically keyed this source-side field to
    // the input slot the kernel presented (including magnifier sub-bars).
    // Keep that policy on the named input coordinate while the kernel's public
    // interval_index remains script-bar space.
    return context.coordinate.input_interval_index;
}
 
int PineExecutionAdapter::projection_bar_index(
        const NativeCoordinate& coordinate) const noexcept {
    NativeDecisionContext context;
    context.coordinate = coordinate;
    context.script_bar_open_ms = last_broker_open_ms_;
    return projection_bar_index(context);
}
 
namespace {
[[noreturn]] void refuse_unbound_adapter() {
    throw coded<std::logic_error>(RunFailureCode::engine_invariant, {},
                                  "Pine execution adapter is not bound to a native host");
}
}  // namespace
 
// The refusal is out of line so this check is a test and a load wherever it
// inlines (the per-pump state cache: the adapter reads its host through it at every read).
NativeStrategyHost& PineExecutionAdapter::require_host() const {
    if (!host_) refuse_unbound_adapter();
    return *host_;
}
 
OrderBirth PineExecutionAdapter::capture_order_birth() const {
    const auto point = detail::callback_point(require_host());
    if (!point) return OrderBirth::direct_command(-1, require_host().native_decision_floor());
    const int bar = point->decision.coordinate.interval_index;
    const std::int64_t timestamp = point->decision.sub_bar_open_ms;
    if (!coof_recalc_active_) return OrderBirth::chart_evaluation(bar, timestamp);
 
    const bool magnified = point->decision.sub_count > 1;
    const auto domain = magnified ? BirthCursorDomain::MagnifierTicks
                                  : BirthCursorDomain::HistoricalPath;
    const int count = magnified ? std::max(1, point->decision.sub_count) : 4;
    int index = magnified ? point->decision.sub_index : 0;
    if (!magnified) {
        const bool high_first = source_path_uses_high_first(coof_script_bar_);
        switch (point->decision.coordinate.path_phase) {
        case NativePathPhase::Open: index = 0; break;
        case NativePathPhase::High: index = high_first ? 1 : 2; break;
        case NativePathPhase::Low: index = high_first ? 2 : 1; break;
        case NativePathPhase::Close: index = 3; break;
        case NativePathPhase::None: index = 0; break;
        }
    }
    index = std::max(0, std::min(index, count - 1));
    const auto cursor = BirthCursor::point(domain, index, count);
    const std::uint64_t ordinal = std::max<std::uint64_t>(1, last_applied_ordinal_);
    return OrderBirth::fill_evaluation(bar, timestamp, cursor, point->price,
                                       ordinal, ordinal, ordinal);
}
 
bool PineExecutionAdapter::opening_market_short_scope(PineOrderFamily family) const {
    const auto point = detail::callback_point(require_host());
    const auto opening_parent = placement_.find(coof_market_entry_recalc_incarnation_);
    const bool carried_opening_parent = point && opening_parent != placement_.end()
        && opening_parent->second.placement_script_open_ms < point->decision.script_bar_open_ms;
    const bool opening_high = coof_script_bar_valid_
        && source_decimal_tick(coof_script_bar_.open, staged_.syminfo.mintick)
            == source_decimal_tick(coof_script_bar_.high, staged_.syminfo.mintick);
    const auto native = detail::run_state(require_host());
    return family == PineOrderFamily::ExitStop && coof_recalc_active_
        && coof_market_entry_recalc_incarnation_ != 0 && config_.slippage == 0
        && (opening_high || (config_.margin_short == 0.0
            && (coof_first_open_ || carried_opening_parent)))
        && detail::run_position(require_host()).signed_units < 0.0
        && (!native.spec || native.spec->intrabar.is_none())
        && point && point->decision.coordinate.path_phase == NativePathPhase::Open;
}
 
void PineExecutionAdapter::initialize_l4c_policy(PlacementSnapshot& snapshot,
                                                  native_order::RequestHandle handle) {
    if (snapshot.birth.cause() == OrderBirthCause::Unattributed)
        snapshot.birth = capture_order_birth();
    const bool trailing = finite_positive(snapshot.exit_levels.trail_points)
        || finite_positive(snapshot.exit_levels.trail_price)
        || finite_positive(snapshot.exit_levels.trail_offset);
    snapshot.birth_reach = compat::pine::select_historical_birth_reach(snapshot.birth, trailing);
    if (coof_recalc_active_) {
        snapshot.coof_cascade_seg_i = coof_context_.coordinate.interval_index;
        snapshot.coof_cascade_inflight_fires = true;
    }
    if (handle.incarnation && placement_.contains(handle.incarnation)) invalidate_retirement();
    const bool exit = snapshot.family == PineOrderFamily::ExitLimit
        || snapshot.family == PineOrderFamily::ExitStop
        || snapshot.family == PineOrderFamily::ExitTrail;
    if (!exit) return;
 
    const exit_legs::Prices prices{snapshot.exit_levels.limit, snapshot.exit_levels.stop,
        snapshot.exit_levels.trail_points, snapshot.exit_levels.trail_price,
        snapshot.exit_levels.trail_offset, snapshot.exit_levels.profit_ticks,
        snapshot.exit_levels.loss_ticks};
    if (!snapshot.legs.target().incarnation && handle.incarnation != 0) {
        snapshot.legs.set_prices(prices);
        snapshot.legs.attach(handle.incarnation, std::max<std::int64_t>(0, snapshot.placement_cycle));
    } else if (handle.incarnation != 0
               && snapshot.legs.target().incarnation != handle.incarnation) {
        snapshot.legs.fork(handle.incarnation, std::max<std::int64_t>(0, snapshot.placement_cycle));
        snapshot.legs.set_prices(prices);
    }
 
    const auto physical = detail::run_position(require_host());
    if (physical.signed_units == 0.0 || snapshot.projection_created_bar < 0) return;
    const int direction = physical.signed_units > 0.0 ? 1 : -1;
    const auto point = detail::callback_point(require_host());
    const Bar activation_bar = coof_script_bar_valid_ ? coof_script_bar_
                                                       : policy_script_bar_;
    const bool path_high_first = source_path_uses_high_first(activation_bar);
    int historical_point = 0;
    double waypoint = activation_bar.open;
    if (point) {
        switch (point->decision.coordinate.path_phase) {
        case NativePathPhase::Open:
            historical_point = 0; waypoint = activation_bar.open; break;
        case NativePathPhase::High:
            historical_point = path_high_first ? 1 : 2; waypoint = activation_bar.high; break;
        case NativePathPhase::Low:
            historical_point = path_high_first ? 2 : 1; waypoint = activation_bar.low; break;
        case NativePathPhase::Close:
            historical_point = 3; waypoint = activation_bar.close; break;
        case NativePathPhase::None:
            historical_point = 0; waypoint = point->price; break;
        }
    }
    const bool at_waypoint = point
        && source_same_point(point->price, waypoint, staged_.syminfo.mintick);
    const bool historical_segment = point && historical_point > 0 && !at_waypoint;
    const int recalc_leg = historical_segment
        ? std::max(0, historical_point - 1) : historical_point;
 
    std::string_view first_lot_id;
    std::uint64_t first_lot_incarnation = 0;
    for (const auto& cohort : cohorts_by_id_.held_rows()) {
        for (const auto& opening : cohort.second.opened) {
            const auto units = cohort.second.live_units_by_origin.find(opening.incarnation);
            if (units == cohort.second.live_units_by_origin.end()
                || !(units->second > 0.0)) {
                continue;
            }
            first_lot_id = cohort.first;
            first_lot_incarnation = opening.incarnation;
            break;
        }
        if (first_lot_incarnation != 0) break;
    }
 
    const double activation_quantity = std::isfinite(snapshot.projection_remaining_qty)
        ? snapshot.projection_remaining_qty : snapshot.requested_qty;
    const bool full_quantity = (!std::isfinite(snapshot.qty_percent)
            || snapshot.qty_percent >= 100.0 - 1e-9)
        && (!std::isfinite(activation_quantity)
            || activation_quantity >= std::abs(physical.signed_units) - 1e-9);
    compat::pine::ExitActivationContext context;
    context.cycle = current_position_cycle_;
    context.bar_index = snapshot.projection_created_bar;
    context.position_open_bar = position_open_bar_index_;
    context.direction = direction;
    context.cursor_price = point ? point->price : snapshot.sizing.price;
    context.fill_recalc = coof_recalc_active_;
    context.scheduler = config_.calc_on_order_fills;
    context.magnifier = point && point->decision.sub_count > 1;
    context.process_on_close = config_.process_orders_on_close;
    context.warmup = !modeled_input() && detail::run_state(require_host()).phase == NativeRunPhase::Warmup;
    context.stream_idle = modeled_input();
    context.first_open_fill = opening_market_short_scope(snapshot.family);
    context.after_first_open_fill = coof_recalc_active_ && !coof_first_open_
        && point && point->decision.coordinate.path_phase == NativePathPhase::Open;
    context.recalc_leg = recalc_leg;
    context.historical_segment = historical_segment;
    context.at_extreme = at_waypoint
        && (historical_point == 1 || historical_point == 2);
    context.historical_point = historical_point;
    context.current_fill = coof_current_fill_seq_;
    context.bar = activation_bar;
    context.position_entry_count = static_cast<int>(physical.lot_count);
    context.position_quantity = std::abs(physical.signed_units);
    context.pyramiding = config_.pyramiding;
    context.lot_count = physical.lot_count;
    context.first_lot_id = first_lot_id;
    context.first_lot_incarnation = first_lot_incarnation;
    context.market_recalc_incarnation = coof_market_entry_recalc_incarnation_;
    context.market_recalc_fill = coof_market_entry_recalc_fill_seq_;
    context.pending_empty = live_handles_.empty() && pending_entries_.empty()
        && pending_bracket_legs_.empty() && pending_same_bar_commands_.empty()
        && pending_coof_requests_.empty();
    context.slippage = config_.slippage;
    context.pointvalue = staged_.syminfo.pointvalue;
    context.account_fx = point ? active_staged_fx(point->decision.sub_bar_open_ms)
                               : staged_.account_fx;
    context.fx_series_empty = staged_.account_fx_effective_from_ms.empty();
    context.bar_path_high_first = path_high_first;
    context.tick_high = source_bar_fill_tick(activation_bar.high, staged_.syminfo.mintick);
    compat::pine::ExitActivationRequest request;
    request.requested_trailing = trailing;
    request.full_quantity = full_quantity;
    request.from_fill = snapshot.birth.from_fill();
    request.has_from_entry = !snapshot.from_entry.empty();
    request.birth_reach = snapshot.birth_reach;
    request.from_entry = snapshot.from_entry;
    request.oca_name = snapshot.oca_name;
    request.quantity = activation_quantity;
    snapshot.exit_activation = compat::pine::select_exit_activation(
        request, snapshot.exit_levels.stop, snapshot.exit_levels.limit, context);
    if (snapshot.exit_activation.evidence()) {
        snapshot.leg_activation.bind(snapshot.exit_activation.resolve(
            current_position_cycle_, position_open_bar_index_));
    }
 
    // ab9714be reservation_expansion.cpp:7-27 and
    // pine_strategy_commands.cpp:1891-1924: only an ordinary same-bar MARKET
    // population can grow a global full POOC exit. The immutable source birth
    // and placement facts select that population; the native cohort remains
    // the execution authority.
    const bool full_global = config_.process_orders_on_close && snapshot.from_entry.empty()
        && !std::isfinite(snapshot.requested_qty)
        && (!std::isfinite(snapshot.qty_percent) || snapshot.qty_percent >= 100.0)
        && physical.signed_units != 0.0;
    const bool side = physical.signed_units > 0.0;
    const auto is_unpriced_market_add = [](const PlacementSnapshot& candidate) {
        return !finite_positive(candidate.exit_levels.limit)
            && !finite_positive(candidate.exit_levels.stop)
            && !finite_positive(candidate.exit_levels.trail_offset)
            && !finite_positive(candidate.exit_levels.trail_price);
    };
    const auto is_entry_like = [](const PlacementSnapshot& candidate) {
        return candidate.opening && (candidate.family == PineOrderFamily::Entry
                                     || candidate.family == PineOrderFamily::Order);
    };
    struct CandidateRef {
        PlacementSnapshot* snapshot = nullptr;
        std::uint64_t incarnation = 0;
    };
    std::vector<compat::pine::ReservationGrowthCandidate> candidates;
    std::vector<CandidateRef> candidate_refs;
    const auto collect = [&](PlacementSnapshot& candidate,
                             std::uint64_t incarnation) {
        if (!is_entry_like(candidate)) return;
        compat::pine::ReservationGrowthCandidate fact;
        fact.incarnation = incarnation;
        fact.source_id = candidate.source_id;
        fact.market_entry = candidate.family == PineOrderFamily::Entry
            && is_unpriced_market_add(candidate);
        fact.from_fill = candidate.birth.from_fill();
        fact.at_entry_capacity = candidate.projection_over_pyramiding;
        fact.is_long = candidate.is_long;
        fact.created_position_side =
            static_cast<PositionSide>(candidate.projection_position_side);
        fact.created_bar = candidate.projection_created_bar;
        candidates.push_back(std::move(fact));
        candidate_refs.push_back({&candidate, incarnation});
    };
    // The candidates feed the reservation-growth selection alone, which only
    // a full global exit makes; otherwise nothing is selected, nothing is
    // admitted, and the references are never visited (the trigger-band and scratch reuse).
    if (full_global) {
        for (auto& pending : pending_entries_) collect(pending.snapshot, 0);
        for (auto& pending : pending_same_bar_commands_) collect(pending.snapshot, 0);
        for (const auto& live : live_handles_) {
            const auto existing = placement_.find(live.incarnation);
            if (existing != placement_.end()) collect(existing->second, live.incarnation);
        }
    }
    const double percent = std::isfinite(snapshot.qty_percent)
        ? snapshot.qty_percent : 100.0;
    const auto selected = full_global
        ? compat::pine::select_reservation_growth_sources(
              candidates, snapshot.from_entry, config_.process_orders_on_close,
              physical.signed_units == 0.0, percent,
              snapshot.projection_created_bar,
              side ? PositionSide::LONG : PositionSide::SHORT)
        : std::vector<std::uint64_t>{};
    const bool partial = percent < 100.0 - 1e-9
        || (std::isfinite(snapshot.projection_remaining_qty)
            && snapshot.projection_remaining_qty
                < std::abs(physical.signed_units) - 1e-9);
    const bool qualified_adds = compat::pine::admits_reservation_expansion(
        selected, partial, snapshot.projection_remaining_qty,
        std::abs(physical.signed_units));
    snapshot.pooc_global_full_exit_dynamic_qty = qualified_adds;
    snapshot.pooc_global_full_exit_tracks_bound_adds = qualified_adds;
    if (qualified_adds && handle.incarnation != 0) {
        try {
            snapshot.reservation_expansion.capture(handle.incarnation, current_position_cycle_,
                                                   direction > 0 ? PositionSide::LONG
                                                                 : PositionSide::SHORT,
                                                   std::abs(physical.signed_units));
        } catch (const std::invalid_argument&) {
            // A replacement carries its existing immutable capture.
        }
        for (const auto& selected_source : candidate_refs) {
            auto* candidate = selected_source.snapshot;
            if (!candidate) continue;
            candidate->reservation_growth_owner_incarnation = handle.incarnation; invalidate_retirement();
            if (selected_source.incarnation != 0
                && selected_source.incarnation != handle.incarnation) {
                try {
                    candidate->reservation_growth_source.assign_capture(
                        selected_source.incarnation, handle.incarnation);
                    candidate->pooc_global_full_exit_bound_add = true;
                } catch (const std::invalid_argument&) {
                    // This exact source already owns the capture receipt.
                }
            }
        }
    }
}
 
void PineExecutionAdapter::update_l4c_priority() {
    auto& host = require_host();
    // The one ordering the priority can select, the retained-child /
    // fresh-parent exception, is refused by OrderPriority::select before it
    // reads a candidate unless the policy is attached and on, the run
    // processes orders on close without calc_on_order_fills or a fill
    // recalculation, and exactly two live handles carry a placement row
    // (src/compat/pine/order_priority.cpp). Those facts are the adapter's
    // own, so a call they rule out builds no candidates and reads nothing
    // (the trigger-band and scratch reuse); its only effect, the reorder of live_handles_, needs
    // a selection.
    if (!priority.attached() || !priority.retained_parent_first()
        || !config_.process_orders_on_close || config_.calc_on_order_fills
        || coof_recalc_active_) {
        return;
    }
    std::size_t placed = 0;
    for (const auto& handle : live_handles_) {
        if (placement_.find(handle.incarnation) != placement_.end()) ++placed;
    }
    if (placed != 2) return;
    std::vector<compat::pine::OrderPriorityCandidate> candidates;
    candidates.reserve(live_handles_.size());
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& snapshot = found->second;
        compat::pine::OrderPriorityCandidate candidate;
        candidate.handle = handle;
        candidate.kind = snapshot.family == PineOrderFamily::Entry
            ? compat::pine::OrderPriorityKind::Entry
            : ((snapshot.family == PineOrderFamily::ExitLimit
                || snapshot.family == PineOrderFamily::ExitStop
                || snapshot.family == PineOrderFamily::ExitTrail)
                ? compat::pine::OrderPriorityKind::Exit
                : compat::pine::OrderPriorityKind::Other);
        candidate.id = snapshot.source_id;
        candidate.from_entry = snapshot.from_entry;
        candidate.created_bar = snapshot.projection_created_bar;
        candidate.source_sequence = snapshot.source_sequence;
        candidate.predecessor = snapshot.projection_predecessor;
        candidate.recreated_after_named_cancelled =
            snapshot.recreated_after_named_cancelled_entry_incarnation;
        candidate.named_cancel_surviving_exit = snapshot.named_cancel_surviving_exit_incarnation;
        candidate.created_flat = snapshot.projection_position_side
            == static_cast<std::int32_t>(PositionSide::FLAT);
        candidate.birth_from_fill = snapshot.birth.from_fill();
        candidate.prior_close = snapshot.projection_after_close;
        candidate.at_entry_capacity = snapshot.projection_over_pyramiding;
        candidate.stop_limit_activated = snapshot.stop_limit_activated;
        candidate.default_quantity = !std::isfinite(snapshot.requested_qty);
        candidate.requested_qty = snapshot.requested_qty;
        candidate.qty_percent = snapshot.qty_percent;
        candidate.stop = snapshot.exit_levels.stop;
        candidate.limit = snapshot.exit_levels.limit;
        candidate.trail_points = snapshot.exit_levels.trail_points;
        candidate.trail_price = snapshot.exit_levels.trail_price;
        candidate.trail_offset = snapshot.exit_levels.trail_offset;
        candidate.profit_ticks = snapshot.exit_levels.profit_ticks;
        candidate.loss_ticks = snapshot.exit_levels.loss_ticks;
        candidate.oca_name = snapshot.oca_name;
        candidate.oca_type = snapshot.oca_type;
        candidates.push_back(std::move(candidate));
    }
    const auto point = detail::callback_point(host);
    const compat::pine::OrderPriorityContext context{
        detail::run_position(host).signed_units == 0.0,
        config_.process_orders_on_close, config_.calc_on_order_fills,
        coof_recalc_active_, point && point->decision.sub_count > 1, false, true,
        point ? point->decision.coordinate.interval_index : -1};
    const auto decision = priority.select(context, candidates);
    if (!decision) return;
    const auto rank = [&](const native_order::RequestHandle& handle) {
        if (handle == decision->parent) return 0;
        if (handle == decision->child) return 1;
        return 2;
    };
    std::stable_sort(pending_write(live_handles_).begin(), live_handles_.end(),
                     [&](const auto& left, const auto& right) { return rank(left) < rank(right); });
}
 
void PineExecutionAdapter::update_l4c_lifecycle(
        const native_order::ExecutionAppliedEvent& event,
        const NativeDecisionContext& context) {
    const auto found = placement_.find(event.handle().incarnation);
    if (found == placement_.end()) return;
    auto& snapshot = found->second;
    const bool exit = snapshot.family == PineOrderFamily::ExitLimit
        || snapshot.family == PineOrderFamily::ExitStop
        || snapshot.family == PineOrderFamily::ExitTrail;
    if (!exit || !snapshot.legs.target().incarnation) return;
    const auto domain = context.sub_count > 1
        ? (config_.calc_on_order_fills ? exit_legs::Domain::MagnifierFillRecalc
                                       : exit_legs::Domain::Magnifier)
        : (config_.calc_on_order_fills ? exit_legs::Domain::FillRecalc
                                       : exit_legs::Domain::Ordinary);
    const exit_legs::Frame cause{event.ordinal, context.coordinate.interval_index,
                                 domain, exit_legs::Phase::AfterMargin};
    if (const auto completion = compat::pine::select_exit_completion(snapshot.legs, cause)) {
        const exit_legs::Action action{snapshot.legs.target(), snapshot.legs.revision(),
                                       cause, *completion};
        (void)snapshot.legs.apply(snapshot.legs.target(), action); invalidate_retirement();
    }
    if (detail::run_position(require_host()).signed_units == 0.0) snapshot.leg_activation.unbind();
}
 
bool PineExecutionAdapter::is_declined_market_reversal(
        const native_order::MatchRejectedEvent& event) const noexcept {
    if (event.reason != native_order::MatchRejectReason::HostPrecommit
        && event.reason != native_order::MatchRejectReason::InitialMargin) {
        return false;
    }
    const auto found = placement_.find(event.handle().incarnation);
    if (found == placement_.end()) return false;
    const auto& source = found->second;
    const auto prior = static_cast<PositionSide>(source.projection_position_side);
    return source.opening && source.family == PineOrderFamily::Entry
        && source.reverse_to && std::holds_alternative<native_order::Market>(event.request().trigger)
        && prior != PositionSide::FLAT
        && ((prior == PositionSide::LONG) != source.is_long);
}
 
bool PineExecutionAdapter::follows_same_bar_declined_reversal(
        const PlacementSnapshot& exit, const NativePrecommitView& view) const {
    if (!exit.legs.target().incarnation) return false;
    const auto follows = [&](const native_order::CommandEvent& command) {
        const auto* rejected = std::get_if<native_order::MatchRejectedEvent>(&command);
        if (!rejected || rejected->cursor.point.interval_index != view.cursor.point.interval_index
            || !is_declined_market_reversal(*rejected)) {
            return false;
        }
        const auto reversal = placement_.find(rejected->handle().incarnation);
        // A from_entry="" exit names every entry, so it is always the held
        // position's: the declined reversal holds it as it holds a named
        // bracket of that side (lab tv tapes tests/fixtures/margin_v6 w5-mr-*,
        // lane W5-ENG-MARGIN-V6) -- unless it was placed under the side the
        // rejected entry would have opened, which another entry of the bar
        // already reversed into (lab tv w3bf05-r1c, lane W3B-ENG-GRID).
        return reversal != placement_.end()
            && (exit.from_entry.empty()
                    ? exit.projection_position_side
                        != static_cast<std::int32_t>(reversal->second.is_long
                            ? PositionSide::LONG : PositionSide::SHORT)
                    : bracket_belongs_to_reversal(exit, reversal->second));
    };
    auto& host = require_host();
    // In place on a PineStrategyHost, as in observe_terminal_receipts.
    if (auto* pine = pine_view_of(&host)) {
        return as_native_consumer(pine->execution_consumer())
            .visit_commands_after(receipt_cursor_, follows);
    }
    for (const auto& row : host.native_events(receipt_cursor_)) {
        if (row.command && follows(*row.command)) return true;
    }
    return false;
}
 
// The host bookkeeping index cache: the indexes the adapter reads its retained bookkeeping
// through. The native consumer keeps them for the adapter (a by-value member
// of PineStrategyHost, whose layout is the generated script's ABI, holds no
// index itself), drops them at every run begin, and never reads them. They
// are derived from state the adapter retains and hashes, folded into nothing,
// and each lookup answers what the walk it replaces answers.
// The kind of the cache below (pine_host_reads.hpp, the per-pump state cache).
const char detail::kPineRunCacheKind = 0;
 
namespace {
 
class AdapterLookupIndex final : public detail::PineRunCache {
public:
 
    // Per cohort, over its origin roster: how many roster entries are folded,
    // and whether a folded origin is an opening on each side. The roster only
    // grows (every accepted opening is appended once, after its placement row
    // exists), and an opening row's `opening` and `is_long` are never written
    // after it is remembered, so the two flags only ever turn on and a fold
    // over the entries appended since the last lookup keeps them exact. Keyed
    // by the durable cohort handle, not a resident row address: a row can
    // become empty outside retire_origin_prefixes and its storage can be
    // reused before the derived entry is explicitly erased. A restored empty
    // roster answers from its erased sides, and reset_for_run clears the index.
    struct CohortSides {
        std::size_t folded = 0;
        bool opened_long = false;
        bool opened_short = false;
    };
 
    std::uint64_t answers = 0;
    // Derived index, one entry (~24 payload bytes, plus hash-node/bucket
    // overhead) per id that exceeded 16 origins and needed this query.
    // Bound: ids that ever exceeded 16 origins, not live/held cohorts.
    // Prefix retirement can erase entries; the unjailed profile is unbounded.
    std::unordered_map<std::uint64_t, CohortSides> cohort_sides;
 
    // Over the placement table's rows: exit legs by the origin they are
    // bound to and their leg kind, and immediate closes by the bar they were
    // placed on. A row's family, `immediately` and projection_created_bar are
    // never written after it is remembered; its bracket_origin is, exactly
    // once, from zero to the parent whose fill binds it (on_applied), and only
    // while the leg is working. So a row is filed where it will stay when it
    // is folded, except a working leg still bound to origin zero, which waits
    // in `unbound` until it is bound (then it is filed) or stops working (a
    // handle that stops working never works again, so it is never bound).
    // Rows mostly arrive above every row folded so far; one that arrives
    // below (an anchored leg adopted at its parent's fill), and any erasure
    // (the retired-row compaction: the table keeps only what can still be read), refolds
    // the index from the table's rows, which are the live few. Each lookup
    // verifies every row it reads.
    std::uint64_t erased_seen = 0;
    std::uint64_t folded_high = 0;
    std::size_t rows_folded = 0;
    std::vector<std::uint64_t> unbound;
    std::array<std::unordered_map<std::uint64_t, std::vector<std::uint64_t>>, 3> legs_by_origin;
    std::unordered_map<std::int32_t, std::vector<std::uint64_t>> immediate_closes_by_bar;
 
    // The UTC chart-day memo: chart_day_key's last day on a UTC chart -- the whole
    // seconds [day_lo, day_hi) of one floor day inside the civil arithmetic's
    // span, and the key they answer. That key is a function of the floor day
    // alone, so every second of the range answers it. Empty until the first
    // arithmetic read; never counted in `answers`.
    std::int64_t day_lo = 1;
    std::int64_t day_hi = 0;
    std::int64_t day_key = 0;
 
    std::uint64_t answered() const noexcept override { return answers; }
 
    void clear() noexcept {
        cohort_sides.clear();
        clear_rows();
        day_lo = 1;
        day_hi = 0;
        day_key = 0;
    }
 
    void clear_rows() noexcept {
        erased_seen = 0;
        folded_high = 0;
        rows_folded = 0;
        unbound.clear();
        for (auto& legs : legs_by_origin) legs.clear();
        immediate_closes_by_bar.clear();
    }
 
    static bool exit_leg(PineOrderFamily family) noexcept {
        return family == PineOrderFamily::ExitLimit || family == PineOrderFamily::ExitStop
            || family == PineOrderFamily::ExitTrail;
    }
 
    static bool working(const std::vector<native_order::RequestHandle>& live,
                        std::uint64_t incarnation) noexcept {
        return std::any_of(live.begin(), live.end(),
            [&](const native_order::RequestHandle& handle) {
                return handle.incarnation == incarnation;
            });
    }
 
    // The rows bound to `origin` of that leg kind, or null.
    const std::vector<std::uint64_t>* legs_of(PineOrderFamily family,
                                              std::uint64_t origin) const noexcept {
        const auto& legs = legs_by_origin[static_cast<std::size_t>(family)
            - static_cast<std::size_t>(PineOrderFamily::ExitLimit)];
        const auto found = legs.find(origin);
        return found == legs.end() ? nullptr : &found->second;
    }
 
    void fold(std::uint64_t incarnation, const PlacementSnapshot& row,
              const std::vector<native_order::RequestHandle>& live) {
        if (exit_leg(row.family)) {
            if (row.bracket_origin.incarnation != 0) {
                legs_by_origin[static_cast<std::size_t>(row.family)
                    - static_cast<std::size_t>(PineOrderFamily::ExitLimit)]
                    [row.bracket_origin.incarnation].push_back(incarnation);
            } else if (working(live, incarnation)) {
                unbound.push_back(incarnation);
            }
        } else if (row.family == PineOrderFamily::Close && row.immediately) {
            immediate_closes_by_bar[row.projection_created_bar].push_back(incarnation);
        }
    }
 
    // Brings the row index up to the table. May throw std::bad_alloc; every
    // step leaves the index consistent, so a later sync resumes it.
    void sync_rows(const PlacementTable& table,
                   const std::vector<native_order::RequestHandle>& live) {
        if (table.erased_rows() != erased_seen || table.size() < rows_folded
            || table.high_water() < folded_high) {
            clear_rows();
            erased_seen = table.erased_rows();
        }
        for (std::size_t i = 0; i < unbound.size();) {
            const auto found = table.find(unbound[i]);
            if (found != table.end() && found->second.bracket_origin.incarnation != 0) {
                fold(unbound[i], found->second, live);
            } else if (found != table.end() && working(live, unbound[i])) {
                ++i;
                continue;
            }
            unbound.erase(unbound.begin() + static_cast<std::ptrdiff_t>(i));
        }
        for (auto row = table.upper_bound(folded_high); row != table.end(); ++row) {
            fold(row->first, row->second, live);
            ++rows_folded;
            folded_high = row->first;
        }
        if (rows_folded < table.size()) {
            // A row arrived below the folded mark: fold the table afresh.
            clear_rows();
            erased_seen = table.erased_rows();
            for (const auto& row : table) {
                fold(row.first, row.second, live);
                ++rows_folded;
                folded_high = row.first;
            }
        }
    }
};
 
// A walk over at most this many retained entries costs less than reaching
// the consumer's cache (the host downcast, the consumer, the cache's type):
// below it the lookups walk, above it they read the index. Either answer is
// the walk's, so the threshold only moves cost.
constexpr std::size_t kIndexedFrom = 16;
 
// The index `consumer` keeps for the adapter at `owner` in run `run`: the
// one it adopted in this run, else (when `create`) a fresh one, else null.
// Any other cache it holds (another adapter bound to the same host, an
// earlier run) is replaced, never read.
AdapterLookupIndex* adapter_lookup_index(IExecutionConsumer* consumer, const void* owner,
                                         std::uint64_t run, bool create = true) noexcept {
    if (!consumer) return nullptr;
    auto& native = as_native_consumer(*consumer);
    NativeHostCache* const cache = native.host_cache();
    auto* index = cache && cache->kind() == &detail::kPineRunCacheKind
        ? static_cast<AdapterLookupIndex*>(cache) : nullptr;
    if (index && index->owner == owner && index->run == run) return index;
    if (!create) return nullptr;
    try {
        auto fresh = std::make_unique<AdapterLookupIndex>();
        fresh->owner = owner;
        fresh->run = run;
        return static_cast<AdapterLookupIndex*>(native.adopt_host_cache(std::move(fresh)));
    } catch (const std::bad_alloc&) {
        return nullptr;
    }
}
 
// A fresh index for the adapter at `owner` in run `run`, adopted by `native`,
// or null when it holds none. Out of line: the per-bar read below reaches it
// once a run.
[[gnu::noinline]] AdapterLookupIndex* adopt_lookup_index(NativeExecutionConsumer& native,
                                                         const void* owner,
                                                         std::uint64_t run) noexcept {
    try {
        auto fresh = std::make_unique<AdapterLookupIndex>();
        fresh->owner = owner;
        fresh->run = run;
        return static_cast<AdapterLookupIndex*>(native.adopt_host_cache(std::move(fresh)));
    } catch (...) {
        return nullptr;
    }
}
 
// The same index, reached for a read made on every bar (the UTC chart-day memo): the
// consumer straight off the host's engine slot (NativeExecutionConsumer::
// bound, which is what the host's own reads use) and the cache's exact type,
// instead of the host's Pine view and a dynamic_cast, which cost about what
// that read saves. AdapterLookupIndex is final, so the type test answers
// exactly what adapter_lookup_index's dynamic_cast does, and the index it
// finds or adopts is the one adapter_lookup_index answers for the same run.
AdapterLookupIndex* parked_lookup_index(NativeStrategyHost* host, const void* owner,
                                        std::uint64_t run) noexcept {
    if (host == nullptr) return nullptr;
    NativeExecutionConsumer* native = nullptr;
    try {
        native = &NativeExecutionConsumer::bound(*host);
    } catch (...) {
        return nullptr;
    }
    NativeHostCache* cache = native->host_cache();
    if (cache != nullptr && typeid(*cache) == typeid(AdapterLookupIndex)) {
        auto* index = static_cast<AdapterLookupIndex*>(cache);
        if (index->owner == owner && index->run == run) return index;
    }
    return adopt_lookup_index(*native, owner, run);
}
 
} // namespace
 
// The per-pump state cache (pine_host_reads.hpp): the running spec's facts the host reads
// every bar, taken once per run into the adapter's cache -- the P7 index, which
// the run's first lookup would otherwise create. Only a running spec is fixed
// for the run the cache belongs to.
void detail::take_run_facts(NativeExecutionConsumer& consumer,
                            const PineExecutionAdapter& adapter, std::uint64_t run) {
    if (!consumer.running()) return;
    if (auto* index = adapter_lookup_index(&consumer, &adapter, run))
        index->aggregates_input_bars = consumer.aggregates_input();
}
 
IExecutionConsumer* PineExecutionAdapter::bound_consumer() const noexcept {
    auto* pine = pine_view_of(host_);
    if (!pine) return nullptr;
    try {
        return &detail::run_consumer(*pine);
    } catch (...) {
        return nullptr;
    }
}
 
bool PineExecutionAdapter::cohort_opened_on_side(const CohortFacts& cohort,
                                                 bool is_long) const noexcept {
    // The openings whose rows were erased left their side behind (the
    // retired-row compaction); the walk and the index read the retained rows beside it.
    const bool erased = (cohort.erased_opening_sides & (is_long ? 1U : 2U)) != 0;
    const auto walk = [&] {
        if (erased) return true;
        for (const auto& origin : cohort.origins) {
            if (!placement_.contains(origin.incarnation)) continue;  // in `erased`
            const auto opening = placement_.find(origin.incarnation);
            if (opening != placement_.end() && opening->second.opening
                && opening->second.is_long == is_long) {
                return true;
            }
        }
        return false;
    };
    if (cohort.origins.size() <= kIndexedFrom || cohort.origins.members().empty()) return walk();
    AdapterLookupIndex* index = adapter_lookup_index(bound_consumer(), this, run_counter_);
    if (!index) return walk();
    try {
        auto& sides = index->cohort_sides[cohort.handle.value];
        const auto& roster = cohort.origins;
        if (roster.size() < sides.folded) sides = {};
        for (sides.folded = std::max(sides.folded, roster.base());
             sides.folded < roster.size(); ++sides.folded) {
            if (!placement_.contains(roster[sides.folded].incarnation)) continue;
            const auto opening = placement_.find(roster[sides.folded].incarnation);
            if (opening == placement_.end() || !opening->second.opening) continue;
            (opening->second.is_long ? sides.opened_long : sides.opened_short) = true;
        }
        ++index->answers;
        PINEFORGE_LOOKUP_INDEX_WORK("cohort_side_answer", this, run_counter_, 1);
        const bool opened = erased || (is_long ? sides.opened_long : sides.opened_short);
        assert(opened == walk());
        return opened;
    } catch (const std::bad_alloc&) {
        return walk();
    }
}
 
bool PineExecutionAdapter::origin_leg_consumed(
        std::uint64_t family_key, PineOrderFamily family,
        const native_order::RequestHandle& origin) const noexcept {
    PINEFORGE_LOOKUP_INDEX_WORK("consumed_leg_probe", this, run_counter_, 1);
    const auto members = bracket_families_.find(family_key);
    if (members == bracket_families_.end()) return false;
    // A consumed member whose row was erased left the (leg kind, origin) it
    // answers for in the family (the retired-row compaction).
    const bool erased = members->second.consumed(static_cast<std::uint8_t>(family),
                                                 origin.incarnation);
    const auto consumed = [&](std::uint64_t incarnation) {
        // A leg whose row was erased answers through its fact (`erased`).
        if (!placement_.contains(incarnation)) return false;
        const auto found = placement_.find(incarnation);
        if (found == placement_.end()) return false;
        const auto& prior = found->second;
        return prior.family == family && prior.bracket_origin == origin
            && !prior.legs.dormant()
            && std::none_of(live_handles_.begin(), live_handles_.end(),
                [&](const native_order::RequestHandle& live) {
                    return live.incarnation == incarnation;
                });
    };
    // The walk: every leg the family placed. A leg whose row was erased is
    // in the settled prefix or the working tail and answered through its
    // fact; the rest are in the working tail.
    const auto walk = [&] {
        return erased || std::any_of(members->second.working_tail().begin(),
                                     members->second.working_tail().end(),
            [&](const native_order::RequestHandle& handle) {
                return consumed(handle.incarnation);
            });
    };
    if (members->second.size() <= kIndexedFrom) return walk();
    AdapterLookupIndex* index = AdapterLookupIndex::exit_leg(family)
        ? adapter_lookup_index(bound_consumer(), this, run_counter_) : nullptr;
    if (!index) return walk();
    try {
        index->sync_rows(placement_, live_handles_);
        // Only a row bound to this origin, of this leg kind, can satisfy
        // `consumed`; the family is the walk's set, so a candidate counts
        // only while the family holds it.
        bool answer = erased;
        if (const auto* legs = answer ? nullptr : index->legs_of(family, origin.incarnation)) {
            for (const auto incarnation : *legs) {
                if (members->second.count(incarnation) != 0 && consumed(incarnation)) {
                    answer = true;
                    break;
                }
            }
        }
        ++index->answers;
        PINEFORGE_LOOKUP_INDEX_WORK("consumed_leg_answer", this, run_counter_, 1);
        assert(answer == walk());
        return answer;
    } catch (const std::bad_alloc&) {
        return walk();
    }
}
 
bool PineExecutionAdapter::immediate_close_placed_on(std::int32_t bar) const noexcept {
    const auto placed = [&](const PlacementSnapshot& row) {
        return row.family == PineOrderFamily::Close && row.immediately
            && row.projection_created_bar == bar;
    };
    // The walk: every row the table holds (an immediate close is kept while
    // its placement bar is the current one or later: erase_retired_rows, K4).
    const auto walk = [&] {
        return std::any_of(placement_.begin(), placement_.end(),
            [&](const auto& row) { return placed(row.second); });
    };
    PINEFORGE_AUDIT_PLACEMENT_SCAN(placement_,
        [&](std::uint64_t, const PlacementSnapshot& row) { return placed(row); });
    if (placement_.size() <= kIndexedFrom) return walk();
    AdapterLookupIndex* index = adapter_lookup_index(bound_consumer(), this, run_counter_);
    if (!index) return walk();
    try {
        index->sync_rows(placement_, live_handles_);
        bool answer = false;
        if (const auto closes = index->immediate_closes_by_bar.find(bar);
            closes != index->immediate_closes_by_bar.end()) {
            for (const auto incarnation : closes->second) {
                const auto found = placement_.find(incarnation);
                if (found != placement_.end() && placed(found->second)) {
                    answer = true;
                    break;
                }
            }
        }
        ++index->answers;
        PINEFORGE_LOOKUP_INDEX_WORK("same_bar_answer", this, run_counter_, 1);
        assert(answer == walk());
        return answer;
    } catch (const std::bad_alloc&) {
        return walk();
    }
}
 
bool PineExecutionAdapter::bracket_belongs_to_reversal(
        const PlacementSnapshot& bracket,
        const PlacementSnapshot& reversal) const {
    if (bracket.projection_position_side == reversal.projection_position_side)
        return true;
    const auto cohort = cohorts_by_id_.find(bracket.from_entry);
    if (cohort == cohorts_by_id_.end()) return false;
    const bool prior_long = reversal.projection_position_side
        == static_cast<std::int32_t>(PositionSide::LONG);
    return cohort_opened_on_side(cohort->second, prior_long);
}
 
void PineExecutionAdapter::suspend_declined_reversal_brackets(
        const native_order::MatchRejectedEvent& event) {
    if (!is_declined_market_reversal(event)) return;
    const auto reversal = placement_.find(event.handle().incarnation);
    if (reversal == placement_.end()) return;
    const auto domain = config_.calc_on_order_fills ? exit_legs::Domain::FillRecalc
                                                    : exit_legs::Domain::Ordinary;
    const exit_legs::Frame cause{event.ordinal, event.cursor.point.interval_index,
                                 domain, exit_legs::Phase::Observation};
    suspend_brackets_for_reversal(reversal->second, cause,
        policy_script_bar_valid_ ? policy_script_bar_.open : reversal->second.sizing.mark);
}
 
bool PineExecutionAdapter::reissue_revives_declined_exit(
        const PlacementSnapshot& previous) const noexcept {
    // A declined reversal kills the held position's stop and limit exits
    // (round 9 family X: an exit issued once never fills after the decline,
    // test_famx_declined_reversal_trail_leg_l4c). Re-issued by a later
    // calculation the exit is a new order and lives, as the replacement path
    // already treats a changed re-issue (fresh_after_dormant): an unchanged
    // re-issue must not keep the killed row either, whatever the side, the
    // sizing or the exit's kind. `lab tv` synthetics in
    // tests/fixtures/callback_lifecycle, BINANCE:ETHUSDT.P 15m 2025-05-28,
    // a 100%-of-equity reversal declined at the 19:45 open and the exit
    // re-issued on every bar, 4 identical exports each: the long's limit
    // (range-breakout-may-rev, -rev-sl), the short mirror's limit
    // (declined-reissue-short) and a partial stop (declined-reissue-stop)
    // each fill on their first reaching bar after the decline. Fixed and
    // cash sizing never reach this row: their unaffordable reversal keeps
    // its close leg and flattens the long (declined-reissue-fixed, -cash).
    //
    // Only the kill revives: the entry/strategy.close pair hold
    // (hold_reversal_pair_brackets) also makes a row dormant, behind a
    // barrier that keeps the pending reversal ahead of the position's own
    // gapped bracket at the next open; a re-issue in the pair's calculation
    // keeps that barrier (pair-hold-reissue: the admitted pair closes the
    // long at the gap open, its gapped stop never fills). The
    // fill-recalculation pass declines through its own path and keeps its
    // dormant rows.
    if (!detail::pine_callback_lifecycle_rule(detail::PineCallbackLifecycleRule::DeclinedReversalReissueRevives)
        || config_.calc_on_order_fills
        || (previous.family != PineOrderFamily::ExitLimit
            && previous.family != PineOrderFamily::ExitStop)) {
        return false;
    }
    const auto& suspension = previous.legs.suspension();
    return suspension && !suspension->hold && suspension->window
        && !suspension->replacement;
}
 
void PineExecutionAdapter::suspend_brackets_for_reversal(
        const PlacementSnapshot& reversal, const exit_legs::Frame& cause,
        double open_price) {
    const int direction = reversal.projection_position_side
        == static_cast<std::int32_t>(PositionSide::LONG) ? 1 : -1;
    // Off the reversal's side, bracket_belongs_to_reversal() answers from a
    // walk of the bracket's from_entry origins, which this loop never changes
    // (it only rewrites leg lifecycles): memoise that answer per from_entry
    // instead of repeating the walk for every retained exit row.
    std::unordered_map<SourceId, bool> cross_side_by_entry;
    const auto belongs = [&](const PlacementSnapshot& bracket) {
        // A from_entry="" exit is the held position's, not one placed under
        // the side the reversal would open (follows_same_bar_declined_reversal).
        if (bracket.from_entry.empty()) {
            return bracket.projection_position_side
                != static_cast<std::int32_t>(reversal.is_long ? PositionSide::LONG
                                                              : PositionSide::SHORT);
        }
        if (bracket.projection_position_side == reversal.projection_position_side)
            return true;
        const auto cached = cross_side_by_entry.find(bracket.from_entry);
        if (cached != cross_side_by_entry.end()) return cached->second;
        const bool value = bracket_belongs_to_reversal(bracket, reversal);
        cross_side_by_entry.emplace(bracket.from_entry, value);
        return value;
    };
    // An erased row this suspension would rewrite is a leg of an ended cycle
    // bound to an origin that can no longer be asked about (erase_retired_
    // rows, K1): nothing reads its lifecycle again. The audit holds that.
    PINEFORGE_AUDIT_PLACEMENT_SCAN(placement_,
        [&](std::uint64_t, const PlacementSnapshot& candidate) {
            return lifecycle_readable(candidate);
        });
    for (auto row : placement_) {
        auto& candidate = row.second;
        const bool exit = candidate.family == PineOrderFamily::ExitLimit
            || candidate.family == PineOrderFamily::ExitStop
            || candidate.family == PineOrderFamily::ExitTrail;
        if (!exit || candidate.legs.dormant()
            || !candidate.legs.target().incarnation
            || !belongs(candidate)) {
            continue;
        }
        const compat::pine::ExitSuspensionContext context{
            cause, direction, require_host().position_avg_price(), staged_.syminfo.mintick,
            open_price,
            candidate.legs.trail_best(), false, true};
        const auto operation = compat::pine::select_exit_suspension(candidate.legs, context);
        if (!operation) continue;
        const exit_legs::Action action{candidate.legs.target(), candidate.legs.revision(),
                                       cause, *operation};
        (void)candidate.legs.apply(candidate.legs.target(), action); invalidate_retirement();
    }
}
 
void PineExecutionAdapter::suspend_coof_declined_reversal_at_open(
        const Bar& bar, const NativeDecisionContext& context) {
    const auto physical = detail::run_position(require_host());
    if (physical.signed_units == 0.0 || !finite_positive(bar.open)) return;
    const auto handles = live_handles_;
    for (const auto& handle : handles) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& reversal = found->second;
        const bool opposite = (physical.signed_units > 0.0) != reversal.is_long;
        const bool market_entry = !finite_positive(reversal.exit_levels.limit)
            && !finite_positive(reversal.exit_levels.stop)
            && !finite_positive(reversal.exit_levels.trail_offset)
            && !finite_positive(reversal.exit_levels.trail_price);
        if (!reversal.opening || reversal.family != PineOrderFamily::Entry
            || !reversal.reverse_to || !opposite || !market_entry) {
            continue;
        }
        const double units = finite_positive(reversal.sizing.frozen_units)
            ? reversal.sizing.frozen_units : reversal.requested_qty;
        const double margin = reversal.is_long ? config_.margin_long : config_.margin_short;
        const double fx = active_staged_fx(context.sub_bar_open_ms);
        const double required = units * bar.open * staged_.syminfo.pointvalue
            * fx * margin / 100.0;
        const double equity = std::isfinite(reversal.sizing.equity)
            ? reversal.sizing.equity : require_host().native_marked_equity(bar.open);
        const double guard = std::max(1e-9, std::abs(equity) * 1e-12);
        if (finite_positive(units) && finite_positive(margin) && std::isfinite(required)
            && std::isfinite(equity) && required > equity + guard) {
            const auto domain = config_.calc_on_order_fills ? exit_legs::Domain::FillRecalc
                                                            : exit_legs::Domain::Ordinary;
            const exit_legs::Frame cause{context.coordinate.ordinal,
                context.coordinate.interval_index, domain,
                exit_legs::Phase::Observation};
            suspend_brackets_for_reversal(reversal, cause, bar.open);
        }
    }
}
 
void PineExecutionAdapter::hold_reversal_pair_brackets(const SourceId& from_entry) {
    const auto point = detail::callback_point(require_host());
    // The cause's ordinal is the kernel's own event number, the live frame's even
    // where `point` is a retained one being replayed.
    const auto live = detail::live_callback_point(require_host());
    if (!point || !live) return;
    const auto domain = config_.calc_on_order_fills ? exit_legs::Domain::FillRecalc
                                                    : exit_legs::Domain::Ordinary;
    const exit_legs::Frame cause{live->decision.coordinate.ordinal,
        point->decision.coordinate.interval_index, domain, exit_legs::Phase::Observation};
    // As in suspend_brackets_for_reversal: no erased lifecycle is read again.
    PINEFORGE_AUDIT_PLACEMENT_SCAN(placement_,
        [&](std::uint64_t, const PlacementSnapshot& candidate) {
            return lifecycle_readable(candidate);
        });
    for (auto row : placement_) {
        auto& candidate = row.second;
        const bool exit = candidate.family == PineOrderFamily::ExitLimit
            || candidate.family == PineOrderFamily::ExitStop
            || candidate.family == PineOrderFamily::ExitTrail;
        if (!exit || candidate.from_entry != from_entry || candidate.legs.dormant()
            || !candidate.legs.target().incarnation) {
            continue;
        }
        const auto operation = compat::pine::select_pair_hold(candidate.legs, cause);
        const exit_legs::Action action{candidate.legs.target(), candidate.legs.revision(),
                                       cause, operation};
        (void)candidate.legs.apply(candidate.legs.target(), action); invalidate_retirement();
    }
}
 
// strategy.cancel / strategy.cancel_all withdraw an exit whatever its state:
// a live exit the cancel takes off the book, and a dormant one -- an exit a
// declined reversal held (finding-311) -- alike. TradingView never brings a
// cancelled exit back. The paired control and cancel tapes
// (NYSE:F 15m) show one script with and without
// strategy.cancel("X") while X is dormant: the margin call revives
// the standing dormant X and closes the position through it; after the cancel
// it does not, and a second margin call follows. The tapes
// that cancel before the pair and after the entry fill (the cancelled-origin retirement) cancel
// X while it is still live. Synthetic accounting: 1000 initial shares,
// calls of 20 and 80, then 900 left open (1000 - 20 - 80): the
// declined pair's suspension still makes the cancelled leg dormant later,
// and the revival must not read that as a standing exit. The legacy engine
// skipped any cancelled order in the same pass (ab9714be
// pine_fills.cpp:2065-2076). The lifecycle records the withdrawal where the
// revival reads it: every leg retired (`withdrawn`), a state no suspension
// produces. `cancelled` names the live requests this cancel withdrew, each
// with the ordinal of its Cancelled event: that event is the cause, so the
// withdrawal lands after whatever the same callback did to the lifecycle
// before (a pair hold at the callback's own ordinal would otherwise make it a
// conflicting replay, and the lifecycle would refuse it). Every other exit
// row the cancel names -- a dormant one, or one the adapter itself took off
// the book on the script's behalf -- is found by id, caused at the callback,
// or just past the lifecycle's last step when that step is no older.
//
// The adapter takes an exit off the book on the script's behalf where
// TradingView keeps it pending: a gapped exit stop a declined reversal
// retires waits in pending_margin_revivals_ for the next margin-call slice
// (apply_reversal_gap_bracket_policy), and the declined pair's suspension
// can still make its row dormant. A cancel drops the waiting revival and
// withdraws the row -- the paired gapped-stop control and cancel tapes
// (synthetic stop 25.15) close the remaining 980 shares through X at the
// margin call without the cancel and book the cancel tape's trades with it.
void PineExecutionAdapter::retire_cancelled_exits(
        const SourceId* id,
        const std::vector<std::pair<std::uint64_t, std::uint64_t>>& cancelled) {
    const auto point = detail::callback_point(require_host());
    // The sweep's event ordinal below is the kernel's own, the live frame's even
    // where `point` is a retained one being replayed (the bar stays `point`'s).
    const auto live = detail::live_callback_point(require_host());
    if (!point || !live) return;
    const auto domain = config_.calc_on_order_fills ? exit_legs::Domain::FillRecalc
                                                    : exit_legs::Domain::Ordinary;
    const auto retire_legs = [&](PlacementSnapshot& candidate, std::uint64_t event) {
        const bool exit = candidate.family == PineOrderFamily::ExitLimit
            || candidate.family == PineOrderFamily::ExitStop
            || candidate.family == PineOrderFamily::ExitTrail;
        if (!exit || !candidate.legs.target().incarnation || withdrawn(candidate.legs)) return;
        // Never at or before the lifecycle's last step: a dormant row a pair
        // hold suspended earlier in this callback took the callback's own
        // ordinal, and the lifecycle refuses a second, different action there
        // (a conflicting replay) as it refuses an older one.
        if (const auto& last = candidate.legs.last_action(); last && last->cause.event >= event)
            event = last->cause.event + 1;
        const exit_legs::Frame cause{event, point->decision.coordinate.interval_index, domain,
                                     exit_legs::Phase::Observation};
        const exit_legs::Action action{candidate.legs.target(), candidate.legs.revision(),
            cause, exit_legs::Cancel{{exit_legs::Leg::Stop, exit_legs::Leg::Limit,
                                      exit_legs::Leg::Trail}}};
        (void)candidate.legs.apply(candidate.legs.target(), action); invalidate_retirement();
    };
    for (const auto& [incarnation, event] : cancelled) {
        const auto found = placement_.find(incarnation);
        if (found != placement_.end()) retire_legs(found->second, event);
    }
    // As in hold_reversal_pair_brackets: no erased lifecycle is read again.
    PINEFORGE_AUDIT_PLACEMENT_SCAN(placement_,
        [&](std::uint64_t, const PlacementSnapshot& candidate) {
            return lifecycle_readable(candidate);
        });
    for (auto row : placement_) {
        auto& candidate = row.second;
        if (id && candidate.source_id != *id) continue;
        retire_legs(candidate, live->decision.coordinate.ordinal);
    }
}
 
void PineExecutionAdapter::purge_brackets_after_applied_reversal(
        const PlacementSnapshot& reversal) {
    const bool prior_long = reversal.projection_position_side
        == static_cast<std::int32_t>(PositionSide::LONG);
    std::vector<native_order::RequestHandle> stale;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& candidate = found->second;
        const bool exit = candidate.family == PineOrderFamily::ExitLimit
            || candidate.family == PineOrderFamily::ExitStop
            || candidate.family == PineOrderFamily::ExitTrail;
        const bool stale_margin = candidate.family == PineOrderFamily::Margin
            && candidate.projection_position_side == reversal.projection_position_side;
        bool targets_prior = false;
        if (const auto cohort = cohorts_by_id_.find(candidate.from_entry);
            cohort != cohorts_by_id_.end()) {
            targets_prior = cohort_opened_on_side(cohort->second, prior_long);
        }
        if ((exit && targets_prior) || stale_margin) stale.push_back(handle);
    }
    for (const auto& handle : stale) {
        (void)require_host().cancel(handle);
        retire(handle);
    }
    const auto held = cohorts_by_id_.held_rows();
    for (auto at = held.begin(); at != held.end();) {
        const auto current = at++;
        auto& cohort = *current;
        // The flip cleared every held cohort before this opening was credited,
        // so the reversal's cohort can only hold the new credit.
        if (cohort.first == reversal.source_id) continue;
        if (cohort_opened_on_side(cohort.second, prior_long)) {
            if (position_tail_summary_) {
                for (const auto& origin : cohort.second.live_units_by_origin)
                    position_tail_summary_->retire_origin(origin.first);
                position_tail_summary_->live_cohort(&cohort, false);
            }
            assert(cohort_opened_slot_count_ >= cohort.second.opened.size());
            cohort_opened_slot_count_ -= cohort.second.opened.size();
            ::pineforge::detail::clear_exposure_storage(cohort.second.opened);
            ::pineforge::detail::clear_exposure_storage(cohort.second.live_units_by_origin);
            cohorts_by_id_.refresh_held(current);
        }
    }
}
 
void PineExecutionAdapter::revive_brackets_after_margin(
        const native_order::ExecutionAppliedEvent& event,
        const NativeDecisionContext& context) {
    const auto physical = detail::run_position(require_host());
    if (physical.signed_units == 0.0) return;
    // A same-path declined reversal and its dormant bracket can both precede
    // this margin event before the next bar-open receipt sweep.  Apply the
    // already-recorded rejection at this Applied boundary so the revival sees
    // the same lifecycle state as the legacy margin callback.
    const auto suspend = [&](const native_order::CommandEvent& command) {
        const auto* rejected = std::get_if<native_order::MatchRejectedEvent>(&command);
        if (rejected
            && rejected->cursor.point.interval_index == context.coordinate.interval_index
            && is_declined_market_reversal(*rejected)) {
            suspend_declined_reversal_brackets(*rejected);
        }
        return false;
    };
    // In place on a PineStrategyHost, as in observe_terminal_receipts.
    if (auto* pine = pine_view_of(&require_host())) {
        as_native_consumer(pine->execution_consumer())
            .visit_commands_after(receipt_cursor_, suspend);
    } else {
        for (const auto& row : require_host().native_events(receipt_cursor_)) {
            if (row.command) suspend(*row.command);
        }
    }
    const auto domain = context.sub_count > 1
        ? (config_.calc_on_order_fills ? exit_legs::Domain::MagnifierFillRecalc
                                       : exit_legs::Domain::Magnifier)
        : (config_.calc_on_order_fills ? exit_legs::Domain::FillRecalc
                                       : exit_legs::Domain::Ordinary);
    const exit_legs::Frame cause{event.ordinal, context.coordinate.interval_index,
                                 domain, exit_legs::Phase::AfterMargin};
    std::optional<PlacementSnapshot> marketable;
    native_order::RequestHandle marketable_handle{};
    // K1 keeps unwithdrawn lifecycle rows for the whole current cycle,
    // including global legs and named ids with temporarily zero exposure.
    // Superseded legs can leave: K2 keeps a row naming their predecessor;
    // K3 keeps the first different-stop re-issue. One retained supersessor
    // answers this test; withdrawn and past-cycle legs are never revived.
    PINEFORGE_AUDIT_PLACEMENT_SCAN(placement_,
        [&](std::uint64_t, const PlacementSnapshot& candidate) {
            return candidate.placement_cycle == current_position_cycle_
                && candidate.legs.dormant() && candidate.legs.target().incarnation != 0
                && !withdrawn(candidate.legs) && !filled_limit_without_revival(candidate);
        });
#if PINEFORGE_PLACEMENT_AUDIT
    for (const auto& retained : placement_) {
        const auto& candidate = retained.second;
        if (retained.second.placement_cycle != current_position_cycle_
            || !candidate.legs.dormant() || !candidate.legs.target().incarnation
            || withdrawn(candidate.legs) || filled_limit_without_revival(candidate)) {
            continue;
        }
        const auto inc = retained.first;
        const auto target_inc = candidate.legs.target().incarnation;
        const auto supersedes = [&](std::uint64_t incarnation, const PlacementSnapshot& peer) {
            return peer.placement_cycle == current_position_cycle_
                && ((peer.projection_predecessor != 0
                     && (peer.projection_predecessor == inc
                         || peer.projection_predecessor == target_inc))
                    || (incarnation > inc && peer.family == candidate.family
                        && peer.source_id == candidate.source_id
                        && peer.from_entry == candidate.from_entry
                        && peer.placement_script_open_ms > candidate.placement_script_open_ms
                        && !same_double_bits(peer.exit_levels.stop,
                                             candidate.exit_levels.stop)));
        };
        // The test below stops at the first supersessor it finds: an erased
        // one only reaches it when no retained row answers first.
        const bool answered = std::any_of(placement_.begin(), placement_.end(),
            [&](const auto& peer) { return supersedes(peer.first, peer.second); });
        if (!answered) PINEFORGE_AUDIT_PLACEMENT_SCAN(placement_, supersedes);
    }
#endif
    PINEFORGE_MARGIN_REVIVAL_OBSERVE(true, placement_, event, context,
        physical.signed_units, current_position_cycle_, 0);
    for (auto row : placement_) {
        // ab9714be pine_orders.cpp:597-608: leg ownership is position-cycle
        // scoped, so only a bracket bound to the cycle this margin call is
        // settling may be revived; one parked by an earlier cycle stays
        // dormant until that cycle re-arms it.
        if (row.second.placement_cycle != current_position_cycle_) continue;
        auto& candidate = row.second;
        const bool exit = candidate.family == PineOrderFamily::ExitLimit
            || candidate.family == PineOrderFamily::ExitStop
            || candidate.family == PineOrderFamily::ExitTrail;
        // A from_entry="" exit the declined reversal held is revived like a
        // named bracket: it names every entry, so the whole held position is
        // its exposure (lab tv tape tests/fixtures/margin_v6
        // w5-rv-global-held, lane W5-ENG-MARGIN-V6).
        const bool global = candidate.from_entry.empty();
        if (!exit || !candidate.legs.dormant()
            || (!global && !(cohort_exposure_for(candidate.from_entry) > 0.0))
            || !candidate.legs.target().incarnation) {
            continue;
        }
        // The script cancelled it, live or dormant (retire_cancelled_exits):
        // every leg is retired, and a cancelled exit is never revived
        // (V19D-P1, the cancelled-origin retirement).
        if (withdrawn(candidate.legs)) continue;
        // A same-id exit re-issued after the slice REPLACED this bracket: the
        // successor carries the cycle's legs, and reviving the superseded parent
        // here would fire the finished cycle's already-touched level against the
        // new lot (ab9714be pine_fills.cpp:7669-7673).
        const auto inc = row.first;
        const auto target_inc = candidate.legs.target().incarnation;
        bool superseded = false;
        for (const auto other : placement_) {
            if (other.second.placement_cycle == current_position_cycle_
                && other.second.projection_predecessor != 0
                && (other.second.projection_predecessor == inc
                    || other.second.projection_predecessor == target_inc)) {
                superseded = true;
                break;
            }
            // The owner keeps ONE pending exit per (id, from_entry): a later
            // bar's same-id strategy.exit re-priced it in place, so the older
            // stop is gone and only that re-issue is a revival candidate
            // (ab9714be pine_fills.cpp:2069-2094 scans the live pending_orders_
            // only).  A re-issue made over a dormant predecessor carries no
            // projection link, so match it by identity: same leg family, a
            // later script bar and a different stop.  A same-bar re-issue
            // still revives the originally armed stop (ab9714be
            // pine_fills.cpp:2088-2094); a same-level re-materialization
            // changes nothing and keeps the predecessor.
            const auto& peer = other.second;
            if (other.first > inc && peer.placement_cycle == current_position_cycle_
                && peer.family == candidate.family
                && peer.source_id == candidate.source_id
                && peer.from_entry == candidate.from_entry
                && peer.placement_script_open_ms > candidate.placement_script_open_ms
                && !same_double_bits(peer.exit_levels.stop, candidate.exit_levels.stop)) {
                superseded = true;
                break;
            }
        }
        if (superseded) continue;
        const double revive_stop = compat::pine::select_margin_revival_stop(candidate.legs);
        const exit_legs::Action restore{candidate.legs.target(), candidate.legs.revision(),
            cause, exit_legs::Restore{{exit_legs::Leg::Stop, exit_legs::Leg::Limit,
                                       exit_legs::Leg::Trail}}};
        const auto restored = candidate.legs.apply(candidate.legs.target(), restore); invalidate_retirement();
        if (restored != exit_legs::Result::Applied
            && restored != exit_legs::Result::Replay) {
            continue;
        }
        candidate.restored_after_margin = true;
        const double held = std::abs(physical.signed_units);
        // Full coverage is compared with a tolerance: the slice has already been
        // split off the physical lot, so the surviving quantity sits below the
        // pre-slice request (ab9714be spells full-position coverage as
        // `qty - kQtyEpsilon`, pine_fills.cpp:1618).
        const bool full = !std::isfinite(candidate.requested_qty)
            ? (!std::isfinite(candidate.qty_percent) || candidate.qty_percent >= 100.0 - 1e-5)
            : candidate.requested_qty >= held - 1e-9;
        const bool ready = !candidate.leg_activation.bounds()
            || candidate.leg_activation.stop_ready(
                current_position_cycle_, context.coordinate.interval_index);
        const double executable_stop = finite_positive(candidate.exit_levels.stop)
            ? candidate.exit_levels.stop : revive_stop;
        const bool reaches = std::isfinite(executable_stop)
            && (physical.signed_units < 0.0
                    ? executable_stop <= event.resolved_price
                    : executable_stop >= event.resolved_price);
        if (!marketable && full && ready && reaches) {
            marketable = candidate;
            marketable_handle = native_order::RequestHandle{
                event.handle().run, candidate.legs.target().incarnation};
        }
    }
    PINEFORGE_MARGIN_REVIVAL_OBSERVE(false, placement_, event, context,
        physical.signed_units, current_position_cycle_, marketable_handle.incarnation);
    if (!marketable) return;
    if (marketable_handle.incarnation) {
        (void)require_host().cancel(marketable_handle);
        retire(marketable_handle);
    }
    native_order::Request request;
    request.intent = native_order::Flatten{};
    request.label = marketable->source_id;
    request.comment = marketable->comment;
    PlacementSnapshot snapshot = *marketable;
    snapshot.forced_execution_price = event.resolved_price;
    snapshot.requested_qty = std::numeric_limits<double>::quiet_NaN();
    snapshot.qty_percent = 100.0;
    snapshot.immediately = true;
    snapshot.legs = {};
    snapshot.leg_activation = {};
    snapshot.exit_activation = {};
    const auto accepted = submit_or_replace(
        std::move(request), std::move(snapshot), false,
        "__margin_revival__" + std::to_string(marketable->legs.target().incarnation));
    if (accepted) {
        (void)require_host().execute_current(
            {*accepted, NativeCurrentPriceRule::NearestTick});
    }
}
 
void PineExecutionAdapter::reset_for_run() {
    position_tail_spill_.reset();
    position_tail_summary_ = std::make_shared<detail::AdapterPositionTailSummary>();
    exit_scratch_ = nullptr;
    pine_view_host_ = nullptr;
    // Incarnations start over with the run.
    retired_row_scratch_.unsuperseded.clear();
    retired_row_scratch_.reissues.clear();
    retired_row_scratch_.adopted_reissues.clear();
    retired_row_scratch_.reissue_high_water = 0;
    retired_row_scratch_.reissue_cycle = -1;
    retired_row_scratch_.roster_pass_due = true; retirement_gate_ = {};
    if (auto* index = adapter_lookup_index(bound_consumer(), this, run_counter_, false))
        index->clear();
    admission_journal.reset();
    cohort_opened_slot_count_ = 0;
    cohorts_by_id_.clear();
    pending_scan_work_ = {}; retirement_work_ = {};
    placement_.clear();
    live_by_source_key_.clear();
    clear_bracket_families();
    pending_write(pending_bracket_legs_).clear();
    pending_write(pending_entries_).clear();
    delayed_market_orders_.clear();
    deferred_open_marketable_sells_.clear();
    throttled_reopen_rearm_.clear();
    entry_openings_interval_index_ = -1;
    entry_openings_this_interval_ = 0;
    pending_write(pending_same_bar_commands_).clear();
    pending_write(source_shadow_pending_).clear();
    pending_same_bar_close_qty_ = 0.0;
    pending_relative_exits_.clear();
    anchored_relative_legs_.clear();
    anchored_relative_stats_ = {};
    anchored_cohort_sequence_ = 0;
    per_entry_exits_.clear();
    pending_write(pending_coof_requests_).clear();
    pending_margin_revivals_.clear();
    clear_live();
    first_open_newborns_.clear();
    dropped_close_count_ = 0;
    dropped_close_digest_ = 1469598103934665603ULL;
    open_entry_fees_.clear();
    trade_exit_phase_.clear(); exit_group_certificate_ = {}; exit_group_work_ = {};
    exit_phase_final_ = 0;
    exit_phase_digest_ = 1469598103934665603ULL;
    exit_rank_keys_.clear();
    exit_rank_keys_digest_ = 1469598103934665603ULL;
    exit_rank_peak_ = 0;
    exit_rank_alt_peak_ = 0;
    admission_events_folded_ = 0;
    admission_events_last_ = 0;
    admission_events_digest_ = 1469598103934665603ULL;
    current_debited_applied_ordinals_.clear();
    intraday_loss_relabel_ordinals_.clear();
    consumed_partial_exit_cycles_.clear();
    bracket_shadowed_openings_.clear();
    named_entry_cancel_tokens_.clear();
    id_bound_exits_.clear();
    close_logical_units_.clear();
    close_ledger_records_.clear();
    pyramiding_records_.clear();
    exit_tombstones_.clear();
    close_batch_callsites_.clear();
    close_batch_bar_ = -1;
    close_batch_queue_sequence_ = 0;
    close_batch_pending_debt_ = 0.0;
    close_batch_admitted_total_ = 0.0;
    receipt_cursor_ = 0;
    last_applied_ordinal_ = 0;
    terminal_receipt_cursor_ = 0;
    materializing_relative_ = false;
    current_position_cycle_ = 0;
    current_position_sign_ = 0;
    next_sequential_group_ = 0;
    source_batch_mutated_ = false;
    coof_recalc_active_ = false;
    coof_first_open_ = false;
    coof_open_stop_next_waypoint_ = false;
    coof_fill_forced_ = false;
    coof_market_entry_recalc_incarnation_ = 0;
    coof_market_entry_recalc_fill_seq_ = 0;
    coof_current_fill_seq_ = 0;
    coof_fill_cursor_t_ = kNaN;
    coof_fill_target_print_ = kNaN;
    coof_context_ = {};
    coof_script_bar_ = {};
    coof_script_bar_valid_ = false;
    pooc_close_basis_last_bar_ = std::numeric_limits<std::int64_t>::min();
    pooc_close_basis_count_ = 0;
    pooc_close_basis_digest_ = 1469598103934665603ULL;
    pooc_open_basis_ = 0.0;
    pooc_open_script_bar_ = std::numeric_limits<std::int64_t>::min();
    close_all_pending_script_bar_ = std::numeric_limits<std::int64_t>::min();
    close_first_script_bar_ = std::numeric_limits<std::int64_t>::min();
    close_first_side_ = 0;
    last_fx_rate_ = kNaN;
    position_open_script_bar_ = std::numeric_limits<std::int64_t>::min();
    position_open_epoch_ = 0;
    position_open_bar_index_ = -1;
    position_open_phase_ = NativePathPhase::None;
    position_open_priced_ = false;
    last_margin_call_script_bar_ = std::numeric_limits<std::int64_t>::min();
    kernel_margin_path_point_ = std::numeric_limits<std::uint64_t>::max();
    kernel_margin_resize_point_ = std::numeric_limits<std::uint64_t>::max();
    close_margin_point_ = std::numeric_limits<std::uint64_t>::max();
    close_margin_cancelled_bar_ = std::numeric_limits<std::int64_t>::min();
    close_margin_follow_up_bar_ = std::numeric_limits<std::int64_t>::min();
    close_margin_follow_up_units_ = 0.0;
    close_margin_open_bar_ = std::numeric_limits<std::int64_t>::min();
    owed_follow_up_bar_ = std::numeric_limits<std::int64_t>::min();
    owed_follow_up_point_ = -1;
    owed_follow_up_units_ = 0.0;
    open_exit_first_bar_ = std::numeric_limits<std::int64_t>::min();
    open_exit_first_origin_ = 0;
    open_exit_first_id_.clear();
    open_exit_first_fill_ = 0.0;
    open_call_sequence_ = false;
    unrepeated_margin_calls_.clear();
    close_call_after_script_bar_ = std::numeric_limits<std::int64_t>::min();
    close_call_after_script_book_ = 0.0;
    close_call_after_script_units_ = 0.0;
    waypoint_chain_bar_ = std::numeric_limits<std::int64_t>::min();
    pooc_close_checkpoint_deferred_ms_ = std::numeric_limits<std::int64_t>::min();
    signal_close_mc_event_bar_ = -1;
    signal_close_mc_position_cycle_ = 0;
    signal_close_mc_entry_incarnation_ = 0;
    signal_close_mc_fill_seq_ = 0;
    signal_close_mc_before_qty_ = kNaN;
    signal_close_mc_remaining_qty_ = kNaN;
    last_margin_call_event_ordinal_ = 0;
    last_margin_call_entry_incarnation_ = 0;
    last_margin_call_position_cycle_ = 0;
    last_margin_call_at_script_close_ = false;
    last_margin_call_closed_units_ = 0.0;
    last_margin_call_remaining_units_ = 0.0;
    source_gains_ = 0.0;
    source_losses_ = 0.0;
    source_money_folded_ = 0;
    risk_coof_direct_script_bar_ = std::numeric_limits<std::int64_t>::min();
    cap_latest_fill_ = 0;
    day_ledger_ = {};
    risk_.observed_peak_equity = kNaN;
    risk_.observed_max_drawdown = 0.0;
    risk_.intraday_block_day = std::numeric_limits<std::int64_t>::min();
    risk_.intraday_cancel_pending = false;
    policy_script_bar_ = {};
    policy_script_bar_valid_ = false;
    market_pyramid_adds_.clear();
    trail_state_at_open_.clear();
    carried_trail_retunes_.clear();
    stream_mode_ = false;
    bar_magnifier_ = false;
    short_seed_ = {};
    pending_short_seed_ = {};
    short_seed_long_candidate_ = {};
    last_bar_dual_entry_path_ = 0;
    last_bar_dual_entry_script_open_ms_ =
        std::numeric_limits<std::int64_t>::min();
    source_sequence_ = 0;
    command_ordinal_ = 0;
    broker_open_epoch_ = 0;
    last_broker_open_ms_ = std::numeric_limits<std::int64_t>::min();
    source_command_sequence_ = 0;
    entry_attempt_bar_ = -1;
    entry_attempts_on_bar_ = 0;
    cap.reset_run();
    refresh_pending_view();
}
 
// The configuration's conjuncts of the margin and admission scopes, formed
// once per configuration rather than at every ask: each scope function
// answers false whenever its flag is false, and reads the rest of its scope
// as before. The process-wide switches stay read at every ask. The host sets
// the configuration again after every script calculation, so this part is
// plain reads of config_ against the staged facts set_staged_configuration
// formed.
// `config` is the configuration being set (read before it is copied in).
[[gnu::always_inline]] inline void
PineExecutionAdapter::refresh_configuration_scopes(const PineStrategyConfig& config) noexcept {
    const bool commission_free = config.commission_value == 0.0;
    const bool one_lot_cap = config.pyramiding >= 0 && config.pyramiding <= 1;
    gain_loss_configured_ = commission_free && staged_scopes_.unit_money && lot_grid_pinned_;
    slipped_long_configured_ = config.margin_long == 100.0 && commission_free
        && config.slippage > 0 && staged_scopes_.unit_grid && one_lot_cap
        && staged_scopes_.unit_money;
    unified_configured_ = lot_grid_pinned_ && !config.calc_on_order_fills && commission_free
        && one_lot_cap && staged_scopes_.unit_money && staged_scopes_.mintick;
    ledger_records_configured_ = config.pyramiding > 1 && !config.close_entries_rule_any
        && lot_grid_pinned_;
    pooc_fee_configured_ = config.process_orders_on_close
        && config.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        && config.commission_value > 0.0
        && config.commission_type == static_cast<int>(CommissionType::PERCENT)
        && staged_scopes_.positive_grid && staged_scopes_.unit_point_money;
}
 
void PineExecutionAdapter::set_configuration(const PineStrategyConfig& config) noexcept {
    refresh_configuration_scopes(config);
    config_ = config;
}
void PineExecutionAdapter::set_staged_configuration(const StagedConfiguration& staged) {
    staged_ = staged;
    const auto& grid = staged_.quantity_grid;
    lot_grid_pinned_ = grid && *grid > 0.0 && decimal_grid_exponent(*grid).has_value();
    staged_scopes_.positive_grid = grid && *grid > 0.0;
    staged_scopes_.unit_grid = grid && *grid > 0.0 && *grid <= 1.0;
    staged_scopes_.unit_point_money = staged_.syminfo.pointvalue == 1.0
        && staged_.account_fx_effective_from_ms.empty();
    staged_scopes_.unit_money = staged_scopes_.unit_point_money && staged_.account_fx == 1.0;
    staged_scopes_.mintick = finite_positive(staged_.syminfo.mintick);
    refresh_configuration_scopes(config_);
}
void PineExecutionAdapter::set_begin_mode(bool is_stream, bool bar_magnifier) noexcept {
    stream_mode_ = is_stream;
    bar_magnifier_ = bar_magnifier;
}
 
const char* instrument_feed_field_name(NativeRunSpecField field) noexcept {
    switch (field) {
    case NativeRunSpecField::InstrumentFeedInstrument: return "instrument_feed_instrument";
    case NativeRunSpecField::InstrumentFeedTimeframe: return "instrument_feed_timeframe";
    case NativeRunSpecField::InstrumentFeedBars: return "instrument_feed_bars";
    case NativeRunSpecField::InstrumentFeedClose: return "instrument_feed_close";
    case NativeRunSpecField::InstrumentFeedColumns: return "instrument_feed_columns";
    case NativeRunSpecField::SubscriptionInstrument: return "subscription_instrument";
    default: return nullptr;
    }
}
 
RunFailureValue run_spec_field_failure(NativeRunSpecField field) noexcept {
    using F = NativeRunSpecField;
    const char* symbol = nullptr;
    const char* setting = nullptr;
    const char* option = nullptr;
    const char* feed = instrument_feed_field_name(field);
    switch (field) {
    case F::Ticker: symbol = "ticker"; break;
    case F::TickerId: symbol = "ticker_id"; break;
    case F::Type: symbol = "type"; break;
    case F::Currency: symbol = "currency"; break;
    case F::BaseCurrency: symbol = "base_currency"; break;
    case F::Description: symbol = "description"; break;
    case F::VolumeType: symbol = "volume_type"; break;
    case F::Timezone: symbol = "timezone"; break;
    case F::Session: symbol = "session"; break;
    case F::ChartTimezone: symbol = "chart_timezone"; break;
    case F::PointValue: symbol = "point_value"; break;
    case F::AccountFx: symbol = "account_fx"; break;
    case F::PriceTick: symbol = "price_tick"; break;
    case F::QuantityGrid:
        return make_run_failure(RunFailureCode::lot_grid_rejected, {});
    case F::InitialCapital: setting = "initial_capital"; break;
    case F::SlippageTicks: setting = "slippage_ticks"; break;
    case F::FeeKind: setting = "fee_kind"; break;
    case F::FeeValue: setting = "fee_value"; break;
    case F::CloseExecution: setting = "close_execution"; break;
    case F::MaxAbsUnits: setting = "max_abs_units"; break;
    case F::MaxOpenLots: setting = "max_open_lots"; break;
    case F::AllowedOpenDirections: setting = "allowed_open_directions"; break;
    case F::InitialMarginFraction: setting = "initial_margin_fraction"; break;
    case F::PriceGrid: setting = "price_grid"; break;
    case F::GridRounding: setting = "grid_rounding"; break;
    case F::MarginModel: setting = "margin_model"; break;
    case F::MarginInitial: setting = "margin_initial"; break;
    case F::MarginMaintenance: setting = "margin_maintenance"; break;
    case F::MarginSizing: setting = "margin_sizing"; break;
    case F::MarginShortfallMultiple: setting = "margin_shortfall_multiple"; break;
    case F::MarginMinUnits: setting = "margin_min_units"; break;
    case F::MarginCheck: setting = "margin_check"; break;
    case F::MarginEquityBasis: setting = "margin_equity_basis"; break;
    case F::MarginLevelBase: setting = "margin_level_base"; break;
    case F::Calculation: setting = "calculation"; break;
    case F::OpenBarView: setting = "open_bar_view"; break;
    case F::RiskLimits: setting = "risk_limits"; break;
    case F::RiskDrawdown: setting = "risk_drawdown"; break;
    case F::RiskIntradayLoss: setting = "risk_intraday_loss"; break;
    case F::RiskLossDays: setting = "risk_loss_days"; break;
    case F::RiskFillsPerDay: setting = "risk_fills_per_day"; break;
    case F::RiskDayBasis: setting = "risk_day_basis"; break;
    case F::RiskAction: setting = "risk_action"; break;
    case F::QuantityTolerance: setting = "quantity_tolerance"; break;
    case F::InputTimeframe: option = "input_timeframe"; break;
    case F::ScriptTimeframe: option = "script_timeframe"; break;
    case F::IntrabarTimeframe: option = "intrabar_timeframe"; break;
    case F::IntrabarSamples: option = "intrabar_samples"; break;
    case F::IntrabarDistribution: option = "intrabar_distribution"; break;
    case F::IntrabarVolumeSamples: option = "intrabar_volume_samples"; break;
    case F::IntrabarSampleEligibility: option = "intrabar_sample_eligibility"; break;
    case F::PathOrder: option = "path_order"; break;
    // The other symbols' feeds the harness installed (strategy_set_symbol_feed):
    // symbol_feeds_refused, named by instrument_feed_field_name above.
    case F::InstrumentFeedInstrument:
    case F::InstrumentFeedTimeframe:
    case F::InstrumentFeedBars:
    case F::InstrumentFeedClose:
    case F::InstrumentFeedColumns:
    case F::SubscriptionInstrument:
        break;
    // The fields the adapter builds itself: a refusal there is our bug.
    case F::None:
    case F::SessionKey:
    case F::RunNumber:
    case F::AbortReporting:
    case F::TimeframeUndetected:
    case F::SlotLabelPolicy:
    case F::LegacyTolerance:
    case F::ReportPolicy:
    case F::SubscriptionTimeframe:
    case F::SubscriptionBars:
    case F::AuxiliaryFeedTimeframe:
    case F::AuxiliaryFeedBars:
    case F::SubscriptionSource:
    case F::EventRetention:
        break;
    }
    try {
        if (symbol) {
            return make_run_failure(RunFailureCode::symbol_metadata_rejected,
                                    {{"field", symbol}});
        }
        if (setting) {
            return make_run_failure(RunFailureCode::strategy_settings_rejected,
                                    {{"field", setting}});
        }
        if (option) {
            return make_run_failure(RunFailureCode::run_options_rejected,
                                    {{"option", option}});
        }
        if (feed) {
            return make_run_failure(RunFailureCode::symbol_feeds_refused,
                                    {{"reason", "kernel_refused_series"}, {"field", feed}});
        }
    } catch (const std::bad_alloc&) {
        return RunFailureValue{RunFailureCode::out_of_memory, nullptr};
    }
    return make_run_failure(RunFailureCode::engine_invariant, {});
}
 
NativeRunSpec PineExecutionAdapter::project(const PineStrategyConfig& config,
                                             const StagedConfiguration& staged,
                                             const NativeBeginArgs& args,
                                             NativePathOrder path_order,
                                             std::vector<NativeInstrumentFeed>* instrument_feeds) const {
    NativeRunSpec spec;
    if (run_counter_ == std::numeric_limits<std::uint64_t>::max()) {
        throw coded<std::overflow_error>(RunFailureCode::engine_invariant, {},
                                         "Pine native run counter exhausted");
    }
    const std::string timezone = staged.syminfo.timezone.empty() ? "UTC" : staged.syminfo.timezone;
    const std::string session = staged.syminfo.session.empty() ? "24x7" : staged.syminfo.session;
    // Bind a stable identity only to staged session/timezone facts; labels and
    // source ids never cross this generic identity boundary.
    spec.identity = {session + "@" + timezone, ++run_counter_};
 
    // A11: sub-two-bar public starts retain the explicit undetected state and
    // intentionally leave both string fields empty.
    // A historical one-bar run has no detectable timeframe, but a stream
    // begin carries an explicit provider timeframe even when its warmup has
    // only one bar.  Preserve that public stream contract rather than
    // erasing the caller's labels into the undetected batch shape.
    // The simple begin has no timeframe argument to preserve when fewer than
    // two bars cannot establish one. A TF-aware public begin is explicit even
    // for one historical bar, and follows the legacy run_tf_impl path.
    spec.timeframe_undetected = args.n < 2 && !args.is_stream
        && args.input_tf.empty() && args.script_tf.empty();
    if (!spec.timeframe_undetected) {
        std::string effective_input = args.input_tf;
        if (effective_input.empty() && args.n >= 2 && args.bars != nullptr) {
            effective_input = detect_timeframe(args.bars, args.n);
        }
        spec.input_tf = std::move(effective_input);
        spec.script_tf = args.script_tf.empty() ? spec.input_tf : args.script_tf;
        // Legacy run_tf_impl used tf_ratio(), for which spelling aliases such
        // as D and 1D are passthrough.  When the input spelling was detected
        // (and therefore was not an explicit public argument), retain the
        // caller's equal-duration script spelling so the generic calendar
        // also takes its raw-label passthrough path.
        if (args.input_tf.empty() && !spec.input_tf.empty() && !spec.script_tf.empty()
            && tf_ratio(spec.input_tf, spec.script_tf) == 1) {
            spec.input_tf = spec.script_tf;
        }
    }
    spec.ticker = staged.syminfo.ticker;
    spec.tickerid = staged.syminfo.tickerid;
    spec.type = staged.syminfo.type;
    spec.currency = staged.syminfo.currency;
    spec.basecurrency = staged.syminfo.basecurrency;
    spec.description = staged.syminfo.description;
    spec.volumetype = staged.syminfo.volumetype;
    spec.timezone = timezone;
    spec.session = session;
    spec.chart_timezone = staged.chart_timezone;
    spec.initial_capital = config.initial_capital;
    spec.point_value = staged.syminfo.pointvalue;
    spec.account_fx = staged.account_fx;
    spec.price_tick = staged.syminfo.mintick;
    spec.slippage_ticks = config.slippage < 0 ? 0U : static_cast<std::uint32_t>(config.slippage);
    spec.fee_kind = fee_kind_for(config.commission_type);
    spec.fee_value = config.commission_value;
    spec.quantity_grid = staged.quantity_grid;
    // Lane XSYM-D: another symbol's bars a request site reads are the
    // kernel's instrument feeds, merged by interval there. A run that
    // installs none leaves the field empty, which folds nothing. They are the
    // host's own, moved in rather than copied (AR-R4); a throw below, the
    // validation at the end included, moves them back.
    struct FeedsBack {
        std::vector<NativeInstrumentFeed>* home;
        NativeRunSpec& spec;
        int pending = std::uncaught_exceptions();
        ~FeedsBack() {
            if (home != nullptr && std::uncaught_exceptions() > pending)
                *home = std::exchange(spec.instrument_feeds, {});
        }
    } feeds_back{instrument_feeds, spec};
    if (instrument_feeds != nullptr) spec.instrument_feeds = std::exchange(*instrument_feeds, {});
    // A13: source hosts opt into the generic tolerant batch ingress.
    // Native-only hosts retain the strict Canonical/None defaults.
    spec.slot_label_policy = NativeSlotLabelPolicy::FeedTolerant;
    spec.legacy_tolerance = NativeFeedTolerance::BatchStructuralBars;
    if (args.is_stream) {
        // A36: legacy stream warmups permit zero-valued interim OHLC bars;
        // the final close is checked by the stream preflight boundary.
        spec.legacy_tolerance = static_cast<NativeFeedTolerance>(
            static_cast<std::uint32_t>(spec.legacy_tolerance)
            | static_cast<std::uint32_t>(NativeFeedTolerance::WarmupNonNegativeOHLC));
    }
    spec.path_order = path_order;
    spec.close_execution = config.process_orders_on_close
        ? NativeCloseExecution::AfterCalculation : NativeCloseExecution::NextEligiblePoint;
    // R6: calc_on_order_fills IS the kernel's fill-triggered cadence. The
    // consumer drives one recalculation at each applied execution's cursor
    // from its own notification drain (A.4 chronology), delivered to
    // PineStrategyHost::on_native_recalculate with reason OrderFill; Pine
    // keeps only its language-state rollback, its waypoint deferral and this
    // guard literal. The open-bar view stays Complete: TradingView's COOF
    // callback reads the whole script bar (CT4).
    if (config.calc_on_order_fills) {
        spec.calculation = NativeCalculationTrigger::BarCloseAndFills;
        spec.max_recalculations_per_point = kCoofLoopGuard;
    }
    // Pine's request_abort surface reports a cooperative cancellation through
    // status, not through last_error(). Native-only hosts retain Error.
    spec.abort_reporting = NativeAbortReporting::Quiet;
    // RP3/RP9 (L2): the kernel records the equity curve and its extremes; the
    // source host keeps only the Pine cadence that marks where the points
    // fall (pine_strategy_host.cpp scheduler_mark_report_point). TradingView's
    // range-end report — which re-marks the curve's last point and re-folds
    // every extreme from it (pine_strategy_host.cpp scheduler_record_range_end)
    // — is report shape, not a mark-to-market row, so the kernel's own
    // range-end producer stays off and report_open_position_at_end with it.
    //
    // R5 audit lane Q6 measured what that costs. The ROWS are no longer
    // duplicated: scheduler_record_range_end calls the kernel's generic
    // producer (NativeExecutionConsumer::append_open_position_report_rows),
    // and tests/test_adapter_range_end_relower.cpp asserts both sides get
    // the identical rows out of it (RE1 pnl=500/300 with no fee; RE2
    // pnl=479.5 comm=20.5 and 279.30000000000001/20.700000000000003 at
    // 0.1 %). What this policy value keeps out is the SHAPE, and each piece
    // is a named divergence in docs/design/native-feature-parity.md §3.7:
    // the equity re-mark off the NET row P&L (RE2: the curve's last point
    // reads eq=100758.8 op=0 here against the kernel's eq=100800 op=800 —
    // 41.2 apart, the round-trip commission of both lots), the extreme
    // re-fold that follows it (RE3: maxru=1758.8000000000029 against 1800),
    // the same-bar bracket re-sort, and three marks on the terminal bar
    // against the kernel's one at run end. RE4, the flat control, agrees on
    // both sides, so every divergence above belongs to the range end.
    spec.report_policy = NativeReportPolicy::KernelRecordedAtHostMarks;
    // Contract P6: Pine pyramiding is adapter command policy. A resting source
    // entry must not consume a generic physical-lot cap before it fills, so
    // the projected native spec deliberately leaves max_open_lots unbounded.
    spec.allowed_open_directions = directions_for(risk_.direction);
    // Pine's frozen default sizing admits against its signal-time tuple.  The
    // generic initial-margin gate only sees the later fill-time FX rate, so
    // source admission is reproduced in validate_precommit instead: every
    // opening verdict below is AdmitWithHostMargin, which is what keeps the
    // kernel's own initial-margin requirement out of the CANDIDATE decision.
    // The declared model is maintenance-only (zero per-side initial, below),
    // which is what keeps it out of L3b's PLACEMENT decision, where a
    // candidate verdict does not exist yet. The two together are the whole
    // statement "the source owns opening admission".
    // R5: the broker model itself is the kernel's. TradingView's two margin
    // percents ARE the maintenance fractions (strategy(margin_long=,
    // margin_short=) is the fraction of the position's value the account must
    // keep, and the emulator liquidates the moment it cannot), the check is
    // made at the remaining path's adverse mark and rests there, and the
    // whole model is present exactly when the call is enabled -- which is how
    // set_margin_call_enabled() keeps its C-ABI semantics without a second
    // switch. The money rules TradingView layers on top (its equity basis,
    // its ten-significant-digit requirement, its lot-floored 4x slice with
    // the whole-drop band, its scheduling) are host policy and live in the
    // three hooks below, never in this spec.
    const double margin_long_fraction = config.margin_long / 100.0;
    const double margin_short_fraction = config.margin_short / 100.0;
    if (source_margin_call_enabled_
        && std::isfinite(margin_long_fraction) && margin_long_fraction > 0.0
        && std::isfinite(margin_short_fraction) && margin_short_fraction > 0.0) {
        NativeMarginModel margin;
        // Wave-4 ruling: opening admission and liquidation are two different
        // broker functions, and this adapter takes only the second one from
        // the kernel. Its own pre-trade check is TradingView's
        // ten-significant-digit money admission against the signal-time
        // tuple, answered as AdmitWithHostMargin at every opening candidate
        // (validate_precommit below), so the model is declared
        // MAINTENANCE-ONLY: zero per-side initial means the kernel enforces
        // no opening requirement -- at the candidate gate and at L3b's
        // placement gate alike -- while the maintenance fractions keep the
        // kernel's liquidation. A positive initial here would re-run the
        // kernel's raw-double requirement over a quantity the source's money
        // rule has already admitted, and decline openings TradingView takes.
        margin.initial_long = 0.0;
        margin.initial_short = 0.0;
        margin.maintenance_long = margin_long_fraction;
        margin.maintenance_short = margin_short_fraction;
        // No sizing knob (R5 N11): resolve_margin_call_units answers every
        // call, so sizing / shortfall_multiple / liquidation_min_units would
        // be set only to be shadowed, and TradingView's slice (restore
        // lot-floored BEFORE the 4x, floored again, one-contract whole-drop
        // band) is no generic policy; check_adapter_spec_shadowing.py guards.
        // The slice belongs to the adverse waypoint it was measured at, not to
        // a solved level -- and a 1x long, whose slope solves no level at all,
        // still has to be checked.
        margin.check = NativeLiquidationCheck::PathAdverseExtremeMark;
        // TradingView's margin equity charges only a PERCENT entry commission
        // against the account; a cash or per-contract entry fee is added back
        // (percent_commission_live_equity).
        margin.basis =
            (config.commission_type == static_cast<int>(CommissionType::PERCENT)
             && config.commission_value > 0.0)
                ? NativeMarginEquityBasis::MarkedEquity
                : NativeMarginEquityBasis::MarkedEquityBeforeOpenCommission;
        // margin_liquidation_price() reads this level: closed money alone.
        margin.level_base = NativeLiquidationLevelBase::RealizedOnly;
        // TradingView's own liquidation ticket. The adapter's host classifies
        // a row as MARGIN_CALL from exactly this exit id (the kernel/source boundary extraction, 2.ii l:
        // PineStrategyHost::on_native_applied states execution::CloseCause,
        // which pineforge.h pins as `3`), so the ticket the kernel books has
        // to be this one.
        margin.liquidation_label = "__margin_call__";
        margin.liquidation_comment = "Margin call";
        spec.margin = margin;
    }
    if (host_ != nullptr)
        NativeExecutionConsumer::bound(*host_).stage_lower_path_source(nullptr);
    if (args.bar_magnifier) {
        // pine_scheduler.cpp:894-899/:1035-1041 supplied the legacy
        // volume-weighted bound.  The native API's generic default remains
        // 64; the source provider owns this policy projection.
        const int volume_weighted_cap =
            legacy_volume_weighted_max_samples(args.magnifier_samples);
        const bool synthesized = spec.timeframe_undetected || spec.input_tf == spec.script_tf;
        if (synthesized) {
            IntrabarPath::synthesized path;
            path.samples = args.magnifier_samples;
            path.distribution = args.magnifier_distribution;
            path.volume_weighted = args.magnifier_volume_weighted;
            path.volume_weighted_min_samples = args.magnifier_volume_weighted_min_samples;
            path.volume_weighted_max_samples = volume_weighted_cap;
            spec.intrabar.value = std::move(path);
        } else {
            // A18: a genuinely finer supplied feed uses a lower-timeframe
            // path. The generic validator owns duration and
            // divisibility rejection for any non-finer malformed pairing.
            // TradingView's magnifier walks its own intrabars at its table's
            // timeframe, not the feed: on a 15-minute chart 2-minute bars,
            // each owned by the chart bar holding its last minute, between
            // the chart bar's own open and close (the TradingView intrabar import,
            // tests/fixtures/magnifier_intrabars). The path is built from the
            // feed and stays on its grid, so its literal is the input's.
            IntrabarPath::lower_tf path;
            if (host_ != nullptr) {
                NativeExecutionConsumer::bound(*host_).stage_lower_path_source(
                    make_magnifier_path_source(args.bars, args.n, spec.input_tf,
                                               spec.script_tf, spec.session, spec.timezone));
            } else if (args.bars && args.n > 0) {
                // Standalone projection remains a value-only reference path.
                path.bars = tradingview_magnifier_bars(
                    args.bars, args.n, spec.input_tf, spec.script_tf, spec.session,
                    spec.timezone);
            }
            path.tf = spec.input_tf;
            path.samples = args.magnifier_samples;
            path.distribution = args.magnifier_distribution;
            path.volume_weighted = args.magnifier_volume_weighted;
            path.volume_weighted_min_samples = args.magnifier_volume_weighted_min_samples;
            path.volume_weighted_max_samples = volume_weighted_cap;
            // Real lower-timeframe bars already carry the legacy four
            // turning points.  Preserve the source broker's continuous
            // segment crossing over those points: a stop reached between the
            // open and an endpoint fills at its level, while synthesized
            // paths below retain the sampled one-price/gap semantics.
            path.sample_eligibility = IntrabarPath::SampleEligibility::ContinuousSegments;
            spec.intrabar.value = std::move(path);
        }
    } else if (!spec.timeframe_undetected
               && (args.magnifier_samples != 4
                   || args.magnifier_distribution != MagnifierDistribution::ENDPOINTS)) {
        // Legacy TF-aware callers accept inactive sampler arguments. Preserve
        // that source-surface shape without relaxing the strict native public
        // API: an empty lower path is already defined to fall back to the
        // caller's confirmed script-bar path at delivery.
        IntrabarPath::lower_tf inert;
        inert.tf = spec.input_tf;
        inert.samples = 4;
        inert.distribution = MagnifierDistribution::ENDPOINTS;
        inert.volume_weighted = false;
        inert.volume_weighted_min_samples = 2;
        inert.volume_weighted_max_samples = 64;
        inert.sample_eligibility = IntrabarPath::SampleEligibility::ContinuousSegments;
        spec.intrabar.value = std::move(inert);
    }
    // The adapter reads the command journal above its own receipt cursor and
    // nowhere else, and acknowledges the cursor as it moves
    // (observe_terminal_receipts), so it keeps only the unread window: the
    // kernel default, which folds nothing into the spec digest.
    spec.event_retention = NativeEventRetention::Window;
    const auto validation = host_ != nullptr
        ? NativeExecutionConsumer::bound(*host_).normalize_projected_spec(spec)
        : native_bar_views_v1::normalize_native_run_spec(spec, {});
    if (!validation) {
        throw coded<std::logic_error>(run_spec_field_failure(validation.field),
                                      "Pine adapter produced invalid native run spec field "
                                      + std::to_string(static_cast<unsigned>(validation.field)));
    }
    // Projection owns only the standalone exit service. Trade and dependency
    // workspaces are installed once by the admitted run's consumer/host setup.
    const CacheDefaults defaults;
    const auto& cache_policy = host_ ? host_->cache_policy_for_run() : defaults;
    auto exit_scratch = detail::make_exit_scratch(spec.identity, cache_policy.projection_exit_pages);
    exit_scratch_ = std::move(exit_scratch);
    return spec;
}
 
std::uint64_t PineExecutionAdapter::key_for(const SourceId& left, const SourceId& right) const noexcept {
    return source_key(left, right);
}
 
native_order::CohortHandle PineExecutionAdapter::cohort_for(const SourceId& id) {
    // Read index bytes before find can spill and before the host issues a handle.
    cohorts_by_id_.require_insert(id);
    auto found = cohorts_by_id_.find(id);
    if (found != cohorts_by_id_.end()) return found->second.handle;
    CohortFacts facts;
    cohorts_by_id_.admit(id, facts.spillable());
    facts.handle = require_host().cohort_open();
    if (facts.handle.value == 0) {
        throw coded<std::logic_error>(RunFailureCode::engine_invariant, {},
                                      "native cohort allocation refused");
    }
    const auto result = facts.handle;
    cohorts_by_id_.place(id, std::move(facts));
    return result;
}
PineSizingSnapshot PineExecutionAdapter::sizing_snapshot() const {
    PineSizingSnapshot snapshot;
    const auto& host = require_host();
    if (const auto point = detail::callback_point(host)) {
        // The source broker captures its signal tuple at the tick-built close,
        // never at the raw sub-tick callback print.  Preserve that one basis
        // for frozen sizing, money-band admission and the paired FX fact.
        snapshot.mark = nearest_tick(point->price, staged_.syminfo.mintick);
        snapshot.price = snapshot.mark;
        mark_sizing_equity(snapshot, snapshot.mark);
    }
    snapshot.fx = staged_.account_fx;
    if (const auto point = detail::callback_point(host))
        snapshot.fx = active_staged_fx(point->decision.sub_bar_open_ms);
    return snapshot;
}
 
// The money a default-quantity declaration converts.  CASH is the declared
// value itself; a percentage is taken of the equity the snapshot marked, and
// that money -- not the equity it is a percentage of -- goes on the
// ten-significant-digit money grid whenever the instrument has a lot grid
// (lab tv tapes tests/fixtures/margin_residual w5b-sz-eur-p50-10m and -p33-10m:
// on ten million, whose equity carries more decimals than ten digits keep,
// rounding the equity first floors 44 of the 504 quantities at 50 % and 37 at
// 33 % one lot off TradingView's, and no rounding at all 8 and 18; at 100 %
// the two roundings are one number, w5b-sz-eur-p100-10m-0410, where no
// rounding misses 98 of 130; lane W5B-ENG-MARGIN-RESIDUAL). Which equity that
// is (ab9714be pine_fills.cpp:1411-1426, restated in
// percent_commission_live_equity) and this rounding are source policy the
// generic EquityFraction basis deliberately does not model, so the source
// hands the core the money and the core converts it.  Any other declaration
// has no money of its own and returns NaN.
//
// Under a cash commission the percentage is taken of strategy.equity -- every
// open entry fee charged, the cash fees percent_commission_live_equity
// restores included -- and the fee the order itself pays is left out of the
// money: the value per order, or the value per unit, so that the units' notional
// and their fee together spend the money (units = pct * E / (price * pointvalue
// + fee)).  The cash-sizing fee correction, `lab tv` tapes tests/fixtures/cash_fee_sizing:
// every sized entry of the thirteen tapes there (percentages 50, 100 and 200,
// long and short, flat, pyramided, after a partial close, reversing, priced
// entries and strategy.order, point values 1 and 50) and all 366 trades of
// corpus order-percent-equity-cash-commission-01.
double PineExecutionAdapter::default_sizing_cash(
        const PineSizingSnapshot& sizing) const {
    if (config_.default_qty_type == static_cast<int>(QtyType::CASH)) {
        if (!std::isfinite(config_.default_qty_value)) {
            engine_command_value_invalid_or_count("sizing.quantity", EngineValueStage::sizing,
                                                 EngineValueReason::nonfinite);
        }
        return config_.default_qty_value;
    }
    if (config_.default_qty_type != static_cast<int>(QtyType::PERCENT_OF_EQUITY)) return kNaN;
    if (default_sizing_reserves_cash_fee()) {
        if (!finite_positive(sizing.strategy_equity)) {
            if (!std::isfinite(sizing.strategy_equity)) {
                engine_command_value_invalid_or_count("sizing.basis", EngineValueStage::sizing,
                                                     EngineValueReason::nonfinite);
            }
            return kNaN;
        }
        const double equity = staged_.quantity_grid ? source_money_round(sizing.strategy_equity)
                                                    : sizing.strategy_equity;
        const double money = config_.default_qty_value / 100.0 * equity;
        if (!std::isfinite(money)) {
            engine_command_value_invalid_or_count("sizing.quantity", EngineValueStage::sizing,
                                                 EngineValueReason::nonfinite);
        }
        if (config_.commission_type == static_cast<int>(CommissionType::CASH_PER_ORDER)) {
            const double cash = money - config_.commission_value;
            if (!std::isfinite(cash)) {
                engine_command_value_invalid_or_count("sizing.quantity", EngineValueStage::sizing,
                                                     EngineValueReason::nonfinite);
            }
            return cash;
        }
        // The core converts cash / unit_cost; this cash leaves
        // units * (unit_cost + fee) == money.
        const double unit_cost = sizing.price * staged_.syminfo.pointvalue * sizing.fx;
        if (!finite_positive(unit_cost)) {
            if (!std::isfinite(unit_cost)) {
                engine_command_value_invalid_or_count("sizing.quantity", EngineValueStage::sizing,
                                                     EngineValueReason::nonfinite);
            }
            return kNaN;
        }
        const double divisor = unit_cost + config_.commission_value;
        if (!std::isfinite(divisor)) {
            engine_command_value_invalid_or_count("sizing.quantity", EngineValueStage::sizing,
                                                 EngineValueReason::nonfinite);
        }
        const double cash = money * unit_cost / divisor;
        if (!std::isfinite(cash)) {
            engine_command_value_invalid_or_count("sizing.quantity", EngineValueStage::sizing,
                                                 EngineValueReason::nonfinite);
        }
        return cash;
    }
    if (!finite_positive(sizing.equity)) {
        if (!std::isfinite(sizing.equity)) {
            engine_command_value_invalid_or_count("sizing.basis", EngineValueStage::sizing,
                                                 EngineValueReason::nonfinite);
        }
        return kNaN;
    }
    const double money = config_.default_qty_value / 100.0 * sizing.equity;
    const double cash = staged_.quantity_grid ? source_money_round(money) : money;
    if (!std::isfinite(money) || !std::isfinite(cash)) {
        engine_command_value_invalid_or_count("sizing.quantity", EngineValueStage::sizing,
                                             EngineValueReason::nonfinite);
    }
    return cash;
}
 
// A percentage declaration reserves a percentage commission out of its own
// money before converting; a cash declaration does not.  The divisor is the
// exact inverse of the charge, which is what native_order::Sized spells as
// reserve_percent_fee.
bool PineExecutionAdapter::default_sizing_reserves_percent_fee() const noexcept {
    return config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        && config_.commission_type == static_cast<int>(CommissionType::PERCENT)
        && config_.commission_value > 0.0;
}
 
bool PineExecutionAdapter::default_sizing_reserves_cash_fee() const noexcept {
    return config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        && (config_.commission_type == static_cast<int>(CommissionType::CASH_PER_ORDER)
            || config_.commission_type == static_cast<int>(CommissionType::CASH_PER_CONTRACT))
        && config_.commission_value > 0.0;
}
 
// The source lot floor.  The two declarations do not share one: a percentage
// quantity uses the money floor with its cent-grid case, a cash quantity the
// ordinary grid helper with its proportional epsilon.  Neither is the core's
// generic "largest grid multiple at or below the quotient", so the core hands
// back the raw quotient (ExecutionGridPolicy::ExplicitUnits) and this runs on
// top of it in resolve_terms.
double PineExecutionAdapter::default_sizing_lot_floor(double units) const noexcept {
    if (config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        && staged_.quantity_grid) {
        // Margin rule 1, pinned fee-free at point value 1 without an FX
        // series: the quotient is the one division sig10(E) / close.
        if (detail::margin_rule_switches().decimal_sizing
            && !default_sizing_reserves_percent_fee() && !default_sizing_reserves_cash_fee()
            && staged_.syminfo.pointvalue == 1.0 && staged_.account_fx == 1.0
            && staged_.account_fx_effective_from_ms.empty()) {
            if (const auto floored = decimal_floor_lot(units, *staged_.quantity_grid))
                return *floored;
        }
        return source_money_floor_lot(units, staged_.quantity_grid);
    }
    return floor_quantity_grid(units, staged_.quantity_grid);
}
 
// The core intent a default-quantity declaration spells: the source money as
// the CashValue basis, the core's fee reserve, the raw quotient for the source
// lot floor, frozen at acceptance against the signal rule.  No money, no shape.
std::optional<native_order::Sized> PineExecutionAdapter::default_sizing_shape(
        const PineSizingSnapshot& sizing) const {
    const double cash = default_sizing_cash(sizing);
    if (!finite_positive(cash)) return std::nullopt;
    native_order::Sized sized;
    sized.basis = native_order::CashValue{cash};
    sized.time = native_order::SizeTime::AtAcceptance;
    sized.price = native_order::SizePrice::SignalOnTick;
    sized.grid_policy = native_order::ExecutionGridPolicy::ExplicitUnits;
    sized.reserve_percent_fee = default_sizing_reserves_percent_fee();
    return sized;
}
 
// The placement-time default quantity: the source's money band and
// affordability gates consume it before any request exists (entry(): "The TV
// money band is a source policy"), so the source asks the core for its own
// conversion and floors it -- the arithmetic exists once (R5 N11).
double PineExecutionAdapter::default_sizing_units(const PineSizingSnapshot& sizing) const {
    if (!finite_positive(sizing.price) || !finite_positive(sizing.fx)) {
        if (!std::isfinite(sizing.price) || !std::isfinite(sizing.fx)) {
            engine_command_value_invalid_or_count("sizing.quantity", EngineValueStage::sizing,
                                                 EngineValueReason::nonfinite);
        }
        return 0.0;
    }
    const auto sized = default_sizing_shape(sizing);
    if (!sized) return 0.0;
    const auto quotient = require_host().native_sized_units(
        *sized, sizing.price, sizing.equity, sizing.fx);
    return quotient ? default_sizing_lot_floor(*quotient) : 0.0;
}
 
// A typed quantity's units at `price`: the core converts the money the source
// chose, and reserves a percentage fee out of a percentage's money, exactly as
// for a default quantity; the source floors the quotient onto its grid, as
// ab9714be calc_qty_for_type (pine_orders.cpp:130-170) did for both types.
double PineExecutionAdapter::typed_quantity_units(double money, bool percent, double price,
                                                  double fx) const {
    native_order::Sized sized;
    sized.basis = native_order::CashValue{money};
    sized.grid_policy = native_order::ExecutionGridPolicy::ExplicitUnits;
    sized.reserve_percent_fee = percent
        && config_.commission_type == static_cast<int>(CommissionType::PERCENT)
        && config_.commission_value > 0.0;
    return floor_quantity_grid(
        require_host().native_sized_units(sized, price, 0.0, fx).value_or(0.0),
        staged_.quantity_grid);
}
 
// What a typed entry opens when it fills at `price`: its cash, or its
// percentage of the source's sizing equity -- of the hypothetical Flatten's
// realized balance when it was placed as a reversal (ab9714be
// pine_orders.cpp:96-191: the old opening fee and this close's fee are
// realized once, before the new opening's percentage fee is reserved).
std::optional<double> PineExecutionAdapter::typed_entry_units(
        const PlacementSnapshot& source, double price, double fx,
        native_order::RequestHandle target) const {
    const double qty = source.requested_qty;
    if (source.qty_type == static_cast<int>(QtyType::CASH))
        return typed_quantity_units(qty, false, price, fx);
    if (source.qty_type != static_cast<int>(QtyType::PERCENT_OF_EQUITY)) return qty;
    if (source.terms_priced_reverse) {
        const auto* pine_host = pine_view_of(&require_host());
        if (!pine_host) return std::nullopt;
        const auto projection = pine_host->project_native_settlement_at(
            execution::Flatten{},
            execution::Fill{price, source.source_id, source.comment, target.incarnation}, fx);
        return typed_quantity_units(projection.realized_balance * qty / 100.0, true, price, fx);
    }
    return typed_quantity_units(percent_commission_live_equity(price, fx) * qty / 100.0, true,
                                price, fx);
}
 
std::optional<native_order::Sized> PineExecutionAdapter::default_sizing_intent(
        const PineSizingSnapshot& sizing, bool is_long) const {
    // The core converts at the run's own point value; whether it also converts
    // at the source's FX rate is decided where it accepts the command
    // (core_sizing_price_matches), so a staged FX series keeps this shape.
    if (!finite_positive(staged_.account_fx)
        || !finite_positive(sizing.price) || !finite_positive(staged_.syminfo.pointvalue)
        || !finite_positive(staged_.syminfo.mintick)) {
        return std::nullopt;
    }
    auto sized = default_sizing_shape(sizing);
    if (sized) sized->side = is_long ? native_order::Side::Long : native_order::Side::Short;
    return sized;
}
 
// The sizing price of a default-sized MARKET entry: the signal mark carried
// to the expected fill by the side's slippage ticks and re-snapped onto the
// chart tick (ab9714be pine_strategy_commands.cpp:325-328).  This is the rule
// native_order::SizePrice::SignalOnTick names generically.
double PineExecutionAdapter::default_market_sizing_price(
        double mark, bool is_long) const noexcept {
    const double tick = staged_.syminfo.mintick;
    return nearest_tick(mark + (is_long ? 1.0 : -1.0) * config_.slippage * tick, tick);
}
 
// POOC_FEE_SIZING (switch pooc_fee_sizing): under process_orders_on_close a
// default percent-of-equity MARKET order is sized on its slipped tick-built
// execution price, and with a percentage commission on that price grossed up
// by the fee on the ten-digit money grid: unit = sig10(exec x (1 + fee)),
// Q = the decimal lot floor of sig10(E) / unit. A BTC reversal at a close of
// 85253.54 with a 0.05 % fee buys 1.13834 on sig10(85296.15676499999) =
// 85296.15676, where the raw product buys 1.13833 (tests/fixtures/
// margin_call_rules fee-sizing tapes); at fee 0 the unit is exec itself. The
// order keeps this quantity to its fill (host-sized, not the core's quotient).
// Out of line: inlined into its one caller, it widened that per-bar
// function's fetch footprint (CMakeLists.txt, -falign-functions).
[[gnu::noinline]]
std::optional<double> PineExecutionAdapter::pooc_fee_units(
        const PineSizingSnapshot& sizing) const {
    const auto& rules = detail::margin_rule_switches();
    if (!rules.pooc_fee_sizing || !config_.process_orders_on_close
        || config_.default_qty_type != static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        || !(config_.commission_value > 0.0)
        || config_.commission_type != static_cast<int>(CommissionType::PERCENT)
        || !staged_.quantity_grid || !(*staged_.quantity_grid > 0.0)
        || staged_.syminfo.pointvalue != 1.0 || sizing.fx != 1.0
        || !staged_.account_fx_effective_from_ms.empty() || !finite_positive(sizing.price)
        || !std::isfinite(sizing.equity)) {
        return std::nullopt;
    }
    const double money = config_.default_qty_value / 100.0 * sizing.equity;
    const double cash = source_money_round(money);
    const double unit = tv_pooc_fee_grossed_unit(sizing.price);
    if (!finite_positive(cash) || !finite_positive(unit)) return std::nullopt;
    const double quotient = cash / unit;
    if (rules.decimal_sizing) {
        if (const auto floored = decimal_floor_lot(quotient, *staged_.quantity_grid))
            return *floored;
    }
    return source_money_floor_lot(quotient, staged_.quantity_grid);
}
 
// TradingView's process_orders_on_close fee-grossed sizing unit: the slipped
// execution price grossed up by the percentage commission on the ten-digit
// money grid, sig10(exec x (1 + c / 100)). Pinned by the fee-sizing tapes
// under tests/fixtures/margin_call_rules (fee-sizing/, 13 tapes; the
// factorial/c1r3-fee0-* controls show no rounding at commission 0): a BTC
// reversal at a close of 85253.54 with a 0.05 % fee buys 1.13834 on
// sig10(85296.15676499999) = 85296.15676, where the raw product buys 1.13833.
// It is not the core's reserve divisor -- the quotient divides the ten-digit
// cash by this rounded unit -- and it is the one place the adapter spells the
// fee factor: guard (e) of tests/test_adapter_sizing_relower.cpp allows the
// spelling inside this function alone, by an explicit exception.
double PineExecutionAdapter::tv_pooc_fee_grossed_unit(double price) const {
    double unit = source_money_round(price * (1.0 + config_.commission_value / 100.0));
#ifdef PINEFORGE_VALUE_INVALID_FIXTURES
    unit = fixture_adapter_execution_value("fee.adapter.grossed_unit", unit);
#endif
    if (std::isfinite(price) && !std::isfinite(unit)) {
        engine_command_value_invalid_or_count("fee.commission", EngineValueStage::fee,
                                              EngineValueReason::numeric_overflow);
    }
    return unit;
}
 
bool PineExecutionAdapter::core_sizes_default_opening(bool is_long) const {
    PineSizingSnapshot sizing = sizing_snapshot();
    if (!finite_positive(sizing.mark)) return false;
    sizing.price = default_market_sizing_price(sizing.mark, is_long);
#ifdef PINEFORGE_VALUE_INVALID_FIXTURES
    sizing.price = fixture_adapter_execution_value("slippage.default.core", sizing.price);
#endif
    check_slippage_fill_price(sizing.price, std::isfinite(sizing.mark));
    mark_sizing_equity(sizing, sizing.mark);
    return finite_positive(default_sizing_units(sizing))
        && default_sizing_intent(sizing, is_long).has_value()
        && core_sizing_price_matches(sizing, is_long);
}
 
bool PineExecutionAdapter::core_sizing_price_matches(
        const PineSizingSnapshot& sizing, bool is_long) const {
    const double tick = staged_.syminfo.mintick;
    if (!finite_positive(tick) || !finite_positive(sizing.price)) return false;
    // The core freezes at its own live frame, never at a retained one a replay
    // is reading, so this prediction reads the live point.
    const auto point = detail::live_callback_point(require_host());
    if (!point || !finite_positive(point->price)) return false;
    // The core freezes the quotient at the FX of the acceptance coordinate (a
    // script calculation's coordinate is the next bar's open); the source
    // sized at its sub-bar open's. They differ only across a curve step.
    if (active_staged_fx(point->decision.coordinate.effective_time_ms) != sizing.fx) return false;
    // SizePrice::SignalOnTick in the core's own arithmetic -- its nearest tick
    // is std::round with ties away from zero, not this file's
    // floor(v / tick + 0.5) -- so this is a comparison against the core and
    // not a restatement of the source rule.  The two agree on every price a
    // tick ladder can present; where they would not, the command keeps its
    // host-resolved intent and its own frozen quantity.
    const auto on_tick = [tick](double value) { return std::round(value / tick) * tick; };
    const double ticks = config_.slippage < 0 ? 0.0 : static_cast<double>(config_.slippage);
    const double slipped = is_long ? on_tick(point->price) + ticks * tick
                                   : on_tick(point->price) - ticks * tick;
    return on_tick(slipped) == sizing.price;
}
 
bool PineExecutionAdapter::same_bar_market_tx_scope() const {
    return config_.commission_value == 0.0 && config_.pyramiding <= 1
        && !config_.calc_on_order_fills && same_point_pair_scope();
}
 
bool PineExecutionAdapter::fixed_unmargined_market_batch_scope() const {
    return config_.pyramiding >= 2
        && config_.default_qty_type == static_cast<int>(QtyType::FIXED)
        && config_.margin_long == 0.0 && config_.margin_short == 0.0
        && config_.commission_value == 0.0 && !config_.calc_on_order_fills
        && same_point_pair_scope();
}
 
// The flat-entry pair handling: where the flat-pair rules of the entry/reversal fill ordering hold
// -- the order at one fill point, the later call's transaction of its own
// quantity plus the pending market's, and that transaction's admission. The
// zero-cost batch above is its subset; TradingView books a commissioned pair
// the same way, the admission leaving the commission out (lab tv w6-f10i,
// w6-f10j, w6b-p1b/p1c/p1d), a pair under any pyramiding, same-side lots by
// rank too (w6-f10c, w6b-p2a/p2b/p2c), and a pair under calc_on_order_fills
// placed outside a fill recalculation (w6-f10f, w6b-p4a/p4b;
// tests/fixtures/same_point_entries).
bool PineExecutionAdapter::same_point_pair_scope() const {
    const bool all_in_percent = config_.default_qty_type
        == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        && config_.default_qty_value >= 100.0;
    const bool fixed_default = config_.default_qty_type == static_cast<int>(QtyType::FIXED);
    const bool variable_default = config_.default_qty_type == static_cast<int>(QtyType::CASH)
        || (config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
            && config_.default_qty_value < 100.0);
    const bool variable_short_seed = variable_default && short_seed_context_is_live();
    if (!host_ || config_.process_orders_on_close
        || coof_recalc_active_ || config_.close_entries_rule_any || all_in_percent
        || (!fixed_default && !variable_short_seed)
        || config_.slippage != 0
        || risk_.direction != 0 || risk_.max_cons_loss_days != 0
        || risk_.max_drawdown > 0.0 || risk_.max_intraday_loss > 0.0
        || risk_.max_position_size > 0.0 || risk_.halted || cap.active()) {
        return false;
    }
    const auto state = detail::run_state(require_host());
    const auto* inert = state.spec ? state.spec->intrabar.lower() : nullptr;
    const auto views = detail::run_consumer(require_host()).bar_views();
    const bool inactive_sampler_path = inert != nullptr && inert->bars.empty()
        && (views.lower_path == nullptr || views.lower_path->count() == 0)
        && inert->tf == state.spec->input_tf && inert->samples == 4
        && inert->distribution == MagnifierDistribution::ENDPOINTS
        && !inert->volume_weighted && inert->volume_weighted_min_samples == 2
        && inert->volume_weighted_max_samples == 64
        && inert->sample_eligibility == IntrabarPath::SampleEligibility::ContinuousSegments;
    return state.spec != nullptr
        && (state.spec->intrabar.is_none() || inactive_sampler_path);
}
 
// Entry-family triggers only: every trailing shape the source language can
// ask for is built in exit(), on the kernel's own Trail / TrailTicks
// spelling, so this helper never carried a live trail case.
native_order::Trigger PineExecutionAdapter::trigger_for(double limit_price,
                                                         double stop_price) const {
    if (price_present(limit_price) && price_present(stop_price))
        return native_order::StopLimit{stop_price, limit_price};
    if (price_present(limit_price)) return native_order::Limit{limit_price};
    if (price_present(stop_price)) return native_order::Stop{stop_price};
    return native_order::Market{};
}
 
native_order::Group PineExecutionAdapter::group_for(const std::string& name, int type,
                                                     std::int64_t cohort) const {
    if (name.empty() || type == 0) return native_order::NoGroup{};
    const auto group = fnv_string(name);
    return native_order::Member{group == 0 ? 1 : group, cohort,
        type == 1 ? native_order::GroupEffect::Cancel : native_order::GroupEffect::Reduce};
}
 
void PineExecutionAdapter::remember(const native_order::RequestHandle& handle,
                                    PlacementSnapshot&& snapshot) {
    snapshot.filled_exit = false;
    // Most rows arrive above the high water. An anchored leg can be adopted
    // later: K3 must compare that new peer against old (even resolved)
    // candidates too. A wholesale rewrite invalidates the immutable-field
    // memo rather than trusting its former identity/stop answer.
    if (placement_.contains(handle.incarnation)) {
        retired_row_scratch_.reissues.clear();
        retired_row_scratch_.reissue_high_water = 0;
    } else if (handle.incarnation <= retired_row_scratch_.reissue_high_water) {
        retired_row_scratch_.adopted_reissues.push_back(handle.incarnation);
    }
    if (snapshot.reservation_growth_owner_incarnation != 0
        && snapshot.reservation_growth_owner_incarnation != handle.incarnation) {
        snapshot.reservation_growth_source.assign_capture(
            handle.incarnation, snapshot.reservation_growth_owner_incarnation);
        snapshot.pooc_global_full_exit_bound_add = true;
    }
    initialize_l4c_policy(snapshot, handle);
    // The chain's oldest source sequence: the predecessor's, while it is
    // retained (a queued command's predecessor is a root of
    // erase_retired_rows).
    // A re-issue made once its entry exists does not continue a void call's
    // chain: its place in the exit queue is its own (exit_queue_rank).
    if (snapshot.projection_predecessor == 0) {
        snapshot.chain_origin_sequence = snapshot.source_sequence;
    } else if (placement_.contains(snapshot.projection_predecessor)) {
        const auto& predecessor = placement_.at(snapshot.projection_predecessor);
        snapshot.chain_origin_sequence = predecessor.void_issue && !snapshot.void_issue
            ? snapshot.source_sequence : predecessor.chain_origin_sequence;
    } else if (snapshot.chain_origin_sequence == 0) {
        snapshot.chain_origin_sequence = snapshot.source_sequence;
    }
    // Otherwise the snapshot is a copy of a row that named the same
    // predecessor, now erased, and carries that row's chain origin: the one
    // a walk through the predecessor reaches.
    // Every accepted request receives a fresh incarnation. Construct its
    // immutable placement evidence directly in the hash table rather than
    // default-constructing a string-bearing snapshot and move-assigning it.
    // The insertion and live-family accounting share one mutation boundary.
    // A new placement cannot already have a live handle: erasure keeps every
    // live placement. Re-adoption / replacement still checks the old handle.
    remember_live(handle, std::move(snapshot));
    // A close order is a transient key of the entry-id table while it waits
    // (global_exit_child_ranks).
    const auto family = placement_.at(handle.incarnation).family;
    if (family == PineOrderFamily::Close || family == PineOrderFamily::CloseAll
        || family == PineOrderFamily::Order) {
        note_exit_rank_transients();
    }
    update_l4c_priority();
    refresh_pending_view();
}
 
void PineExecutionAdapter::retire(native_order::RequestHandle handle) noexcept {
    retired_row_scratch_.roster_pass_due = true;
    forget_live(handle);
    first_open_newborns_.erase(std::remove(first_open_newborns_.begin(),
        first_open_newborns_.end(), handle), first_open_newborns_.end());
    for (auto it = live_by_source_key_.begin(); it != live_by_source_key_.end();) {
        if (it->second == handle) it = live_by_source_key_.erase(it); else ++it;
    }
    if (pending_short_seed_.ready && (handle == pending_short_seed_.plan.long_entry
        || handle == pending_short_seed_.plan.materialize_long
        || handle == pending_short_seed_.plan.final_short)) {
        pending_short_seed_ = {};
    }
    if (handle == short_seed_long_candidate_) short_seed_long_candidate_ = {};
    if (short_seed_.active && (handle == short_seed_.long_entry
        || handle == short_seed_.materialize_long || handle == short_seed_.final_short)) {
        short_seed_.active = false;
    }
    refresh_pending_view();
}
 
namespace detail {
namespace {
// Process-wide, not thread_local: a strategy module is dlopen'd, and every
// thread_local it reads per bar is a dynamic TLS lookup.
std::atomic<bool> retain_rows{false};
std::atomic<std::uint64_t> rows_erased{0};
} // namespace
void set_retain_retired_rows(bool retain) noexcept {
    retain_rows.store(retain, std::memory_order_relaxed);
}
bool retain_retired_rows() noexcept { return retain_rows.load(std::memory_order_relaxed); }
namespace {
// The handle-preserving reissue change: process-wide like retain_rows, and for the same reason.
std::atomic<bool> carry_bindings{true};
} // namespace
void set_carry_reissue_bindings(bool carry) noexcept {
    carry_bindings.store(carry, std::memory_order_relaxed);
}
bool carry_reissue_bindings() noexcept {
    return carry_bindings.load(std::memory_order_relaxed);
}
std::uint64_t retired_rows_erased() noexcept { return rows_erased.load(std::memory_order_relaxed); }
} // namespace detail
 
// Audit mirror of K1's cycle and oldest dormant-representative pins.
// A named id's momentary exposure does not shorten the cycle pin.
bool PineExecutionAdapter::lifecycle_readable(const PlacementSnapshot& row) const noexcept {
    if (row.legs.target().incarnation == 0 || filled_limit_without_revival(row)) return false;
    const std::uint64_t origin = row.bracket_origin.incarnation;
    bool askable = false;
    for (const auto& handle : live_handles_) if (handle.incarnation == origin) askable = true;
    for (const auto& cohort : cohorts_by_id_.held_rows())
        for (const auto& opening : cohort.second.opened) if (opening.incarnation == origin) askable = true;
    if ((row.placement_cycle >= current_position_cycle_ && !withdrawn(row.legs))
        || (askable && !row.legs.dormant())) return true;
    if (!askable || !row.legs.dormant() || (row.family != PineOrderFamily::ExitLimit
        && row.family != PineOrderFamily::ExitStop && row.family != PineOrderFamily::ExitTrail)) return false;
    for (auto peer : placement_) {
        const auto& pin = peer.second;
        if (!pin.legs.dormant() || pin.legs.target().incarnation == 0 || pin.family != row.family
            || pin.bracket_origin != row.bracket_origin || pin.source_id != row.source_id
            || pin.from_entry != row.from_entry) continue;
        return &pin == &row;
    }
    return false;
}
 
// The retired-row compaction: which placement rows can go.
//
// retire() takes a request out of the live collections when it stops
// working; its row used to stay for the rest of the run. Here, at every bar
// open -- the start of an outermost native callback, after
// observe_terminal_receipts() has consumed every command event up to the
// high water (so the terminal receipt of every retired request has been
// observed, and no applied notification is still queued: the kernel drains
// them when the callback that caused them returns) -- each row whose request
// is not live is erased unless some reader can still reach it. The readers,
// by how they reach a row:
//   - by a live handle (live_handles_, live_by_source_key_,
//     first_open_newborns_, the precommit/terms target, a list the same call
//     built from those): a live row is never erased;
//   - by a kernel event (on_applied, observe_terminal_receipts, the commands
//     visited after the receipt cursor): consumed before the sweep;
//   - by a handle another collection holds: the roots below keep the row;
//   - by a whole-table scan: a row is kept while some scan could still accept
//     it (the pins below), or the scan reads a compact record instead
//     (PlacementTable: the per-id sequence minima, the non-margin source
//     ids; BracketRoster: the consumed legs; CohortFacts: the sides of the
//     erased openings; PlacementSnapshot::chain_origin_sequence).
// Roots: the cohorts' opened lists and the host's open lots (an opening
// while it holds units); every handle a queued command's snapshot or request
// names (bracket origin, paired reversal parent, close-all preservation,
// predecessor, lifecycle target, reservation owner, wait/bind owner); the
// anchored relative legs and the parent being materialized; the short-seed
// plans.
// Pins, one per scan that reads rows of requests that are no longer live:
//   K1 an unwithdrawn lifecycle for the whole current cycle, including global
//      legs and named ids whose exposure may return; askable origins also keep
//      non-dormant rows and one dormant representative per family. Margin revival,
//      reversal suspension and pair hold read lifecycles; exit() asks whether
//      an opened origin's leg was consumed;
//   K2 a current-cycle row naming a revival candidate as its predecessor,
//   K3 the first later-bar current-cycle exit of the same family, source id
//      and from-entry id with different stop bits: the revival's superseded
//      test asks whether ANY such re-issue exists, and a row's family, ids, placement bar and stop
//      never change, so the lowest-incarnation one answers for every later
//      one (pinning them all kept two rows per exit per bar through a flat
//      cycle that re-issues its exits every bar, each walked at every bar
//      open);
//   K4 an immediate strategy.close placed on this bar or later
//      (immediate_close_placed_on asks about the current bar);
//   K5 an entry or raw order placed on the previous bar or later (the open
//      admission counts the previous bar's entry commands);
//   K7 an entry of a sequential group that still has a live or queued member
//      (resolve_terms pairs the group's ranks);
//   K8 an opening flat stop entry whose placement bar a live or queued entry
//      shares, or placed on this bar or later (the flat dual-stop test of
//      resolve_terms and on_applied).
// K1 leaves a leg of an ended cycle bound to an origin that can never open
// again: the revival never picks an ended cycle, and origin_leg_consumed only
// asks about opened origins, so its lifecycle is read by nobody.
//
// Nor does K1 keep a dormant leg bound to an askable origin,
// or an origin-free current-cycle leg, once the superseded test answers -- some
// row of the cycle names it (or its target) as its predecessor, or a later-bar
// exit of the same family and ids has a different stop. K2 and K3 keep one such row for as long
// as the leg is a candidate, so a leg superseded now stays superseded for the
// rest of its cycle: the revival never picks it again, and the suspension and
// the pair hold only rewrite its own lifecycle, which nothing else reads. A
// cycle that cancels and re-places its exits every bar at a moving level no
// longer holds a row per bar.
//
// The cancelled-origin retirement: nor a leg the script withdrew (every leg retired, by
// strategy.cancel or strategy.cancel_all whether it was live or dormant:
// retire_cancelled_exits), whatever its cycle, unless it is bound to an
// askable origin as its family's one representative. A withdrawn leg is no candidate
// and K2/K3 keep nothing for it; the suspension and the pair hold only
// rewrite its own lifecycle, which only origin_leg_consumed reads, and only
// for an origin that is live or opened. A cycle that cancels and re-places an
// exit every bar at the same level -- no re-issue at another stop supersedes
// it -- no longer holds a row per bar either.
//
// O1W: a terminally filled named origin-free limit without any stop/loss/trail
// or inherited replacement definition is not a revival candidate. K2, K3 and
// the ordinary roots still keep it when another reader needs its identity.
// Global filled limits retain K1: they can supersede global dormant legs that
// are outside K3's named candidate population.
void PineExecutionAdapter::sweep_retired_rows(const NativeDecisionContext& context, RetirementWork& work) {
    // The previous bars' trades are final: their exit phases fold once.
    const std::size_t phase_base = detail::run_consumer(require_host()).closed_trade_prefix().base;
    if (exit_phase_final_ < phase_base)
        throw coded<std::logic_error>(RunFailureCode::engine_invariant, {},
                                       "exit-phase fold precedes the sealed prefix");
    const auto finish_phases = [&] {
        for (; exit_phase_final_ < phase_base + trade_exit_phase_.size(); ++exit_phase_final_) {
            exit_phase_digest_ = fold_exit_phase(exit_phase_digest_,
                                                 trade_exit_phase_.at(exit_phase_final_ - phase_base));
        }
        detail::run_consumer(require_host()).finish_exit_phase_restart();
    };
    const bool retain_rows = detail::retain_retired_rows(); RetirementObservation observation(*this, work);
    // Every live handle has a row; nothing beyond them means nothing retired.
    if (placement_.size() <= live_handles_.size()) { finish_phases(); return; }
    const int interval = context.coordinate.interval_index;
    const std::int64_t cycle = current_position_cycle_;
    ++work.placement_sweeps;
    auto& sweep = retired_row_scratch_;
    sweep.clear();
    const auto contains = [](const std::vector<std::uint64_t>& sorted, std::uint64_t value) {
        return std::binary_search(sorted.begin(), sorted.end(), value);
    };
    const auto exit_family = [](PineOrderFamily family) {
        return family == PineOrderFamily::ExitLimit || family == PineOrderFamily::ExitStop
            || family == PineOrderFamily::ExitTrail;
    };
    // The origins a live leg or an opened entry answers for (K1, and the
    // consumed-leg facts pruned below).
    auto& askable_origins = sweep.askable_origins;
    for (const auto& handle : live_handles_) askable_origins.push_back(handle.incarnation);
    for (const auto& cohort : cohorts_by_id_.held_rows()) {
        for (const auto& opening : cohort.second.opened)
            askable_origins.push_back(opening.incarnation);
    }
    std::sort(askable_origins.begin(), askable_origins.end());
    askable_origins.erase(std::unique(askable_origins.begin(), askable_origins.end()),
                          askable_origins.end());
    // One dormant origin pin per (origin, exit id, from-entry, family), in oldest
    // incarnation order. Keep its lifecycle so suspension/cancellation still
    // changes the consumed-leg answer; do not replace it with a sticky bit.
    auto& origin_pins = sweep.origin_pins;
    placement_.visit_rows([&](std::uint64_t, const PlacementSnapshot& value) { ++work.row_visits; ++work.pin_rows; observe_retirement_expiry(value, interval);
        if (!exit_family(value.family) || !value.legs.dormant()
            || value.legs.target().incarnation == 0
            || !contains(askable_origins, value.bracket_origin.incarnation)) return false;
        const bool represented = std::any_of(origin_pins.begin(), origin_pins.end(),
            [&](const PlacementSnapshot* pin) {
                ++work.pin_comparisons; return pin->bracket_origin == value.bracket_origin && pin->family == value.family
                    && pin->source_id == value.source_id && pin->from_entry == value.from_entry;
            });
        if (!represented) origin_pins.push_back(&value);
        return false;
    });
    const auto pinned_by_itself = [&](const PlacementSnapshot& value) {
        // K1: preserve unwithdrawn lifecycle rows for their entire cycle.
        // Global legs need no named exposure; an empty named cohort may reopen.
        // Exposure at this sweep cannot decide what a later margin call reads.
        // Supersession below still releases legs the revival can no longer use.
        const bool askable = contains(askable_origins, value.bracket_origin.incarnation);
        if (value.legs.target().incarnation != 0 && !filled_limit_without_revival(value)
            && ((value.placement_cycle >= cycle && !withdrawn(value.legs))
                || (askable && !value.legs.dormant())
                || std::find_if(origin_pins.begin(), origin_pins.end(), [&](const auto* pin) { ++work.pin_comparisons; return pin == &value; }) != origin_pins.end())) return true;
        // K4
        if (value.family == PineOrderFamily::Close && value.immediately
            && value.projection_created_bar >= interval) {
            return true;
        }
        // K5: last_broker_open_ms_ is still the prior script bar's open (on_bar_open updates it after this sweep).
        return (value.family == PineOrderFamily::Entry || value.family == PineOrderFamily::Order)
            && value.placement_script_open_ms >= last_broker_open_ms_;
    };
    // An askable-origin leg, dormant or not, stays pinned for its cycle as
    // v1.6.3's K1 pinned it: releasing a dormant one let the sweep erase its
    // supersessor while K3 kept the released leg as a witness, and the margin
    // revival then restored the superseded leg.
    const auto held_by_cycle = [&](const PlacementSnapshot& value) {
        return pinned_by_itself(value) && value.placement_cycle == cycle
            && exit_family(value.family) && !value.from_entry.empty()
            && !withdrawn(value.legs)
            && !contains(askable_origins, value.bracket_origin.incarnation);
    };
    auto& held = sweep.held;
    bool unpinned = false;
    // K5 ages in script-bar space even when a chart gathers finer input;
    // only the current and previous script bars keep their retired commands.
    auto askable_cursor = askable_origins.begin();
    placement_.visit_rows([&](std::uint64_t incarnation, const PlacementSnapshot& value) { ++work.row_visits; ++work.gate_rows;
        const bool cycle_held = held_by_cycle(value);
        if (!cycle_held && pinned_by_itself(value)) return false;
        while (askable_cursor != askable_origins.end() && *askable_cursor < incarnation)
            ++askable_cursor;
        if (askable_cursor != askable_origins.end() && *askable_cursor == incarnation)
            return false;
        if (cycle_held) {
            held.push_back({incarnation, &value});
            return false;
        }
        unpinned = true;
        return true;
    });
    // The revival's exact superseded test, over retained rows. Supersessors
    // are newer than their named leg/target, so start above the oldest name
    // or the memo's previously read high water.
    auto& released = sweep.released;
    auto& memo = sweep.unsuperseded;
    const auto release_superseded = [&] {
        if (held.empty()) return;
        const std::uint64_t top = placement_.high_water();
        std::uint64_t scan_from = std::numeric_limits<std::uint64_t>::max();
        std::size_t cursor = 0;
        for (auto& leg : held) {
            while (cursor < memo.size() && memo[cursor].first < leg.incarnation) ++cursor;
            if (cursor < memo.size() && memo[cursor].first == leg.incarnation) {
                leg.read_through = memo[cursor].second;
            } else {
                const std::uint64_t target = leg.row->legs.target().incarnation;
                leg.read_through = std::min(leg.incarnation, target) - 1;
            }
            scan_from = std::min(scan_from, leg.read_through);
        }
        // Every leg was read through the high water, and no row has been
        // placed since: nothing new to read, and the memo stands.
        if (scan_from >= top) return;
        const auto stop_bits = [](double value) {
            std::uint64_t out = 0;
            std::memcpy(&out, &value, sizeof(out));
            return out;
        };
        const PlacementTable& rows = placement_;
        for (auto it = rows.upper_bound(scan_from); it != rows.end(); ++it) {
            const PlacementSnapshot& peer = it->second; ++work.row_visits; ++work.peer_visits;
            if (peer.placement_cycle != cycle) continue;
            const bool reissue = exit_family(peer.family);
            const std::uint64_t named = peer.projection_predecessor;
            if (named == 0 && !reissue) continue;
            for (auto& leg : held) { ++work.held_comparisons;
                if (leg.released || it->first <= leg.read_through) continue;
                const PlacementSnapshot& own = *leg.row;
                if (named != 0
                    && (named == leg.incarnation || named == own.legs.target().incarnation)) {
                    leg.released = true;
                } else if (reissue && it->first > leg.incarnation && peer.family == own.family
                           && peer.placement_script_open_ms > own.placement_script_open_ms
                           && stop_bits(peer.exit_levels.stop) != stop_bits(own.exit_levels.stop)
                           && peer.source_id == own.source_id
                           && peer.from_entry == own.from_entry) {
                    leg.released = true;
                }
            }
        }
        std::size_t kept = 0;
        for (const auto& leg : held) kept += leg.released ? 0 : 1;
        memo.resize(kept);
        kept = 0;
        for (const auto& leg : held) {
            if (leg.released) released.push_back(leg.incarnation);
            else memo[kept++] = {leg.incarnation, top};
        }
    };
    // With every row walked, the held legs are all known.
    if (!unpinned) release_superseded();
    // Quiet bars stop before gathering roots. Market-add marks still need
    // the full pass to prune them against the roots.
    if (market_pyramid_adds_.empty() && !unpinned && released.empty()) { finish_phases(); return; }
    // Only a host whose kernel can say what it still works erases a row.
    IExecutionConsumer* consumer = bound_consumer();
    if (!consumer) { finish_phases(); return; }
    const auto& core = as_native_consumer(*consumer).request_core();
 
    auto& roots = sweep.roots;
    const auto root = [&](std::uint64_t incarnation) {
        ++work.root_visits; if (incarnation != 0) roots.push_back(incarnation);
    };
    for (const auto& handle : live_handles_) root(handle.incarnation);
    // A request the kernel still works may still be matched, filled or
    // refused, and every such event reads its row: the kernel liquidation the
    // adapter adopted on its first fill (on_applied) is one that is never a
    // live handle of the adapter's own.
    for (const auto& working : core.live()) root(working.definition->handle.incarnation);
    // Commands above receipt_cursor_ are unobserved; even cancels issued
    // during receipt observation name rows still needed at the next read.
    // V19-B retires only acknowledged events. The adapter acknowledges no
    // further than its monotone cursor, so the window includes every root.
    assert(as_native_consumer(*consumer).event_window_start() <= receipt_cursor_ + 1);
    as_native_consumer(*consumer).visit_commands_after(receipt_cursor_,
        [&](const native_order::CommandEvent& command) {
            std::visit([&](const auto& event) {
                using Event = std::decay_t<decltype(event)>;
                if constexpr (std::is_same_v<Event, native_order::RejectedEvent>) {
                    // No request exists.
                } else if constexpr (std::is_same_v<Event, native_order::ReplacedEvent>) {
                    root(event.predecessor().incarnation);
                    root(event.successor().incarnation);
                } else if constexpr (std::is_same_v<Event, native_order::ReplaceRejectedEvent>) {
                    root(event.target().incarnation);
                } else if constexpr (std::is_same_v<Event, native_order::NotWorkingEvent>
                                     || std::is_same_v<Event, native_order::InvalidHandleEvent>) {
                    root(event.target.incarnation);
                } else if constexpr (std::is_same_v<Event, native_order::NativeRiskEvent>) {
                    // An account fact; it names no request.
                } else {
                    if (event.definition) root(event.definition->handle.incarnation);
                    if constexpr (std::is_same_v<Event, native_order::ReservationReducedEvent>
                                  || std::is_same_v<Event,
                                                    native_order::DeferredGroupAdjustmentEvent>) {
                        root(event.recipient.incarnation);
                    }
                }
            }, command);
            return false;
        });
    for (const auto& cohort : cohorts_by_id_.held_rows()) {
        for (const auto& opening : cohort.second.opened) root(opening.incarnation);
    }
    if (auto* pine = pine_view_of(host_)) {
        for (const auto& lot : pine->pyramid_entries_) root(lot.entry_incarnation);
    }
    for (const auto& handle : first_open_newborns_) root(handle.incarnation);
    for (const auto& row : live_by_source_key_) root(row.second.incarnation);
    auto& live_groups = sweep.live_groups;
    auto& source_bars = sweep.source_bars;
    const auto queued_snapshot = [&](const PlacementSnapshot& snapshot) {
        root(snapshot.bracket_origin.incarnation);
        root(snapshot.paired_reversal_parent.incarnation);
        root(snapshot.preserved_by_close_all.incarnation);
        root(snapshot.projection_predecessor);
        root(snapshot.legs.target().incarnation);
        root(snapshot.reservation_growth_owner_incarnation);
        if (snapshot.sequential_group != 0) live_groups.push_back(snapshot.sequential_group);
        if (snapshot.projection_created_bar_pinned)
            source_bars.push_back(snapshot.projection_created_bar);
    };
    const auto queued_request = [&](const native_order::Request& request) {
        if (const auto* wait = std::get_if<native_order::WaitForApplied>(&request.owner)) {
            root(wait->parent.incarnation);
        } else if (const auto* opening = std::get_if<native_order::BindOpening>(&request.owner)) {
            root(opening->opening.incarnation);
        } else if (const auto* openings
                   = std::get_if<native_order::BindOpenings>(&request.owner)) {
            for (const auto& handle : openings->openings) root(handle.incarnation);
        }
    };
    for (const auto& leg : pending_bracket_legs_) {
        queued_snapshot(leg.snapshot);
        queued_request(leg.request);
    }
    for (const auto& entry : pending_entries_) {
        queued_snapshot(entry.snapshot);
        queued_request(entry.request);
    }
    for (const auto& order : delayed_market_orders_) {
        queued_snapshot(order.snapshot);
        queued_request(order.request);
    }
    for (const auto& sell : deferred_open_marketable_sells_) queued_snapshot(sell.snapshot);
    for (const auto& snapshot : throttled_reopen_rearm_) queued_snapshot(snapshot);
    for (const auto& command : pending_same_bar_commands_) {
        queued_snapshot(command.snapshot);
        queued_request(command.request);
    }
    for (const auto& shadow : source_shadow_pending_) queued_snapshot(shadow.snapshot);
    for (const auto& pending : pending_coof_requests_) {
        queued_snapshot(pending.snapshot);
        queued_request(pending.request);
    }
    for (const auto& revival : pending_margin_revivals_) queued_snapshot(revival.snapshot);
    for (const auto& leg : anchored_relative_legs_) {
        root(leg.handle.incarnation);
        root(leg.parent.incarnation);
        queued_request(leg.request);
    }
    root(materializing_parent_.incarnation);
    for (const ShortSeedPlan* plan : {&short_seed_, &pending_short_seed_.plan}) {
        root(plan->long_entry.incarnation);
        root(plan->materialize_long.incarnation);
        root(plan->final_short.incarnation);
    }
    root(short_seed_long_candidate_.incarnation);
    std::sort(roots.begin(), roots.end());
    roots.erase(std::unique(roots.begin(), roots.end()), roots.end());
    // Live rows supply K7/K8; K1's unwithdrawn current-cycle lifecycles
    // supply the K2/K3 revival candidates.
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        if (found->second.sequential_group != 0)
            live_groups.push_back(found->second.sequential_group);
        if (found->second.family == PineOrderFamily::Entry)
            source_bars.push_back(found->second.projection_created_bar);
    }
    std::sort(live_groups.begin(), live_groups.end());
    std::sort(source_bars.begin(), source_bars.end());
    auto& candidates = sweep.candidates;
    auto& candidate_names = sweep.candidate_names;
    // A partial pre-pass needs its held legs gathered alongside candidates.
    if (unpinned) held.clear();
    auto candidate_origin_cursor = askable_origins.begin();
    placement_.visit_rows([&](std::uint64_t incarnation, const PlacementSnapshot& value) { ++work.row_visits; ++work.candidate_rows;
        if (value.legs.target().incarnation == 0 || value.placement_cycle != cycle
            || !exit_family(value.family) || value.from_entry.empty()
            || withdrawn(value.legs) || filled_limit_without_revival(value)) {
            return false;
        }
        if (unpinned) {
            while (candidate_origin_cursor != askable_origins.end()
                   && *candidate_origin_cursor < incarnation) ++candidate_origin_cursor;
            const bool askable = candidate_origin_cursor != askable_origins.end()
                && *candidate_origin_cursor == incarnation;
            if (!askable && !contains(askable_origins, value.bracket_origin.incarnation))
                held.push_back({incarnation, &value});
        }
        candidates.emplace_back(incarnation, &value);
        return false;
    });
    if (unpinned) release_superseded();
    // Only newly released askable-origin legs lose K2/K3; keep legacy certificates.
    candidates.erase(std::remove_if(candidates.begin(), candidates.end(), [&](const auto& c) {
        return !contains(roots, c.first) && contains(released, c.first)
            && contains(askable_origins, c.second->bracket_origin.incarnation);
    }), candidates.end());
    for (const auto& c : candidates) {
        candidate_names.push_back(c.first);
        candidate_names.push_back(c.second->legs.target().incarnation);
    }
    std::sort(candidate_names.begin(), candidate_names.end());
    // K3: preserve the first witness, but never repeat old-candidate x old-row
    // comparisons. Identity, stop bits and placement time do not change.
    // Rows appended since the last K3 pass can only add later witnesses.
    auto& first_reissues = sweep.first_reissues;
    auto& next_reissues = sweep.next_reissues;
    if (sweep.reissue_cycle != cycle) {
        sweep.reissues.clear();
        sweep.reissue_high_water = 0;
        sweep.reissue_cycle = cycle;
    }
    std::size_t prior = 0;
    for (std::size_t index = 0; index < candidates.size(); ++index) {
        const auto incarnation = candidates[index].first;
        while (prior < sweep.reissues.size() && sweep.reissues[prior].first < incarnation) ++prior;
        const bool known = prior < sweep.reissues.size()
            && sweep.reissues[prior].first == incarnation
            && (sweep.reissues[prior].second == 0
                || placement_.contains(sweep.reissues[prior].second));
        const auto witness = known ? sweep.reissues[prior].second : 0;
        next_reissues.emplace_back(incarnation, witness);
        if (!known) sweep.new_candidates.push_back(index);
        else {
            sweep.known_candidates.push_back(index);
            if (witness == 0) sweep.unresolved_candidates.push_back(index);
        }
    }
    const auto compare_reissue = [&](std::uint64_t incarnation, const PlacementSnapshot& value,
                                     std::size_t index) {
        ++work.k3_pairs; PINEFORGE_TAIL_WORK("k3_pairs", 1);
        auto& witness = next_reissues[index].second;
        const auto& c = candidates[index];
        if (incarnation <= c.first || (witness != 0 && incarnation >= witness)) return;
        const auto& q = *c.second;
        if (q.family == value.family
            && q.placement_script_open_ms < value.placement_script_open_ms
            && !same_double_bits(q.exit_levels.stop, value.exit_levels.stop)
            && q.source_id == value.source_id && q.from_entry == value.from_entry)
            witness = incarnation;
    };
    if (!sweep.new_candidates.empty()) {
        placement_.visit_rows([&](std::uint64_t incarnation, const PlacementSnapshot& value) { ++work.row_visits; ++work.peer_visits;
            if (value.placement_cycle == cycle && exit_family(value.family))
                for (const auto index : sweep.new_candidates) compare_reissue(incarnation, value, index);
            return false;
        });
    }
    if (!sweep.unresolved_candidates.empty()) {
        const PlacementTable& rows = placement_;
        for (auto it = rows.upper_bound(sweep.reissue_high_water); it != rows.end(); ++it) {
            const auto& value = it->second; ++work.row_visits; ++work.peer_visits;
            if (value.placement_cycle == cycle && exit_family(value.family))
                for (const auto index : sweep.unresolved_candidates)
                    compare_reissue(it->first, value, index);
        }
    }
    for (const auto incarnation : sweep.adopted_reissues) {
        const auto row = placement_.find(incarnation);
        if (row == placement_.end() || row->second.placement_cycle != cycle
            || !exit_family(row->second.family)) continue;
        ++work.row_visits; ++work.peer_visits; for (const auto index : sweep.known_candidates)
            compare_reissue(incarnation, row->second, index);
    }
    sweep.adopted_reissues.clear();
    for (const auto& answer : next_reissues)
        if (answer.second != 0) first_reissues.push_back(answer.second);
    std::sort(first_reissues.begin(), first_reissues.end());
    sweep.reissues.swap(next_reissues);
    sweep.reissue_high_water = placement_.high_water();
    PINEFORGE_RETIREMENT_OBSERVE(placement_, cycle, askable_origins, roots,
                                candidates, first_reissues);
 
    auto& doomed = sweep.doomed;
    auto root_cursor = roots.begin();
    placement_.visit_rows([&](std::uint64_t incarnation, const PlacementSnapshot& value) { ++work.row_visits; ++work.final_rows;
        // K1 (but for the legs it releases), K4, K5; then the roots. A row
        // either keeps is kept, so the cheaper test comes first.
        if (pinned_by_itself(value) && (released.empty() || !contains(released, incarnation)))
            return false;
        while (root_cursor != roots.end() && *root_cursor < incarnation) ++root_cursor;
        if (root_cursor != roots.end() && *root_cursor == incarnation) return false;
        if (value.placement_cycle == cycle) {
            // K2
            if (value.projection_predecessor != 0
                && contains(candidate_names, value.projection_predecessor)) {
                return false;
            }
            // K3
            if (exit_family(value.family) && contains(first_reissues, incarnation)) return false;
        }
        // K7
        if (value.family == PineOrderFamily::Entry && value.sequential_group != 0
            && value.sequential_rank != 0
            && std::binary_search(live_groups.begin(), live_groups.end(),
                                  value.sequential_group)) {
            return false;
        }
        // K8
        if (value.opening && value.family == PineOrderFamily::Entry
            && value.projection_position_side == static_cast<std::int32_t>(PositionSide::FLAT)
            && finite_positive(value.exit_levels.stop) && !finite_positive(value.exit_levels.limit)
            && (value.projection_created_bar >= interval
                || std::binary_search(source_bars.begin(), source_bars.end(),
                                      value.projection_created_bar))) {
            return false;
        }
        doomed.push_back(incarnation);
        return false;
    });
    // The entire retirement workset, before phase/digest publication, mark
    // pruning, bracket consumed facts, cohort sides or the first row removal.
    // The workset contains handles only; the ticket borrows the retained rows.
    if (!retain_rows) {
        placement_.preflight_erased_rows([&](const auto& emit) {
            for (const auto incarnation : doomed) emit(placement_.at(incarnation));
        });
    }
    finish_phases();
    // Only an open lot or working request can still ask for a market-add mark.
    for (auto mark = market_pyramid_adds_.begin(); mark != market_pyramid_adds_.end();) {
        if (std::binary_search(roots.begin(), roots.end(), *mark)) ++mark;
        else mark = market_pyramid_adds_.erase(mark);
    }
    if (doomed.empty()) return;
 
    for (const auto incarnation : doomed) {
        const auto& value = placement_.at(incarnation);
        // A leg of a bracket family stays its member (the bracket cancel still
        // names it); the consumed-leg question it answered is kept as a fact.
        // Only exit legs are ever members.
        if (exit_family(value.family) && !value.legs.dormant()) {
            const auto record = [&](BracketRoster& family) {
                if (family.count(incarnation) == 0) return false;
                family.record_consumed(static_cast<std::uint8_t>(value.family),
                                       value.bracket_origin.incarnation);
                return true;
            };
            const auto keyed = bracket_families_.find(key_for(value.source_id, value.from_entry));
            if (keyed == bracket_families_.end() || !record(keyed->second)) {
                for (auto& family : bracket_families_) record(family.second);
            }
        }
        // An opening of a cohort's roster leaves its side behind.
        if (value.opening) {
            const auto cohort = cohorts_by_id_.find(value.source_id);
            if (cohort != cohorts_by_id_.end()
                && cohort->second.origins.positions_of(incarnation) != nullptr) {
                cohort->second.erased_opening_sides |= value.is_long ? 1U : 2U;
            }
        }
        if (!retain_rows) erase_placement(incarnation);
        if (!retain_rows) detail::rows_erased.fetch_add(1, std::memory_order_relaxed);
    }
    // Every family settles the members whose rows would be gone (or are gone),
    // and keeps a consumed-leg fact only while its origin is live or opened.
    for (auto& family : bracket_families_) {
        ++work.family_visits; PINEFORGE_TAIL_WORK("settle_families", 1);
        family.second.settle([&](std::uint64_t incarnation) {
            return retain_rows ? contains(doomed, incarnation)
                               : !placement_.contains(incarnation);
        });
        family.second.prune_consumed([&](std::uint64_t origin) {
            return contains(askable_origins, origin);
        });
    }
    // The existing every-row-retained reference also keeps family records
    // in their old table; normal runs archive only immutable prefixes.
    if (!retain_rows) archive_settled_bracket_families();
    if (!retain_rows) placement_.compact();
}
 
BracketRoster& PineExecutionAdapter::bracket_family(std::uint64_t key) {
    const auto archived = settled_bracket_families_.find(key);
    if (archived != settled_bracket_families_.end()) {
        // Publish before removing the immutable record, so a failed allocation
        // leaves the old family and its digest intact.
        const auto placed = bracket_families_.try_emplace(key, archived->second);
        assert(placed.second);
        settled_bracket_digest_ ^= settled_bracket_hash(key, archived->second);
        settled_bracket_families_.erase(archived);
        return placed.first->second;
    }
    return bracket_families_[key];
}
 
void PineExecutionAdapter::archive_settled_bracket_families() {
    for (auto at = bracket_families_.begin(); at != bracket_families_.end();) {
        if (!at->second.wholly_settled()) {
            ++at;
            continue;
        }
        const auto value = at->second.settled_record();
        [[maybe_unused]] const auto inserted = settled_bracket_families_.emplace(at->first, value);
        assert(inserted.second);
        settled_bracket_digest_ ^= settled_bracket_hash(at->first, value);
        at = bracket_families_.erase(at);
    }
}
 
void PineExecutionAdapter::clear_bracket_families() noexcept {
    bracket_families_.clear();
    settled_bracket_families_.clear();
    settled_bracket_digest_ = 0;
}
 
// The cancelled-origin retirement: the kernel's cohort rosters hold what can still be bound.
//
// Every opening this adapter accepts joins its id's kernel roster
// (cohort_add, submit_or_replace), and the kernel folds every member of every
// roster into each continuation read (hash_cohorts), so a run that recorded a
// hash per bar paid for every opening it ever made at every bar. A roster is
// matching authority for the lots it names and nothing else: a CohortClose or
// BindCohort request reads it only through the open lots
// (NativeExecutionConsumer::cohort_contains over the book's lots). An origin
// whose chain has no working request and no open lot can never be bound
// again -- nothing opens a lot under a request that stopped working -- so at
// every bar open, after observe_terminal_receipts, each such origin leaves
// its kernel roster (cohort_remove). The adapter's own roster
// (CohortFacts::origins) can then retire its unreachable front prefix while
// keeping the count/digest and erased sides. The kernel roster costs what is live.
//
// A roster holds chain roots; a working request names its root in its
// definition, and a lot names the request that filled it, which is the root
// unless it is a replace successor. The root of a successor's lot is not a
// public fact, but it is older than the successor (incarnations only grow):
// while such a lot is open, every member of its roster older than it stays.
//
// Commands ending requests/closing lots mark the pass due at receipt
// observation; a bar open after only quiet reads has no member to remove.
void PineExecutionAdapter::release_closed_cohort_origins() {
    auto& scratch = retired_row_scratch_;
    if (!scratch.roster_pass_due) return;
    scratch.roster_pass_due = false; PF_ROSTER_PASS_WORK(due_passes);
    IExecutionConsumer* consumer = bound_consumer();
    if (!consumer) return;
    auto* pine = pine_view_of(host_);
    if (!pine) return;
    const auto& core = as_native_consumer(*consumer).request_core();
    std::size_t members = 0;
    for (const auto& [key, roster] : core.nonempty_cohorts()) { PF_ROSTER_PASS_WORK(roster_cohort_visits); members += roster.origins.size(); }
    if (members == 0) return;
    // The common case, in a direct scan with nothing allocated or sorted:
    // every member still opened a lot that is open, or roots a working
    // request, so none can go.
    const auto root_of = [](const native_order::LiveRequest& row) {
        return row.definition->root ? row.definition->root->incarnation
                                    : row.handle().incarnation;
    };
    constexpr std::size_t kDirectScan = 64;
    if (members * (pine->pyramid_entries_.size() + core.live().size()) <= kDirectScan) {
        bool every_member_bound = true;
        for (const auto& [key, roster] : core.nonempty_cohorts()) { PF_ROSTER_PASS_WORK(roster_cohort_visits);
            for (const auto& origin : roster.origins) {
                const std::uint64_t incarnation = origin.incarnation;
                const bool bound = std::any_of(pine->pyramid_entries_.begin(),
                        pine->pyramid_entries_.end(), [&](const PyramidEntry& lot) {
                            return lot.entry_incarnation == incarnation;
                        })
                    || std::any_of(core.live().begin(), core.live().end(),
                        [&](const native_order::LiveRequest& row) {
                            return root_of(row) == incarnation;
                        });
                if (!bound) {
                    every_member_bound = false;
                    break;
                }
            }
            if (!every_member_bound) break;
        }
        if (every_member_bound) return;
    }
    PINEFORGE_LOOKUP_INDEX_WORK("cohort_origin_pass", this, run_counter_, 1);
    auto& working = scratch.working_roots;
    auto& lots = scratch.lot_openings;
    if (!position_tail_summary_) position_tail_summary_ = std::make_shared<detail::AdapterPositionTailSummary>();
    auto& roster_roots = static_cast<detail::AdapterPositionTailSummary&>(
        *position_tail_summary_).roster_roots;
    auto& successor_lots = scratch.successor_lots;
    auto& released = scratch.released_origins;
    working.clear();
    lots.clear();
    roster_roots.clear();
    successor_lots.clear();
    released.clear();
    for (const auto& live : core.live()) working.push_back(root_of(live));
    std::sort(working.begin(), working.end());
    for (const auto& lot : pine->pyramid_entries_) lots.push_back(lot.entry_incarnation);
    std::sort(lots.begin(), lots.end());
    lots.erase(std::unique(lots.begin(), lots.end()), lots.end());
    for (const auto& [key, roster] : core.nonempty_cohorts()) { PF_ROSTER_PASS_WORK(roster_cohort_visits);
        PINEFORGE_LOOKUP_INDEX_WORK("cohort_origin_roster", this, run_counter_, 1);
        for (const auto& origin : roster.origins)
            roster_roots.push_back(origin.incarnation);
    }
    std::sort(roster_roots.begin(), roster_roots.end());
    roster_roots.erase(std::unique(roster_roots.begin(), roster_roots.end()),
                       roster_roots.end());
    // The lots no roster names as a root: a replace successor's (or an
    // opening no roster holds).
    for (const auto opening : lots) {
        if (opening == 0) continue;
        if (!std::binary_search(roster_roots.begin(), roster_roots.end(), opening)) {
            successor_lots.push_back(opening);
        }
    }
    auto& probe = scratch.lot_probe;
    for (const auto& [key, roster] : core.nonempty_cohorts()) { PF_ROSTER_PASS_WORK(roster_cohort_visits);
        const auto& origins = roster.origins;
        if (origins.empty()) continue;
        if (probe.run != origins.front().run) probe.run = origins.front().run;
        // The newest open successor lot this roster binds: every member older
        // than it may be its root.
        std::uint64_t kept_below = 0;
        for (const auto opening : successor_lots) { PF_ROSTER_PASS_WORK(roster_cohort_visits);
            probe.incarnation = opening;
            if (core.cohort_contains(roster.handle, probe)) kept_below = opening;
        }
        for (const auto& origin : origins) {
            const std::uint64_t incarnation = origin.incarnation;
            if (incarnation < kept_below
                || std::binary_search(working.begin(), working.end(), incarnation)
                || std::binary_search(lots.begin(), lots.end(), incarnation)) {
                continue;
            }
            released.emplace_back(roster.handle, incarnation);
        }
    }
    if (released.empty()) return;
    auto& host = require_host();
    for (const auto& [cohort, incarnation] : released) {
        native_order::RequestHandle origin = probe;
        origin.incarnation = incarnation;
        host.cohort_remove(cohort, std::move(origin));
    }
}
 
void PineExecutionAdapter::maybe_activate_short_seed_plan() {
    // The legacy sort qualifies at the broker boundary, never midway through
    // the source callback that created the three objects.  on_bar_open owns
    // the final activation when the live next-bar predicate is available.
}
 
bool PineExecutionAdapter::short_seed_context_is_live() const noexcept {
    if (!host_) return false;
    const auto physical = detail::run_position(*host_);
    if (!(physical.signed_units < 0.0) || physical.lot_count != 1U) return false;
    const double held = std::abs(physical.signed_units);
    for (const auto& cohort : cohorts_by_id_.held_rows()) {
        if (cohort_exposure_for(cohort.second) == held) return true;
    }
    return false;
}
 
bool PineExecutionAdapter::qualify_short_seed_plan(const ShortSeedPlan& plan) const {
    if (!host_ || plan.long_entry.incarnation == 0 || plan.materialize_long.incarnation == 0
        || plan.final_short.incarnation == 0 || plan.seed_id.empty()) {
        return false;
    }
    const auto long_it = placement_.find(plan.long_entry.incarnation);
    const auto materialize_it = placement_.find(plan.materialize_long.incarnation);
    const auto final_it = placement_.find(plan.final_short.incarnation);
    if (long_it == placement_.end() || materialize_it == placement_.end()
        || final_it == placement_.end()) {
        return false;
    }
    const PlacementSnapshot& long_entry = long_it->second;
    const PlacementSnapshot& materialize = materialize_it->second;
    const PlacementSnapshot& final_short = final_it->second;
    const bool bar_magnifier = bar_magnifier_;
    const auto is_live = [&](const native_order::RequestHandle& handle) {
        return std::find(live_handles_.begin(), live_handles_.end(), handle) != live_handles_.end();
    };
    const auto no_level = [](const PineExitLevels& levels) {
        return std::isnan(levels.limit) && std::isnan(levels.stop)
            && std::isnan(levels.trail_points) && std::isnan(levels.trail_offset)
            && std::isnan(levels.trail_price) && std::isnan(levels.profit_ticks)
            && std::isnan(levels.loss_ticks);
    };
    const auto fresh_plain = [&](const PlacementSnapshot& row) {
        return row.placement_open_epoch + 1U == broker_open_epoch_
            && row.projection_position_side == static_cast<std::int32_t>(PositionSide::SHORT)
            && !row.replaced_opening && row.projection_predecessor == 0
            && row.recreated_after_named_cancelled_entry_incarnation == 0
            && row.named_cancel_surviving_exit_incarnation == 0
            && !row.birth.from_fill() && !row.birth.at_terminal_fill()
            && !compat::pine::historical_cascade_reach(row.birth_reach)
            && !row.projection_created_during_coof
            && !row.reservation_expansion.capture()
            && row.oca_name.empty() && row.oca_type == 0;
    };
    const bool fixed_default = config_.default_qty_type == static_cast<int>(QtyType::FIXED);
    const auto pure_default_market_entry = [&](const PlacementSnapshot& row) {
        const bool sizing_shape = fixed_default ? std::isnan(row.sizing.frozen_units)
            : finite_positive(row.sizing.frozen_units) && finite_positive(row.sizing.equity)
                && finite_positive(row.sizing.price) && finite_positive(row.sizing.mark)
                && finite_positive(row.sizing.fx);
        return row.family == PineOrderFamily::Entry && row.deferred_cohort
            && std::isnan(row.requested_qty) && row.qty_type == -1 && sizing_shape
            && no_level(row.exit_levels) && !row.projection_after_close;
    };
    const auto exact_full_fifo_close_short = [&]() {
        return materialize.family == PineOrderFamily::Close
            && materialize.source_id == plan.seed_id && materialize.from_entry == plan.seed_id
            && !materialize.is_long && finite_positive(materialize.requested_qty)
            && materialize.qty_percent == 100.0 && no_level(materialize.exit_levels)
            && materialize.frozen_market_instruction && materialize.frozen_market_targeted_close
            && finite_positive(materialize.frozen_market_transaction_units)
            && !materialize.reservation_expansion.capture()
            && std::abs(materialize.frozen_market_transaction_units - plan.seed_qty) <= 1e-12
            && std::abs(materialize.requested_qty - plan.seed_qty) <= 1e-12;
    };
    std::array<std::uint64_t, 3> incarnations{
        plan.long_entry.incarnation,
        plan.materialize_long.incarnation,
        plan.final_short.incarnation,
    };
    std::sort(incarnations.begin(), incarnations.end());
    const bool consecutive_incarnations = incarnations[0] != 0
        && incarnations[0] != std::numeric_limits<std::uint64_t>::max()
        && incarnations[0] + 1U == incarnations[1]
        && incarnations[1] != std::numeric_limits<std::uint64_t>::max()
        && incarnations[1] + 1U == incarnations[2];
    const auto physical = detail::run_position(*host_);
    const auto point = detail::callback_point(*host_);
    const double open = point ? point->price : kNaN;
    const double tick = staged_.syminfo.mintick;
    const double admit = finite_positive(tick) ? nearest_tick(open, tick) : open;
    const double entry_qty = fixed_default ? config_.default_qty_value : long_entry.sizing.frozen_units;
    const double final_qty = fixed_default ? config_.default_qty_value : final_short.sizing.frozen_units;
    const double fx = point ? active_staged_fx(point->decision.sub_bar_open_ms) : staged_.account_fx;
    const double notional = staged_.syminfo.pointvalue * fx;
    const double marked = percent_commission_live_equity(open);
    const double projected_long = entry_qty + std::min(plan.seed_qty, entry_qty);
    const double projected_free = marked - projected_long * open * notional;
    const double projected_required = (projected_long + final_qty) * admit * notional;
    const double epsilon = std::max(1e-9, std::abs(marked) * 1e-12);
    const bool projected_final_short_admission_is_safe = finite_positive(admit)
        && finite_positive(entry_qty) && finite_positive(final_qty) && finite_positive(notional)
        && std::isfinite(projected_free) && std::isfinite(projected_required)
        && projected_required <= projected_free + epsilon;
    bool percent_rechecks_safe = true;
    if (config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        && config_.default_qty_value <= 100.0) {
        for (const PlacementSnapshot* row : {&long_entry, &final_short}) {
            const double required = row->sizing.frozen_units * admit * staged_.syminfo.pointvalue
                * row->sizing.fx;
            if (!(finite_positive(required) && required <= row->sizing.equity)) {
                percent_rechecks_safe = false;
                break;
            }
        }
    }
    const int source_bar = long_entry.projection_created_bar;
    return !config_.close_entries_rule_any && !config_.process_orders_on_close
        && !config_.calc_on_order_fills && !coof_recalc_active_
        && !bar_magnifier && !risk_.halted
        && risk_.direction == 0 && risk_.max_cons_loss_days == 0 && risk_.max_drawdown <= 0.0
        && risk_.max_intraday_loss <= 0.0 && risk_.max_position_size <= 0.0 && !cap.active()
        && config_.pyramiding == 1 && config_.slippage == 0 && config_.commission_value == 0.0
        && std::abs(config_.margin_long - 100.0) < 1e-12
        && std::abs(config_.margin_short - 100.0) < 1e-12
        && physical.signed_units < 0.0 && physical.lot_count == 1U && current_position_cycle_ > 0
        && is_live(plan.long_entry) && is_live(plan.materialize_long) && is_live(plan.final_short)
        && source_bar >= 0
        && compat::pine::last_rejected_command_bar(admission_journal) != source_bar
        && long_entry.command_ordinal + 1U == final_short.command_ordinal
        && final_short.command_ordinal + 1U == materialize.command_ordinal
        && consecutive_incarnations
        && fresh_plain(long_entry) && fresh_plain(final_short) && fresh_plain(materialize)
        && pure_default_market_entry(long_entry) && pure_default_market_entry(final_short)
        && !long_entry.source_id.empty() && long_entry.is_long
        && !long_entry.projection_over_pyramiding && !final_short.source_id.empty()
        && long_entry.source_id != final_short.source_id
        && long_entry.source_id != materialize.source_id && !final_short.is_long
        && final_short.projection_over_pyramiding
        && long_entry.placement_cycle == plan.seed_cycle
        && final_short.placement_cycle == plan.seed_cycle
        && std::abs(long_entry.projection_tv_carry_qty - plan.seed_qty) <= 1e-12
        && std::abs(final_short.projection_tv_carry_qty - plan.seed_qty) <= 1e-12
        && exact_full_fifo_close_short() && plan.seed_id == final_short.source_id
        && position_open_epoch_ < broker_open_epoch_
        && finite_positive(plan.seed_qty) && std::abs(std::abs(physical.signed_units) - plan.seed_qty) <= 1e-12
        && (fixed_default ? std::abs(config_.default_qty_value - plan.seed_qty) <= 1e-12
                          : std::abs(long_entry.sizing.frozen_units - final_short.sizing.frozen_units) <= 1e-12)
        && std::abs(materialize.projection_tv_carry_qty - plan.seed_qty) <= 1e-12
        && projected_final_short_admission_is_safe && percent_rechecks_safe;
}
 
void PineExecutionAdapter::activate_short_seed_plan_at_open(const NativeDecisionContext&) {
    if (!pending_short_seed_.ready) return;
    if (broker_open_epoch_ < pending_short_seed_.expected_open_epoch) return;
    if (broker_open_epoch_ == pending_short_seed_.expected_open_epoch
        && qualify_short_seed_plan(pending_short_seed_.plan)) {
        short_seed_ = pending_short_seed_.plan;
        short_seed_.active = true;
    } else if (short_seed_.long_entry == pending_short_seed_.plan.long_entry
               && short_seed_.materialize_long == pending_short_seed_.plan.materialize_long
               && short_seed_.final_short == pending_short_seed_.plan.final_short) {
        short_seed_ = {};
    }
    pending_short_seed_ = {};
}
 
std::optional<native_order::RequestHandle> PineExecutionAdapter::submit_or_replace(
        native_order::Request request, PlacementSnapshot snapshot, bool opening,
        const SourceId& replacement_key) {
    // The accepted opening appends its cohort below. Hold the complete node
    // ticket before any host submit/replace or source placement/origin write.
    if (opening) cohorts_by_id_.require_insert(snapshot.source_id);
    auto& host = require_host();
    // A core-sized opening freezes its basis at the execution point the CORE
    // sees when it accepts the command; the source froze the same rule when
    // the command was written.  A command queued for a later point, or one
    // the source repriced after writing it, has moved the two apart: it keeps
    // its host-resolved intent and its own frozen quantity rather than
    // silently resizing at the submission point.
    if (std::holds_alternative<native_order::Sized>(request.intent)
        && !core_sizing_price_matches(snapshot.sizing, snapshot.is_long)) {
        request.intent = native_order::HostSized{native_order::HostSizedKind::Open,
            snapshot.is_long ? native_order::Side::Long : native_order::Side::Short};
    }
    const NativePhysicalPosition physical = detail::run_position(host);
    snapshot.projection_position_side = physical.signed_units > 0.0
        ? static_cast<std::int32_t>(PositionSide::LONG)
        : (physical.signed_units < 0.0 ? static_cast<std::int32_t>(PositionSide::SHORT)
                                       : static_cast<std::int32_t>(PositionSide::FLAT));
    snapshot.projection_after_close = snapshot.projection_after_close
        || pending_same_bar_close_qty_ > 0.0;
    const auto ledger_records = opening ? open_ledger_records() : std::nullopt;
    snapshot.projection_over_pyramiding = opening
        && !(config_.process_orders_on_close && snapshot.projection_after_close)
        && config_.pyramiding > 0
        && ((physical.signed_units > 0.0) == snapshot.is_long)
        && physical.signed_units != 0.0
        && (ledger_records ? *ledger_records : physical.lot_count)
            >= static_cast<std::size_t>(config_.pyramiding);
    snapshot.projection_created_during_coof =
        snapshot.projection_created_during_coof || coof_recalc_active_;
    snapshot.projection_coof_at_terminal = snapshot.projection_coof_at_terminal
        || (coof_recalc_active_ && coof_context_.is_terminal_sub_bar);
    snapshot.projection_coof_mid_bar = snapshot.projection_coof_mid_bar
        || (coof_recalc_active_ && !coof_context_.is_terminal_sub_bar);
    snapshot.projection_tv_carry_qty = opening
        ? std::max(0.0, std::abs(physical.signed_units)
                           - pending_same_bar_close_qty_)
        : std::abs(physical.signed_units);
    snapshot.projection_default_stop_equity = snapshot.sizing.equity;
    snapshot.projection_default_stop_signal_close = snapshot.sizing.mark;
    snapshot.projection_explicit_equity = std::isfinite(snapshot.requested_qty)
        ? snapshot.sizing.equity : kNaN;
    snapshot.projection_explicit_signal_close = std::isfinite(snapshot.requested_qty)
        ? snapshot.sizing.price : kNaN;
    if (snapshot.affordability_policy_active) {
        snapshot.projection_affordability_equity = snapshot.sizing.equity;
        snapshot.projection_affordability_signal_price = snapshot.sizing.price;
        snapshot.projection_affordability_held_qty = std::abs(physical.signed_units);
    } else {
        snapshot.projection_affordability_equity = kNaN;
        snapshot.projection_affordability_signal_price = kNaN;
        snapshot.projection_affordability_held_qty = kNaN;
    }
    const bool fill_time_any_percentage = snapshot.family == PineOrderFamily::Close
        && config_.close_entries_rule_any && !std::isfinite(snapshot.requested_qty)
        && std::isfinite(snapshot.qty_percent);
    if (!opening && !snapshot.reservation_deferred_to_pending_entry
        && !fill_time_any_percentage
        && !std::isfinite(snapshot.projection_remaining_qty)
        && snapshot.deferred_cohort && !std::isfinite(snapshot.requested_qty)
        && physical.signed_units != 0.0) {
        const double percent = std::isfinite(snapshot.qty_percent)
            ? snapshot.qty_percent : 100.0;
        snapshot.projection_remaining_qty = quantize_close_units(
            std::abs(physical.signed_units), percent);
    }
    if (opening && !snapshot.source_id.empty()) {
        if (const auto token = named_entry_cancel_tokens_.find(snapshot.source_id);
            token != named_entry_cancel_tokens_.end()) {
            snapshot.recreated_after_named_cancelled_entry_incarnation =
                token->second.entry_incarnation;
            snapshot.named_cancel_surviving_exit_incarnation =
                token->second.surviving_exit_incarnation;
            named_entry_cancel_tokens_.erase(token);
        }
    }
    // ab9714be pine_strategy_commands.cpp:497: order records created_position_cycle_seq from current cycle
    if (snapshot.placement_cycle == 0)
        snapshot.placement_cycle = current_position_cycle_;
    if (snapshot.birth.cause() == OrderBirthCause::Unattributed)
        snapshot.birth = capture_order_birth();
    snapshot.coof_cascade_seg_i = coof_recalc_active_
        ? coof_context_.coordinate.interval_index : -1;
    snapshot.coof_cascade_inflight_fires = coof_recalc_active_;
    if (!snapshot.paired_flat_market_candidate) {
        snapshot.paired_flat_market_candidate = snapshot.frozen_market_instruction
            && physical.signed_units == 0.0;
        snapshot.paired_flat_market_own_qty = snapshot.frozen_market_own_units;
        snapshot.paired_flat_market_transaction_qty =
            snapshot.frozen_market_transaction_units;
    }
    snapshot.paired_flat_market_signal_close = snapshot.sizing.price;
    snapshot.paired_flat_market_signal_equity = snapshot.sizing.equity;
    snapshot.paired_flat_market_signal_margin_pct = snapshot.is_long
        ? config_.margin_long : config_.margin_short;
    snapshot.paired_flat_market_signal_pointvalue = staged_.syminfo.pointvalue;
    snapshot.paired_flat_market_signal_fx = snapshot.sizing.fx;
    snapshot.pooc_global_full_exit_dynamic_qty = config_.process_orders_on_close
        && !opening && !std::isfinite(snapshot.requested_qty)
        && (!std::isfinite(snapshot.qty_percent) || snapshot.qty_percent >= 100.0);
    snapshot.pooc_global_full_exit_tracks_bound_adds = snapshot.pooc_global_full_exit_dynamic_qty;
    if (const auto point = detail::callback_point(host)) {
        // ab9714be src/source/pine_strategy_commands.cpp:481 and
        // src/source/pine_strategy_commands.cpp:1959 stamp an order's
        // created_bar at the bar of the source command, and a bracket leg the
        // pass skipped while flat stays in that same book slot
        // (src/source/pine_fills.cpp:7461-7468), so only the
        // process_orders_on_close gate of src/source/pine_fills.cpp:7620-7648
        // compares created_bar with the current bar. Submitting the staged leg
        // when its parent entry applies must not re-stamp the bar.
        if (!snapshot.projection_created_bar_pinned) {
            snapshot.projection_created_bar = projection_bar_index(point->decision);
        }
        snapshot.placement_script_open_ms = point->decision.script_bar_open_ms;
        snapshot.placement_sub_open_ms = point->decision.sub_bar_open_ms;
    }
    if (opening && snapshot.family == PineOrderFamily::Entry
        && !snapshot.is_long && snapshot.deferred_cohort
        && snapshot.affordability_close_only
        && !std::isfinite(snapshot.requested_qty)
        && !finite_positive(snapshot.exit_levels.limit)
        && !finite_positive(snapshot.exit_levels.stop)
        && !snapshot.projection_after_close
        && !config_.process_orders_on_close && !config_.calc_on_order_fills
        && !coof_recalc_active_
        && physical.signed_units > 0.0 && physical.lot_count == 1U
        && last_margin_call_script_bar_ == snapshot.placement_script_open_ms
        && last_margin_call_event_ordinal_ != 0
        && last_margin_call_event_ordinal_ == last_applied_ordinal_
        && last_margin_call_entry_incarnation_ != 0
        && last_margin_call_position_cycle_ == current_position_cycle_
        && last_margin_call_at_script_close_
        && last_margin_call_closed_units_ == 1.0
        && last_margin_call_remaining_units_ == std::abs(physical.signed_units)) {
        const auto* pine_host = pine_view_of(&host);
        const auto state = detail::run_state(host);
        const bool magnifier = pine_host
            && pine_host->scheduler_.bar_magnifier_enabled();
        const double carried = last_margin_call_remaining_units_
            + last_margin_call_closed_units_;
        if (pine_host && !magnifier
            && std::isfinite(carried)
            && std::abs(carried - std::abs(physical.signed_units) - 1.0) < 1e-6) {
            // The native pre-open/path callback has already applied the
            // signal-close margin event before this source command is
            // published. Preserve the exact event receipt the legacy pending
            // owner wrote after command publication (pine_fills.cpp:2049-52).
            snapshot.projection_tv_carry_qty = carried;
            snapshot.signal_close_mc_bar = snapshot.projection_created_bar;
            snapshot.signal_close_mc_entry_incarnation =
                last_margin_call_entry_incarnation_;
            snapshot.signal_close_mc_fill_seq =
                pine_host->adapter_broker_fill_event_sequence();
            snapshot.signal_close_mc_remaining_qty =
                last_margin_call_remaining_units_;
            snapshot.affordability_keep_mc_close_surplus = true;
        }
    }
    if (snapshot.opening && snapshot.family == PineOrderFamily::Entry
        && !snapshot.is_long && snapshot.rounded_signal_cost_close_only
        && snapshot.affordability_close_only
        && signal_close_mc_event_bar_ == snapshot.projection_created_bar
        && signal_close_mc_position_cycle_ == snapshot.placement_cycle
        && signal_close_mc_entry_incarnation_ != 0
        && signal_close_mc_fill_seq_ != 0) {
        snapshot.signal_close_mc_bar = signal_close_mc_event_bar_;
        snapshot.signal_close_mc_entry_incarnation =
            signal_close_mc_entry_incarnation_;
        snapshot.signal_close_mc_fill_seq = signal_close_mc_fill_seq_;
        snapshot.signal_close_mc_remaining_qty = signal_close_mc_remaining_qty_;
        snapshot.projection_tv_carry_qty = signal_close_mc_before_qty_;
    }
    snapshot.placement_open_epoch = broker_open_epoch_;
    if (snapshot.command_ordinal == 0) snapshot.command_ordinal = ++command_ordinal_;
    if (snapshot.command_sequence == 0) {
        if (source_command_sequence_ == std::numeric_limits<std::uint64_t>::max()) {
            throw coded<std::overflow_error>(RunFailureCode::engine_invariant, {},
                                             "Pine source command sequence exhausted");
        }
        snapshot.command_sequence = ++source_command_sequence_;
    }
    std::optional<admission::Allocation> admission_allocation;
    std::shared_ptr<const admission::CommandObservation> admission_observation;
    if (snapshot.family == PineOrderFamily::Entry
        || snapshot.family == PineOrderFamily::Order) {
        admission_allocation.emplace(admission_journal.reserve());
        auto observed = std::make_shared<admission::CommandObservation>();
        observed->command = admission_allocation->sequence();
        observed->kind = snapshot.family == PineOrderFamily::Entry
            ? admission::CommandKind::Entry : admission::CommandKind::Raw;
        observed->birth = snapshot.birth;
        observed->id = snapshot.source_id;
        observed->requested_quantity = snapshot.requested_qty;
        observed->quantity_type = snapshot.qty_type;
        observed->buy = snapshot.is_long;
        observed->prices = {snapshot.exit_levels.limit, snapshot.exit_levels.stop};
        observed->oca_name = snapshot.oca_name;
        observed->oca_type = snapshot.oca_type;
        const auto native = detail::run_state(host);
        auto& configuration = observed->configuration;
        configuration.process_on_close = config_.process_orders_on_close;
        configuration.calc_on_fills = config_.calc_on_order_fills;
        configuration.magnifier = native.spec && !native.spec->intrabar.is_none();
        configuration.fill_recalculation = coof_recalc_active_;
        configuration.scheduler = config_.calc_on_order_fills;
        configuration.slippage = config_.slippage;
        configuration.pyramiding = config_.pyramiding;
        configuration.default_quantity_type = config_.default_qty_type;
        configuration.default_quantity_value = config_.default_qty_value;
        configuration.long_margin = config_.margin_long;
        configuration.short_margin = config_.margin_short;
        configuration.commission_value = config_.commission_value;
        configuration.commission_type = config_.commission_type;
        configuration.pointvalue = staged_.syminfo.pointvalue;
        configuration.fx = snapshot.sizing.fx;
        configuration.quantity_step = staged_.quantity_grid.value_or(0.0);
        configuration.mintick = staged_.syminfo.mintick;
        configuration.risk_direction = risk_.direction;
        configuration.loss_days_limit = risk_.max_cons_loss_days;
        configuration.drawdown_limit = risk_.max_drawdown;
        configuration.intraday_loss_limit = risk_.max_intraday_loss;
        configuration.position_limit = risk_.max_position_size;
        configuration.fill_cap_active = cap.active();
        configuration.risk_halted = risk_.halted;
        observed->bar = snapshot.projection_created_bar;
        observed->placement_side = snapshot.projection_position_side;
        observed->placement_cycle = snapshot.placement_cycle;
        observed->prior_close_quantity = snapshot.projection_after_close
            ? snapshot.projection_tv_carry_qty : 0.0;
        observed->held_quantity = snapshot.projection_tv_carry_qty;
        observed->held_entries = static_cast<int>(physical.lot_count);
        observed->realized_equity = snapshot.sizing.equity;
        observed->placement_equity = snapshot.sizing.equity;
        observed->signal_close = snapshot.sizing.mark;
        observed->quantized_fixed_quantity = std::isfinite(snapshot.requested_qty)
            ? snapshot.requested_qty : kNaN;
        if (!std::isfinite(snapshot.requested_qty)
            && std::holds_alternative<native_order::Market>(request.trigger)
            && (config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
                || config_.default_qty_type == static_cast<int>(QtyType::CASH))) {
            observed->original_sizing = admission::SizingObservation{
                snapshot.sizing.frozen_units, snapshot.sizing.equity,
                snapshot.sizing.price, snapshot.sizing.mark, snapshot.sizing.fx};
        }
        observed->explicit_equity = snapshot.projection_explicit_equity;
        observed->explicit_price = snapshot.projection_explicit_signal_close;
        admission_observation = std::move(observed);
        snapshot.market_admission.bind(admission_observation);
    }
    if (auto* member = std::get_if<native_order::Member>(&request.group)) {
        if (source_sequence_ >= static_cast<std::uint64_t>(std::numeric_limits<std::int64_t>::max())) {
            throw coded<std::overflow_error>(RunFailureCode::engine_invariant, {},
                                             "Pine OCA member sequence exhausted");
        }
        // The generic group member's cohort distinguishes siblings. A source
        // OCA name identifies the group; every accepted source instruction is
        // a distinct member of it, including replacement incarnations.
        member->cohort = static_cast<std::int64_t>(source_sequence_ + 1U);
    }
    const auto key = replacement_key.empty() ? 0 : checked_live_key(replacement_key);
    std::optional<native_order::RequestHandle> accepted;
    // The predecessor's placement row, read in place (the trigger-band and scratch reuse; this
    // was a copy of the whole row). Nothing writes the row between here and
    // its last read below -- the replace runs no adapter code and the table
    // gains no row before remember() -- except the reset of its legs after
    // the replace, which moves their value out into predecessor_legs.
    const PlacementSnapshot* predecessor_snapshot = nullptr;
    exit_legs::Lifecycle predecessor_legs;
    // The node retire() would erase for `key`, kept for the successor's
    // entry instead of allocating one.
    decltype(live_by_source_key_)::node_type reused_key_node;
    bool predecessor_exit = false;
    bool predecessor_market = false;
    const auto unchanged_dynamic_exit = [&](const PlacementSnapshot& prior) {
        const bool preserve_coof_birth = prior.projection_created_during_coof
            && !coof_recalc_active_;
        if (opening || materializing_relative_
            || ((coof_recalc_active_ || config_.calc_on_order_fills)
                && !preserve_coof_birth)
            || !snapshot.deferred_cohort
            || !prior.deferred_cohort || snapshot.family != prior.family
            || (snapshot.family != PineOrderFamily::ExitLimit
                && snapshot.family != PineOrderFamily::ExitStop
                && snapshot.family != PineOrderFamily::ExitTrail)
            || !std::isnan(snapshot.requested_qty) || !std::isnan(prior.requested_qty)
            || snapshot.source_id != prior.source_id || snapshot.from_entry != prior.from_entry
            || snapshot.comment != prior.comment || snapshot.oca_name != prior.oca_name
            || snapshot.oca_type != prior.oca_type
            || !same_double_bits(snapshot.qty_percent, prior.qty_percent)
            || snapshot.bracket_origin != prior.bracket_origin
            || !same_exit_levels(snapshot.exit_levels, prior.exit_levels)) {
            return false;
        }
        const auto* sized = std::get_if<native_order::HostSized>(&request.intent);
        const auto* owner = std::get_if<native_order::BindCohort>(&request.owner);
        const auto cohort = cohorts_by_id_.find(snapshot.from_entry);
        const bool fifo_live_owner = !config_.close_entries_rule_any
            && std::holds_alternative<native_order::Independent>(request.owner)
            && cohort != cohorts_by_id_.end()
            && cohort_exposure_for(snapshot.from_entry) > 0.0;
        if (!sized || sized->kind != native_order::HostSizedKind::Close || sized->side
            || ((!owner || cohort == cohorts_by_id_.end()
                 || owner->cohort != cohort->second.handle)
                && !fifo_live_owner)) {
            return false;
        }
        if (const auto* limit = std::get_if<native_order::Limit>(&request.trigger)) {
            if (preserve_coof_birth)
                return snapshot.family == PineOrderFamily::ExitLimit;
            return snapshot.family == PineOrderFamily::ExitLimit
                && same_double_bits(limit->price, prior.exit_levels.limit);
        }
        if (const auto* stop = std::get_if<native_order::Stop>(&request.trigger)) {
            if (preserve_coof_birth)
                return snapshot.family == PineOrderFamily::ExitStop;
            return snapshot.family == PineOrderFamily::ExitStop
                && same_double_bits(stop->price, prior.exit_levels.stop);
        }
        if (const auto* trail = std::get_if<native_order::Trail>(&request.trigger)) {
            // An attempted request still carries the kernel's tick spelling;
            // acceptance resolves it against the same mintick, so read the
            // price distance this leg will be stored with.
            const double trail_offset = trail->ticks
                ? trail->ticks->ticks * staged_.syminfo.mintick : trail->offset;
            // exit() arms the leg at source_trail_arm_level of the source
            // trail_price, on the close side of the cohort pinned above.
            const auto arm_of_prior = [&](bool exit_is_buy) {
                return source_trail_arm_level(prior.exit_levels.trail_price,
                                              staged_.syminfo.mintick, exit_is_buy);
            };
            return snapshot.family == PineOrderFamily::ExitTrail
                && same_double_bits(trail_offset, prior.exit_levels.trail_offset)
                && trail->arm_price.has_value() == std::isfinite(prior.exit_levels.trail_price)
                && (!trail->arm_price
                    || same_double_bits(*trail->arm_price, arm_of_prior(true))
                    || same_double_bits(*trail->arm_price, arm_of_prior(false)));
        }
        return false;
    };
    std::optional<std::uint64_t> retained_source_sequence;
    if (key != 0) {
        std::optional<native_order::RequestHandle> existing_handle;
        if (const auto existing = live_by_source_key_.find(key);
            existing != live_by_source_key_.end()) {
            // `retire` removes this key from live_by_source_key_. Keep the
            // handle independent of the map node before either operation.
            existing_handle = existing->second;
            if (const auto previous = placement_.find(existing_handle->incarnation);
                previous != placement_.end()) {
                predecessor_snapshot = &previous->second;
                // The legacy pending book leaves a same-definition bracket
                // untouched. Its source cohort remains live and its dynamic
                // close quantity is resolved at fill time, so a normal-bar
                // reissue has no new executable fact to record.
                if (unchanged_dynamic_exit(previous->second)
                    && !reissue_revives_declined_exit(previous->second)) {
                    if (previous->second.void_issue && !snapshot.void_issue)
                        unvoid_exit(previous->second);
                    return existing_handle;
                }
                const auto family = previous->second.family;
                predecessor_exit = family == PineOrderFamily::ExitLimit
                    || family == PineOrderFamily::ExitStop || family == PineOrderFamily::ExitTrail;
                predecessor_market = family == PineOrderFamily::Entry
                    && !std::isfinite(previous->second.exit_levels.limit)
                    && !std::isfinite(previous->second.exit_levels.stop)
                    && !std::isfinite(previous->second.exit_levels.trail_offset);
            }
        }
        if (existing_handle) {
            // A close-time re-issue whose activation is unchanged but whose
            // offset alone moves keeps the running trail extreme.  The
            // native Trail owns that evolving generic state, so replacing it
            // would incorrectly reset the track at every script close.  The
            // source projection still records the latest offset operand.
            if (predecessor_snapshot
                && predecessor_snapshot->family == PineOrderFamily::ExitTrail
                && snapshot.family == PineOrderFamily::ExitTrail) {
                const auto same = [](double left, double right) {
                    return (std::isnan(left) && std::isnan(right)) || left == right;
                };
                const bool same_activation = same(predecessor_snapshot->exit_levels.trail_points,
                                                   snapshot.exit_levels.trail_points)
                    && same(predecessor_snapshot->exit_levels.trail_price,
                            snapshot.exit_levels.trail_price);
                const bool offset_changed = !same(predecessor_snapshot->exit_levels.trail_offset,
                                                   snapshot.exit_levels.trail_offset);
                if (same_activation) {
                    const auto live = placement_.find(existing_handle->incarnation);
                    if (live != placement_.end()) {
                        if (offset_changed) {
                            if (const auto trail = host.trail_state(*existing_handle);
                                trail && trail->activated
                                && std::isfinite(trail->best_price)) {
                                live->second.retained_trail_best = trail->best_price;
                            }
                        }
                        if (live->second.void_issue && !snapshot.void_issue)
                            unvoid_exit(live->second);
                        live->second.exit_levels.trail_offset = snapshot.exit_levels.trail_offset; invalidate_retirement();
                        live->second.trail_activation_level = snapshot.trail_activation_level;
                        live->second.requested_qty = snapshot.requested_qty;
                        live->second.projection_remaining_qty = snapshot.projection_remaining_qty;
                        live->second.qty_percent = snapshot.qty_percent;
                        live->second.comment = snapshot.comment;
                        live->second.sizing = snapshot.sizing;
                    }
                    refresh_pending_view();
                    return existing_handle;
                }
                if (std::isfinite(snapshot.sizing.price))
                    snapshot.retained_trail_best = snapshot.sizing.price;
            }
            // The handle-preserving reissue change: the re-issue carries a close's book binding
            // (ReplaceOptions::keep_binding). A leg the kernel bound to the
            // position binds to it again at its next point with no
            // CloseBoundEvent when the position has not moved, and exactly
            // as before when it has; every other successor carries nothing.
            // The handle is not kept: this table, the families and the
            // pending-order rows name each placement by the incarnation its
            // own command was issued.
            native_order::ReplaceOptions reissue;
            reissue.keep_binding = detail::carry_reissue_bindings();
            const auto result = host.replace(*existing_handle, request, reissue);
            if (result.status == native_order::ReplaceStatus::Replaced && result.successor) {
                // ab9714be pine_strategy_host.cpp:239-241 + 270-275: the flatten
                // unbinds every exit's leg activation and the fresh open rebinds
                // only RETAINED activations, so a same-id exit that replaces a
                // bracket across a stop-out starts its successor with clean legs
                // instead of inheriting the finished cycle's touched stop / trail
                // state and firing it against the new lot.
                if (const auto found_p = placement_.find(existing_handle->incarnation);
                    found_p != placement_.end()) {
                    predecessor_legs = std::move(found_p->second.legs);
                    found_p->second.legs = {}; invalidate_retirement();
                }
                snapshot.projection_predecessor = existing_handle->incarnation;
                if (predecessor_snapshot) {
                    const auto family = predecessor_snapshot->family;
                    snapshot.projection_predecessor_exit = family == PineOrderFamily::ExitLimit
                        || family == PineOrderFamily::ExitStop || family == PineOrderFamily::ExitTrail;
                    snapshot.projection_predecessor_market = family == PineOrderFamily::Entry
                        && !std::isfinite(predecessor_snapshot->exit_levels.limit)
                        && !std::isfinite(predecessor_snapshot->exit_levels.stop)
                        && !std::isfinite(predecessor_snapshot->exit_levels.trail_offset);
                    const bool fresh_after_dormant = predecessor_legs.dormant()
                        && (snapshot.family == PineOrderFamily::ExitLimit
                            || snapshot.family == PineOrderFamily::ExitStop
                            || snapshot.family == PineOrderFamily::ExitTrail);
                    // A void call's request was never TradingView's order: a
                    // re-issue made once the entry exists starts afresh.
                    const bool fresh_after_void =
                        predecessor_snapshot->void_issue && !snapshot.void_issue;
                    const auto predecessor_revision = predecessor_legs.revision();
                    // pine_execution_lifecycle.cpp's same-(id, from_entry)
                    // reissue replaces a dormant bracket wholesale.  Carrying
                    // its suspension into the successor would leave the fresh
                    // source prices permanently unmatchable.
                    if (!fresh_after_dormant && !fresh_after_void) {
                        snapshot.legs = std::move(predecessor_legs);
                        snapshot.leg_activation = predecessor_snapshot->leg_activation;
                        snapshot.exit_activation = predecessor_snapshot->exit_activation;
                        snapshot.restored_after_margin =
                            predecessor_snapshot->restored_after_margin;
                    }
                    if (!fresh_after_void) {
                        snapshot.reservation_expansion =
                            predecessor_snapshot->reservation_expansion;
                        snapshot.reservation_growth_source =
                            predecessor_snapshot->reservation_growth_source;
                    }
                    snapshot.cancellation = {PineCancellationCause::Replacement, 1, 0,
                        existing_handle->incarnation,
                        static_cast<std::int64_t>(predecessor_snapshot->source_sequence),
                        existing_handle->incarnation, predecessor_snapshot->placement_cycle,
                        predecessor_revision,
                        predecessor_snapshot->requested_qty, kNaN};
                    if ((family == PineOrderFamily::ExitLimit
                         || family == PineOrderFamily::ExitStop
                         || family == PineOrderFamily::ExitTrail)
                        && !snapshot.from_entry.empty()) {
                        const auto token = named_entry_cancel_tokens_.find(snapshot.from_entry);
                        bool retained_child = token != named_entry_cancel_tokens_.end()
                            && token->second.surviving_exit_incarnation
                                == existing_handle->incarnation;
                        for (const auto& live : live_handles_) {
                            const auto parent = placement_.find(live.incarnation);
                            if (parent != placement_.end() && parent->second.opening
                                && parent->second.family == PineOrderFamily::Entry
                                && parent->second.source_id == snapshot.from_entry
                                && (parent->second.named_cancel_surviving_exit_incarnation
                                        == existing_handle->incarnation
                                    || predecessor_snapshot->source_sequence
                                        < parent->second.source_sequence)) {
                                retained_child = true;
                                break;
                            }
                        }
                        if (retained_child
                            && (!predecessor_snapshot->void_issue || snapshot.void_issue)) {
                            retained_source_sequence = predecessor_snapshot->source_sequence;
                        }
                    }
                    // ab9714be pine_strategy_commands.cpp:482: same-id entry replacement preserves created_seq (preserved_seq > 0)
                    if ((family == PineOrderFamily::Entry && snapshot.family == PineOrderFamily::Entry)
                        || (family == PineOrderFamily::Order && snapshot.family == PineOrderFamily::Order)) {
                        retained_source_sequence = predecessor_snapshot->source_sequence;
                    }
                }
                snapshot.projection_predecessor_exit = predecessor_exit;
                snapshot.projection_predecessor_market = predecessor_market;
                reused_key_node = live_by_source_key_.extract(key);
                retire(*existing_handle);
                accepted = *result.successor;
            }
        }
    }
    if (auto* member = std::get_if<native_order::Member>(&request.group)) {
        if (source_sequence_ >= static_cast<std::uint64_t>(std::numeric_limits<std::int64_t>::max())) {
            throw coded<std::overflow_error>(RunFailureCode::engine_invariant, {},
                                             "Pine OCA member sequence exhausted");
        }
        // The generic group member's cohort distinguishes siblings. A source
        // OCA name identifies the group; every accepted source instruction is
        // a distinct member of it, including replacement incarnations.
        member->cohort = static_cast<std::int64_t>(source_sequence_ + 1U);
    }
    if (!accepted && materializing_relative_ && !opening) {
        // The anchored-leg integration: the kernel already armed this leg at the parent's
        // fill. When the request this fill point builds is that very trigger
        // on that very group, the armed child IS the accepted request and
        // nothing is submitted; every source fact of the snapshot stays the
        // fill point's own.
        const auto armed = std::find_if(
            anchored_relative_legs_.begin(), anchored_relative_legs_.end(),
            [&](const AnchoredRelativeLeg& leg) {
                return leg.armed && leg.parent == materializing_parent_
                    && leg.family == snapshot.family
                    && leg.exit_id == snapshot.source_id
                    && leg.from_entry == snapshot.from_entry;
            });
        if (armed != anchored_relative_legs_.end()) {
            const auto same_trigger = [&] {
                const auto& mine = armed->request.trigger;
                if (mine.index() != request.trigger.index()) return false;
                if (const auto* limit = std::get_if<native_order::Limit>(&request.trigger)) {
                    return same_double_bits(limit->price, armed->installed_level)
                        && limit->fill_through
                            == std::get<native_order::Limit>(mine).fill_through;
                }
                if (const auto* stop = std::get_if<native_order::Stop>(&request.trigger))
                    return same_double_bits(stop->price, armed->installed_level);
                if (const auto* trail = std::get_if<native_order::Trail>(&request.trigger)) {
                    const auto& anchored = std::get<native_order::Trail>(mine);
                    return trail->arm_price && trail->ticks && anchored.ticks
                        && same_double_bits(*trail->arm_price, armed->installed_level)
                        && same_double_bits(trail->ticks->ticks, anchored.ticks->ticks)
                        && trail->offset == 0.0;
                }
                return false;
            }();
            const auto* mine_group = std::get_if<native_order::Member>(&armed->request.group);
            const auto* group = std::get_if<native_order::Member>(&request.group);
            const bool same_group = mine_group && group && mine_group->group == group->group
                && mine_group->effect == group->effect;
            // The armed child is a host-sized close of the book (its arm
            // scope); so must the request be, or it is another request.
            const auto* sized = std::get_if<native_order::HostSized>(&request.intent);
            const bool same_close = sized && sized->kind == native_order::HostSizedKind::Close
                && !sized->side
                && std::holds_alternative<native_order::Independent>(request.owner)
                && std::holds_alternative<native_order::ImmediateRemaining>(request.capacity);
            if (same_trigger && same_group && same_close) {
                accepted = armed->handle;
                anchored_relative_legs_.erase(armed);
                ++anchored_relative_stats_.adopted;
            }
        }
    }
    if (!accepted) {
        const auto result = host.submit(request);
        if (result.status != native_order::SubmitStatus::Accepted || !result.handle) return std::nullopt;
        accepted = *result.handle;
    }
    snapshot.opening = opening;
    if (!std::isfinite(snapshot.projection_remaining_qty)
        && std::isfinite(snapshot.requested_qty)) {
        snapshot.projection_remaining_qty = snapshot.requested_qty;
    }
    const auto next_source_sequence = ++source_sequence_;
    const bool staged_replacement_sequence = snapshot.projection_predecessor != 0
        && snapshot.source_sequence != 0;
    snapshot.source_sequence = retained_source_sequence
        ? *retained_source_sequence
        : (staged_replacement_sequence ? snapshot.source_sequence : next_source_sequence);
    if (admission_observation) {
        admission::CommandEvent event;
        event.observation = admission_observation;
        event.outcome = admission::Outcome::Admitted;
        event.admitted_incarnation = accepted->incarnation;
        admission_journal.append(std::move(event));
    }
    // remember() consumes the snapshot; the same-id cleanup below reads the
    // accepted request's family and its place in the source command order.
    const PineOrderFamily accepted_family = snapshot.family;
    const std::uint64_t accepted_command_sequence = snapshot.command_sequence;
    remember(*accepted, std::move(snapshot));
    // ab9714be pine_strategy_commands.cpp:445-446 (entry/order) and
    // 1694-1703 (exit): an accepted same-id instruction removes the prior
    // pending order, including one still queued here for a later submission.
    if (!replacement_key.empty()) {
        pending_write(pending_coof_requests_).erase(
            std::remove_if(pending_coof_requests_.begin(), pending_coof_requests_.end(),
                [&](const PendingCoofRequest& row) { return row.replacement_key == replacement_key; }),
            pending_coof_requests_.end());
        pending_write(pending_bracket_legs_).erase(
            std::remove_if(pending_bracket_legs_.begin(), pending_bracket_legs_.end(),
                [&](const PendingBracketLeg& row) { return row.replacement_key == replacement_key; }),
            pending_bracket_legs_.end());
        delayed_market_orders_.erase(
            std::remove_if(delayed_market_orders_.begin(), delayed_market_orders_.end(),
                [&](const DelayedMarketOrder& row) { return row.replacement_key == replacement_key; }),
            delayed_market_orders_.end());
        // A flat calc_on_order_fills evaluation holds its priced entries
        // back until the evaluation ends (submit_entry_with_policy). An
        // accepted entry replaces a held earlier entry of the same id, so
        // the held row is dropped here: flushed when the evaluation ends, it
        // would replace the later entry instead. The rule is entry to entry:
        // an accepted strategy.order call leaves the held row alone. A row
        // issued after the accepted entry stays, and so does one waiting for
        // a close (paired_reversal_parent) or a recreated parent
        // (retained_parent_topology): those keep their own submission rules.
        if (opening && accepted_family == PineOrderFamily::Entry
            && config_.calc_on_order_fills && !coof_recalc_active_) {
            pending_write(pending_entries_).erase(
                std::remove_if(pending_entries_.begin(), pending_entries_.end(),
                    [&](const PendingEntry& row) {
                        return row.replacement_key == replacement_key
                            && row.snapshot.family == PineOrderFamily::Entry
                            && row.snapshot.opening
                            && row.snapshot.paired_reversal_parent.incarnation == 0
                            && !row.snapshot.retained_parent_topology
                            && row.snapshot.command_sequence < accepted_command_sequence;
                    }),
                pending_entries_.end());
        }
    }
    if (key != 0) {
        if (reused_key_node) {
            reused_key_node.mapped() = live_source_value(*accepted, replacement_key);
            auto placed = live_by_source_key_.insert(std::move(reused_key_node));
            if (!placed.inserted) { (void)checked_live_key(replacement_key); placed.position->second = live_source_value(*accepted, replacement_key); }
        } else {
            live_by_source_key_[checked_live_key(replacement_key)] = live_source_value(*accepted, replacement_key);
        }
    }
    if (opening) {
        const auto source = placement_.at(accepted->incarnation).source_id;
        const auto cohort = cohort_for(source);
        host.cohort_add(cohort, *accepted);
        require_cohort(source)->second.origins.push_back(*accepted);
    }
    const auto& accepted_snapshot = placement_.at(accepted->incarnation);
    if (coof_recalc_active_
        && ((std::holds_alternative<native_order::Market>(request.trigger)
             && (coof_first_open_
                 || finite_positive(accepted_snapshot.forced_execution_price)))
            || (coof_first_open_
                && finite_positive(accepted_snapshot.forced_execution_price)))
        && std::holds_alternative<native_order::ImmediateRemaining>(request.capacity)
        && detail::callback_point(host)) {
        first_open_newborns_.push_back(*accepted);
    }
    return accepted;
}
 
std::vector<native_order::RequestHandle> PineExecutionAdapter::openings_for(const SourceId& id) const {
    const auto found = cohorts_by_id_.find(id);
    return found == cohorts_by_id_.end() ? std::vector<native_order::RequestHandle>{}
                                         : found->second.opened;
}
 
bool PineExecutionAdapter::from_entry_filled_this_cycle(const SourceId& id) const {
    // The source analogue of ab9714be cycle_filled_entry_ids_: the id opened
    // in the live position cycle (reset when the book goes flat).
    const auto found = cohorts_by_id_.find(id);
    return found != cohorts_by_id_.end() && current_position_cycle_ > 0
        && found->second.cycle == current_position_cycle_;
}
 
double PineExecutionAdapter::cohort_exposure_for(const SourceId& id) const noexcept {
    const auto found = cohorts_by_id_.find_resident(id);
    return found == cohorts_by_id_.end() ? 0.0 : cohort_exposure_for(found->second);
}
 
double PineExecutionAdapter::cohort_exposure_for(const CohortFacts& facts) const noexcept {
    PINEFORGE_LOOKUP_INDEX_WORK("cohort_exposure_call", this, run_counter_, 1);
    // Quantities follow source insertion order, never the lookup table's
    // hash buckets. Each retained position contributes separately.
    // Repeated incarnations contribute once per occurrence, in that order.
    // Allocation-free: pending-order readback calls this const noexcept member.
    // Finite/positive filtering and the final clamp preserve overflow to zero.
    // Reordering, regrouping or multiplying repeated units changes bits.
    // Diagnostic work belongs to the returned value, never adapter state.
    // The seam receives the original roster and map by const reference.
    // Global positions keep their order after prefix retirement.
    // A unit row without a retained position contributes no term.
    const auto folded = detail::fold_cohort_exposure(facts.origins,
                                                    facts.live_units_by_origin);
    PINEFORGE_LOOKUP_INDEX_WORK("cohort_exposure_step", this, run_counter_, folded.steps);
    PINEFORGE_LOOKUP_INDEX_WORK("cohort_exposure_window", this, run_counter_,
                               facts.origins.members().size());
    PINEFORGE_LOOKUP_INDEX_WORK("cohort_exposure_rows", this, run_counter_,
                               facts.live_units_by_origin.size());
    if (folded.path == 2)
        PINEFORGE_LOOKUP_INDEX_WORK("cohort_exposure_path_b", this, run_counter_, 1);
    if (folded.path == 3)
        PINEFORGE_LOOKUP_INDEX_WORK("cohort_exposure_b_abandoned", this, run_counter_, 1);
#ifdef PINEFORGE_COHORT_EXPOSURE_FIXTURES
    detail::verify_cohort_exposure(facts.origins, facts.live_units_by_origin,
                                  folded.total);
#endif
    // The fixture oracle is independent of the selected production path.
    // It checks every call, including both empty-state early returns.
    // No aggregate or reservation state is updated by this read.
    // Callers receive only the clamped exposure value.
    return folded.total;
}
 
// The units of the position an exit's entry (from_entry) holds; none for an
// exit that names no entry, which acts on the whole position. An exit whose
// entry holds none is inert: it fills nothing until that entry fills. Each
// caller keeps its own test: the point order at the open counts an exit only
// above kQtyEpsilon, and the bracket ranking under process_orders_on_close
// (flush_pending_bracket_legs) drops one only while its entry also has no
// working order.
std::optional<double> PineExecutionAdapter::from_entry_units(
        const SourceId& from_entry) const noexcept {
    if (from_entry.empty()) return std::nullopt;
    return cohort_exposure_for(from_entry);
}
 
int PineExecutionAdapter::source_entry_slot_count() const noexcept {
    assert(cohorts_by_id_.resident_opened_slot_count() == cohort_opened_slot_count_);
    if (fixture_verify_source_entry_slots_) {
        std::size_t direct = 0;
        for (const auto& row : cohorts_by_id_.resident_rows()) direct += row.second.opened.size();
        if (direct != cohort_opened_slot_count_) std::abort();
    }
    return cohort_opened_slot_count_ > static_cast<std::size_t>(std::numeric_limits<int>::max())
        ? std::numeric_limits<int>::max()
        : static_cast<int>(cohort_opened_slot_count_);
}
 
PineExecutionAdapter::CohortHeapEstimate
PineExecutionAdapter::cohort_heap_estimate() const noexcept {
    // bytes_per_row counts PHYSICAL resident rows; deferred empty rows inflate
    // the estimate even though they carry no live cohort members.
    CohortHeapEstimate result;
    result.resident_rows = cohorts_by_id_.resident_size();
    result.row_bytes = result.resident_rows * CohortTable::resident_row_bytes();
    result.directory_bytes = cohorts_by_id_.resident_directory_heap_estimate();
    for (const auto& row : cohorts_by_id_.resident_rows()) {
        result.key_bytes += row.first.capacity() + 1;
        const auto& facts = row.second;
        result.origin_bytes += facts.origins.heap_bytes_estimate();
        result.opened_bytes += facts.opened.capacity() * sizeof(native_order::RequestHandle);
        // Session keys inside handles are shared run-level objects: not counted.
        result.live_unit_bytes += facts.live_units_by_origin.bucket_count() * sizeof(void*)
            + facts.live_units_by_origin.size()
                * (sizeof(decltype(facts.live_units_by_origin)::value_type) + 2 * sizeof(void*));
    }
    result.total_bytes = result.row_bytes + result.key_bytes + result.origin_bytes
        + result.opened_bytes + result.live_unit_bytes + result.directory_bytes;
    result.bytes_per_row = result.resident_rows == 0 ? 0 : result.total_bytes / result.resident_rows;
    return result;
}
 
double PineExecutionAdapter::percent_commission_live_equity(double mark) const noexcept {
    return percent_commission_live_equity(mark, std::nullopt);
}
 
double PineExecutionAdapter::percent_commission_live_equity(
        double mark, std::optional<double> fx) const noexcept {
    if (!host_) return std::numeric_limits<double>::quiet_NaN();
    // ab9714be pine_fills.cpp:1411-1426: entry-bar affordability marks open positions
    // from closed equity (initial capital + realized net profit) minus the open
    // entries' percentage commission, plus the lot's open PnL.
    if (auto* pine = pine_view_of(host_)) {
        if (config_.commission_type == static_cast<int>(CommissionType::PERCENT)
            && config_.commission_value > 0.0
            && pine->position_side_ != PositionSide::FLAT) {
            double paid_open_commission = 0.0;
            for (const auto& pe : pine->pyramid_entries_) {
                if (pe.qty <= internal::kQtyEpsilon) continue;
                const double fee = pine->open_entry_commission(pe);
                if (!std::isfinite(fee)) return std::numeric_limits<double>::quiet_NaN();
                paid_open_commission += fee;
            }
            const double open = fx ? pine->open_profit_at(mark, *fx)
                                  : pine->BacktestEngine::open_profit(mark);
            return (pine->closed_trade_equity() + open) - paid_open_commission;
        }
    }
    const double marked = strategy_equity_at(mark, fx);
    if (!std::isfinite(marked)) return marked;
    // `marked_equity()` accounts for every open entry fee.  The legacy money
    // gates read an equity that subtracts only surviving PERCENT entry
    // commissions, so restore the adapter-recorded
    // cash-per-order/contract fees without changing generic accounting or
    // marked equity itself.  A percent-of-equity default QUANTITY does not
    // read this: TradingView sizes it from strategy.equity, cash fees charged
    // (default_sizing_cash, the cash-sizing fee correction).  source_margin_money also
    // charges cash-per-contract fees for its tape-pinned margin policy.
    double restored = 0.0;
    for (const auto& fact : open_entry_fees_) {
        if (!std::isfinite(fact.nonpercent_fee))
            return std::numeric_limits<double>::quiet_NaN();
        restored += fact.nonpercent_fee;
    }
    return std::isfinite(restored) ? marked + restored
                                   : std::numeric_limits<double>::quiet_NaN();
}
 
double PineExecutionAdapter::strategy_equity_at(
        double mark, std::optional<double> fx) const noexcept {
    if (!host_) return std::numeric_limits<double>::quiet_NaN();
    const auto* pine = pine_view_of(host_);
    return fx && pine ? pine->marked_equity_at(mark, *fx) : host_->native_marked_equity(mark);
}
 
void PineExecutionAdapter::mark_sizing_equity(
        PineSizingSnapshot& sizing, double mark, std::optional<double> fx) const noexcept {
    sizing.equity = percent_commission_live_equity(mark, fx);
    if (!fx) {
        const double mirrored = gain_loss_signal_equity(mark);
        if (std::isfinite(mirrored)) sizing.equity = mirrored;
    }
    sizing.strategy_equity = default_sizing_reserves_cash_fee()
        ? strategy_equity_at(mark, fx) : kNaN;
}
 
void PineExecutionAdapter::record_opening_fee(
        const PlacementSnapshot& source, const native_order::ExecutionAppliedEvent& event) {
    const double opened = std::abs(event.opened_units);
    if (!(opened > 0.0) || !std::isfinite(opened)
        || config_.commission_type == static_cast<int>(CommissionType::PERCENT)) {
        return;
    }
    double fee = 0.0;
    if (config_.commission_type == static_cast<int>(CommissionType::CASH_PER_CONTRACT)) {
        fee = config_.commission_value * opened;
    } else if (config_.commission_type == static_cast<int>(CommissionType::CASH_PER_ORDER)) {
        const double total = opened + std::abs(event.closed_units);
        fee = total > 0.0 ? config_.commission_value * opened / total : 0.0;
    }
#ifdef PINEFORGE_VALUE_INVALID_FIXTURES
    fee = fixture_adapter_execution_value("fee.adapter.opening", fee);
#endif
    if (!std::isfinite(fee)) {
        engine_command_value_invalid_or_count("fee.commission", EngineValueStage::fee,
                                              EngineValueReason::numeric_overflow);
        return;
    }
    open_entry_fees_.push_back({event.handle(), source.source_id, opened, fee});
}
 
void PineExecutionAdapter::consume_opening_fees(
        const native_order::ExecutionAppliedEvent& event, const SourceId* source_id) {
    if (!(event.closed_units > 0.0) || !std::isfinite(event.closed_units)) return;
    std::vector<std::uint64_t> selected;
    if (const auto* opening = std::get_if<execution::OpeningExposure>(&event.scope)) {
        selected.push_back(opening->incarnation);
    } else if (const auto* openings = std::get_if<native_order::SelectedExposure>(&event.scope)) {
        selected = openings->incarnations;
    }
    double remaining = event.closed_units;
    for (auto it = open_entry_fees_.begin(); it != open_entry_fees_.end() && remaining > 0.0;) {
        const bool selected_origin = selected.empty()
            || std::find(selected.begin(), selected.end(), it->opening.incarnation) != selected.end();
        if (!selected_origin || (source_id && it->source_id != *source_id)
            || !(it->units > 0.0) || !std::isfinite(it->units)) {
            ++it;
            continue;
        }
        const double consumed = std::min(it->units, remaining);
        const double fraction = consumed / it->units;
        it->units -= consumed;
        it->nonpercent_fee -= it->nonpercent_fee * fraction;
        remaining -= consumed;
        if (!(it->units > 0.0)) it = open_entry_fees_.erase(it); else ++it;
    }
}
 
void PineExecutionAdapter::record_dropped_close(
        const SourceId& id, const std::string& comment, double qty, double qty_percent,
        bool immediately, std::uint64_t callsite_token) {
    dropped_close_digest_ = fold_dropped_close(dropped_close_digest_,
        {id, comment, qty, qty_percent, immediately, callsite_token, command_ordinal_});
    ++dropped_close_count_;
}
 
double PineExecutionAdapter::quantize_close_units(double basis, double percent) const noexcept {
    if (!std::isfinite(basis) || basis <= 0.0 || !std::isfinite(percent) || percent <= 0.0)
        return 0.0;
    // ab9714be pine_fills.cpp:6893-6896: `is_partial` is decided by
    // `qp < 100.0 - kFullPercentEps`, so a reservation percentage that only
    // misses 100 by the binary64 rounding of `reserved / live_basis * 100`
    // (pine_fills.cpp:7124) is a FULL exit and books the whole live basis.
    // Sizing it through the multiply/grid floor instead leaves a sub-lot dust
    // remainder that never flattens (ab9714be pine_fills.cpp:1618 spells the
    // same whole-position coverage as `qty - kQtyEpsilon`).
    if (percent >= 100.0 - internal::kFullPercentEps) {
        if (staged_.quantity_grid && *staged_.quantity_grid > 0.0) {
            const double nearest = std::round(basis / *staged_.quantity_grid) * *staged_.quantity_grid;
            if (std::abs(basis - nearest) <= internal::kQtyEpsilon) return nearest;
        }
        return basis;
    }
    double units = basis * percent / 100.0;
    if (!std::isfinite(units) || units <= 0.0) return 0.0;
    return quantize_percent_exit_units(units, basis);
}
 
double PineExecutionAdapter::quantize_percent_exit_units(
        double requested, double available) const noexcept {
    if (!std::isfinite(requested) || requested <= 0.0) return 0.0;
    if (!staged_.quantity_grid || !std::isfinite(*staged_.quantity_grid)
        || *staged_.quantity_grid <= 0.0) {
        return requested;
    }
    const double step = *staged_.quantity_grid;
    const double floored = std::floor(requested / step + 1e-6) * step;
    double result = floored < requested ? floored : requested;
    // ab9714be:engine.hpp:1587-1598.  A percentage exit keeps one minimum
    // unit while one full step of reservation capacity remains: 50 % of one
    // contract, and of one 0.01 lot of OANDA:XAUUSD, reserves the whole of it
    // on TradingView (lane TAIL-H rule PS, tape tailh-d1a).
    if (requested < step && available + internal::kQtyEpsilon >= step) result = step;
    return result;
}
 
bool PineExecutionAdapter::compute_exit_reservation(
        const SourceId& exit_id, const SourceId& from_entry,
        double requested_qty, double& qty_percent, double live_basis,
        double percentage_basis, double& reserved_qty) const {
    qty_percent = std::isfinite(qty_percent)
        ? std::clamp(qty_percent, 0.0, 100.0) : 100.0;
    reserved_qty = kNaN;
    if (!(live_basis > internal::kQtyEpsilon)) {
        if (std::isfinite(requested_qty)) {
            reserved_qty = std::abs(requested_qty);
            return reserved_qty > internal::kQtyEpsilon;
        }
        return true;
    }
 
    struct Reservation {
        std::uint64_t family = 0;
        double units = kNaN;
        double percent = 100.0;
        bool explicit_units = false;
        std::vector<std::uint64_t> origins;
        // The family's place in the exit queue (exit_queue_rank); a
        // strategy.close reservation has none and always holds its units.
        std::uint64_t rank = std::numeric_limits<std::uint64_t>::max();
        bool queued_exit = false;
    };
    std::vector<Reservation> reservations;
    auto observe = [&](const PlacementSnapshot& snapshot) {
        const bool queued_exit = snapshot.family == PineOrderFamily::ExitLimit
            || snapshot.family == PineOrderFamily::ExitStop
            || snapshot.family == PineOrderFamily::ExitTrail;
        const bool exit = queued_exit || snapshot.family == PineOrderFamily::Close;
        // A call TradingView voided reserves nothing (void_issue).
        if (!exit || snapshot.from_entry != from_entry || snapshot.void_issue) return;
        // ab9714be pine_orders.cpp:599-602: close reservations only apply to positions matching active position_cycle_seq_
        if (snapshot.family == PineOrderFamily::Close
            && snapshot.placement_cycle != 0
            && snapshot.placement_cycle < current_position_cycle_) {
            return;
        }
        const auto family = key_for(snapshot.source_id, snapshot.from_entry);
        auto row = std::find_if(reservations.begin(), reservations.end(),
            [&](const Reservation& value) { return value.family == family; });
        const double percent = std::isfinite(snapshot.qty_percent)
            ? std::clamp(snapshot.qty_percent, 0.0, 100.0) : 100.0;
        const double units = std::isfinite(snapshot.projection_remaining_qty)
            ? std::max(0.0, snapshot.projection_remaining_qty)
            : (std::isfinite(snapshot.requested_qty)
                ? std::max(0.0, std::abs(snapshot.requested_qty))
                // ab9714be src/source/pine_strategy_commands.cpp:2761 and
                // src/source/pine_fills.cpp:7094 both reserve a sibling leg's
                // share as ``live_pos * (oqp / 100.0)``, percent divided first.
                : live_basis * (percent / 100.0));
        const bool explicit_units = std::isfinite(snapshot.requested_qty);
        const auto origin = snapshot.bracket_origin.incarnation;
        const auto rank = queued_exit ? exit_queue_rank(placement_, snapshot)
                                      : std::numeric_limits<std::uint64_t>::max();
        if (row == reservations.end()) {
            Reservation next;
            next.family = family;
            next.units = units;
            next.percent = percent;
            next.explicit_units = explicit_units;
            if (explicit_units) next.origins.push_back(origin);
            next.rank = rank;
            next.queued_exit = queued_exit;
            reservations.push_back(std::move(next));
        } else {
            if (explicit_units && row->explicit_units
                && std::find(row->origins.begin(), row->origins.end(), origin)
                    == row->origins.end()) {
                row->units += units;
                row->origins.push_back(origin);
            } else {
                row->units = std::max(row->units, units);
            }
            row->explicit_units = row->explicit_units || explicit_units;
            row->percent = std::max(row->percent, percent);
            row->rank = std::min(row->rank, rank);
            row->queued_exit = row->queued_exit && queued_exit;
        }
    };
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found != placement_.end()) observe(found->second);
    }
    for (const auto& pending : pending_bracket_legs_) observe(pending.snapshot);
    for (const auto& pending : pending_coof_requests_) observe(pending.snapshot);
    for (const auto& delayed : delayed_market_orders_) observe(delayed.snapshot);
 
    const auto this_family = key_for(exit_id, from_entry);
    // A re-issued exit keeps its place in the queue (exit_queue_rank): an exit
    // created after it holds nothing ahead of it, however it was re-issued
    // since. A new exit is at the back and yields to every one already there.
    std::uint64_t this_rank = std::numeric_limits<std::uint64_t>::max();
    for (const auto& reservation : reservations) {
        if (reservation.family == this_family) this_rank = reservation.rank;
    }
    double already_reserved = 0.0;
    double preserved_reserved = kNaN;
    bool other_full_exit = false;
    for (const auto& reservation : reservations) {
        if (reservation.family == this_family) {
            if (std::isfinite(reservation.units)) {
                preserved_reserved = std::isfinite(preserved_reserved)
                    ? std::max(preserved_reserved, reservation.units)
                    : reservation.units;
            }
            continue;
        }
        if (reservation.queued_exit && reservation.rank > this_rank) continue;
        if (std::isfinite(reservation.units)) already_reserved += reservation.units;
        if (reservation.percent >= 100.0 - internal::kFullPercentEps) other_full_exit = true;
    }
    const double available = std::max(0.0, live_basis - already_reserved);
    if (std::isfinite(requested_qty)) {
        reserved_qty = std::min(std::abs(requested_qty), available);
    } else if (qty_percent < 100.0 - internal::kFullPercentEps
               && std::isfinite(preserved_reserved)) {
        reserved_qty = std::min(preserved_reserved, live_basis);
    } else {
        // A full source bracket owns the exact live exposure.  Multiplying
        // that exposure by 100/100 can round down by one binary64 step and
        // turn the legacy execute_market_exit branch into a dust reduction
        // (ab9714be:src/source/pine_fills.cpp:6893-6932; A33).
        double requested = qty_percent >= 100.0 - internal::kFullPercentEps
            ? live_basis : percentage_basis * qty_percent / 100.0;
        if (qty_percent < 100.0 - internal::kFullPercentEps) {
            requested = quantize_percent_exit_units(requested, available);
        }
        reserved_qty = std::min(requested, available);
    }
    if (!(reserved_qty > internal::kQtyEpsilon)) return false;
    qty_percent = reserved_qty / live_basis * 100.0;
    const bool partial = reserved_qty < live_basis - 1e-9;
    if (partial && other_full_exit) return false;
    return true;
}
 
void PineExecutionAdapter::reconcile_deferred_exit_reservations(
        const SourceId& from_entry, double live_basis) {
    if (!(live_basis > internal::kQtyEpsilon)) return;
 
    struct Family {
        std::uint64_t key = 0;
        std::uint64_t command_sequence = 0;
        std::uint64_t rank = std::numeric_limits<std::uint64_t>::max();
        double percent = 100.0;
        double existing = kNaN;
        double explicit_requested = kNaN;
        std::vector<native_order::RequestHandle> handles;
        std::vector<std::size_t> queued;
        std::vector<std::size_t> delayed;
        std::vector<std::uint64_t> origins;
    };
    std::vector<Family> families;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& snapshot = found->second;
        const bool exit = snapshot.family == PineOrderFamily::ExitLimit
            || snapshot.family == PineOrderFamily::ExitStop
            || snapshot.family == PineOrderFamily::ExitTrail;
        if (!exit || snapshot.from_entry != from_entry || snapshot.void_issue) continue;
        const auto key = key_for(snapshot.source_id, snapshot.from_entry);
        auto family = std::find_if(families.begin(), families.end(),
            [&](const Family& value) { return value.key == key; });
        if (family == families.end()) {
            Family next;
            next.key = key;
            next.command_sequence = snapshot.command_sequence;
            next.rank = exit_queue_rank(placement_, snapshot);
            next.percent = std::isfinite(snapshot.qty_percent)
                ? std::clamp(snapshot.qty_percent, 0.0, 100.0) : 100.0;
            next.existing = snapshot.projection_remaining_qty;
            next.explicit_requested = snapshot.requested_qty;
            next.handles.push_back(handle);
            next.origins.push_back(snapshot.bracket_origin.incarnation);
            families.push_back(std::move(next));
        } else {
            family->command_sequence = std::min(family->command_sequence,
                                                snapshot.command_sequence);
            family->rank = std::min(family->rank, exit_queue_rank(placement_, snapshot));
            family->handles.push_back(handle);
            if (std::isfinite(snapshot.projection_remaining_qty)) {
                family->existing = std::isfinite(family->existing)
                    ? std::max(family->existing, snapshot.projection_remaining_qty)
                    : snapshot.projection_remaining_qty;
            }
            if (std::isfinite(snapshot.requested_qty))
                family->explicit_requested = snapshot.requested_qty;
            if (std::find(family->origins.begin(), family->origins.end(),
                          snapshot.bracket_origin.incarnation) == family->origins.end()) {
                family->origins.push_back(snapshot.bracket_origin.incarnation);
            }
        }
    }
    for (std::size_t index = 0; index < pending_bracket_legs_.size(); ++index) {
        const auto& snapshot = pending_bracket_legs_[index].snapshot;
        const bool exit = snapshot.family == PineOrderFamily::ExitLimit
            || snapshot.family == PineOrderFamily::ExitStop
            || snapshot.family == PineOrderFamily::ExitTrail;
        if (!exit || snapshot.from_entry != from_entry || snapshot.void_issue) continue;
        const auto key = key_for(snapshot.source_id, snapshot.from_entry);
        auto family = std::find_if(families.begin(), families.end(),
            [&](const Family& value) { return value.key == key; });
        if (family == families.end()) {
            Family next;
            next.key = key;
            next.command_sequence = snapshot.command_sequence;
            next.rank = exit_queue_rank(placement_, snapshot);
            next.percent = std::isfinite(snapshot.qty_percent)
                ? std::clamp(snapshot.qty_percent, 0.0, 100.0) : 100.0;
            next.existing = snapshot.projection_remaining_qty;
            next.explicit_requested = snapshot.requested_qty;
            next.queued.push_back(index);
            next.origins.push_back(snapshot.bracket_origin.incarnation);
            families.push_back(std::move(next));
        } else {
            family->command_sequence = std::min(family->command_sequence,
                                                snapshot.command_sequence);
            family->rank = std::min(family->rank, exit_queue_rank(placement_, snapshot));
            family->queued.push_back(index);
            if (std::isfinite(snapshot.projection_remaining_qty)) {
                family->existing = std::isfinite(family->existing)
                    ? std::max(family->existing, snapshot.projection_remaining_qty)
                    : snapshot.projection_remaining_qty;
            }
            if (std::isfinite(snapshot.requested_qty))
                family->explicit_requested = snapshot.requested_qty;
            if (std::find(family->origins.begin(), family->origins.end(),
                          snapshot.bracket_origin.incarnation) == family->origins.end()) {
                family->origins.push_back(snapshot.bracket_origin.incarnation);
            }
        }
    }
    for (std::size_t index = 0; index < delayed_market_orders_.size(); ++index) {
        const auto& snapshot = delayed_market_orders_[index].snapshot;
        const bool exit = snapshot.family == PineOrderFamily::ExitLimit
            || snapshot.family == PineOrderFamily::ExitStop
            || snapshot.family == PineOrderFamily::ExitTrail;
        if (!exit || snapshot.from_entry != from_entry || snapshot.void_issue) continue;
        const auto key = key_for(snapshot.source_id, snapshot.from_entry);
        auto family = std::find_if(families.begin(), families.end(),
            [&](const Family& value) { return value.key == key; });
        if (family == families.end()) {
            Family next;
            next.key = key;
            next.command_sequence = snapshot.command_sequence;
            next.rank = exit_queue_rank(placement_, snapshot);
            next.percent = std::isfinite(snapshot.qty_percent)
                ? std::clamp(snapshot.qty_percent, 0.0, 100.0) : 100.0;
            next.existing = snapshot.projection_remaining_qty;
            next.explicit_requested = snapshot.requested_qty;
            next.delayed.push_back(index);
            next.origins.push_back(snapshot.bracket_origin.incarnation);
            families.push_back(std::move(next));
        } else {
            family->command_sequence = std::min(family->command_sequence,
                                                snapshot.command_sequence);
            family->rank = std::min(family->rank, exit_queue_rank(placement_, snapshot));
            family->delayed.push_back(index);
            if (std::isfinite(snapshot.projection_remaining_qty)) {
                family->existing = std::isfinite(family->existing)
                    ? std::max(family->existing, snapshot.projection_remaining_qty)
                    : snapshot.projection_remaining_qty;
            }
            if (std::isfinite(snapshot.requested_qty))
                family->explicit_requested = snapshot.requested_qty;
            if (std::find(family->origins.begin(), family->origins.end(),
                          snapshot.bracket_origin.incarnation) == family->origins.end()) {
                family->origins.push_back(snapshot.bracket_origin.incarnation);
            }
        }
    }
    // The live position goes to the exits in their queue order
    // (exit_queue_rank), each taking what the ones before it leave.
    std::stable_sort(families.begin(), families.end(),
        [](const Family& left, const Family& right) {
            if (left.rank != right.rank) return left.rank < right.rank;
            return left.command_sequence < right.command_sequence;
        });
 
    double reserved = 0.0;
    std::vector<native_order::RequestHandle> cancel;
    for (const auto& family : families) {
        const double available = std::max(0.0, live_basis - reserved);
        double units = 0.0;
        if (std::isfinite(family.explicit_requested)) {
            // An explicit strategy.exit quantity belongs to each bound entry
            // instance. Opening a later same-id parent adds another leg; it
            // must not turn every existing one-unit leg into a percentage of
            // the enlarged net position (ab9714be:pine_strategy_commands.cpp
            // :2739-2811 and test_exit_bracket_pending_entry_leg).
            units = std::min(std::abs(family.explicit_requested), available);
        } else if (family.percent < 100.0 - internal::kFullPercentEps
            && std::isfinite(family.existing)) {
            units = std::min(family.existing, available);
        } else {
            // ab9714be pine_fills.cpp:6893-6896: a reservation percentage
            // inside kFullPercentEps of 100 is a FULL exit, so it owns the
            // exact live exposure. Recomputing `live_basis * 100 / 100` can
            // land one binary64 step low and strand a sub-lot dust remainder
            // that never flattens (ab9714be pine_fills.cpp:1618 spells the
            // same whole-position coverage as `qty - kQtyEpsilon`).
            double requested = family.percent >= 100.0 - internal::kFullPercentEps
                ? live_basis : live_basis * family.percent / 100.0;
            if (family.percent < 100.0 - internal::kFullPercentEps) {
                requested = quantize_percent_exit_units(requested, available);
            }
            units = std::min(requested, available);
        }
        if (!(units > internal::kQtyEpsilon)) {
            cancel.insert(cancel.end(), family.handles.begin(), family.handles.end());
            for (const auto index : family.queued) {
                if (index < pending_bracket_legs_.size())
                    pending_bracket_legs_[index].snapshot.qty_percent = 0.0;
            }
            for (const auto index : family.delayed) {
                if (index < delayed_market_orders_.size())
                    delayed_market_orders_[index].snapshot.qty_percent = 0.0;
            }
            continue;
        }
        const double normalized_percent = units / live_basis * 100.0;
        for (const auto& handle : family.handles) {
            const auto found = placement_.find(handle.incarnation);
            if (found == placement_.end()) continue;
            found->second.projection_remaining_qty = units;
            found->second.qty_percent = normalized_percent;
            found->second.fixed_exit_reservation =
                std::isfinite(family.explicit_requested)
                || family.percent < 100.0 - internal::kFullPercentEps
                || std::isfinite(family.existing);
            found->second.reservation_deferred_to_pending_entry = false;
        }
        for (const auto index : family.queued) {
            if (index >= pending_bracket_legs_.size()) continue;
            auto& snapshot = pending_bracket_legs_[index].snapshot;
            snapshot.projection_remaining_qty = units;
            snapshot.qty_percent = normalized_percent;
            snapshot.fixed_exit_reservation =
                std::isfinite(family.explicit_requested)
                || family.percent < 100.0 - internal::kFullPercentEps
                || std::isfinite(family.existing);
            snapshot.reservation_deferred_to_pending_entry = false;
        }
        for (const auto index : family.delayed) {
            if (index >= delayed_market_orders_.size()) continue;
            auto& snapshot = delayed_market_orders_[index].snapshot;
            snapshot.projection_remaining_qty = units;
            snapshot.qty_percent = normalized_percent;
            snapshot.fixed_exit_reservation =
                std::isfinite(family.explicit_requested)
                || family.percent < 100.0 - internal::kFullPercentEps
                || std::isfinite(family.existing);
            snapshot.reservation_deferred_to_pending_entry = false;
        }
        // A limit/stop/trail OCA set for one opening consumes one reservation,
        // even though it has multiple native request handles. Count distinct
        // bound entry origins, not executable sibling legs.
        const std::size_t multiplicity = std::max<std::size_t>(1, family.origins.size());
        reserved += std::isfinite(family.explicit_requested)
            ? std::min(available, units * static_cast<double>(multiplicity))
            : units;
    }
    for (const auto& handle : cancel) {
        const auto result = require_host().cancel(handle);
        if (result.status == native_order::CancelStatus::Cancelled) retire(handle);
    }
    pending_write(pending_bracket_legs_).erase(
        std::remove_if(pending_bracket_legs_.begin(), pending_bracket_legs_.end(),
            [](const PendingBracketLeg& leg) {
                return leg.snapshot.qty_percent == 0.0;
            }),
        pending_bracket_legs_.end());
}
 
// A margin call shrinks the position under its exits without filling any of
// them. TradingView keeps each percentage exit's reserved share and hands the
// position to the exits in their queue order again, each taking what the ones
// before it leave (lane TAIL-H rule PK, tapes tailh-d2a / tailh-d2b): with 8
// of 25 contracts left, a 50 % exit created first holds all 8 of its 12 and
// the stop exit created after it, left nothing, never fires.
void PineExecutionAdapter::reconcile_exit_reservations_after_margin() {
    std::vector<SourceId> entries;
    const auto note = [&](const PlacementSnapshot& snapshot) {
        const bool exit = snapshot.family == PineOrderFamily::ExitLimit
            || snapshot.family == PineOrderFamily::ExitStop
            || snapshot.family == PineOrderFamily::ExitTrail;
        if (!exit || snapshot.void_issue) return;
        if (std::find(entries.begin(), entries.end(), snapshot.from_entry) == entries.end())
            entries.push_back(snapshot.from_entry);
    };
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found != placement_.end()) note(found->second);
    }
    for (const auto& pending : pending_bracket_legs_) note(pending.snapshot);
    for (const auto& delayed : delayed_market_orders_) note(delayed.snapshot);
    if (entries.empty()) return;
    const double physical = std::abs(detail::run_position(require_host()).signed_units);
    for (const auto& entry : entries) {
        const double exposure = entry.empty() ? physical : cohort_exposure_for(entry);
        if (exposure > internal::kQtyEpsilon)
            reconcile_deferred_exit_reservations(entry, exposure);
    }
}
 
// The account FX in force at an instant is the kernel's lookup: the staged
// scalar and series are the engine's own (staged_configuration copies them at
// begin), validated positive and finite by their setters.
double PineExecutionAdapter::active_staged_fx(std::int64_t timestamp_ms) const noexcept {
    const auto* pine = pine_view_of(host_);
    return pine ? pine->account_currency_fx_at(timestamp_ms) : staged_.account_fx;
}
 
// TradingView revalues a carried position at the first broker open under a new
// account FX rate (ab9714be pine_fills.cpp:830-1000, the TV-pinned 1x long
// row; test_affordability_fx G, G2, NEW-S1): its money at the OPEN price, its
// lot-floored 4x restore, executed at the open before any resting order sees
// the bar -- exactly the open checkpoint submit_margin_call_slice takes, at the
// position side's own margin (the margin and cancellation comparison: that formula was always per-side,
// ab9714be's leveraged cells were only switched off). A survivor that is not a
// 1x long is then checked over the rest of the bar by the kernel's liquidation
// (on_applied re-schedules the path). The kernel's own FxRoll point is not
// this checkpoint -- see margin_check_allowed.
void PineExecutionAdapter::apply_fx_open_margin_slice(
        const Bar& bar, const NativeDecisionContext& context) {
    const double rate = active_staged_fx(context.sub_bar_open_ms);
    const double prior = last_fx_rate_;
    last_fx_rate_ = rate;
    if (!std::isfinite(prior) || prior == rate) return;
    const auto position = detail::run_position(require_host());
    if (position.signed_units == 0.0
        || position_open_script_bar_ >= context.script_bar_open_ms) return;
    (void)submit_margin_call_slice(bar.open, context);
}
 
void PineExecutionAdapter::apply_fx_opening_margin_slice(
        const native_order::ExecutionAppliedEvent& event,
        const NativeDecisionContext& context) {
    // A percentage-commission percent-of-equity configuration only: any other
    // returns before the row is copied (every fill asks).
    if (config_.default_qty_type != static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        || config_.commission_type != static_cast<int>(CommissionType::PERCENT)
        || !(config_.commission_value > 0.0)) {
        return;
    }
    std::optional<PlacementSnapshot> opening_snapshot;
    if (const auto found = placement_.find(event.handle().incarnation);
        found != placement_.end()) {
        opening_snapshot = found->second;
    }
    if (!opening_snapshot || !opening_snapshot->opening
        || opening_snapshot->family != PineOrderFamily::Entry
        || !finite_positive(opening_snapshot->sizing.frozen_units)
        || config_.default_qty_type != static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        || config_.commission_type != static_cast<int>(CommissionType::PERCENT)
        || !(config_.commission_value > 0.0)) {
        return;
    }
    const double rate = active_staged_fx(context.sub_bar_open_ms);
    if (!std::isfinite(opening_snapshot->sizing.fx) || opening_snapshot->sizing.fx == rate) return;
    // The FX twin of on_applied's opening checkpoint (a full-margin opening
    // whose rate moved between its signal and its fill): the same TradingView
    // money and slice at the fill, settled at the same current coordinate
    // before the next candidate (A31(b)).
    const auto position = detail::run_position(require_host());
    if ((position.signed_units > 0.0 ? config_.margin_long : config_.margin_short) != 100.0) {
        return;
    }
    (void)submit_margin_call_slice(event.resolved_price, context, true);
}
 
// Whether on_applied admits the kernel's post-fill point on a leveraged
// opening's entry bar: the run shapes ab9714be took the entry-bar suffix on
// (pine_fills.cpp:1014-1023), and process_orders_on_close and
// calc_on_order_fills, where TradingView books the same call on the same bar
// (the intrabar margin correction: tests/fixtures/margin_entry_bar/pm2-m7-coof-* and
// pm2-m7-poocl-*). Not a timestamped-FX run, whose path checks on_bar_open
// does not schedule either, nor a magnified one, whose later samples the
// kernel's IntrabarSample point checks (intrabar_sample_checked).
bool PineExecutionAdapter::leveraged_entry_bar_checked() const noexcept {
    return !bar_magnifier_ && staged_.account_fx_effective_from_ms.empty();
}
 
// The opening schedule_preopen_margin_slice answers for: a default-percent
// stop entry taken at its bar's open. That slice sizes its entry-bar call on
// the entry's frozen units, and its verdict -- a slice, or none -- stands for
// the bar; the kernel's post-fill point is not admitted beside it.
bool PineExecutionAdapter::preopen_slice_class(
        const PlacementSnapshot& opening, const NativeDecisionContext& context) const noexcept {
    return config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        && opening.family == PineOrderFamily::Entry
        && finite_positive(opening.sizing.frozen_units)
        && finite_positive(opening.exit_levels.stop)
        && context.coordinate.path_phase == NativePathPhase::Open;
}
 
void PineExecutionAdapter::schedule_preopen_margin_slice(
        const Bar& bar, const NativeDecisionContext& context) {
    // The legacy broker checks the adverse excursion of a default-percent
    // stop entry's fill bar after the opening is admitted.  Submit its
    // source-owned close leg at the preceding open: BindCohort resolves only
    // after that opening applies, then the ordinary native path matches the
    // adverse waypoint in the same bar.  This keeps the liquidation policy
    // entirely above the generic driver.
    if (!source_margin_call_enabled_
        || detail::run_position(require_host()).signed_units != 0.0
        || config_.default_qty_type != static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        || !finite_positive(staged_.syminfo.pointvalue)
        || !finite_positive(staged_.syminfo.mintick)
        || !finite_positive(bar.open)) {
        return;
    }
 
    // A pre-open margin submission can append to live_handles_ and insert
    // into placement_; scan value copies rather than retaining either
    // container's elements across submit_or_replace.
    const auto live_handles = live_handles_;
    for (const auto& handle : live_handles) {
        std::optional<PlacementSnapshot> opening_copy;
        if (const auto found = placement_.find(handle.incarnation);
            found != placement_.end()) {
            opening_copy = found->second;
        }
        if (!opening_copy) continue;
        const PlacementSnapshot& opening = *opening_copy;
        if (!opening.opening || opening.family != PineOrderFamily::Entry
            || !finite_positive(opening.sizing.frozen_units)
            || !finite_positive(opening.exit_levels.stop)) {
            continue;
        }
        const bool marketable = opening.is_long
            ? opening.exit_levels.stop <= bar.open
            : opening.exit_levels.stop >= bar.open;
        if (!marketable) continue;
 
        const double entry = nearest_tick(bar.open, staged_.syminfo.mintick);
        const double adverse_raw = opening.is_long ? bar.low : bar.high;
        const double adverse = nearest_tick(adverse_raw, staged_.syminfo.mintick);
        if (!finite_positive(entry) || !finite_positive(adverse)
            || (opening.is_long ? !(adverse < entry) : !(adverse > entry))) {
            continue;
        }
        const double fx = active_staged_fx(context.sub_bar_open_ms);
        const double margin = opening.is_long ? config_.margin_long : config_.margin_short;
        if (!finite_positive(fx) || !finite_positive(margin)) continue;
        const double units = opening.sizing.frozen_units;
        // Owner sequencing: the source broker evaluates the adverse excursion
        // only AFTER the opening is admitted, and an all-in marketable stop
        // entry that cannot be funded at its own fill price is declined there
        // (ab9714be src/source/pine_fills.cpp:4618
        // stop_entry_margin_admission_declines consumes the fill at :4741:
        // required = qty * round_to_mintick(fill) * pointvalue * fx * margin,
        // refused when it exceeds realized equity plus the same
        // max(1e-9, |equity|*1e-12) guard; a gap-through fill price is the
        // rounded open).  Arming the deferred close for such a candidate
        // leaves a stale Reduce that a LATER bar's different opening matches:
        // A synthetic OANDA:XAUUSD example sizes 3.20 units against
        // equity 8000.00, costs 3.20 * 2501.00 = 8003.20 at
        // the open, so the owner never opens there -- its all-in long fills on
        // the next open (3.19 * 2502.00 = 7981.38) as ONE lot.  A synthetic
        // ETH feed's admitted all-in short (4.00 * 2000.00 against
        // equity 8000.00, cost 8000.00) keeps its legitimate
        // same-bar slice.
        const double admission_cost = units * entry * staged_.syminfo.pointvalue
            * fx * margin / 100.0;
        const double admission_guard = std::max(
            1e-9, std::abs(opening.sizing.equity) * 1e-12);
        if (!std::isfinite(admission_cost)
            || admission_cost > opening.sizing.equity + admission_guard) {
            continue;
        }
        const double unrealized = (opening.is_long ? adverse - entry : entry - adverse)
            * units * staged_.syminfo.pointvalue * fx;
        const double marked_equity = opening.sizing.equity + unrealized;
        const double required = units * adverse * staged_.syminfo.pointvalue * fx
            * margin / 100.0;
        const double unit_margin = adverse * staged_.syminfo.pointvalue * fx
            * margin / 100.0;
        if (!std::isfinite(marked_equity) || !std::isfinite(required)
            || !finite_positive(unit_margin) || !(required > marked_equity)) {
            continue;
        }
        // TradingView's slice from this money is the shared rule
        // (source_margin_units: the lot-floored restore taken four times and
        // floored again, the one-contract band, the dust gates), sized here
        // on the frozen signal-time units the opening will book.
        SourceMarginMoney money;
        money.valid = true;
        money.mark = adverse;
        money.held = units;
        money.unit_margin = unit_margin;
        money.exact_required = required;
        money.required = required;
        money.equity = marked_equity;
        const double slice = source_margin_units(money, /*opening_checkpoint=*/false);
        if (!finite_positive(slice)) continue;
 
        native_order::Request request;
        request.intent = native_order::HostSized{native_order::HostSizedKind::Close, std::nullopt};
        request.label = "__margin_preopen__" + opening.source_id;
        request.comment = "Margin call";
        // Preserve the exact source adverse waypoint as the generic trigger;
        // terms rounds its resulting fill by the source tick rule.
        request.trigger = native_order::Stop{adverse_raw};
        request.owner = native_order::BindCohort{cohort_for(opening.source_id)};
        PlacementSnapshot snapshot;
        snapshot.family = PineOrderFamily::Margin;
        snapshot.source_id = request.label;
        snapshot.from_entry = opening.source_id;
        snapshot.comment = request.comment;
        snapshot.requested_qty = slice;
        snapshot.sizing = opening.sizing;
        (void)submit_or_replace(std::move(request), std::move(snapshot), false,
                                "__margin_preopen__" + opening.source_id);
        // The source stop-entry row is unique under this pre-open condition;
        // a second candidate belongs to a later source evaluation.
        return;
    }
}
 
void PineExecutionAdapter::consume_cohort_units(
        const SourceId& id, const native_order::ExecutionAppliedEvent& event) {
    if (!(event.closed_units > 0.0) || !std::isfinite(event.closed_units)) return;
    observe_position_tail_rows(); // execute_current can expose rows before Applied
    const auto found = cohorts_by_id_.find(id);
    if (found == cohorts_by_id_.end()) return;
    auto& facts = found->second;
    std::vector<std::uint64_t> selected;
    if (const auto* opening = std::get_if<execution::OpeningExposure>(&event.scope)) {
        selected.push_back(opening->incarnation);
    } else if (const auto* openings = std::get_if<native_order::SelectedExposure>(&event.scope)) {
        selected = openings->incarnations;
    } else {
        for (const auto& handle : facts.opened) selected.push_back(handle.incarnation);
    }
    double remaining = event.closed_units;
    for (const auto incarnation : selected) {
        auto unit = facts.live_units_by_origin.find(incarnation);
        if (unit == facts.live_units_by_origin.end() || !(unit->second > 0.0)) continue;
        const double deduction = std::min(unit->second, remaining);
        unit->second -= deduction;
        remaining -= deduction;
        if (unit->second == 0.0) {
            facts.live_units_by_origin.erase(unit);
            if (position_tail_summary_) position_tail_summary_->retire_origin(incarnation);
        }
        if (!(remaining > 0.0)) break;
    }
    if (position_tail_summary_)
        position_tail_summary_->live_cohort(&*found, !facts.live_units_by_origin.empty());
    cohorts_by_id_.refresh_held(found);
    ::pineforge::detail::release_empty_exposure_capacity(facts.live_units_by_origin);
}
 
void PineExecutionAdapter::consume_closed_trade_rows(
        const native_order::ExecutionAppliedEvent& event,
        const PlacementSnapshot* cause) {
    observe_position_tail_rows();
    auto& host = require_host();
    const auto settle_slot = [&](CohortFacts& cohort, const Trade& trade,
                                 bool drained) {
        ::pineforge::detail::release_empty_exposure_capacity(cohort.live_units_by_origin);
        if (!cause) return;
        const bool bracket = cause->family == PineOrderFamily::ExitLimit
            || cause->family == PineOrderFamily::ExitStop
            || cause->family == PineOrderFamily::ExitTrail;
        const bool close_path = cause->family == PineOrderFamily::Close
            || cause->family == PineOrderFamily::CloseAll
            || cause->family == PineOrderFamily::Risk
            || cause->family == PineOrderFamily::Margin
            || cause->family == PineOrderFamily::Entry
            || cause->family == PineOrderFamily::Order;
        const bool exact_bracket_owner = cause->bracket_origin.incarnation != 0
            ? cause->bracket_origin.incarnation == trade.entry_incarnation
            : cause->from_entry == trade.entry_id;
        if (bracket && !exact_bracket_owner)
            bracket_shadowed_openings_.insert(trade.entry_incarnation);
        if (!drained) return;
        const bool owned_bracket = bracket && exact_bracket_owner
            && bracket_shadowed_openings_.find(trade.entry_incarnation)
                == bracket_shadowed_openings_.end();
        if (!close_path && !owned_bracket) return;
        const auto removed_at = std::remove_if(cohort.opened.begin(), cohort.opened.end(),
            [&](const auto& opening) {
                return opening.incarnation == trade.entry_incarnation;
            });
        const auto removed = static_cast<std::size_t>(
            std::distance(removed_at, cohort.opened.end()));
        cohort.opened.erase(removed_at, cohort.opened.end());
        assert(cohort_opened_slot_count_ >= removed);
        cohort_opened_slot_count_ -= removed;
        ::pineforge::detail::release_empty_exposure_capacity(cohort.opened);
        bracket_shadowed_openings_.erase(trade.entry_incarnation);
    };
    for (std::size_t row = 0; row < event.closed_trade_count; ++row) {
        const std::size_t index = event.first_trade_index + row;
        if (index >= static_cast<std::size_t>(host.trade_count())) continue;
        const Trade& trade = host.get_trade(static_cast<int>(index));
        double remaining = trade.qty;
        bool matched = false;
        const auto held = cohorts_by_id_.held_rows();
        for (auto at = held.begin(); at != held.end();) {
            const auto current = at++; // Removal below may erase the held node.
            auto& cohort = *current;
            auto units = cohort.second.live_units_by_origin.find(
                trade.entry_incarnation);
            if (units == cohort.second.live_units_by_origin.end()) continue;
            const double consumed = std::min(units->second, remaining);
            units->second -= consumed;
            remaining -= consumed;
            const bool drained = !(units->second > 1e-10);
            if (drained) {
                cohort.second.live_units_by_origin.erase(units);
                if (position_tail_summary_)
                    position_tail_summary_->retire_origin(trade.entry_incarnation);
            }
            if (position_tail_summary_)
                position_tail_summary_->live_cohort(
                    &cohort, !cohort.second.live_units_by_origin.empty());
            settle_slot(cohort.second, trade, drained);
            cohorts_by_id_.refresh_held(current);
            matched = true;
            break;
        }
        if (matched || !(remaining > 0.0)) continue;
        const auto cohort = cohorts_by_id_.find(trade.entry_id);
        if (cohort == cohorts_by_id_.end()) continue;
        // False once nothing remains to consume.
        const auto consume_origin = [&](std::uint64_t incarnation) {
            auto units = cohort->second.live_units_by_origin.find(incarnation);
            if (units == cohort->second.live_units_by_origin.end()) return true;
            const double consumed = std::min(units->second, remaining);
            units->second -= consumed;
            remaining -= consumed;
            const bool drained = !(units->second > 1e-10);
            if (drained) {
                cohort->second.live_units_by_origin.erase(units);
                if (position_tail_summary_) position_tail_summary_->retire_origin(incarnation);
            }
            if (position_tail_summary_)
                position_tail_summary_->live_cohort(
                    &*cohort, !cohort->second.live_units_by_origin.empty());
            settle_slot(cohort->second, trade, drained);
            cohorts_by_id_.refresh_held(cohort);
            return remaining > 0.0;
        };
        auto* lookup = cohort->second.origins.size() <= kIndexedFrom ? nullptr
            : adapter_lookup_index(bound_consumer(), this, run_counter_);
        if (!lookup) {
            for (const auto& origin : cohort->second.origins)
                if (!consume_origin(origin.incarnation)) break;
            continue;
        }
        // The walk above consumes only at a roster position whose origin
        // still has a unit row, and each such origin only at its first
        // position: after consuming there, its row is gone (drained) or
        // nothing remains. So visit exactly those first positions, ascending,
        // which the roster's position index names without walking the id's
        // whole history.
        std::vector<std::pair<std::size_t, std::uint64_t>> carrying;
        carrying.reserve(cohort->second.live_units_by_origin.size());
        for (const auto& unit : cohort->second.live_units_by_origin) {
            // Empty only after a push_back that failed to allocate: no roster
            // entry carries the incarnation, so the walk never visits it.
            const auto* positions = cohort->second.origins.positions_of(unit.first);
            if (positions && !positions->empty())
                carrying.emplace_back(positions->front(), unit.first);
        }
        std::sort(carrying.begin(), carrying.end());
        ++lookup->answers;
        PINEFORGE_LOOKUP_INDEX_WORK("closed_trade_origin_answer", this, run_counter_, 1);
        for (const auto& origin : carrying)
            if (!consume_origin(origin.second)) break;
    }
}
 
bool PineExecutionAdapter::origin_is_pending(
        const native_order::RequestHandle& origin) const noexcept {
    if (origin.incarnation == 0) return false;
    // Live first: a live handle's row is always held.
    if (std::find(live_handles_.begin(), live_handles_.end(), origin) == live_handles_.end())
        return false;
    const auto placement = placement_.find(origin.incarnation);
    return placement != placement_.end() && placement->second.opening;
}
 
std::vector<std::size_t> PineExecutionAdapter::live_origin_positions(
        const CohortFacts& cohort) const {
    std::vector<std::size_t> positions;
    for (const auto& handle : live_handles_) cohort.origins.append_positions_of(handle, positions);
    std::sort(positions.rbegin(), positions.rend());
    positions.erase(std::unique(positions.begin(), positions.end()), positions.end());
    return positions;
}
 
void PineExecutionAdapter::cancel_bracket_origin(native_order::RequestHandle origin) {
    pending_write(pending_bracket_legs_).erase(std::remove_if(pending_bracket_legs_.begin(), pending_bracket_legs_.end(),
        [&](const PendingBracketLeg& leg) { return leg.snapshot.bracket_origin == origin; }),
        pending_bracket_legs_.end());
    std::vector<native_order::RequestHandle> matches;
    for (const auto& handle : live_handles_) {
        const auto placement = placement_.find(handle.incarnation);
        if (placement != placement_.end() && placement->second.bracket_origin == origin)
            matches.push_back(handle);
    }
    for (const auto& handle : matches) {
        const auto result = require_host().cancel(handle);
        if (result.status == native_order::CancelStatus::Cancelled) {
            if (const auto placement = placement_.find(handle.incarnation);
                placement != placement_.end()) {
                placement->second.cancellation = {PineCancellationCause::Explicit, 1, 0,
                    handle.incarnation, static_cast<std::int64_t>(placement->second.source_sequence),
                    handle.incarnation, placement->second.placement_cycle,
                    placement->second.legs.revision(), placement->second.requested_qty, kNaN};
            }
            retire(handle);
        }
    }
}
 
void PineExecutionAdapter::cancel_bracket_siblings(native_order::RequestHandle handle,
                                                   std::uint64_t executed_at) {
    // Only an exit leg has siblings: any other row is answered before it is
    // copied (every fill asks).
    std::optional<PlacementSnapshot> snapshot_copy;
    if (const auto source = placement_.find(handle.incarnation);
        source != placement_.end()) {
        const auto family = source->second.family;
        if (family != PineOrderFamily::ExitLimit && family != PineOrderFamily::ExitStop
            && family != PineOrderFamily::ExitTrail) return;
        snapshot_copy = source->second;
    }
    if (!snapshot_copy) return;
    const PlacementSnapshot& snapshot = *snapshot_copy;
    std::vector<native_order::RequestHandle> matches;
    for (const auto& candidate : live_handles_) {
        if (candidate == handle) continue;
        const auto placement = placement_.find(candidate.incarnation);
        if (placement == placement_.end()) continue;
        const auto& sibling = placement->second;
        if (sibling.source_id == snapshot.source_id && sibling.from_entry == snapshot.from_entry
            && sibling.bracket_origin == snapshot.bracket_origin
            && (sibling.family == PineOrderFamily::ExitLimit || sibling.family == PineOrderFamily::ExitStop
                || sibling.family == PineOrderFamily::ExitTrail)) {
            matches.push_back(candidate);
        }
    }
    // The terminal-receipt integration: a terminal receipt is observed at the adapter's next
    // read, not when its leg executed. A bracket leg the pre-script drain
    // settles on its parent's touch bar is read at the next bar open, after
    // that bar's source body and its process_orders_on_close pass; by then a
    // same-bar re-entry the close already reached has opened (PAR-ORDERS,
    // H-MEASURE 6b) and its own strategy.exit legs of the same id are
    // working. A leg of a later strategy.exit call (another command_sequence)
    // that the kernel accepted after the execution is that later order, not a
    // sibling of the leg that filled, and it stays. A leg of the filled leg's
    // own call is its sibling however late it was accepted -- the drain
    // submits a bracket's legs one at a time, executing each -- and goes.
    const auto later_call = [&](const native_order::RequestHandle& sibling) {
        const auto placement = placement_.find(sibling.incarnation);
        return placement != placement_.end()
            && placement->second.command_sequence != snapshot.command_sequence;
    };
    if (executed_at != 0 && std::any_of(matches.begin(), matches.end(), later_call)) {
        const auto working = require_host().native_working_requests();
        matches.erase(std::remove_if(matches.begin(), matches.end(),
            [&](const native_order::RequestHandle& sibling) {
                if (!later_call(sibling)) return false;
                const auto row = std::find_if(working.begin(), working.end(),
                    [&](const NativeWorkingRequest& request) {
                        return request.definition->handle == sibling;
                    });
                return row != working.end()
                    && row->definition->birth.acceptance_ordinal > executed_at;
            }), matches.end());
    }
    for (const auto& sibling : matches) {
        const auto result = require_host().cancel(sibling);
        if (result.status == native_order::CancelStatus::Cancelled) retire(sibling);
    }
}
 
void PineExecutionAdapter::cancel_exit_orders_for_full_close(
        const SourceId& from_entry) {
    const auto text = detail::exit_scratch_text(from_entry);
    cancel_exit_orders_for_full_close(text);
}
 
void PineExecutionAdapter::cancel_exit_orders_for_full_close(
        const detail::ScratchByteSource& from_entry) {
    // An exit bound to the id while it held no lot waits for the id's next
    // fill: a close of the id, or of the position, has nothing of it to close
    // (tests/fixtures/exit_binding close-pending-id, cancel-flat-replace).
    const bool keep_pending_bound =
        detail::exit_binding_rule_switches().pending_bound_exit_survives_flat;
    const auto matches = [&](const PlacementSnapshot& snapshot) {
        const bool exit = snapshot.family == PineOrderFamily::ExitLimit
            || snapshot.family == PineOrderFamily::ExitStop
            || snapshot.family == PineOrderFamily::ExitTrail;
        return exit && !(keep_pending_bound && snapshot.pending_bound_exit)
            && detail::exit_scratch_equal(detail::exit_scratch_text(snapshot.from_entry),
                                           from_entry);
    };
    pending_write(pending_bracket_legs_).erase(
        std::remove_if(pending_bracket_legs_.begin(), pending_bracket_legs_.end(),
            [&](const PendingBracketLeg& row) { return matches(row.snapshot); }),
        pending_bracket_legs_.end());
    pending_write(pending_coof_requests_).erase(
        std::remove_if(pending_coof_requests_.begin(), pending_coof_requests_.end(),
            [&](const PendingCoofRequest& row) { return matches(row.snapshot); }),
        pending_coof_requests_.end());
    pending_write(source_shadow_pending_).erase(
        std::remove_if(source_shadow_pending_.begin(), source_shadow_pending_.end(),
            [&](const SourceShadowPending& row) { return matches(row.snapshot); }),
        source_shadow_pending_.end());
    pending_relative_exits_.erase(
        std::remove_if(pending_relative_exits_.begin(), pending_relative_exits_.end(),
            [&](const PendingRelativeExit& row) {
                return detail::exit_scratch_equal(detail::exit_scratch_text(row.from_entry),
                                                   from_entry);
            }),
        pending_relative_exits_.end());
    if (from_entry.size() != 0) withdraw_anchored_relative_readers(nullptr, &from_entry);
 
    detail::ExitScratchRows<native_order::RequestHandle> handles(*this);
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found != placement_.end() && matches(found->second)
            && !coof_leg_reaches_exit(found->second)) {
            handles.push_back(handle);
        }
    }
    for (const auto& handle : handles) {
        const auto result = require_host().cancel(handle);
        if (result.status == native_order::CancelStatus::Cancelled) retire(handle);
    }
    detail::ExitScratchIndex removed(handles.context());
    for (const auto& handle : handles) removed.put(handle.incarnation, 0);
    const BracketRoster::RemovalSelection selection(handles);
    for (auto family = bracket_families_.begin(); family != bracket_families_.end();) {
        if (!handles.empty()) family->second.remove_selected(
            removed, handles.context().run, selection,
            fixture_bracket_remove_precheck_);
        if (family->second.empty()) family = bracket_families_.erase(family);
        else ++family;
    }
    refresh_pending_view();
}
 
// ab9714be pine_fills.cpp:7461-7468: while the book is flat, an EXIT whose
// ``created_position_side`` is not FLAT is Removed outright and never Skipped
// — a bracket armed against a position that has since closed does not survive
// the flat.  pine_fills.cpp:7667-7675 gives the reason and the second half of
// the rule: an EXIT whose ``from_entry`` has not filled in the CURRENT
// position cycle is Removed as well, and ``cycle_filled_entry_ids_`` is
// cleared the moment the book goes flat, so a stale bracket must not fire
// later against a FUTURE position reusing the same entry id.  A retired
// candidate row keeps its lifecycle, so ``revive_brackets_after_margin`` can
// resurrect the dormant leg the moment the reused id regains exposure, and a
// still-live leg can fill against the reversal's fresh lot on the same bar.
// Removing both the book entry and the lifecycle restores the legacy rule.
// The lifecycle half is the position-cycle filter at the top of
// ``revive_brackets_after_margin`` (pine_orders.cpp:597-608): a row parked by
// a finished cycle is never revived, so no walk over the whole placement
// history is needed here -- one per flat made a long run quadratic.
//
// Both legacy Removes are LAZY per-broker-point eligibility checks that walk
// the pending queue once in ``created_seq`` order, not an eager sweep.  An
// exit placed on the SAME script bar as the flattening close and BEHIND it in
// command order — the close's paired reversal entry sits between the two
// (pine_fills.cpp:8013-8018) — is therefore only reached once that entry has
// filled and repopulated ``cycle_filled_entry_ids_`` for the new cycle, so
// neither Remove applies to it and it stays armed for the fresh lot.  A
// bracket placed on any EARLIER bar was reached while the retiring cycle was
// still the live one, with its ``from_entry`` absent from that cycle's filled
// set, and was Removed there.  ``paired_close`` carries the same-bar close
// that defines the boundary; a null pointer keeps the unrestricted
// preservation the transient-flat cleanup at the end of a close relies on.
void PineExecutionAdapter::retire_in_position_exits_at_flat(
        bool preserve_pending_parents, bool dormant_rows_only,
        const PlacementSnapshot* paired_close) {
    // A transient flat between two same-point reversal transactions does not
    // end the pending parent's lifecycle, so the parent's own brackets are
    // kept (the same exclusion the flat cleanup below applies per owner).
    // A batched strategy.close takes its command sequence when the batch
    // flushes, after the commands its calculation placed behind it, so the
    // bracket that follows the close's paired entry -- the one that opens the
    // other side -- in that calculation is also behind the close: TradingView
    // fills it for the entry (lab tv w4-f14-pooc-pct50 cell F, w4-f08-plain
    // cell H; lane W4-ENG-POOC-SAMEPASS).
    const auto pending_parent = [&](const PlacementSnapshot& row) {
        if (!preserve_pending_parents || row.from_entry.empty()) return false;
        if (paired_close != nullptr
            && row.projection_created_bar != paired_close->projection_created_bar) {
            return false;
        }
        const SourceId& owner = row.from_entry;
        const auto admits = [&](const PlacementSnapshot& parent) {
            return paired_close == nullptr
                || row.command_sequence > paired_close->command_sequence
                || (parent.projection_created_bar == row.projection_created_bar
                    && row.command_sequence > parent.command_sequence
                    && paired_close->projection_position_side
                        == static_cast<std::int32_t>(parent.is_long ? PositionSide::SHORT
                                                                    : PositionSide::LONG));
        };
        for (const auto& handle : live_handles_) {
            const auto found = placement_.find(handle.incarnation);
            if (found != placement_.end() && found->second.opening
                && found->second.family == PineOrderFamily::Entry
                && found->second.source_id == owner && admits(found->second)) {
                return true;
            }
        }
        return std::any_of(pending_entries_.begin(), pending_entries_.end(),
            [&](const PendingEntry& entry) {
                return entry.snapshot.opening && entry.snapshot.source_id == owner
                    && admits(entry.snapshot);
            });
    };
    // An exit bound to its entry id while that id's order worked is not an
    // exit of the position the flat ends: TradingView keeps it for the id's
    // next fill, whatever bar it was called on and whether an order of the id
    // still works now (tests/fixtures/exit_binding).
    const bool keep_pending_bound =
        detail::exit_binding_rule_switches().pending_bound_exit_survives_flat;
    const auto matches = [&](const PlacementSnapshot& snapshot) {
        const bool exit = snapshot.family == PineOrderFamily::ExitLimit
            || snapshot.family == PineOrderFamily::ExitStop
            || snapshot.family == PineOrderFamily::ExitTrail;
        return exit
            && static_cast<PositionSide>(snapshot.projection_position_side)
                   != PositionSide::FLAT
            && !(keep_pending_bound && snapshot.pending_bound_exit)
            && !pending_parent(snapshot);
    };
    if (!dormant_rows_only) {
        pending_write(pending_bracket_legs_).erase(
            std::remove_if(pending_bracket_legs_.begin(), pending_bracket_legs_.end(),
                [&](const PendingBracketLeg& row) { return matches(row.snapshot); }),
            pending_bracket_legs_.end());
        pending_write(pending_coof_requests_).erase(
            std::remove_if(pending_coof_requests_.begin(), pending_coof_requests_.end(),
                [&](const PendingCoofRequest& row) { return matches(row.snapshot); }),
            pending_coof_requests_.end());
        pending_write(source_shadow_pending_).erase(
            std::remove_if(source_shadow_pending_.begin(), source_shadow_pending_.end(),
                [&](const SourceShadowPending& row) { return matches(row.snapshot); }),
            source_shadow_pending_.end());
    }
 
    std::vector<native_order::RequestHandle> handles;
    if (!dormant_rows_only) {
        for (const auto& handle : live_handles_) {
            const auto found = placement_.find(handle.incarnation);
            if (found != placement_.end() && matches(found->second))
                handles.push_back(handle);
        }
        for (const auto& handle : handles) {
            const auto result = require_host().cancel(handle);
            if (result.status == native_order::CancelStatus::Cancelled) retire(handle);
        }
        for (auto family = bracket_families_.begin(); family != bracket_families_.end();) {
            family->second.remove_all(handles);
            if (family->second.empty()) family = bracket_families_.erase(family);
            else ++family;
        }
    }
    refresh_pending_view();
}
 
// R4-D L10z review fix 6: the exit's placement row is selected by the
// (exit id, from_entry) pair, so two exits sharing a source id over different
// entries no longer tie-break on the wrong command sequence.  The pair-less
// minimum is kept as a documented fallback for a re-issued exit whose row was
// bound to no entry (it preserves the historical ordering of those rows);
// UINT64_MAX is returned only when the exit id has no placement row at all.
// ab9714be pine_fills.cpp:664-670: candidate exit fills tie-break by order creation sequence created_seq
std::uint64_t PineExecutionAdapter::command_sequence_for_exit(
        const SourceId& exit_id, const SourceId& from_entry) const {
    // The same-bar exit sort asks this on every script bar while its tail
    // group persists; the table scans retained placements and consults the
    // historical minima for erased rows.
    return placement_.command_sequence_for(exit_id, from_entry);
}
 
std::uint8_t PineExecutionAdapter::exit_phase_value(std::size_t trade_index) const {
    const std::size_t base = host_ ? detail::run_consumer(*host_).closed_trade_prefix().base : 0;
    if (trade_index < base)
        throw coded<std::logic_error>(RunFailureCode::engine_invariant, {},
                                       "exit-phase read precedes the sealed prefix");
    return trade_index - base < trade_exit_phase_.size()
        ? trade_exit_phase_[trade_index - base] : static_cast<std::uint8_t>(NativePathPhase::None);
}
 
bool PineExecutionAdapter::is_open_phase_exit(std::size_t trade_index) const {
    return exit_phase_value(trade_index) == static_cast<std::uint8_t>(NativePathPhase::Open);
}
 
void PineExecutionAdapter::permute_exit_phases(std::size_t start,
                                               const std::vector<std::size_t>& indices) {
    permute_exit_phase_rows(start, indices.size(),
                           [&](std::size_t i) { return indices[i]; });
}
 
void PineExecutionAdapter::permute_exit_phase_rows(
        std::size_t start, std::size_t count,
        const std::function<std::size_t(std::size_t)>& source_at) {
    // Tests use this permutation seam, including amendments which leave the
    // closed-row count unchanged. Production same-bar sorts and global-child
    // re-cuts read exit_phase_value and write set_exit_phase directly.
    if (position_tail_summary_)
        position_tail_summary_->invalidate(PositionTailGuard::Amendment,
                                           PINEFORGE_POSITION_TAIL_DIAGNOSTICS{});
    const auto none = static_cast<std::uint8_t>(NativePathPhase::None);
    const std::size_t base = host_ ? detail::run_consumer(*host_).closed_trade_prefix().base : 0;
    if (start < base)
        throw coded<std::logic_error>(RunFailureCode::engine_invariant, {},
                                       "exit-phase permutation precedes the sealed prefix");
    ::pineforge::detail::ScratchSequence<std::uint8_t> permuted;
    if (host_)
        permuted.set_directory(detail::run_consumer(*host_).report_scratch_directory(*host_));
    for (std::size_t i = 0; i < count; ++i) {
        const std::size_t index = source_at(i);
        if (index < base)
            throw coded<std::logic_error>(RunFailureCode::engine_invariant, {},
                                           "exit-phase read precedes the sealed prefix");
        permuted.push_back(index - base < trade_exit_phase_.size()
            ? trade_exit_phase_[index - base] : none);
    }
    for (std::size_t i = 0; i < permuted.size(); ++i) {
        const std::size_t target = start + i;
        if (target - base >= trade_exit_phase_.size() && permuted[i] == none) continue;
        set_exit_phase(target, permuted[i]);
    }
}
 
// TradingView orders the children of a strategy.exit that names no entry,
// when one path point triggers several, by the entry ids' place in a table
// that iterates as a java.util.HashMap<String, ?> keyed by String.hashCode
// spread as h ^ (h >>> 16) over power-of-two buckets: buckets ascending, the
// newest key first inside one. Its keys are every entry id from its first
// fill on, never removed, and one transient key per strategy.close /
// close_all order from the call to its fill (an entry order still waiting is
// no key); it starts at 16 buckets and doubles once the keys exceed 13/16 of
// them, never shrinking (127 TradingView tapes of synthetic scripts,
// tests/fixtures/global_exit_children). The pin reaches 16 and 32 buckets
// and, in a grown table, no two of the ids in one bucket; whether a
// strategy.order market order is a transient key too it leaves open, so a
// table the two readings size differently is out of its reach.
void PineExecutionAdapter::note_exit_rank_key(const SourceId& id) {
    // Past 26 keys the table needs 64 buckets, which the pin does not reach;
    // the peak keeps it there, so the ids beyond need no record.
    if (exit_rank_keys_.size() > 26
        || exit_rank_keys_.find(id).has_value()) {
        // The recorded population remains capped at 27 keys, as before.
        return;
    }
    exit_rank_keys_.require_insert(id);
    exit_rank_keys_.insert(id, static_cast<std::uint32_t>(exit_rank_keys_.size()));
    const std::uint64_t size = id.size();
    exit_rank_keys_digest_ = fnv_append(exit_rank_keys_digest_, &size, sizeof(size));
    exit_rank_keys_digest_ = fnv_append(exit_rank_keys_digest_, id.data(), id.size());
    note_exit_rank_transients();
}
 
void PineExecutionAdapter::note_exit_rank_transients() {
    assert_live_counts();
    const auto& counts = retired_row_scratch_.live_families;
    const auto closes = static_cast<std::uint32_t>(
        counts[static_cast<std::size_t>(PineOrderFamily::Close)]
        + counts[static_cast<std::size_t>(PineOrderFamily::CloseAll)]);
    const auto markets = static_cast<std::uint32_t>(
        counts[RetiredRowScratch::family_count]);
    // This is the same census as the old live-handle walk: family and the
    // Order row's source limit/stop are fixed by remember_live. Replacements
    // subtract the old row before adding the new one; retire subtracts once.
    // Keep the original uint32 arithmetic (including wrap) for the peaks.
    // Debug recounts at every reader also check the unpriced-Order slot.
    // No mutable activation, allowance or reservation quantity is summarized.
 
    const auto keys = static_cast<std::uint32_t>(exit_rank_keys_.size());
    exit_rank_peak_ = std::max(exit_rank_peak_, keys + closes);
    exit_rank_alt_peak_ = std::max(exit_rank_alt_peak_, keys + closes + markets);
}
 
std::optional<std::vector<std::uint32_t>> PineExecutionAdapter::global_exit_child_ranks(
        const std::vector<SourceId>& ids) const {
    const auto buckets_for = [](std::uint32_t peak) {
        std::uint32_t capacity = 16;
        while (static_cast<std::uint64_t>(peak) * 16U > static_cast<std::uint64_t>(capacity) * 13U)
            capacity *= 2;
        return capacity;
    };
    const std::uint32_t capacity = buckets_for(exit_rank_peak_);
    if (capacity > 32 || buckets_for(exit_rank_alt_peak_) != capacity) return std::nullopt;
    std::vector<std::uint32_t> bucket(exit_rank_keys_.size());
    std::vector<std::uint32_t> load(capacity, 0);
    bool supported = true;
    exit_rank_keys_.for_each_inserted([&](const auto& key, auto age) {
        std::uint32_t hash = 0;
        if (!java_string_hash(key, hash)) { supported = false; return; }
        bucket[age] = (hash ^ (hash >> 16)) & (capacity - 1);
        // A bin of eight would make java.util.HashMap treeify or resize. The
        // count is of entry ids only: a transient close key landing in a bin
        // of seven would do the same, which no tape reaches.
        if (++load[bucket[age]] >= 8) supported = false;
    });
    if (!supported) return std::nullopt;
    std::vector<std::size_t> ages;
    ages.reserve(ids.size());
    for (const auto& id : ids) {
        const auto found = exit_rank_keys_.find(id);
        if (!found) return std::nullopt;
        const auto age = static_cast<std::size_t>(exit_rank_keys_.get(*found));
        if (capacity > 16) {
            for (const auto other : ages)
                if (bucket[other] == bucket[age]) return std::nullopt;
        }
        ages.push_back(age);
    }
    std::vector<std::uint32_t> ranks;
    ranks.reserve(ids.size());
    for (const auto age : ages) {
        std::uint32_t rank = 0;
        for (std::size_t other = 0; other < bucket.size(); ++other) {
            if (bucket[other] < bucket[age] || (bucket[other] == bucket[age] && other > age))
                ++rank;
        }
        ranks.push_back(rank);
    }
    return ranks;
}
 
bool PineExecutionAdapter::other_exit_reaches(double price, bool closing_long,
                                              const SourceId& exit_id,
                                              const native_order::RequestHandle& filled) const {
    for (const auto& handle : live_handles_) {
        if (handle == filled) continue;
        const auto row = placement_.find(handle.incarnation);
        if (row == placement_.end()) continue;
        const auto& leg = row->second;
        // The filled exit's own other leg is one of the same children.
        if (leg.from_entry.empty() && leg.source_id == exit_id) continue;
        if (leg.family == PineOrderFamily::ExitTrail) return true;
        if (leg.family == PineOrderFamily::ExitLimit && finite_positive(leg.exit_levels.limit)
            && (closing_long ? price >= leg.exit_levels.limit : price <= leg.exit_levels.limit)) {
            return true;
        }
        if (leg.family == PineOrderFamily::ExitStop && finite_positive(leg.exit_levels.stop)
            && (closing_long ? price <= leg.exit_levels.stop : price >= leg.exit_levels.stop)) {
            return true;
        }
    }
    return false;
}
 
void PineExecutionAdapter::set_exit_phase(std::size_t trade_index, std::uint8_t phase) {
    const auto prefix = host_ ? detail::run_consumer(*host_).closed_trade_prefix()
                             : NativeExecutionConsumer::ClosedTradePrefix{};
    if (trade_index < prefix.base)
        throw coded<std::logic_error>(RunFailureCode::engine_invariant, {},
                                       "exit-phase write precedes the sealed prefix");
    const std::size_t offset = trade_index - prefix.base;
    if (trade_exit_phase_.empty() && host_)
        trade_exit_phase_.set_directory(detail::run_consumer(*host_).report_scratch_directory(*host_));
    if (offset >= trade_exit_phase_.size())
        trade_exit_phase_.resize(offset + 1, static_cast<std::uint8_t>(NativePathPhase::None));
    if (trade_index < exit_phase_final_ && trade_exit_phase_[offset] != phase) {
        // A final phase rewritten: fold the prefix afresh at the next mark.
        exit_phase_final_ = prefix.base;
        exit_phase_digest_ = prefix.exit_phase_digest;
        if (host_) detail::run_consumer(*host_).restart_exit_phases();
    }
    if (trade_exit_phase_[offset] != phase) { invalidate_exit_group(trade_index); } trade_exit_phase_.set(offset, phase);
}
 
void PineExecutionAdapter::observe_terminal_receipts() {
    auto& host = require_host();
    // A PineStrategyHost's command history is read in place, through its
    // consumer; any other host is read through native_events().
    auto* pine = pine_view_of(&host);
    const NativeExecutionConsumer* consumer = pine ? &detail::run_consumer(*pine) : nullptr;
    // Quiet: no command event above the cursor -- nothing at all above it,
    // or only driver points and account rows, which are never observed. This
    // is every read of a bar that issued no command. The read below would
    // then visit nothing and end with the cursor on the high water, which is
    // all this does. It also leaves the terminal watermark alone, as the read
    // would: a terminal receipt is a command, and every command's ordinal
    // exceeds the high water of the read before it, so the first read after
    // one always takes the full path, which raises the watermark past it.
    if (consumer) {
        const std::uint64_t high_water = consumer->event_high_water();
        const bool quiet = high_water <= receipt_cursor_
            || !consumer->has_command_after(receipt_cursor_);
        if (detail::skip_quiet(detail::QuietHook::ReceiptRead, quiet)) {
            // No acknowledgement (V19-B's, at the end of the full read) is
            // needed: no command lies between the one the last full read
            // acknowledged and the cursor, so acknowledging the new cursor
            // would let the journal window retire nothing more.
            receipt_cursor_ = std::max(receipt_cursor_, high_water);
            return;
        }
    }
    // Accepted only adds a working root, so the roster release pass can wait.
    // Other commands, including replacements and arms, mark the pass due below.
    // Applied callbacks do the same before any nested adapter work.
    const auto state = detail::run_state(host);
    const bool in_place = consumer != nullptr;
    // The terminal watermark is folded into the broker-state hash
    // (pine_state_hash.cpp) and has only ever advanced on a run without an
    // intrabar path; it still does. The read's early return below no longer
    // depends on the path.
    std::optional<std::uint64_t> terminal_high_water;
    if (in_place && (!state.spec || state.spec->intrabar.is_none())) {
        terminal_high_water = consumer->terminal_receipt_high_water();
    }
    const auto observe = [&](const native_order::CommandEvent& command) {
        std::visit([&](const auto& event) {
            using Event = std::decay_t<decltype(event)>;
            if constexpr (!std::is_same_v<Event, native_order::AcceptedEvent>)
                retired_row_scratch_.roster_pass_due = true;
            if constexpr (std::is_same_v<Event, native_order::MatchRejectedEvent>
                          || std::is_same_v<Event, native_order::CancelledEvent>
                          || std::is_same_v<Event, native_order::NoEffectEvent>) {
                // An anchored relative leg whose parent ended without a fill
                // left with it (OwnerGone); its queued definition waits for
                // the next parent of that id exactly as before.
                const auto ended = std::remove_if(
                    anchored_relative_legs_.begin(), anchored_relative_legs_.end(),
                    [&](const AnchoredRelativeLeg& leg) {
                        return leg.handle == event.handle();
                    });
                anchored_relative_stats_.withdrawn += static_cast<std::uint64_t>(
                    std::distance(ended, anchored_relative_legs_.end()));
                anchored_relative_legs_.erase(ended, anchored_relative_legs_.end());
                const auto placement = placement_.find(event.handle().incarnation);
                if (placement != placement_.end()) {
                    if constexpr (std::is_same_v<Event, native_order::MatchRejectedEvent>) {
                        suspend_declined_reversal_brackets(event);
                    }
                    const auto handle = event.handle();
                    const bool opening = placement->second.opening;
                    placement->second.cancellation = {
                        std::is_same_v<Event, native_order::CancelledEvent>
                            ? PineCancellationCause::Explicit : PineCancellationCause::Admission,
                        1, 0, handle.incarnation,
                        static_cast<std::int64_t>(placement->second.source_sequence),
                        handle.incarnation, placement->second.placement_cycle,
                        placement->second.legs.revision(),
                        placement->second.requested_qty, kNaN};
                    retire(handle);
                    if (opening) cancel_bracket_origin(handle);
                }
            } else if constexpr (std::is_same_v<Event, native_order::ActivatedEvent>) {
                if (std::holds_alternative<native_order::StopLimitLive>(event.after)) {
                    const auto placement = placement_.find(event.definition->handle.incarnation);
                    if (placement != placement_.end()) placement->second.stop_limit_activated = true;
                }
            } else if constexpr (std::is_same_v<Event, native_order::ReservationReducedEvent>) {
                const auto placement = placement_.find(event.recipient.incarnation);
                if (placement != placement_.end()) {
                    if (const auto* remaining = std::get_if<native_order::RemainingProjectionUnits>(
                            &event.after)) {
                        placement->second.projection_remaining_qty = remaining->q;
                    }
                }
            } else if constexpr (std::is_same_v<Event, native_order::ExecutionAppliedEvent>) {
                if (event.terminal) cancel_bracket_siblings(event.handle(), event.ordinal);
            }
        }, command);
    };
    if (in_place) {
        // The in-place command journal reads: visit the command events above the cursor in place
        // instead of copying out every row above it. The materialised rows
        // were in ordinal order, commands first at a tied ordinal, so the
        // cursor held each command's ordinal while that command was observed
        // and ended on the high water the rows reached, driver points and
        // account rows included; it moves the same way here. A cancel issued
        // while observing appends above that high water -- as it appended
        // past the end of the snapshot -- and the next read observes it.
        const std::uint64_t high_water = consumer->event_high_water();
        if (high_water > receipt_cursor_) {
            consumer->visit_commands_after(receipt_cursor_,
                [&](const native_order::CommandEvent& command) {
                    receipt_cursor_ = std::max(receipt_cursor_, std::visit(
                        [](const auto& payload) { return payload.ordinal; }, command));
                    observe(command);
                    return false;
                });
            receipt_cursor_ = std::max(receipt_cursor_, high_water);
        }
    } else {
        for (const auto& row : host.native_events(receipt_cursor_)) {
            receipt_cursor_ = std::max(receipt_cursor_, row.ordinal);
            if (row.command) observe(*row.command);
        }
    }
    if (terminal_high_water) {
        terminal_receipt_cursor_ = std::max(
            terminal_receipt_cursor_, *terminal_high_water);
    }
    // Every command through the cursor is observed, and every later read the
    // adapter makes starts above it (follows_same_bar_declined_reversal, the
    // margin revival), so the kernel's journal window may retire it.
    host.native_acknowledge_events(receipt_cursor_);
}
 
native_order::Owner PineExecutionAdapter::owner_for_close(const SourceId& id, bool dynamic) const {
    // A global strategy.exit has no source-id cohort.  Its source policy is
    // HostSized, but the generic book authority remains the whole physical
    // position rather than a synthetic empty cohort.
    if (id.empty()) return native_order::Independent{};
    cohorts_by_id_.require_insert(id);
    // pine_fills.cpp:7669-7675 uses from_entry as a position-cycle existence
    // gate under FIFO; the actual reduction still consumes the global physical
    // roster.  ANY alone selects the named cohort as the settlement scope.
    const auto found = cohorts_by_id_.find(id);
    if (!config_.close_entries_rule_any) {
        // Before the named parent has opened, retain the generic cohort's
        // NoTarget deferral.  Once that parent is live, FIFO settles against
        // the global book rather than the named cohort.
        if (found == cohorts_by_id_.end() || !(cohort_exposure_for(id) > 0.0)) {
            return native_order::BindCohort{
                found == cohorts_by_id_.end()
                    ? const_cast<PineExecutionAdapter*>(this)->cohort_for(id)
                    : found->second.handle};
        }
        return native_order::Independent{};
    }
    // A bracket born by the first-open COOF callback already has one durable
    // opening receipt. Bind that exact roster at the callback boundary so its
    // next real magnifier tick can consume it; later/deferred source commands
    // retain the growing cohort owner.
    if (dynamic && coof_recalc_active_ && coof_first_open_
        && found != cohorts_by_id_.end() && !found->second.opened.empty()) {
        return native_order::BindOpenings{found->second.opened, found->second.cycle};
    }
    if (dynamic || found == cohorts_by_id_.end()) {
        if (found == cohorts_by_id_.end())
            return native_order::BindCohort{const_cast<PineExecutionAdapter*>(this)->cohort_for(id)};
        return native_order::BindCohort{found->second.handle};
    }
    return native_order::BindOpenings{found->second.opened, found->second.cycle};
}
 
void PineExecutionAdapter::stage_flat_children_before_parent(
        const SourceId& parent_id, std::int32_t created_bar,
        std::int64_t script_open_ms) {
    std::vector<native_order::RequestHandle> children;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& child = found->second;
        const bool bracket = child.family == PineOrderFamily::ExitLimit
            || child.family == PineOrderFamily::ExitStop;
        if (bracket && child.from_entry == parent_id
            && child.projection_position_side
                == static_cast<std::int32_t>(PositionSide::FLAT)
            && child.projection_created_bar == created_bar
            && child.placement_script_open_ms == script_open_ms) {
            children.push_back(handle);
        }
    }
    for (const auto& handle : children) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        PlacementSnapshot snapshot = found->second;
        native_order::Request request;
        request.intent = native_order::HostSized{
            native_order::HostSizedKind::Close, std::nullopt};
        request.label = snapshot.source_id;
        request.comment = snapshot.comment;
        if (snapshot.family == PineOrderFamily::ExitLimit) {
            request.trigger = native_order::Limit{snapshot.exit_levels.limit};
        } else {
            request.trigger = native_order::Stop{snapshot.exit_levels.stop};
        }
        request.owner = owner_for_close(snapshot.from_entry, true);
        const std::string group_name = snapshot.oca_name.empty()
            ? snapshot.source_id + "\x1f" + snapshot.from_entry
            : snapshot.oca_name;
        request.group = group_for(group_name, 1);
        snapshot.defer_until_post_parent_calculation = true;
        const SourceId replacement_key = snapshot.source_id + "\x1f"
            + snapshot.from_entry + std::to_string(static_cast<int>(snapshot.family));
        const auto cancelled = require_host().cancel(handle);
        if (cancelled.status != native_order::CancelStatus::Cancelled) continue;
        retire(handle);
        auto queued = std::find_if(pending_bracket_legs_.begin(), pending_bracket_legs_.end(),
            [&](const PendingBracketLeg& row) {
                return row.replacement_key == replacement_key;
            });
        PendingBracketLeg staged{std::move(request), std::move(snapshot),
                                 replacement_key,
                                 key_for(found->second.source_id,
                                         found->second.from_entry)};
        if (queued == pending_bracket_legs_.end()) {
            pending_write(pending_bracket_legs_).push_back(std::move(staged));
        } else {
            pending_write(*queued) = std::move(staged);
        }
    }
    refresh_pending_view();
}
 
void PineExecutionAdapter::begin_coof_recalc(
        const native_order::ExecutionAppliedEvent& event,
        const NativeDecisionContext& context, bool first_open,
        std::uint64_t source_fill_sequence) {
    coof_recalc_active_ = true;
    coof_first_open_ = first_open;
    coof_current_fill_seq_ = source_fill_sequence;
    coof_fill_cursor_t_ = event.cursor.t;
    coof_market_entry_recalc_fill_seq_ = source_fill_sequence;
    coof_market_entry_recalc_incarnation_ = 0;
    const auto placement = placement_.find(event.handle().incarnation);
    coof_fill_target_print_ = kNaN;
    if (!bar_magnifier_ && placement != placement_.end()
        && finite_positive(placement->second.forced_execution_price)
        && finite_positive(placement->second.forced_waypoint_print)
        && placement->second.placement_script_open_ms == context.script_bar_open_ms) {
        const double tick = staged_.syminfo.mintick;
        const double target = placement->second.forced_waypoint_print;
        const double slippage = config_.slippage * tick;
        const double forced_price = placement->second.forced_execution_price;
        const bool paired = same_double_bits(forced_price, nearest_tick(target, tick) + slippage)
            || same_double_bits(forced_price, nearest_tick(target, tick) - slippage)
            || same_double_bits(forced_price, source_bar_fill_tick(target, tick) + slippage)
            || same_double_bits(forced_price, source_bar_fill_tick(target, tick) - slippage);
        if (paired) coof_fill_target_print_ = target;
    }
    coof_open_stop_next_waypoint_ = placement != placement_.end()
        && placement->second.coof_open_stop_next_waypoint;
    if (event.opened_units != 0.0
        && std::holds_alternative<native_order::Market>(event.request().trigger)) {
        if (placement != placement_.end()
            && placement->second.family == PineOrderFamily::Entry) {
            coof_market_entry_recalc_incarnation_ = event.handle().incarnation;
        }
    }
    // An exit limit already through where a recalculation of the open's
    // refill placed it is armed at the first extreme, which satisfies its
    // level (exit(): StopLimit{W1, level}), and gap-fills at that point: a
    // fill forced onto the extreme, not the matcher's at the limit's own
    // level, even with that level exactly on it -- the orders its
    // recalculation places start the next leg, as TradingView books them
    // (lab tv int27-open-x*-w1-reentry-*).
    const auto* armed_limit = placement != placement_.end()
            && placement->second.family == PineOrderFamily::ExitLimit
        ? std::get_if<native_order::StopLimit>(&event.request().trigger) : nullptr;
    const bool armed_limit_gap_fill = armed_limit
        && (placement->second.projection_position_side
                == static_cast<std::int32_t>(PositionSide::LONG)
            ? armed_limit->stop >= armed_limit->limit
            : armed_limit->stop <= armed_limit->limit)
        && coof_fill_at_path_point(armed_limit->stop);
    coof_fill_forced_ = placement != placement_.end()
        && (finite_positive(placement->second.forced_execution_price)
            || armed_limit_gap_fill);
    coof_context_ = context;
}
 
void PineExecutionAdapter::end_coof_recalc() noexcept {
    coof_recalc_active_ = false;
    coof_first_open_ = false;
    coof_open_stop_next_waypoint_ = false;
    coof_fill_forced_ = false;
    coof_market_entry_recalc_incarnation_ = 0;
    coof_market_entry_recalc_fill_seq_ = 0;
    coof_current_fill_seq_ = 0;
    coof_fill_cursor_t_ = kNaN;
    coof_fill_target_print_ = kNaN;
    coof_context_ = {};
}
 
bool PineExecutionAdapter::suppress_grouped_stop_recalc(
        const native_order::ExecutionAppliedEvent& event,
        const NativeDecisionContext& context) const noexcept {
    // Every exit of one entry that the fill's point also triggers fills there
    // before the point recalculates: the recalculation after the first cannot
    // cancel or outrun the others (lab tv tapes
    // tests/fixtures/coof_same_point_exits td-m1e, -f and -g: two exits of one
    // entry share a stop, and the recalculation of a stop fill calls
    // cancel_all() and close_all(); TradingView books both at the stop; lane
    // TAIL-D). The recalculation of the point's last such fill runs.
    if (host_ && config_.calc_on_order_fills && event.closed_units > 0.0) {
        const double held = detail::run_position(*host_).signed_units;
        const auto filled = placement_.find(event.handle().incarnation);
        if (held != 0.0 && filled != placement_.end() && !filled->second.from_entry.empty()
            && (filled->second.family == PineOrderFamily::ExitStop
                || filled->second.family == PineOrderFamily::ExitLimit)) {
            const double price = event.raw_price;
            const bool closing_long = held > 0.0;
            for (const auto& handle : live_handles_) {
                if (handle == event.handle()) continue;
                const auto sibling = placement_.find(handle.incarnation);
                if (sibling == placement_.end()) continue;
                const auto& row = sibling->second;
                if (row.from_entry != filled->second.from_entry
                    || row.source_id == filled->second.source_id) {
                    continue;
                }
                const double stop = row.exit_levels.stop;
                const double limit = row.exit_levels.limit;
                // The point's print and a level the script computed meet on
                // the tick grid, not in their last bits.
                const auto at = [tick = staged_.syminfo.mintick, price](double level) {
                    return price == level || (finite_positive(tick)
                        && nearest_tick(price, tick) == nearest_tick(level, tick));
                };
                const bool triggered =
                    (row.family == PineOrderFamily::ExitStop && finite_positive(stop)
                        && ((closing_long ? price < stop : price > stop) || at(stop)))
                    || (row.family == PineOrderFamily::ExitLimit && finite_positive(limit)
                        && ((closing_long ? price > limit : price < limit) || at(limit)));
                if (triggered) return true;
            }
        }
    }
    if (!host_ || !config_.calc_on_order_fills || config_.process_orders_on_close
        || !modeled_input() || config_.pyramiding != 0 || config_.close_entries_rule_any
        || config_.slippage != 0 || config_.commission_value != 0.0
        || staged_.account_fx != 1.0 || !staged_.account_fx_effective_from_ms.empty()
        || risk_.max_intraday_loss != 0.0 || risk_.max_drawdown != 0.0
        || risk_.max_cons_loss_days != 0 || cap.active()
        || context.coordinate.path_phase != NativePathPhase::Low
        || !policy_script_bar_valid_ || event.closed_units <= 0.0
        || detail::run_position(*host_).signed_units <= 0.0) {
        return false;
    }
    const auto state = detail::run_state(*host_);
    if (state.spec && !state.spec->intrabar.is_none()) return false;
    const auto filled = placement_.find(event.handle().incarnation);
    if (filled == placement_.end()) return false;
    const auto eligible = [&](const PlacementSnapshot& row) {
        return row.family == PineOrderFamily::ExitStop
            && row.projection_created_bar < projection_bar_index(context)
            && row.from_entry == filled->second.from_entry && !row.from_entry.empty()
            && std::isfinite(row.requested_qty) && row.requested_qty > 0.0
            && row.oca_name.empty() && std::isnan(row.exit_levels.trail_points)
            && std::isnan(row.exit_levels.trail_price)
            && std::isfinite(row.exit_levels.stop)
            && row.exit_levels.stop <= event.resolved_price
            && row.exit_levels.stop >= policy_script_bar_.low;
    };
    if (!eligible(filled->second)) return false;
    return std::any_of(live_handles_.begin(), live_handles_.end(),
        [&](const native_order::RequestHandle& handle) {
            if (handle == event.handle()) return false;
            const auto sibling = placement_.find(handle.incarnation);
            return sibling != placement_.end() && eligible(sibling->second);
        });
}
 
bool PineExecutionAdapter::immediate_calculation_close(
        const native_order::ExecutionAppliedEvent& event,
        const NativeDecisionContext& context) const noexcept {
    if (context.coordinate.provenance != NativePriceProvenance::Calculation) return false;
    const auto filled = placement_.find(event.handle().incarnation);
    return filled != placement_.end() && filled->second.immediately
        && (filled->second.family == PineOrderFamily::Close
            || filled->second.family == PineOrderFamily::CloseAll);
}
 
bool PineExecutionAdapter::defer_coof_tail() const noexcept {
    if (!coof_recalc_active_ || coof_first_open_) return false;
    const auto state = detail::run_state(require_host());
    if (state.spec && state.spec->intrabar.lower()) return false;
    const auto phase = coof_context_.coordinate.path_phase;
    if (phase == NativePathPhase::Close || phase == NativePathPhase::None)
        return true;
    // A fill the adapter forced onto the second extreme leaves the
    // recalculation the close point alone; the matcher's own fill there
    // does not (coof_fill_at_second_extreme, H-MEASURE Finding 6d).
    return coof_fill_forced_ && coof_fill_at_second_extreme();
}
 
// The recalculating fill sits AT the bar's second extreme, the end of its
// approach leg (the high of a low-first bar, the low of a high-first one).
// Two fills book that point, and TradingView answers the recalculation's
// market orders differently for them. The matcher's fill of a resting
// request at its own level there ends the approach leg: those orders fill at
// the extreme (hm-chart-diff-v2 / -v3 / -v6 / -v7 bar 19, lab tv
// pa2-i2-exit-w2-* and pa2-i4-close-w2-*). A request an earlier
// recalculation of the bar placed, which the adapter forced onto the extreme
// it gap-fills at (coof_fill_forced_: forced_execution_price), fills at the
// point itself: they advance to the close, as ab9714be's endpoint rule has
// it (corpus bracket-rivet-calc-on-fill-01 trades 350 and 516; the
// recalculation fill-order correction).
bool PineExecutionAdapter::coof_fill_at_second_extreme() const noexcept {
    if (!coof_recalc_active_ || coof_first_open_ || !coof_script_bar_valid_) return false;
    const bool high_first = source_path_uses_high_first(coof_script_bar_);
    const NativePathPhase second = high_first
        ? NativePathPhase::Low : NativePathPhase::High;
    const double endpoint = high_first ? coof_script_bar_.low : coof_script_bar_.high;
    return coof_context_.coordinate.path_phase == second
        && coof_fill_at_path_point(endpoint);
}
 
bool PineExecutionAdapter::coof_fill_on_path_point() const noexcept {
    // The recalculating fill's matcher cursor sits at a leg end (t 0 or 1),
    // i.e. on an O/H/L/C point, rather than inside a leg.
    return coof_recalc_active_
        && (coof_fill_cursor_t_ == 0.0 || coof_fill_cursor_t_ == 1.0);
}
 
bool PineExecutionAdapter::coof_fill_at_path_point(double waypoint) const noexcept {
    const auto point = detail::callback_point(require_host());
    if (!point) return false;
    // ab9714be engine.hpp:1264-1266: an on-grid print books one ULP-exact
    // tick.  An OFF-grid waypoint books bar_fill_price(waypoint)
    // (pine_fills.cpp:7962-7966), a tick a mid-leg fill can also book, so
    // that tick names the waypoint only for a fill placed on a path point.
    const double tick = staged_.syminfo.mintick;
    if (coof_recalc_active_ && detail::script_rule_switches().coof_forced_fill_at_waypoint
        && finite_positive(coof_fill_target_print_))
        return source_same_point(coof_fill_target_print_, waypoint, tick);
    if (source_same_point(point->price, waypoint, tick)) return true;
    return finite_positive(tick) && source_bar_fill_tick(waypoint, tick) != waypoint
        && source_decimal_tick(point->price, tick) == source_decimal_tick(waypoint, tick)
        && coof_fill_on_path_point();
}
 
// On a magnified path TradingView's next fill point after an intrabar's
// second extreme, or after the chart bar's own open print, is the next
// intrabar's opening (PineScheduler::next_input_waypoint). A plain market
// order reaches exactly that point -- the kernel fills a newborn market
// request at the path's next discrete point -- even when it prints the price
// the fill recalculation stands at, where a waypoint trigger would fill at
// once.
bool PineExecutionAdapter::coof_waits_for_next_sub_bar() const noexcept {
    const auto* pine_host = pine_view_of(host_);
    if (!pine_host) return false;
    const auto next = pine_host->scheduler_.next_input_waypoint(*pine_host, coof_context_);
    return next && next->next_open;
}
 
// The leg order the kernel walks `bar` in -- the run's declared
// NativeRunSpec::path_order, the open-proximity rule under Auto
// (NativeExecutionConsumer::path_high_first). The source layer asks rather
// than keeping a copy of the rule.
bool PineExecutionAdapter::source_path_uses_high_first(const Bar& bar) const noexcept {
    auto* pine = pine_view_of(host_);
    return pine != nullptr && detail::run_consumer(*pine).path_high_first(bar);
}
 
bool PineExecutionAdapter::coof_current_fill_was_forced_waypoint() const noexcept {
    // L6b encodes a later COOF MARKET fill as a priced source waypoint. At
    // the Applied callback its raw coordinate still names the segment on
    // which it was born; advance from the forced waypoint rather than walking
    // back to that segment's endpoint (ab9714be pine_scheduler.cpp:398-619).
    if (!coof_recalc_active_) return false;
    const auto point = detail::callback_point(require_host());
    if (!point) return false;
    for (const auto& cohort : cohorts_by_id_.held_rows()) {
        for (const auto& opening : cohort.second.opened) {
            const auto units = cohort.second.live_units_by_origin.find(
                opening.incarnation);
            if (units == cohort.second.live_units_by_origin.end()
                || !(units->second > 0.0)) {
                continue;
            }
            const auto snapshot = placement_.find(opening.incarnation);
            if (snapshot != placement_.end() && snapshot->second.opening
                && snapshot->second.projection_created_during_coof
                && snapshot->second.placement_script_open_ms
                    == coof_context_.script_bar_open_ms
                && same_double_bits(snapshot->second.forced_execution_price,
                                    point->price)) {
                return true;
            }
        }
    }
    return false;
}
 
double PineExecutionAdapter::coof_next_waypoint(int* path_index) const noexcept {
    // path_index (optional) receives the returned waypoint's historical path
    // index (1/2 = extreme W1/W2, 3 = C), or -1 when it is not an O/H/L/C
    // point of the chart bar (lower-timeframe path, no waypoint).
    if (path_index) *path_index = -1;
    if (!coof_recalc_active_ || !coof_script_bar_valid_) return kNaN;
    const auto state = detail::run_state(require_host());
    if (state.spec && state.spec->intrabar.lower()) {
        if (const auto* pine_host = pine_view_of(&require_host())) {
            const auto next = pine_host->scheduler_.next_input_waypoint(
                *pine_host, coof_context_);
            if (next) return next->price;
        }
    }
    const bool high_first = source_path_uses_high_first(coof_script_bar_);
    const NativePathPhase path_phase[] = {
        NativePathPhase::Open,
        high_first ? NativePathPhase::High : NativePathPhase::Low,
        high_first ? NativePathPhase::Low : NativePathPhase::High,
        NativePathPhase::Close,
    };
    const double path_price[] = {
        coof_script_bar_.open,
        high_first ? coof_script_bar_.high : coof_script_bar_.low,
        high_first ? coof_script_bar_.low : coof_script_bar_.high,
        coof_script_bar_.close,
    };
    const bool forced_waypoint = coof_current_fill_was_forced_waypoint();
    for (int index = 0; index < 4; ++index) {
        if (path_phase[index] != coof_context_.coordinate.path_phase) continue;
        const auto point = detail::callback_point(require_host());
        // ab9714be pine_fills.cpp:7962-7966 and pine_scheduler.cpp:548-563: a
        // fill at a waypoint POINT books bar_fill_price(waypoint), the
        // nearest-tick rounding of the raw OHLC price, so the applied price
        // identifies that point only on the tick grid.  source_bar_fill_tick
        // keeps an on-grid n * mintick booking one ULP off the waypoint's
        // decimal print, so compare the decimal grid forms.
        // An OFF-grid waypoint's booked tick is also reachable mid-leg (a
        // limit at 13.26 on the H->L 13.255 leg), so it names the point
        // only for a fill the matcher placed on a path point.
        const double tick = staged_.syminfo.mintick;
        const bool on_grid_waypoint = finite_positive(tick)
            && source_bar_fill_tick(path_price[index], tick) == path_price[index];
        const bool at_waypoint = detail::script_rule_switches().coof_forced_fill_at_waypoint
                && finite_positive(coof_fill_target_print_)
            ? source_same_point(coof_fill_target_print_, path_price[index], tick)
            : point && finite_positive(tick)
            ? source_decimal_tick(point->price, tick)
                    == source_decimal_tick(path_price[index], tick)
                && (on_grid_waypoint || coof_fill_on_path_point())
            : point && point->price == path_price[index];
        if (index > 0 && point && finite_positive(point->price)
            && !at_waypoint && !forced_waypoint) {
            if (path_index) *path_index = index;
            return path_price[index];
        }
        // The matcher's fill of a resting request at its own level ON an
        // extreme ends the leg there: the recalculation's orders act from that
        // point, as TradingView books them -- a market order, a close or
        // close_all fills at it, a priced order is live at its own level from
        // it (lab tv pa3-f4-level-w1-*; the second extreme, H-MEASURE Finding
        // 6d, pa2-i2-exit-w2-*). A fill the adapter forced onto the point
        // starts the next leg (pa3-f4-point-w1-mkt-*; the extreme-point fill correction).
        if (index > 0 && index < 3 && at_waypoint && !forced_waypoint
            && !coof_fill_forced_) {
            if (path_index) *path_index = index;
            return path_price[index];
        }
        if (index == 0 && coof_open_stop_next_waypoint_
            && (finite_positive(tick)
                ? source_decimal_tick(path_price[1], tick)
                    == source_decimal_tick(path_price[0], tick)
                : path_price[1] == path_price[0])) {
            if (path_index) *path_index = 2;
            return path_price[2];
        }
        if (path_index && index < 3) *path_index = index + 1;
        return index < 3 ? path_price[index + 1] : kNaN;
    }
    return kNaN;
}
 
bool PineExecutionAdapter::coof_remaining_recrosses(
        double level, bool long_position) const noexcept {
    if (!finite_positive(level) || !coof_recalc_active_ || !coof_script_bar_valid_)
        return false;
    const bool high_first = source_path_uses_high_first(coof_script_bar_);
    const NativePathPhase path_phase[] = {
        NativePathPhase::Open,
        high_first ? NativePathPhase::High : NativePathPhase::Low,
        high_first ? NativePathPhase::Low : NativePathPhase::High,
        NativePathPhase::Close,
    };
    const double path_price[] = {
        coof_script_bar_.open,
        high_first ? coof_script_bar_.high : coof_script_bar_.low,
        high_first ? coof_script_bar_.low : coof_script_bar_.high,
        coof_script_bar_.close,
    };
    const bool forced_waypoint = coof_current_fill_was_forced_waypoint();
    for (int index = 0; index < 4; ++index) {
        if (path_phase[index] != coof_context_.coordinate.path_phase) continue;
        const auto point = detail::callback_point(require_host());
        int first = index + 1;
        if (index > 0 && point && finite_positive(point->price)
            && !source_same_point(point->price, path_price[index], staged_.syminfo.mintick)
            && !forced_waypoint) {
            first = index;
        }
        bool crossed_adverse = false;
        for (int cursor = first; cursor < 4; ++cursor) {
            if (long_position) {
                if (path_price[cursor] < level) crossed_adverse = true;
                else if (crossed_adverse && path_price[cursor] >= level) return true;
            } else {
                if (path_price[cursor] > level) crossed_adverse = true;
                else if (crossed_adverse && path_price[cursor] <= level) return true;
            }
        }
        return false;
    }
    return false;
}
 
// Under calc_on_order_fills TradingView applies what the recalculation of a
// mid-leg fill cancels or closes -- strategy.cancel, strategy.cancel_all, a
// full strategy.close -- at the end of that leg: an exit resting from before
// whose level the rest of the leg reaches still fills there, at its level,
// and one the leg does not reach is gone after it (lab tv tapes
// tests/fixtures/coof_inflight_cancel td-m7a .. td-m7d; lane TAIL-D).
bool PineExecutionAdapter::coof_leg_reaches_exit(
        const PlacementSnapshot& row) const noexcept {
    if (!coof_recalc_active_ || coof_first_open_ || !coof_script_bar_valid_) return false;
    if (row.family != PineOrderFamily::ExitLimit && row.family != PineOrderFamily::ExitStop)
        return false;
    const auto point = detail::callback_point(require_host());
    const double units = detail::run_position(require_host()).signed_units;
    const double leg_end = coof_next_waypoint();
    if (!point || !finite_positive(point->price) || units == 0.0 || !finite_positive(leg_end))
        return false;
    const double price = point->price;
    const bool closing_long = units > 0.0;
    // A sell limit and a buy stop wait above the price, a buy limit and a
    // sell stop below it.
    const bool above = (row.family == PineOrderFamily::ExitLimit) == closing_long;
    const double level = row.family == PineOrderFamily::ExitLimit
        ? row.exit_levels.limit : row.exit_levels.stop;
    if (!finite_positive(level)) return false;
    return above ? level > price && level <= leg_end : level < price && level >= leg_end;
}
 
void PineExecutionAdapter::flush_coof_tail(
        bool openings_only, bool include_next_open) {
    auto queued = std::move(pending_write(pending_coof_requests_));
    pending_write(pending_coof_requests_).clear();
    for (auto& pending : queued) {
        if ((pending.next_open && !include_next_open)
            || (openings_only && (!pending.opening
                || std::holds_alternative<native_order::Market>(
                    pending.request.trigger)))) {
            pending_write(pending_coof_requests_).push_back(std::move(pending));
            continue;
        }
        const auto accepted = submit_or_replace(std::move(pending.request), std::move(pending.snapshot),
                                                pending.opening, pending.replacement_key);
        if (accepted && pending.family_key != 0)
            bracket_family(pending.family_key).push_back(*accepted);
    }
}
 
std::size_t PineExecutionAdapter::accepted_entries_in_cycle(
        bool is_long, const SourceId& id) const {
    std::size_t accepted_in_cycle = 0;
    for (const auto& cohort : cohorts_by_id_.held_rows()) {
        for (const auto& origin : cohort.second.opened) {
            const auto placement = placement_.find(origin.incarnation);
            if (placement != placement_.end() && placement->second.is_long == is_long)
                ++accepted_in_cycle;
        }
    }
    for (const auto& handle : live_handles_) {
        const auto placement = placement_.find(handle.incarnation);
        // ab9714be pine_strategy_commands.cpp:446-464: remove_same_id_pending_orders excludes replaced id before pyramiding check
        // TradingView counts a pending same-side MARKET entry against the
        // cap and never a pending LIMIT entry (lane W8A-SIGSTATE-1 R-B,
        // tests/fixtures/pyramiding_open_order).
        if (placement == placement_.end() || !placement->second.opening
            || placement->second.is_long != is_long) continue;
        if (placement->second.source_id != id && !pure_limit_entry(placement->second)) {
            ++accepted_in_cycle;
            continue;
        }
        // A synchronous fill can leave its applied notification queued.
        // Such an opening already occupies a slot, even for the same id or
        // a limit order. An unfilled replacement has no physical origin.
        const auto cohort = cohorts_by_id_.find_resident(placement->second.source_id);
        if (cohort != cohorts_by_id_.end()
            && std::find(cohort->second.opened.begin(), cohort->second.opened.end(), handle)
                != cohort->second.opened.end()) continue;
        struct Opening {
            std::uint64_t incarnation;
            bool settled = false;
        } opening{handle.incarnation};
        (void)require_host().visit_native_open_lot_values(
            &opening, [](void* context, std::uint64_t origin, double, double units) {
                auto& opening = *static_cast<Opening*>(context);
                if (origin != opening.incarnation || units == 0.0) return true;
                opening.settled = true;
                return false;
            });
        if (opening.settled) ++accepted_in_cycle;
    }
    return accepted_in_cycle;
}
 
bool PineExecutionAdapter::opposite_entry_opening_pending(bool is_long) const {
    return std::any_of(live_handles_.begin(), live_handles_.end(),
        [&](const native_order::RequestHandle& handle) {
            const auto existing = placement_.find(handle.incarnation);
            return existing != placement_.end() && existing->second.opening
                && existing->second.family == PineOrderFamily::Entry
                && existing->second.is_long != is_long;
        });
}
 
void PineExecutionAdapter::entry(const SourceId& id, bool is_long, double limit_price,
                                 double stop_price, double qty, const std::string& comment,
                                 const std::string& oca_name, int oca_type, int qty_type) {
    place_entry(id, is_long, limit_price, stop_price, qty, comment, oca_name, oca_type, qty_type);
    if (PF_RARE(!id_bound_exits_.empty())) rearm_id_bound_exits(id);
}
 
void PineExecutionAdapter::place_entry(const SourceId& id, bool is_long, double limit_price,
                                       double stop_price, double qty, const std::string& comment,
                                       const std::string& oca_name, int oca_type, int qty_type) {
    require_cohort_ticket(&id);
    native_order::Request request;
    // An infinite quantity trades the default quantity, as na does (lab tv
    // tailc-a-qty-nonfinite2: +-Infinity and na legs all enter at the
    // strategy's default; the placement and recalculation correction).
    fold_source_money();
    const bool default_sized = !std::isfinite(qty);
    const bool priced = !std::isnan(limit_price) || !std::isnan(stop_price);
    const bool explicit_fixed = !default_sized
        && (qty_type < 0 || qty_type == static_cast<int>(QtyType::FIXED));
    const double normalized_qty = explicit_fixed
        ? explicit_entry_quantity_floor(std::abs(qty), staged_.quantity_grid) : qty;
    const double signed_target = is_long ? normalized_qty : -normalized_qty;
    const double current = detail::run_position(require_host()).signed_units;
    const auto source_point = detail::callback_point(require_host());
    double flat_pending_opposite_market_units = 0.0;
    if (!source_point
        && detail::run_state(require_host()).kind == NativeLifecycleKind::Unconfigured) {
        // The historical source host allowed constructor-time commands to be
        // inspected before a run.  They have no native decision coordinate
        // yet, so retain only their source command projection; the native
        // request core is not invoked outside an admitted begin.
        request.intent = default_sized
            ? native_order::OrderIntent{native_order::HostSized{
                native_order::HostSizedKind::Open,
                is_long ? native_order::Side::Long : native_order::Side::Short}}
            : native_order::OrderIntent{native_order::Transact{signed_target}};
        request.label = id;
        request.comment = comment;
        request.trigger = trigger_for(limit_price, stop_price);
        request.group = group_for(oca_name, oca_type);
        PlacementSnapshot snapshot;
        snapshot.family = PineOrderFamily::Entry;
        snapshot.source_id = id;
        snapshot.comment = comment;
        snapshot.oca_name = oca_name;
        snapshot.oca_type = oca_type;
        snapshot.qty_type = qty_type;
        snapshot.requested_qty = normalized_qty;
        snapshot.is_long = is_long;
        snapshot.opening = true;
        snapshot.deferred_cohort = default_sized;
        snapshot.command_ordinal = ++command_ordinal_;
        snapshot.command_sequence = ++source_command_sequence_;
        snapshot.source_sequence = ++source_sequence_;
        snapshot.exit_levels.limit = limit_price;
        snapshot.exit_levels.stop = stop_price;
        snapshot.sizing = sizing_snapshot();
        pending_write(pending_entries_).push_back(
            {std::move(request), std::move(snapshot), id});
        return;
    }
    if (source_point) {
        const int bar = source_point->decision.coordinate.interval_index;
        if (entry_attempt_bar_ != bar) {
            entry_attempt_bar_ = bar;
            entry_attempts_on_bar_ = 0;
        }
        if (entry_attempts_on_bar_ != std::numeric_limits<std::uint32_t>::max())
            ++entry_attempts_on_bar_;
    }
    bool close_precedes_entry = pending_same_bar_close_qty_ > 0.0;
    const double preceding_close_qty = pending_same_bar_close_qty_;
    // The close-first fact (MarginRuleSwitches::close_first_admission): the
    // script closed the position this entry opposes -- strategy.close(<held
    // id>) or strategy.close_all() -- earlier on this script bar, however
    // that close sized or deferred its own order. TradingView fills such an
    // entry flat behind the close at the same point and never checks it on
    // the price scale, at placement (rule 5) or at the fill; rule 2 still
    // judges it (tests/fixtures/admission_rules cf1..cf10, c3b).
    const bool close_first_fact = source_point && current != 0.0
        && ((current > 0.0) != is_long)
        && close_first_script_bar_ == source_point->decision.script_bar_open_ms
        && close_first_side_ == (current > 0.0 ? 1 : -1);
    const bool close_first = close_first_fact
        && detail::margin_rule_switches().close_first_admission;
    native_order::RequestHandle preceding_close_request{};
    if (source_point) {
        for (auto it = live_handles_.rbegin(); it != live_handles_.rend(); ++it) {
            const auto& handle = *it;
            const auto prior = placement_.find(handle.incarnation);
            if (prior == placement_.end()) continue;
            const auto& row = prior->second;
            if ((row.family == PineOrderFamily::Close
                 || row.family == PineOrderFamily::CloseAll)
                && !row.immediately
                && row.placement_script_open_ms
                    == source_point->decision.script_bar_open_ms) {
                close_precedes_entry = true;
                preceding_close_request = handle;
                break;
            }
        }
    }
    limit_price = source_level_on_price_grid(
        limit_price, staged_.syminfo.mintick, value_field::entry_limit_price);
    stop_price = source_level_on_price_grid(
        stop_price, staged_.syminfo.mintick, value_field::entry_stop_price);
    const bool pure_stop_entry = std::isnan(limit_price)
        && finite_positive(stop_price);
    if (intraday_loss_orders_blocked()
        || (source_point && cap_placement_denied(source_point->decision))) {
        return;
    }
    if (pure_stop_entry && preceding_close_qty > 0.0
        && !pending_same_bar_commands_.empty()) {
        // The fixed-default batching path had retained the earlier close
        // outside the core. Publish it before the later priced entry so the
        // native book receives the legacy source statement order.
        flush_pending_same_bar_commands();
        if (source_point) {
            for (auto it = live_handles_.rbegin(); it != live_handles_.rend(); ++it) {
                const auto prior = placement_.find(it->incarnation);
                if (prior == placement_.end()
                    || prior->second.family != PineOrderFamily::Close
                    || prior->second.placement_script_open_ms
                        != source_point->decision.script_bar_open_ms) {
                    continue;
                }
                preceding_close_request = *it;
                break;
            }
        }
    }
    if (config_.calc_on_order_fills && priced && !coof_recalc_active_
        && source_point && current != 0.0 && ((current > 0.0) == is_long)) {
        std::vector<native_order::RequestHandle> stale_recalc_entries;
        for (const auto& handle : live_handles_) {
            const auto prior = placement_.find(handle.incarnation);
            if (prior == placement_.end()) continue;
            const auto& row = prior->second;
            if (row.opening && row.family == PineOrderFamily::Entry
                && row.is_long == is_long && row.projection_created_during_coof
                && row.projection_created_bar
                    == source_point->decision.coordinate.interval_index) {
                stale_recalc_entries.push_back(handle);
            }
        }
        for (const auto& handle : stale_recalc_entries) {
            const auto cancelled = require_host().cancel(handle);
            if (cancelled.status == native_order::CancelStatus::Cancelled)
                retire(handle);
        }
    }
    // Explicit entry quantities have a source placement-time admission
    // boundary.  In particular, finite values whose required margin
    // overflows must never become a live generic request that waits until a
    // later matching point to be rejected.
    if (!default_sized) {
        const bool opposite_live = current != 0.0 && ((current > 0.0) != is_long);
        if (!opposite_live) {
            // Admission is a source command fact at the signal mark; a
            // priced entry's later trigger/gap check remains at fill time.
            const double mark = source_point ? source_point->price : kNaN;
            const double margin = is_long ? config_.margin_long : config_.margin_short;
            const double fx = source_point
                ? active_staged_fx(source_point->decision.sub_bar_open_ms) : staged_.account_fx;
            const double equity = source_point
                ? require_host().native_marked_equity(source_point->price) : kNaN;
            // A typed quantity names money, not units: the admission prices
            // the units that money buys at the mark -- the conversion its fill
            // books (typed_entry_units), taken at the signal. Reading the cash
            // as units dropped a 1000-cash entry at 125 on 100 000 of equity.
            double units = std::abs(normalized_qty);
            if (qty_type == static_cast<int>(QtyType::CASH)) {
                units = typed_quantity_units(std::abs(qty), false, mark, fx);
            } else if (qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)) {
                units = typed_quantity_units(
                    percent_commission_live_equity(mark) * std::abs(qty) / 100.0, true, mark, fx);
            }
            // The later of two opposite calls on one flat bar is one
            // transaction of its own quantity plus the earlier pending market
            // call's, and TradingView costs that transaction at the signal:
            // past the equity it drops the later call (lab tv
            // w6-f10g-pair-gross; the NQ probe on CME_MINI:NQ1! 15),
            // the commission left out (w6b-p1b/p1c-pair-gross-*). A market
            // call under pyramiding 2 is the batch's, whose exact pair is
            // admitted when it is finalized (p2_explicit_pair).
            if (current == 0.0 && explicit_fixed && source_point
                && same_point_pair_scope() && !(config_.pyramiding == 2 && !priced)
                && (config_.pyramiding <= 1 || same_point_two_leg_book(
                        id, source_point->decision.script_bar_open_ms))) {
                const double pending = pending_opposite_market_units(
                    is_long, source_point->decision.script_bar_open_ms, id);
                if (std::isfinite(pending)) units += pending;
            }
            // An explicit-quantity MARKET buy from flat, filled at the next
            // open, is costed at its signal close's tick plus the slippage
            // ticks its fill will carry; a sell at the close's tick, never
            // lowered by them (lab tv tailc-b-admission-a-slip2 against -b-fee
            // and -c-control; the placement and recalculation correction). Under process_orders_on_close
            // it fills at that close, whose own fill-time check decides it
            // (the TV controls of test_pooc_money_admission_l4b, phase-b/-c).
            const double admission_mark = !priced && current == 0.0 && is_long
                    && explicit_fixed && config_.slippage > 0 && finite_positive(mark)
                    && !config_.process_orders_on_close
                ? source_bar_fill_tick(mark, staged_.syminfo.mintick)
                    + config_.slippage * staged_.syminfo.mintick
                : mark;
            const double required = units * admission_mark
                * staged_.syminfo.pointvalue * fx * margin / 100.0;
            // Finite explicit overflow is a signal-time refusal below, with
            // cancellation and callback continuation. Nonfinite inputs or
            // equity still fault before that refusal.
            const bool finite_explicit_requirement = std::isfinite(units)
                && std::isfinite(admission_mark) && std::isfinite(staged_.syminfo.pointvalue)
                && std::isfinite(fx);
            if (finite_positive(margin) && margin <= 100.0
                && ((!std::isfinite(required) && !finite_explicit_requirement)
                    || !std::isfinite(equity))) {
                engine_command_value_invalid_or_count("margin.required", EngineValueStage::margin,
                                                     EngineValueReason::nonfinite);
            }
            // Margin rule 2: an explicit quantity opening from flat at full
            // margin, market, or a stop under process_orders_on_close, is
            // judged at its signal close c' =
            // ticks x mintick -- on the money scale unslipped, E against
            // sig10(Q c'), and on the price scale with the order's slippage,
            // sig10(sig10(E) / Q) against c' moved by the slippage ticks
            // toward the fill. Dropped whole when either is short; nothing
            // else is checked at placement (tests/fixtures/margin_call_rules
            // admit, stop and stopband tapes: an F long of 2 at 27.359999
            // drops at 13.66 + 2 ticks, an ETH long of 1.5 admitted at
            // 2382.5849996 that the slipped money cost dropped, an EUR short
            // whose per-unit 1.18081 sits under the ulp-dirty c').
            const bool slipped_signal_scope = detail::margin_rule_switches().slipped_signal_admission
                && current == 0.0 && explicit_fixed && margin == 100.0
                && (!priced || (pure_stop_entry && config_.process_orders_on_close))
                && units == std::abs(normalized_qty) && finite_positive(units)
                && finite_positive(mark) && finite_positive(staged_.syminfo.mintick)
                && staged_.syminfo.pointvalue == 1.0 && fx == 1.0
                && staged_.account_fx_effective_from_ms.empty() && std::isfinite(equity);
            if (PF_RARE(slipped_signal_scope)) {
                const double tick = staged_.syminfo.mintick;
                const double ticks = std::floor(mark / tick + 0.5);
                const double signal_close = ticks * tick;
                const double slipped = (ticks + (is_long ? 1.0 : -1.0) * config_.slippage) * tick;
                const double mirrored = gain_loss_signal_equity(nearest_tick(mark, tick));
                const double signal_equity = std::isfinite(mirrored) ? mirrored : equity;
                const double per_unit = source_money_round(
                    source_money_round(signal_equity) / units);
                if (!(signal_equity < source_money_round(units * signal_close))
                    && !(per_unit < slipped)) {
                    // admitted: no other placement check
                } else {
                    if (pure_stop_entry) {
                        if (const auto prior = live_by_source_key_.find(checked_live_key(id));
                            prior != live_by_source_key_.end()) {
                            const auto prior_handle = prior->second;
                            const auto result = require_host().cancel(prior_handle);
                            if (result.status == native_order::CancelStatus::Cancelled)
                                retire(prior_handle);
                        }
                    }
                    return;
                }
            }
            // R4-D L10ad: ab9714be pine_strategy_commands.cpp:344-346 gates the
            // whole placement affordability half on margin_pct > 0.0 ("margin_pct
            // == 0 disables the check, as it does in TradingView").  A strategy
            // declared with margin_long=0 / margin_short=0 therefore keeps taking
            // explicit-qty entries after its equity has gone negative; without the
            // gate required == 0 > equity rejected every later entry once the
            // account traded below zero (the NQ1 probe went flat after a later trade).
            if (!slipped_signal_scope && finite_positive(margin) && margin <= 100.0
                && (!std::isfinite(required) || !std::isfinite(equity)
                    || required > equity)) {
                if (pure_stop_entry) {
                    std::optional<native_order::RequestHandle> prior_handle;
                    if (const auto prior = live_by_source_key_.find(checked_live_key(id));
                        prior != live_by_source_key_.end()) {
                        prior_handle = prior->second;
                    }
                    if (prior_handle) {
                        const auto result = require_host().cancel(*prior_handle);
                        if (result.status == native_order::CancelStatus::Cancelled)
                            retire(*prior_handle);
                    }
                }
                return;
            }
        }
    }
    // The admission's placement half (unified_placement), decided at the
    // signal itself: a market reversal at full margin -- a 100 % of equity
    // default or an explicit quantity -- whose price-scale budget rule 5
    // refuses, sig10(sig10(E) / Q) under (ticks(c') + side x slip) x mintick
    // while rule 2 passes, is refused whole there. It is still placed, marked
    // (PlacementSnapshot::signal_price_refused): the script's later close of
    // the held id then stays an ordinary close and executes
    // (tests/fixtures/margin_ledger_rules aapl-k0-*-after; admission_rules
    // cf11 x2), and the order drops at its fill (resolve_terms). Rule 2, rule
    // 5 for an entry from flat and the fill check are taken at the fill on the
    // same frozen signal values; a close-first entry escapes rule 5, and a
    // book with anything else resting or another opening pending is not
    // judged here.
    bool signal_price_refused = false;
    if (PF_RARE(current != 0.0 && ((current > 0.0) != is_long) && !close_first && !priced
        && source_point && detail::margin_rule_switches().unified_placement
        && (default_sized
                ? config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
                    && config_.default_qty_value == 100.0
                : (qty_type < 0 || qty_type == static_cast<int>(QtyType::FIXED))
                    && finite_positive(normalized_qty))
        && (is_long ? config_.margin_long : config_.margin_short) == 100.0
        && config_.commission_value == 0.0 && config_.pyramiding >= 0 && config_.pyramiding <= 1
        && staged_.syminfo.pointvalue == 1.0 && staged_.account_fx == 1.0
        && staged_.account_fx_effective_from_ms.empty() && oca_name.empty()
        && finite_positive(staged_.syminfo.mintick) && !cap.active()
        && !(risk_.max_intraday_loss > 0.0) && !(risk_.max_drawdown > 0.0)
        && risk_.max_cons_loss_days <= 0 && !(risk_.max_position_size > 0.0)
        && pinned_lot_grid() && !config_.calc_on_order_fills && !bar_magnifier_
        && unified_placement_book_clear())) {
        // The order's own quantity and money, as its snapshot below freezes them.
        auto sizing = sizing_snapshot();
        double units = std::abs(normalized_qty);
        if (default_sized) {
            units = kNaN;
            if (finite_positive(sizing.mark)) {
                sizing.price = default_market_sizing_price(sizing.mark, is_long);
#ifdef PINEFORGE_VALUE_INVALID_FIXTURES
                sizing.price = fixture_adapter_execution_value("slippage.default.signal", sizing.price);
#endif
                check_slippage_fill_price(sizing.price, std::isfinite(sizing.mark));
                mark_sizing_equity(sizing, sizing.mark);
                units = default_sizing_units(sizing);
            }
        }
        if (finite_positive(units) && std::isfinite(sizing.equity)
            && finite_positive(sizing.mark)) {
            const double tick = staged_.syminfo.mintick;
            const double ticks = std::floor(sizing.mark / tick + 0.5);
            const bool money_short = sizing.equity < source_money_round(units * (ticks * tick));
            const bool price_short = source_money_round(source_money_round(sizing.equity) / units)
                < (ticks + (is_long ? 1.0 : -1.0) * config_.slippage) * tick;
            signal_price_refused = !money_short && price_short;
        }
    }
    if (explicit_fixed && normalized_qty == 0.0 && current == 0.0 && !priced) {
        PlacementSnapshot shadow;
        shadow.family = PineOrderFamily::Entry;
        shadow.source_id = id;
        shadow.comment = comment;
        shadow.oca_name = oca_name;
        shadow.oca_type = oca_type;
        shadow.qty_type = qty_type;
        shadow.requested_qty = 0.0;
        shadow.is_long = is_long;
        shadow.opening = true;
        shadow.command_ordinal = ++command_ordinal_;
        shadow.command_sequence = ++source_command_sequence_;
        shadow.source_sequence = ++source_sequence_;
        shadow.projection_created_bar = source_point
            ? projection_bar_index(source_point->decision) : -1;
        shadow.sizing = sizing_snapshot();
        pending_write(source_shadow_pending_).push_back({std::move(shadow), id});
        return;
    }
    if (current == 0.0 && priced && explicit_fixed) {
        for (const auto& pending : pending_same_bar_commands_) {
            const auto& candidate = pending.snapshot;
            if (!pending.opening || candidate.family != PineOrderFamily::Entry
                || candidate.is_long == is_long
                || !candidate.frozen_market_instruction
                || !finite_positive(candidate.frozen_market_own_units)) {
                continue;
            }
            flat_pending_opposite_market_units += candidate.frozen_market_own_units;
        }
        if (flat_pending_opposite_market_units > 0.0
            && pending_same_bar_commands_.size() == 1U)
            flush_pending_same_bar_commands(/*flat_pair_follows=*/true);
        else if (pending_same_bar_commands_.size() != 1U)
            flat_pending_opposite_market_units = 0.0;
    }
    // A later source entry is outside a previously captured POOC global-exit
    // population. Keep the native close live, but stop advertising it as a
    // full-live dynamic reservation.
    if (has_live_exit_policy()) for (const auto& handle : live_handles_) {
        const auto existing = placement_.find(handle.incarnation);
        if (existing != placement_.end()
            && existing->second.pooc_global_full_exit_dynamic_qty) {
            existing->second.pooc_global_full_exit_dynamic_qty = false;
            existing->second.pooc_global_full_exit_tracks_bound_adds = false;
        }
    }
    const bool short_seed_final_candidate = current < 0.0 && !is_long
        && short_seed_long_candidate_.incarnation != 0;
    const bool opposite_opening_pending = opposite_entry_opening_pending(is_long);
    // Under process_orders_on_close a pending opposite opening defers the
    // pyramiding cap below to the close pass, where ab9714be counted the
    // entries then filled (add_to_pyramid_market's position_entry_count_) and
    // TradingView counts the trades then open. That pass fills the opposite
    // opening BEFORE this entry only when it processes it -- a market entry,
    // or one this script bar's own calculation placed -- and the add may be a
    // reversal by then. A priced opposite entry resting from an earlier bar is
    // not in that pass, so the add is held to the lots open now. (Deferred
    // without that bound, every fill's recalculation under the magnifier and
    // calc_on_order_fills re-issued such an add past pyramiding=1: 85 lots on
    // one bar where TradingView's tape books none -- the order-schedule correction.)
    const bool opposite_opening_in_close_pass = std::any_of(
        live_handles_.begin(), live_handles_.end(),
        [&](const native_order::RequestHandle& handle) {
            const auto existing = placement_.find(handle.incarnation);
            if (existing == placement_.end()) return false;
            const auto& row = existing->second;
            if (!row.opening || row.family != PineOrderFamily::Entry
                || row.is_long == is_long) {
                return false;
            }
            const bool market = !finite_positive(row.exit_levels.limit)
                && !finite_positive(row.exit_levels.stop);
            return market
                || (source_point
                    && row.placement_script_open_ms == source_point->decision.script_bar_open_ms);
        });
    // ab9714be src/compat/pine/market_admission.cpp:33-37: the explicit
    // flat-pair scope (explicit_pair_scope) carries no commission term;
    // a commissioned pyramiding=2 pair keeps the gross transaction.
    const bool p2_flat_market_candidate = current == 0.0
        && config_.pyramiding == 2 && !config_.process_orders_on_close
        && !config_.calc_on_order_fills && !coof_recalc_active_
        && config_.default_qty_type == static_cast<int>(QtyType::FIXED)
        && config_.slippage == 0
        && risk_.direction == 0 && risk_.max_cons_loss_days == 0
        && risk_.max_drawdown <= 0.0 && risk_.max_intraday_loss <= 0.0
        && risk_.max_position_size <= 0.0 && !risk_.halted && !cap.active()
        && explicit_fixed && !priced && oca_name.empty();
    if (std::any_of(pending_same_bar_commands_.begin(), pending_same_bar_commands_.end(),
        [&](const PendingSameBarCommand& command) {
            return command.unbatched_request && command.replacement_key == id;
        })) {
        reroute_fixed_entries_before_request();
    }
    const bool fixed_market_batch_candidate = fixed_unmargined_market_batch_scope()
        && !source_batch_mutated_
        && std::none_of(live_handles_.begin(), live_handles_.end(), [&](const auto& handle) {
            const auto prior = placement_.find(handle.incarnation);
            return prior != placement_.end() && prior->second.opening;
        })
        && std::none_of(pending_entries_.begin(), pending_entries_.end(),
            [](const auto& pending) { return pending.snapshot.opening; })
        && std::none_of(delayed_market_orders_.begin(), delayed_market_orders_.end(),
            [](const auto& pending) { return pending.snapshot.opening; })
        && !close_precedes_entry && pending_same_bar_close_qty_ == 0.0
        && (!source_point || close_all_pending_script_bar_
            != source_point->decision.script_bar_open_ms);
    const bool same_bar_market_candidate = (same_bar_market_tx_scope()
        || p2_flat_market_candidate || fixed_market_batch_candidate)
        && !priced && oca_name.empty()
        && (qty_type < 0 || qty_type == static_cast<int>(QtyType::FIXED))
        && (default_sized || finite_positive(qty));
    if (!same_bar_market_candidate) reroute_fixed_entries_before_request();
    if (!same_bar_market_candidate && config_.pyramiding == 2
        && !pending_same_bar_commands_.empty()) {
        source_batch_mutated_ = true;
        flush_pending_same_bar_commands();
    }
    const bool all_in_percent = default_sized && !priced && oca_name.empty()
        && config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        && config_.default_qty_value >= 100.0;
    // ab9714be pine_fills.cpp:2789-3020: an all-in default MARKET emitted
    // while its side is already at the Pine pyramiding cap remains a broker
    // book row until the next opening.  A later opposite sibling can make
    // that row executable before its turn; otherwise the open-boundary
    // adapter retires it without exposing a generic fill.
    const bool default_gross_over_cap_candidate = all_in_percent
        && std::abs(config_.default_qty_value - 100.0) < 1e-12
        && config_.pyramiding == 1 && !config_.process_orders_on_close
        && !config_.calc_on_order_fills && config_.slippage == 0
        && config_.commission_value == 0.0
        && std::abs(config_.margin_long - 100.0) < 1e-12
        && std::abs(config_.margin_short - 100.0) < 1e-12
        && risk_.direction == 0 && risk_.max_cons_loss_days == 0
        && risk_.max_drawdown <= 0.0 && risk_.max_intraday_loss <= 0.0
        && risk_.max_position_size <= 0.0 && !risk_.halted && !cap.active();
    bool paired_all_in_reentry = false;
    if (all_in_percent && current != 0.0 && ((current > 0.0) == is_long) && source_point) {
        for (const auto& handle : live_handles_) {
            const auto prior = placement_.find(handle.incarnation);
            if (prior == placement_.end() || !prior->second.opening
                || prior->second.family != PineOrderFamily::Entry
                || prior->second.is_long == is_long) {
                continue;
            }
            paired_all_in_reentry = true;
            break;
        }
    }
    // Under process_orders_on_close a close the script issued earlier in the
    // same pass settles before this entry: an entry after closes that flatten
    // the position is not a same-side add, and a same-side entry's margin is
    // judged against the position that close flattens (lane W8A-SIGSTATE-1
    // R2, tests/fixtures/pooc_same_pass_close).
    const bool pooc_pass = config_.process_orders_on_close
        && !config_.calc_on_order_fills && !coof_recalc_active_;
    const bool pooc_pass_flattens = pooc_pass && close_precedes_entry && current != 0.0
        && preceding_close_qty + internal::kQtyEpsilon >= std::abs(current);
    if (!same_bar_market_candidate && current != 0.0
        && ((current > 0.0) == is_long) && config_.pyramiding == 0
        && !(priced && config_.process_orders_on_close) && !pooc_pass_flattens) {
        // A zero pyramiding setting permits the flat opening but makes a
        // same-direction MARKET reissue a source no-op.  It must be dropped
        // before native matching so IntradayCap's factor-A policy observes no
        // fabricated physical fill.
        if (source_point) observe_intraday_cap_noop(is_long, source_point->decision);
        return;
    }
    if (!same_bar_market_candidate && config_.pyramiding > 0 && current != 0.0
        && ((current > 0.0) == is_long)
        && !(priced && config_.process_orders_on_close
             && !coof_recalc_active_)) {
        auto accepted_in_cycle = accepted_entries_in_cycle(is_long, id);
        // The pyramiding cap: the open close-ledger records and the same-side market
        // entries the bar placed before this one, in place of the cycle's
        // entry count (open_ledger_records).
        if (const auto records = open_ledger_records(); PF_RARE(records.has_value())) {
            std::size_t pending = 0;
            for (const auto& handle : live_handles_) {
                const auto placement = placement_.find(handle.incarnation);
                if (placement != placement_.end() && placement->second.opening
                    && placement->second.source_id != id
                    && placement->second.is_long == is_long
                    && !pure_limit_entry(placement->second)) {
                    ++pending;
                }
            }
            accepted_in_cycle = *records + pending;
        }
        // Pine's cap is a monotone entry-incarnation count for the current
        // position cycle; a partial close does not free a pyramiding slot.
        if (!(config_.process_orders_on_close && close_precedes_entry)
            && accepted_in_cycle >= static_cast<std::size_t>(config_.pyramiding)
            && !short_seed_final_candidate && !paired_all_in_reentry
            && !default_gross_over_cap_candidate
            && !(config_.process_orders_on_close && opposite_opening_pending
                 && (opposite_opening_in_close_pass
                     || detail::run_position(require_host()).lot_count
                         < static_cast<std::size_t>(config_.pyramiding)))) {
            // Source replacement erases the older same-id priced entry before
            // judging the replacement's pyramiding admission.  A rejected
            // over-cap reissue therefore leaves neither the old nor the new
            // trigger live (ab9714be:pine_strategy_commands.cpp:302-367).
            if (priced) {
                const auto prior = live_by_source_key_.find(checked_live_key(id));
                if (prior != live_by_source_key_.end()) {
                    const auto handle = prior->second;
                    const auto result = require_host().cancel(handle);
                    if (result.status == native_order::CancelStatus::Cancelled)
                        retire(handle);
                }
            }
            return;
        }
    }
    const auto current_point = source_point;
    const bool close_all_precedes = current_point
        && close_all_pending_script_bar_ == current_point->decision.script_bar_open_ms;
    native_order::RequestHandle preceding_close_all{};
    const bool reverses = current != 0.0 && ((current > 0.0) != is_long) && !close_all_precedes;
    if (default_sized
        && config_.default_qty_type == static_cast<int>(QtyType::FIXED)
        && reverses && !priced && config_.process_orders_on_close
        && !close_batch_callsites_.empty()) {
        // A later opposite MARKET entry owns the same source transaction.
        // The queued close remains a command-boundary observation only; the
        // native ReverseTo supplies the one physical close/open settlement.
        close_batch_callsites_.clear();
        close_batch_bar_ = -1;
        close_batch_queue_sequence_ = 0;
        close_batch_pending_debt_ = 0.0;
        close_batch_admitted_total_ = 0.0;
        pending_same_bar_close_qty_ = 0.0;
        close_precedes_entry = false;
    }
    // Default-sized reversal requests are HostSized already; they can carry a
    // fill-time close-only shape without changing explicit F7/F8 transaction
    // intent.  Explicit affordability variants keep their established native
    // request shape unless a separately-qualified source family lowers them.
    const bool affordability_reversal_candidate = reverses && !priced
        && (default_sized
            ? (config_.default_qty_type == static_cast<int>(QtyType::FIXED)
               || config_.default_qty_type == static_cast<int>(QtyType::CASH)
               || (config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
                   && config_.default_qty_value > 100.0))
            // A per-call explicit unit quantity still resolves at the terms
            // boundary when it reverses: the source affordability check may
            // retain only the closing leg regardless of the configured
            // default quantity type (ab9714be pine_fills.cpp:5529-5660).
            : true);
    const bool direction_blocked = (risk_.direction > 0 && !is_long)
        || (risk_.direction < 0 && is_long);
    if (default_sized && reverses && current_point) {
        for (const auto& handle : live_handles_) {
            const auto pending = placement_.find(handle.incarnation);
            if (pending == placement_.end()) continue;
            const auto& prior = pending->second;
            if (prior.family == PineOrderFamily::Entry && prior.opening
                && !prior.is_long && prior.is_long == is_long && prior.replaced_opening
                && prior.replacement_predecessor_market
                && prior.placement_script_open_ms == current_point->decision.script_bar_open_ms) {
                // The replacement's transaction owns this source pass; a
                // later same-side default market command remains unfilled.
                return;
            }
        }
    }
    if (default_sized && reverses && is_long && current_point) {
        std::vector<native_order::RequestHandle> superseded_buy_replacements;
        for (const auto& handle : live_handles_) {
            const auto pending = placement_.find(handle.incarnation);
            if (pending == placement_.end()) continue;
            const auto& prior = pending->second;
            if (prior.family == PineOrderFamily::Entry && prior.opening && prior.is_long
                && prior.replaced_opening && prior.replacement_predecessor_market
                && prior.placement_script_open_ms == current_point->decision.script_bar_open_ms) {
                superseded_buy_replacements.push_back(handle);
            }
        }
        for (const auto& handle : superseded_buy_replacements) {
            cancel_bracket_origin(handle);
            const auto result = require_host().cancel(handle);
            if (result.status == native_order::CancelStatus::Cancelled) retire(handle);
        }
    }
    const bool cash_sized = qty_type == static_cast<int>(QtyType::CASH);
    const bool percent_sized = qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY);
    const bool typed_sized = !default_sized && (cash_sized || percent_sized);
    const bool fixed_priced_reverse = reverses && !default_sized && priced && !cash_sized;
    const bool cash_priced_reverse = reverses && !default_sized && priced && cash_sized;
    // A default-percent stop entry freezes its units at placement whatever
    // the percentage (see the freeze below); ab9714be's own placement
    // admission for it (pine_strategy_commands.cpp:307-310) is the one the
    // percentage caps at 100, and above 100 the affordability arm admits it.
    const bool default_stop_freeze = default_sized && pure_stop_entry
        && finite_positive(stop_price)
        && config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY);
    const bool default_stop_scope = default_stop_freeze
        && config_.default_qty_value <= 100.0;
    double default_stop_sizing_price = kNaN;
    if (default_stop_freeze && finite_positive(staged_.syminfo.mintick)) {
        stop_price = directional_tick(
            stop_price, staged_.syminfo.mintick, is_long, value_field::entry_stop_price);
        const double signal = source_point
            ? nearest_tick(source_point->price, staged_.syminfo.mintick) : kNaN;
        if (config_.process_orders_on_close && source_level_on_price_grid(stop_price, staged_.syminfo.mintick) == source_level_on_price_grid(signal, staged_.syminfo.mintick)) {
            stop_price = source_level_on_price_grid(
                stop_price, staged_.syminfo.mintick);
        }
        const bool marketable = finite_positive(signal)
            && (is_long ? stop_price <= signal : stop_price >= signal);
        // ab9714be pine_strategy_commands.cpp:325-328: pure stop placement sizing price includes directional slippage ticks
        const double slip = (is_long ? 1.0 : -1.0) * config_.slippage * staged_.syminfo.mintick;
        default_stop_sizing_price = (marketable ? signal : stop_price) + slip;
#ifdef PINEFORGE_VALUE_INVALID_FIXTURES
        default_stop_sizing_price = fixture_adapter_execution_value(
            "slippage.default.stop", default_stop_sizing_price);
#endif
        check_slippage_fill_price(default_stop_sizing_price,
                                  std::isfinite(marketable ? signal : stop_price));
    }
    if (default_sized || typed_sized || direction_blocked || affordability_reversal_candidate) {
        request.intent = native_order::HostSized{native_order::HostSizedKind::Open,
            is_long ? native_order::Side::Long : native_order::Side::Short};
    } else if (fixed_priced_reverse || cash_priced_reverse) {
        request.intent = native_order::HostSized{native_order::HostSizedKind::Open,
            is_long ? native_order::Side::Long : native_order::Side::Short};
    } else if (reverses) {
        request.intent = native_order::ReverseTo{signed_target};
    } else {
        request.intent = native_order::Transact{signed_target};
    }
    if (flat_pending_opposite_market_units > 0.0) {
        const double transaction = normalized_qty + flat_pending_opposite_market_units;
        request.intent = native_order::Transact{is_long ? transaction : -transaction};
    }
    // Outside the zero-cost batch the later of two opposite flat market
    // calls is still one transaction of its own quantity plus the earlier
    // pending market call's (lab tv w6-f10j-pair-commission-per-order MM-LF).
    if (!priced && !same_bar_market_candidate && current == 0.0 && explicit_fixed
        && finite_positive(qty) && oca_name.empty() && source_point
        && same_point_pair_scope()
        && (config_.pyramiding <= 1
            || same_point_two_leg_book(id, source_point->decision.script_bar_open_ms))) {
        const double pending = pending_opposite_market_units(
            is_long, source_point->decision.script_bar_open_ms, id);
        if (finite_positive(pending)) {
            const double transaction = normalized_qty + pending;
            request.intent = native_order::Transact{is_long ? transaction : -transaction};
        }
    }
    request.label = id; request.comment = comment;
    const auto coof_native_state = detail::run_state(require_host());
    const bool coof_lower_path = coof_native_state.spec
        && coof_native_state.spec->intrabar.lower();
    // A matcher fill AT the bar's second extreme: the recalculation's market
    // entry fills there, at that extreme. ab9714be advanced every endpoint
    // fill to the following waypoint, the close, which admits no cascade
    // order, and filled the entry at the next open; TradingView books it on
    // the fill's own bar at the extreme (hm-chart-diff-v2 / -v6 bar 19: 11.72
    // / 11.74 at the high, and under process_orders_on_close -v3 / -v7 alike
    // -- the order-schedule correction). A fill the adapter forced there still advances
    // (coof_fill_at_second_extreme; the recalculation fill-order correction).
    bool coof_market_next_open = false;
    bool coof_market_at_second_extreme = false;
    double coof_second_extreme = kNaN;
    if (coof_recalc_active_ && !coof_first_open_ && !coof_lower_path && !priced
        && coof_fill_at_second_extreme()) {
        coof_second_extreme = source_path_uses_high_first(coof_script_bar_)
            ? coof_script_bar_.low : coof_script_bar_.high;
        coof_market_next_open = coof_fill_forced_;
        coof_market_at_second_extreme = !coof_fill_forced_;
    }
    const bool coof_market_next_sub_bar = coof_recalc_active_ && !coof_first_open_
        && coof_lower_path && !priced && coof_waits_for_next_sub_bar();
    double native_limit = limit_price;
    double native_stop = stop_price;
    if (finite_positive(limit_price) && !finite_positive(stop_price)) {
        // ab9714be pine_policy_members.cpp:11-17 + engine.hpp:1374-1381: every
        // entry limit, explicit-qty included, is tested against the
        // tick-quantized bar, so an off-grid level triggers on the half-up
        // rounded print (synthetic NYSE:F limits 25.045 / 26.045 / 27.00).
        native_limit = source_trigger_threshold(
            limit_price, staged_.syminfo.mintick, is_long, true, value_field::entry_limit_price);
    } else if (finite_positive(stop_price) && !finite_positive(limit_price)
               && !config_.calc_on_order_fills) {
        native_stop = source_trigger_threshold(
            stop_price, staged_.syminfo.mintick, is_long, false, value_field::entry_stop_price);
    }
    const auto* pine_host = pine_view_of(&require_host());
    const bool nonpositive_priced = priced && pine_host
        && pine_host->scheduler_uses_aux_security_feed()
        && !finite_positive(native_limit) && !finite_positive(native_stop);
    request.trigger = nonpositive_priced
        ? native_order::Trigger{native_order::Limit{
            is_long ? std::numeric_limits<double>::min()
                    : std::numeric_limits<double>::max()}}
        : trigger_for(native_limit, native_stop);
    double coof_market_fill = kNaN;
    double coof_market_target = kNaN;
    if (coof_recalc_active_ && !coof_first_open_ && !coof_market_next_open
        && !coof_market_next_sub_bar && coof_script_bar_valid_
        && std::holds_alternative<native_order::Market>(request.trigger)
        && (coof_market_at_second_extreme || !defer_coof_tail())) {
        // ab9714be pine_scheduler.cpp:398-619: a MARKET request born by a
        // non-first-open fill recalc waits for the next unconsumed waypoint.
        // A mid-segment fill retains that segment's endpoint; an endpoint
        // fill advances to the following waypoint -- but the second
        // extreme's own (above).
        int next_extreme_index = -1;
        const double next_extreme = coof_market_at_second_extreme
            ? coof_second_extreme : coof_next_waypoint(&next_extreme_index);
        if (coof_market_at_second_extreme) next_extreme_index = 2;
        coof_market_target = next_extreme;
        const auto point = detail::callback_point(require_host());
        const double current_quote = point ? point->price : kNaN;
        coof_market_fill = source_bar_fill_tick(
            next_extreme, staged_.syminfo.mintick)
            + (is_long ? 1.0 : -1.0) * config_.slippage
                * staged_.syminfo.mintick;
#ifdef PINEFORGE_VALUE_INVALID_FIXTURES
        coof_market_fill = fixture_adapter_execution_value("slippage.recalc.entry", coof_market_fill);
#endif
        check_slippage_fill_price(coof_market_fill, std::isfinite(next_extreme));
        if (finite_positive(coof_market_fill) && finite_positive(current_quote)
            && !source_same_point(current_quote, coof_market_fill, staged_.syminfo.mintick)) {
            const bool falling = coof_market_fill < current_quote;
            // An extreme (W1/W2) target arms at the raw waypoint, so the fill
            // lands AT that point (pine_scheduler.cpp:548-563) even when its
            // booked tick lies beyond an off-grid extreme or short of it (L
            // 11.995 booked 12.00 would otherwise fill mid-leg).
            // The booked tick may lie on the wrong side of that raw level,
            // so the limit is a touch trigger (fill-through).
            const bool extreme_target = next_extreme_index == 1
                || next_extreme_index == 2;
            const native_order::Limit limit = extreme_target
                ? native_order::Limit{next_extreme, coof_market_fill != next_extreme}
                : native_order::Limit{coof_market_fill};
            if (is_long) {
                request.trigger = falling
                    ? native_order::Trigger{limit}
                    : native_order::Trigger{native_order::Stop{next_extreme}};
            } else {
                request.trigger = falling
                    ? native_order::Trigger{native_order::Stop{next_extreme}}
                    : native_order::Trigger{limit};
            }
        }
        // ab9714be pine_fills.cpp:7962-7966 + engine.hpp:1207-1210: the
        // waypoint POINT fill books bar_fill_price(waypoint); the trigger
        // above keeps the reachable grid level.
        coof_market_fill = nearest_tick(next_extreme, staged_.syminfo.mintick)
            + (is_long ? 1.0 : -1.0) * config_.slippage
                * staged_.syminfo.mintick;
#ifdef PINEFORGE_VALUE_INVALID_FIXTURES
        coof_market_fill = fixture_adapter_execution_value("slippage.recalc.entry_tick", coof_market_fill);
#endif
        check_slippage_fill_price(coof_market_fill, std::isfinite(next_extreme));
    }
    if (pure_stop_entry && explicit_fixed && current != 0.0
        && ((current > 0.0) != is_long) && source_point
        && !config_.process_orders_on_close && !config_.calc_on_order_fills) {
        auto* pine_host = pine_view_of(&require_host());
        const auto next = pine_host
            ? pine_host->scheduler_.next_source_bar(
                source_point->decision.coordinate.interval_index)
            : std::optional<Bar>{};
        if (next) {
            for (const auto& handle : live_handles_) {
                const auto found = placement_.find(handle.incarnation);
                if (found == placement_.end()) continue;
                const auto& prior = found->second;
                const bool current_exit_limit =
                    prior.family == PineOrderFamily::ExitLimit
                    && prior.projection_created_bar
                        == source_point->decision.coordinate.interval_index
                    && finite_positive(prior.exit_levels.limit);
                const bool both_reached = current > 0.0
                    ? next->high >= prior.exit_levels.limit && next->low <= stop_price
                    : next->low <= prior.exit_levels.limit && next->high >= stop_price;
                if (!current_exit_limit || !both_reached) continue;
                request.intent = native_order::Transact{signed_target};
                request.owner = native_order::WaitForApplied{handle};
                break;
            }
        }
    }
    request.group = group_for(oca_name, oca_type);
    if (close_all_precedes && !priced && current_point
        && !config_.process_orders_on_close) {
        for (auto it = live_handles_.rbegin(); it != live_handles_.rend(); ++it) {
            const auto close = placement_.find(it->incarnation);
            if (close == placement_.end()
                || close->second.family != PineOrderFamily::CloseAll
                || close->second.placement_script_open_ms
                    != current_point->decision.script_bar_open_ms) {
                continue;
            }
            preceding_close_all = *it;
            break;
        }
    }
    const bool sequenced_close_entry = pure_stop_entry
        || (!priced && (!staged_.quantity_grid || *staged_.quantity_grid < 1.0));
    if (preceding_close_all.incarnation == 0 && sequenced_close_entry
        && current != 0.0 && ((current > 0.0) != is_long))
        preceding_close_all = preceding_close_request;
    PlacementSnapshot snapshot;
    snapshot.family = PineOrderFamily::Entry;
    snapshot.source_id = id;
    snapshot.comment = comment;
    snapshot.oca_name = oca_name;
    snapshot.oca_type = oca_type; snapshot.qty_type = qty_type;
    snapshot.requested_qty = normalized_qty; snapshot.is_long = is_long;
    snapshot.opening = true;
    snapshot.paired_reversal_parent = preceding_close_all;
    snapshot.command_ordinal = ++command_ordinal_;
    snapshot.direction_gate = direction_blocked;
    snapshot.deferred_cohort = default_sized;
    if (reverses && source_point) {
        for (const auto& handle : live_handles_) {
            const auto prior = placement_.find(handle.incarnation);
            if (prior != placement_.end()
                && prior->second.family == PineOrderFamily::Close
                && !prior->second.from_entry.empty()
                && prior->second.projection_created_bar
                    == source_point->decision.coordinate.interval_index) {
                snapshot.projection_after_close = true;
                break;
            }
        }
    }
    if (flat_pending_opposite_market_units > 0.0) {
        snapshot.paired_flat_market_candidate = true;
        snapshot.paired_flat_market_own_qty = normalized_qty;
        snapshot.paired_flat_market_transaction_qty =
            normalized_qty + flat_pending_opposite_market_units;
    }
    if (source_command_sequence_ == std::numeric_limits<std::uint64_t>::max()) {
        throw coded<std::overflow_error>(RunFailureCode::engine_invariant, {},
                                         "Pine source command sequence exhausted");
    }
    snapshot.command_sequence = ++source_command_sequence_;
    // Reuse the durable level tuple for the parent trigger facts.  A deferred
    // relative exit may safely arm from a non-gap LIMIT parent's known entry
    // level before that parent is applied.
    snapshot.exit_levels.limit = limit_price;
    snapshot.exit_levels.stop = stop_price;
    snapshot.birth = capture_order_birth();
    snapshot.birth_reach = compat::pine::select_historical_birth_reach(
        snapshot.birth, false);
    snapshot.reverse_to = reverses || paired_all_in_reentry;
    snapshot.projection_after_close = close_precedes_entry;
    snapshot.close_first_entry = close_first_fact;
    snapshot.signal_price_refused = signal_price_refused;
    snapshot.sizing = sizing_snapshot();
    if (finite_positive(coof_market_fill)) {
        snapshot.forced_execution_price = coof_market_fill;
        snapshot.forced_waypoint_print = coof_market_target;
    }
    bool coof_priced_next_open = false;
    if (coof_recalc_active_ && !coof_first_open_ && !coof_lower_path && priced) {
        const auto point = detail::callback_point(require_host());
        const double birth = point ? point->price : kNaN;
        int waypoint_index = -1;
        const double waypoint = coof_next_waypoint(&waypoint_index);
        bool reached = false;
        bool limit_route = false;
        if (finite_positive(stop_price)) {
            reached = is_long ? (waypoint >= stop_price && birth < stop_price)
                              : (waypoint <= stop_price && birth > stop_price);
        } else if (finite_positive(limit_price)) {
            limit_route = true;
            reached = is_long ? (waypoint <= limit_price && birth > limit_price)
                              : (waypoint >= limit_price && birth < limit_price);
        }
        if (reached) {
            const double slipped = waypoint + (limit_route ? 0.0
                : (is_long ? 1.0 : -1.0) * config_.slippage
                    * staged_.syminfo.mintick);
            snapshot.forced_execution_price = nearest_tick(
                slipped, staged_.syminfo.mintick);
        }
        // A pure limit or stop entry that the recalculation of a MID-LEG fill
        // places already executable at that fill's price is live only from
        // the leg's end, the next extreme: when still executable there it
        // fills at the extreme's print (a stop keeps its slippage).
        // TradingView, lab tv tapes tests/fixtures/coof_refill_waypoint
        // (w8d-coof2-a/b/d/e/f; resting-limit control -c): the level fill
        // this path booked at the placement point was never executable
        // after it (the entry-eligibility correction). An entry not executable at the
        // extreme keeps its level fill: TradingView rests it there (-d), but
        // a magnified script's next point is an intrabar one, and resting
        // it to the chart bar's extreme delayed the unmagnified
        // EMA200 probe's refills by a bar or more. Not pinned under
        // process_orders_on_close, on the close leg or on a leg-end fill --
        // but a fill the adapter FORCED onto the first extreme starts the
        // next leg the same way: its entry fills at the second extreme when
        // executable there (lab tv tailc-w2r-c/d, 98 rows; the placement and recalculation correction).
        const bool pure_limit = finite_positive(limit_price) && !finite_positive(stop_price);
        const bool pure_stop = finite_positive(stop_price) && !finite_positive(limit_price);
        const double level = pure_limit ? limit_price : stop_price;
        const auto executable_at = [&](double price) {
            return pure_limit ? (is_long ? price <= level : price >= level)
                              : (is_long ? price >= level : price <= level);
        };
        const bool forced_first_extreme = coof_fill_forced_ && waypoint_index == 2
            && !coof_fill_at_second_extreme();
        if (!reached && (pure_limit || pure_stop) && !config_.process_orders_on_close
            && (waypoint_index == 1 || waypoint_index == 2) && finite_positive(waypoint)
            && finite_positive(birth)
            && (!coof_fill_on_path_point() || forced_first_extreme)
            && executable_at(birth) && executable_at(waypoint)) {
            const double tick = staged_.syminfo.mintick;
            const double booked = source_bar_fill_tick(waypoint, tick);
            const bool falling = waypoint < birth;
            request.trigger = is_long == falling
                ? native_order::Trigger{native_order::Limit{waypoint, booked != waypoint}}
                : native_order::Trigger{native_order::Stop{waypoint}};
            snapshot.forced_execution_price = nearest_tick(waypoint
                + (pure_limit ? 0.0 : (is_long ? 1.0 : -1.0) * config_.slippage * tick),
                tick);
        } else if (!reached && (pure_limit || pure_stop) && !config_.process_orders_on_close
            && (waypoint_index == 1 || waypoint_index == 2) && finite_positive(waypoint)
            && finite_positive(birth)
            && (!coof_fill_on_path_point() || forced_first_extreme)
            && executable_at(birth) && !executable_at(waypoint)) {
            // An entry executable at its birth but not at the extreme rests at
            // its own level from the extreme on (w8d-coof2-d/e/f, and after a
            // forced first-extreme fill tailc-w2r-a/b: every refill filled
            // after the extreme or later, none on the leg before it; the
            // placement and recalculation correction). A limit arms at the extreme: StopLimit{extreme, level}.
            // A stop becomes a trail armed at the extreme, riding its level's
            // distance behind the running best: no print beyond the extreme
            // follows on this bar, so it is the stop at its own level, booked
            // there; on_bar_open hands the next bar the plain stop back.
            if (pure_limit) {
                request.trigger = native_order::StopLimit{waypoint, limit_price};
            } else {
                request.trigger = native_order::Trail{std::abs(stop_price - waypoint), waypoint};
                snapshot.forced_execution_price = nearest_tick(stop_price
                    + (is_long ? 1.0 : -1.0) * config_.slippage * staged_.syminfo.mintick,
                    staged_.syminfo.mintick);
            }
        }
        // A pure limit or stop entry placed by the recalculation of a fill
        // the adapter FORCED onto the bar's second extreme is live only from
        // the next bar's open, as that recalculation's market orders are
        // (coof_market_next_open): TradingView never fills it on the rest of
        // the bar -- at that open when it is executable there, otherwise at
        // its own level later -- executable at the forced fill or not, and
        // even when the leg to the close crosses its level (lab tv tapes
        // tests/fixtures/coof_w2_refill, tailc-w2r-a..f: 1013 refills after
        // such a fill, none on its bar; the placement and recalculation correction). Released at the
        // recalculation, it would also trade on the part of the leg the
        // kernel walks after the forced fill's trigger, which TradingView has
        // already passed.
        coof_priced_next_open = (pure_limit || pure_stop)
            && !config_.process_orders_on_close && coof_fill_forced_
            && coof_fill_at_second_extreme();
    }
    // On a magnified path the recalculation's next fill point is the next
    // point of TradingView's own intrabar path (next_input_waypoint), or the
    // open itself for the refill of a first open fill. A pure limit or stop
    // entry the recalculation places is live only from that point: executable
    // there, it fills at the point's print (a stop keeps its slippage); a
    // limit that is not rests at its own level from the point on. A stop that
    // is not keeps its level: a later intrabar can pass the point, so no
    // trigger here rests it (lab tv tailc-mag-coof-refill-leg; the
    // placement and recalculation correction, the magnified twin of w8d-coof2-*).
    if (coof_recalc_active_ && coof_lower_path && priced && !config_.process_orders_on_close) {
        const bool lower_limit = finite_positive(limit_price) && !finite_positive(stop_price);
        const bool lower_stop = finite_positive(stop_price) && !finite_positive(limit_price);
        const auto lower_point = detail::callback_point(require_host());
        const double lower_birth = lower_point ? lower_point->price : kNaN;
        std::optional<PineScheduler::InputWaypoint> lower_next;
        if (coof_first_open_) {
            if (finite_positive(lower_birth))
                lower_next = PineScheduler::InputWaypoint{lower_birth, false};
        } else if (const auto* lower_host = pine_view_of(&require_host())) {
            lower_next = lower_host->scheduler_.next_input_waypoint(*lower_host, coof_context_);
        }
        // A fill on the chart bar's last intrabar-path point leaves the next
        // bar's opening as the next fill point: the entry is live from that
        // open, as off the magnified path (tailc-mag-coof-refill-leg; synthetic buy limit
        // placed at a 25.01 close print is live at the next bar's open
        // and fills at that open's better 25.00 print).
        if ((lower_limit || lower_stop) && lower_next && lower_next->next_open
            && coof_context_.is_terminal_sub_bar) {
            coof_priced_next_open = true;
        } else if ((lower_limit || lower_stop) && lower_next
            && finite_positive(lower_next->price) && finite_positive(lower_birth)) {
            const double level = lower_limit ? limit_price : stop_price;
            const double waypoint = lower_next->price;
            const double tick = staged_.syminfo.mintick;
            const auto executable_at = [&](double price) {
                return lower_limit ? (is_long ? price <= level : price >= level)
                                   : (is_long ? price >= level : price <= level);
            };
            const bool same_point = coof_first_open_ || lower_next->next_open
                || source_same_point(lower_birth, waypoint, tick);
            if (executable_at(waypoint)) {
                if (same_point) {
                    request.trigger = native_order::Market{};
                } else {
                    const double booked = source_bar_fill_tick(waypoint, tick);
                    const bool falling = waypoint < lower_birth;
                    request.trigger = is_long == falling
                        ? native_order::Trigger{native_order::Limit{waypoint, booked != waypoint}}
                        : native_order::Trigger{native_order::Stop{waypoint}};
                }
                snapshot.forced_execution_price = nearest_tick(waypoint
                    + (lower_limit ? 0.0 : (is_long ? 1.0 : -1.0) * config_.slippage * tick),
                    tick);
            } else if (lower_limit && !same_point && (waypoint > lower_birth) == is_long) {
                request.trigger = native_order::StopLimit{waypoint, level};
            }
        }
    }
    if (current == 0.0 && priced && current_point) {
        const auto is_opposite_market_predecessor = [&](const PlacementSnapshot& prior) {
            return prior.opening && prior.family == PineOrderFamily::Entry
                && prior.is_long != is_long
                && prior.placement_script_open_ms
                    == current_point->decision.script_bar_open_ms
                && !finite_positive(prior.exit_levels.limit)
                && !finite_positive(prior.exit_levels.stop)
                && !finite_positive(prior.exit_levels.trail_points)
                && !finite_positive(prior.exit_levels.trail_price)
                && !finite_positive(prior.exit_levels.trail_offset);
        };
        snapshot.projection_opposite_market_predecessor = std::any_of(
            pending_same_bar_commands_.begin(), pending_same_bar_commands_.end(),
            [&](const PendingSameBarCommand& prior) {
                return is_opposite_market_predecessor(prior.snapshot);
            }) || std::any_of(pending_entries_.begin(), pending_entries_.end(),
            [&](const PendingEntry& prior) {
                return is_opposite_market_predecessor(prior.snapshot);
            }) || std::any_of(live_handles_.begin(), live_handles_.end(),
            [&](const native_order::RequestHandle& handle) {
                const auto prior = placement_.find(handle.incarnation);
                return prior != placement_.end()
                    && is_opposite_market_predecessor(prior->second);
            });
        // A marketable buy stop outranks the sell market it follows at their
        // shared fill point (order_same_point_entries): TradingView fills it
        // first, as one buy of its own quantity plus the market's, and the
        // market then sells only its own (lab tv w6-f10a-open-pair MS-SF).
        const bool fills_ahead = snapshot.projection_opposite_market_predecessor
            && same_point_pair_scope() && explicit_fixed && is_long
            && pure_stop_entry && finite_positive(current_point->price)
            && stop_price <= current_point->price
            && (config_.pyramiding <= 1 || same_point_two_leg_book(
                    id, current_point->decision.script_bar_open_ms));
        const double predecessor_units = fills_ahead
            ? pending_opposite_market_units(
                is_long, current_point->decision.script_bar_open_ms, id)
            : kNaN;
        if (fills_ahead && finite_positive(predecessor_units)) {
            request.intent = native_order::Transact{normalized_qty + predecessor_units};
        } else if (snapshot.projection_opposite_market_predecessor) {
            // ab9714be pine_pending_intent.hpp:507-537: placement_has_opposite_market_predecessor reverses against same-bar predecessor
            request.intent = native_order::HostSized{native_order::HostSizedKind::Open,
                is_long ? native_order::Side::Long : native_order::Side::Short};
            snapshot.terms_priced_reverse = true;
        }
    }
    if (default_sized && !priced && finite_positive(snapshot.sizing.mark)) {
        snapshot.sizing.price = default_market_sizing_price(snapshot.sizing.mark, is_long);
#ifdef PINEFORGE_VALUE_INVALID_FIXTURES
        snapshot.sizing.price = fixture_adapter_execution_value("slippage.default.snapshot", snapshot.sizing.price);
#endif
        check_slippage_fill_price(snapshot.sizing.price, std::isfinite(snapshot.sizing.mark));
        mark_sizing_equity(snapshot.sizing, snapshot.sizing.mark);
    }
    const auto predecessor = live_by_source_key_.find(checked_live_key(id));
    snapshot.replaced_opening = predecessor != live_by_source_key_.end();
    if (snapshot.replaced_opening) {
        const auto prior = placement_.find(predecessor->second.incarnation);
        snapshot.replacement_predecessor_market = prior != placement_.end()
            && !finite_positive(prior->second.exit_levels.limit)
            && !finite_positive(prior->second.exit_levels.stop);
    }
    // R1: a same-id MARKET reissue of a reversal whose predecessor is still
    // staged in this callback's same-bar batch is the same replacement; the
    // staged predecessor never reached live_by_source_key_. TradingView books
    // the reissue as a transaction of its own quantity against the opposite
    // position, not as a reversal, on either side and for every quantity kind
    // (lab tv tapes tests/fixtures/same_bar_reissue, lane R1-CONSOLIDATE).
    bool staged_reversal_replacement = false;
    if (same_bar_market_candidate && !snapshot.replaced_opening && reverses) {
        staged_reversal_replacement = std::any_of(pending_same_bar_commands_.begin(),
            pending_same_bar_commands_.end(), [&](const PendingSameBarCommand& row) {
                return row.opening && !row.snapshot.frozen_market_targeted_close
                    && row.replacement_key == id
                    && row.snapshot.family == PineOrderFamily::Entry
                    && row.snapshot.is_long == is_long;
            });
        snapshot.replaced_opening = staged_reversal_replacement;
        snapshot.replacement_predecessor_market = staged_reversal_replacement;
    }
    const bool special_sell_replacement = default_sized && reverses && !is_long
        && snapshot.replaced_opening && snapshot.replacement_predecessor_market;
    if (special_sell_replacement && current_point) {
        std::vector<native_order::RequestHandle> superseded_siblings;
        for (const auto& handle : live_handles_) {
            const auto pending = placement_.find(handle.incarnation);
            if (pending == placement_.end()) continue;
            const auto& prior = pending->second;
            if (prior.family == PineOrderFamily::Entry && prior.opening
                && prior.source_id != id && prior.is_long == is_long
                && prior.placement_script_open_ms == current_point->decision.script_bar_open_ms) {
                superseded_siblings.push_back(handle);
            }
        }
        for (const auto& handle : superseded_siblings) {
            cancel_bracket_origin(handle);
            const auto result = require_host().cancel(handle);
            if (result.status == native_order::CancelStatus::Cancelled) retire(handle);
        }
        std::vector<native_order::RequestHandle> carried_brackets;
        std::vector<SourceId> carried_ids;
        using CohortRow = std::remove_reference_t<decltype(*cohorts_by_id_.begin())>;
        std::vector<const CohortRow*> cohorts;
        cohorts.reserve(cohorts_by_id_.held_size());
        for (const auto& row : cohorts_by_id_.held_rows()) cohorts.push_back(&row);
        // The cancellation order below was lexical; retain it. Collecting
        // held rows costs O(H), and this existing sort still costs O(H log H).
        std::sort(cohorts.begin(), cohorts.end(),
            [](const auto* a, const auto* b) { return a->first < b->first; });
        for (const auto* cohort : cohorts) {
            for (const auto& origin : cohort->second.opened) {
                const auto prior = placement_.find(origin.incarnation);
                if (prior != placement_.end() && prior->second.is_long != is_long) {
                    carried_brackets.push_back(origin);
                    carried_ids.push_back(cohort->first);
                }
            }
        }
        for (const auto& origin : carried_brackets) cancel_bracket_origin(origin);
        std::vector<native_order::RequestHandle> dynamic_carried_legs;
        for (const auto& handle : live_handles_) {
            const auto leg = placement_.find(handle.incarnation);
            if (leg == placement_.end()) continue;
            const auto family = leg->second.family;
            if ((family == PineOrderFamily::ExitLimit || family == PineOrderFamily::ExitStop
                 || family == PineOrderFamily::ExitTrail)
                && std::find(carried_ids.begin(), carried_ids.end(), leg->second.from_entry)
                    != carried_ids.end()) {
                dynamic_carried_legs.push_back(handle);
            }
        }
        for (const auto& handle : dynamic_carried_legs) {
            const auto result = require_host().cancel(handle);
            if (result.status == native_order::CancelStatus::Cancelled) retire(handle);
        }
    }
    snapshot.terms_priced_reverse = fixed_priced_reverse || cash_priced_reverse
        || (reverses && typed_sized);
    snapshot.placement_cycle = current_position_cycle_;
    if (fixed_priced_reverse) {
        snapshot.frozen_reversal_transaction = std::abs(current) + normalized_qty;
    }
    if (default_stop_freeze && finite_positive(default_stop_sizing_price)) {
        // A default-sized stop entry freezes its quantity against the
        // directionally snapped level, except an already-marketable stop
        // which is a next-open market order and therefore freezes at the
        // source close. Neither path re-sizes at its later fill quote --
        // above 100 % too, where ab9714be sized at the fill: eight lab tv
        // tapes of a 390-400 % stop on NYSE:F (the margin-schedule correction,
        // tests/fixtures/margin_entry_bar/pm-m10-*) open the snapped level's
        // quotient when the stop was not yet marketable and the signal
        // close's when it was, never the fill's.
        snapshot.sizing.price = default_stop_sizing_price;
    }
    bool pooc_fee_sized = false;
    if (default_sized && finite_positive(snapshot.sizing.price)) {
        if (config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
            || config_.default_qty_type == static_cast<int>(QtyType::CASH)) {
            snapshot.sizing.frozen_units = default_sizing_units(snapshot.sizing);
        }
        // pooc_fee_units() answers nothing outside its configuration
        // (pooc_fee_configured_), so only a run inside it asks.
        if (!priced && pooc_fee_configured_) {
            if (const auto fee_units = pooc_fee_units(snapshot.sizing)) {
                snapshot.sizing.frozen_units = *fee_units;
                pooc_fee_sized = true;
            }
        }
        // ab9714be pine_fills.cpp:7139: non-pure-stop priced entries size at fill time using calc_qty(fill_price)
        snapshot.sizing.at_fill = (config_.calc_on_order_fills && coof_recalc_active_)
            || (priced && !default_stop_freeze);
    }
    // Under process_orders_on_close TradingView sizes a default-quantity
    // percent_of_equity MARKET short at its slipped fill -- the close less the
    // slippage ticks -- but opens it only while those units' margin at the
    // close itself fits the equity the calculation marked there: synthetic 99.99 % of
    // 100000 at slippage 15 opens (49.9987 x 2000.00 = 99997.40), 99.995 % and
    // 100 % do not at that price/lot grid. An unfunded one is dropped from a flat
    // book and keeps only its closing leg when it reverses a long, whether a
    // strategy.close of that long precedes it or follows it (w4-f14-pooc-v6-slip:
    // TradingView closes every long and opens no short; lane
    // the third-party NYSE:F, ETH and EURUSD strategies hold no
    // short at all, where the engine opened each one and margin-called it on its
    // entry bar). A lot step coarse against the slippage absorbs the gap, so
    // most such shorts still open on BTC.
    if (config_.process_orders_on_close && !config_.calc_on_order_fills
        && config_.slippage > 0 && default_sized && !priced && !is_long
        && config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        && !snapshot.sizing.at_fill
        && finite_positive(snapshot.sizing.frozen_units)
        && finite_positive(snapshot.sizing.mark) && std::isfinite(snapshot.sizing.equity)
        && snapshot.sizing.fx == 1.0) {
        const double required = snapshot.sizing.frozen_units * snapshot.sizing.mark
            * staged_.syminfo.pointvalue * config_.margin_short / 100.0;
        const double epsilon = std::max(1e-9, std::abs(snapshot.sizing.equity) * 1e-12);
        if (required > snapshot.sizing.equity + epsilon) {
            if (!reverses) return;
            snapshot.affordability_close_only = true;
        }
    }
    // Without process_orders_on_close the same holds for such a short from a
    // flat book, which fills at the next open: TradingView sizes it at the
    // signal close less the slippage ticks (and the commission) and opens it
    // only while those units' margin at the signal close, on its tick, fits
    // the equity there, whatever the open. Synthetic NYSE:F at slippage 1:
    // all 10000 at a close of 25.005 sizes 400 at 25.00 and does not open
    // (400 x 25.01 = 10004.00); the commission's smaller quantity opens where
    // the floor left the tick's room, and at slippage 4 none does (lab tv
    // tapes tests/fixtures/slipped_short int28fix-adm-s-s and int28fix-ou-s4;
    // The slipped-short admission rule). A long, and a short without slippage, are
    // sized at or beyond that close and keep their fill-time admission
    // (int28fix-adm-l-cs, -adm-s-0, -adm-s-c). A reversal, or a book with an
    // entry pending, is not measured.
    if (!config_.process_orders_on_close && !config_.calc_on_order_fills
        && !coof_recalc_active_ && config_.slippage > 0 && default_sized && !priced
        && !is_long && current == 0.0
        && config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        && !snapshot.sizing.at_fill
        && finite_positive(snapshot.sizing.frozen_units)
        && finite_positive(snapshot.sizing.mark) && std::isfinite(snapshot.sizing.equity)
        && snapshot.sizing.fx == 1.0
        && std::none_of(live_handles_.begin(), live_handles_.end(),
            [&](const native_order::RequestHandle& handle) {
                const auto existing = placement_.find(handle.incarnation);
                return existing != placement_.end() && existing->second.opening
                    && existing->second.family == PineOrderFamily::Entry;
            })) {
        const double signal = nearest_tick(snapshot.sizing.mark, staged_.syminfo.mintick);
        const double required = snapshot.sizing.frozen_units * signal
            * staged_.syminfo.pointvalue * config_.margin_short / 100.0;
        const double epsilon = std::max(1e-9, std::abs(snapshot.sizing.equity) * 1e-12);
        if (required > snapshot.sizing.equity + epsilon) return;
    }
    // R5 R2: a declaration-level default quantity whose sizing price IS the
    // signal rule and whose quantity is frozen at the command is exactly what
    // the core's Sized intent names, so it is lowered onto it here.  The
    // fill-time paths (at_fill) and the pure-stop path size at a price the
    // core cannot name -- the source's own resolved fill quote, and the
    // directionally snapped stop level -- and keep their host-resolved shape,
    // as does a direction the run's own opening gate would refuse at
    // placement.  The source keeps its money, its lot floor and its
    // placement admission; the core owns the units that settle.
    if (default_sized && !priced && !snapshot.sizing.at_fill && !direction_blocked
        && !pooc_fee_sized && finite_positive(snapshot.sizing.frozen_units)) {
        const auto* host_shape = std::get_if<native_order::HostSized>(&request.intent);
        if (host_shape && host_shape->kind == native_order::HostSizedKind::Open) {
            if (auto sized = default_sizing_intent(snapshot.sizing, is_long)) {
                request.intent = *sized;
            }
        }
    }
    // The TV money band is a source policy, not a generic margin rule.  Its
    // all-in source tuple is judged at placement on ten-significant-digit
    // money: a true-flat order is dropped, while a real reversal retains only
    // its closing leg.  A later price-scale failure drops the whole command.
    // This is the direct lowering of pine_fills.cpp:5054-5139 at ab9714be.
    const double entry_margin = is_long ? config_.margin_long : config_.margin_short;
    const bool tv_money_scope = default_sized && !priced
        && config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        && std::abs(config_.default_qty_value - 100.0) < 1e-12
        && std::abs(entry_margin - 100.0) < 1e-12
        && staged_.quantity_grid && *staged_.quantity_grid > 0.0
        && finite_positive(snapshot.sizing.frozen_units)
        && finite_positive(snapshot.sizing.price)
        && finite_positive(snapshot.sizing.equity)
        && finite_positive(snapshot.sizing.fx)
        && finite_positive(staged_.syminfo.pointvalue)
        && (*staged_.quantity_grid * snapshot.sizing.price * staged_.syminfo.pointvalue
            * snapshot.sizing.fx < 1.0);
    // The POOC flat-money family is a fill-boundary decision because its
    // threshold includes the slipped signal price.  validate_precommit owns
    // that exact comparison; applying the ordinary signal-price gate here
    // drops the tight-but-admitted POOC controls before the candidate exists.
    if (tv_money_scope && !config_.process_orders_on_close) {
        const double notional_per_price = snapshot.sizing.frozen_units
            * staged_.syminfo.pointvalue * snapshot.sizing.fx;
        const double rounded_cost = source_money_round(notional_per_price * snapshot.sizing.price);
        if (snapshot.sizing.equity + 1e-9 < rounded_cost) {
            if (reverses && !snapshot.projection_after_close) {
                snapshot.affordability_close_only = true;
                snapshot.rounded_signal_cost_close_only = true;
            } else if (reverses)
                snapshot.affordability_close_only = false;
            else return;
        } else if (!snapshot.projection_after_close) {
            const double affordable_price = source_money_round(
                source_money_round(snapshot.sizing.equity) / notional_per_price);
            if (std::isfinite(affordable_price) && affordable_price < snapshot.sizing.price) return;
        }
    }
    // pine_strategy_commands.cpp:284-426 placement half.  A reversal whose
    // proposed opening cannot be funded retains a close-only source request;
    // flat/same-side rejection remains owned by their ordinary admission path.
    const bool affordability_scope = (!priced || pure_stop_entry) && (default_sized
        ? (config_.default_qty_type == static_cast<int>(QtyType::FIXED)
           || config_.default_qty_type == static_cast<int>(QtyType::CASH)
           || (config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
               && config_.default_qty_value > 100.0))
        : true);
    snapshot.affordability_policy_active = affordability_scope;
    if (affordability_scope && finite_positive(snapshot.sizing.mark)) {
        const double margin = is_long ? config_.margin_long : config_.margin_short;
        const double signal = nearest_tick(snapshot.sizing.mark, staged_.syminfo.mintick);
        double own_units = normalized_qty;
        if (default_sized) {
            own_units = finite_positive(snapshot.sizing.frozen_units)
                ? snapshot.sizing.frozen_units : config_.default_qty_value;
        } else if (qty_type == static_cast<int>(QtyType::CASH)) {
            own_units = typed_quantity_units(std::abs(normalized_qty), false, signal,
                                             snapshot.sizing.fx);
        } else if (qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)) {
            own_units = typed_quantity_units(
                snapshot.sizing.equity * std::abs(normalized_qty) / 100.0, true, signal,
                snapshot.sizing.fx);
        }
        const double held = reverses ? 0.0
            : std::max(0.0, std::abs(current) - preceding_close_qty);
        double charged_held = held;
        if ((pooc_pass && close_all_precedes) || pooc_pass_flattens) {
            // The position before this pass's closes: the script's own view,
            // which an ordinary close_all froze when it filled at its call.
            const auto* pine_host = pine_view_of(&require_host());
            const double before = pine_host ? pine_host->signed_position_size() : current;
            charged_held = before != 0.0 && ((before > 0.0) == is_long) ? std::abs(before) : 0.0;
        }
        const double required = (charged_held + std::abs(own_units)) * signal * staged_.syminfo.pointvalue
            * snapshot.sizing.fx * margin / 100.0;
        // The flat/same-side refusal below also owns finite explicit overflow.
        // Default sizing, reversals and nonfinite inputs retain the G fault.
        const bool finite_explicit_rejection = !default_sized && !reverses
            && std::isfinite(charged_held) && std::isfinite(own_units)
            && std::isfinite(signal) && std::isfinite(staged_.syminfo.pointvalue)
            && std::isfinite(snapshot.sizing.fx) && std::isfinite(margin);
        if (margin > 0.0
            && ((!std::isfinite(required) && !finite_explicit_rejection)
                || !std::isfinite(snapshot.sizing.equity))) {
            engine_command_value_invalid_or_count("margin.required", EngineValueStage::margin,
                                                 EngineValueReason::nonfinite);
        }
        const double epsilon = std::max(1e-9, std::abs(snapshot.sizing.equity) * 1e-12);
        snapshot.projection_affordability_equity = snapshot.sizing.equity;
        snapshot.projection_affordability_signal_price = signal;
        snapshot.projection_affordability_held_qty = held;
        if (reverses && margin > 0.0 && std::isfinite(required)
            && std::isfinite(snapshot.sizing.equity)
            && required > snapshot.sizing.equity + epsilon) {
            snapshot.affordability_close_only = true;
        } else if (!reverses && margin > 0.0
                   && (!std::isfinite(required) || !std::isfinite(snapshot.sizing.equity)
                       || required > snapshot.sizing.equity + epsilon)) {
            // The same placement-time rule drops an unaffordable flat or
            // same-side entry before it reaches the native request core.
            // ab9714be pine_strategy_commands.cpp:148-159, :343-426: a
            // rejected same-id pure STOP reissue also removes the older
            // resting request; a MARKET has no comparable carry.
            if (pure_stop_entry) {
                std::optional<native_order::RequestHandle> prior_handle;
                if (const auto prior = live_by_source_key_.find(checked_live_key(id));
                    prior != live_by_source_key_.end()) {
                    prior_handle = prior->second;
                }
                if (prior_handle) {
                    const auto result = require_host().cancel(*prior_handle);
                    if (result.status == native_order::CancelStatus::Cancelled)
                        retire(*prior_handle);
                }
            }
            return;
        }
    }
    // A default percent_of_equity (<= 100) MARKET add to a held position of
    // its own side is judged at placement against the held units plus its
    // own, as the explicit, fixed and cash sizes above are: TradingView drops
    // an add whose combined margin exceeds the equity, even where an exit
    // empties the position at the open the add would fill at, ahead of it
    // (lab tv tapes tests/fixtures/margin_v6 w5-m1-addexit-p100 and -p60 drop
    // every add; lane W5-ENG-MARGIN-V6). Without this the add opened from flat
    // behind the exit whenever the exit's leg took the open first. An over-cap
    // add the cap check above lets through stays a request, as it was: it is
    // judged where it could become executable (apply_open_market_admission).
    if (!affordability_scope && default_sized && !priced && !reverses
        && !same_bar_market_candidate && !short_seed_final_candidate
        && !paired_all_in_reentry && !default_gross_over_cap_candidate
        && !close_precedes_entry && !close_all_precedes
        && !config_.process_orders_on_close && !config_.calc_on_order_fills
        && config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        && config_.default_qty_value <= 100.0
        && current != 0.0 && ((current > 0.0) == is_long)
        && finite_positive(snapshot.sizing.frozen_units)
        && finite_positive(snapshot.sizing.mark)
        && add_margin_exceeds_equity(std::abs(current), snapshot.sizing,
                                     is_long ? config_.margin_long : config_.margin_short,
                                     staged_.syminfo.mintick, staged_.syminfo.pointvalue)) {
        return;
    }
    // TradingView checks a default-quantity LIMIT entry that opens from flat
    // at every call, against the calling bar's close: a call whose quantity
    // costs more than the equity there is rejected, and it takes the resting
    // order of that id with it, however affordable the order's own level is
    // (lane W8A-SIGSTATE-1 R3, tests/fixtures/limit_entry_affordability).
    // The fill-time check still applies to an order the call admitted.
    if (default_sized && config_.default_qty_type == static_cast<int>(QtyType::FIXED)
        && current == 0.0 && finite_positive(limit_price) && std::isnan(stop_price)
        && finite_positive(snapshot.sizing.mark)) {
        const double margin = is_long ? config_.margin_long : config_.margin_short;
        const double signal = nearest_tick(snapshot.sizing.mark, staged_.syminfo.mintick);
        const double required = std::abs(config_.default_qty_value) * signal
            * staged_.syminfo.pointvalue * snapshot.sizing.fx * margin / 100.0;
        const double epsilon = std::max(1e-9, std::abs(snapshot.sizing.equity) * 1e-12);
        if (margin > 0.0 && (!std::isfinite(required) || !std::isfinite(snapshot.sizing.equity)
                             || required > snapshot.sizing.equity + epsilon)) {
            if (const auto prior = live_by_source_key_.find(checked_live_key(id));
                prior != live_by_source_key_.end()) {
                const auto handle = prior->second;
                const auto result = require_host().cancel(handle);
                if (result.status == native_order::CancelStatus::Cancelled) retire(handle);
            }
            return;
        }
    }
    // Margin rule 2 for a percent-of-equity stop opening from flat at full
    // margin without slippage under process_orders_on_close: judged as an
    // explicit quantity is, at the
    // signal close c' = ticks x mintick (tests/fixtures/margin_call_rules
    // stop-40-percent: per-unit 1.18081 under the ulp-dirty
    // 1.1808100000000001 drops it, as it drops the explicit stop).
    if (PF_RARE(detail::margin_rule_switches().slipped_signal_admission && default_stop_scope
        && current == 0.0 && !reverses && config_.slippage == 0
        && config_.process_orders_on_close
        && finite_positive(snapshot.sizing.frozen_units)
        && finite_positive(snapshot.sizing.mark) && finite_positive(staged_.syminfo.mintick)
        && (is_long ? config_.margin_long : config_.margin_short) == 100.0
        && staged_.syminfo.pointvalue == 1.0 && snapshot.sizing.fx == 1.0
        && staged_.account_fx_effective_from_ms.empty()
        && std::isfinite(snapshot.sizing.equity))) {
        const double tick = staged_.syminfo.mintick;
        const double signal_close = std::floor(snapshot.sizing.mark / tick + 0.5) * tick;
        const double units = snapshot.sizing.frozen_units;
        const double equity = snapshot.sizing.equity;
        if (equity < source_money_round(units * signal_close)
            || source_money_round(source_money_round(equity) / units) < signal_close) {
            if (const auto prior = live_by_source_key_.find(checked_live_key(id));
                prior != live_by_source_key_.end()) {
                const auto prior_handle = prior->second;
                const auto result = require_host().cancel(prior_handle);
                if (result.status == native_order::CancelStatus::Cancelled) retire(prior_handle);
            }
            return;
        }
    }
    if (default_stop_scope && finite_positive(snapshot.sizing.frozen_units)
        && finite_positive(snapshot.sizing.mark)) {
        const double margin = is_long ? config_.margin_long : config_.margin_short;
        const double required = snapshot.sizing.frozen_units * snapshot.sizing.mark
            * staged_.syminfo.pointvalue * snapshot.sizing.fx * margin / 100.0;
        // ab9714be pine_strategy_commands.cpp:343-426 prices the default
        // percent_of_equity <= 100 pure STOP against placement equity with the
        // SAME float guard the explicit/FIXED/CASH/>100 arm uses; an all-in
        // stop quantity is floored against tick(close) so its cost lands inside
        // one double-rounding of the equity snapshot and must not be dropped.
        const double stop_epsilon = std::max(
            1e-9, std::abs(snapshot.sizing.equity) * 1e-12);
        const bool unfunded = margin > 0.0 && (!std::isfinite(required)
            || !std::isfinite(snapshot.sizing.equity)
            || required > snapshot.sizing.equity + stop_epsilon);
        if (unfunded && reverses) {
            // The same placement arm keeps a reversal's closing leg
            // (pine_strategy_commands.cpp:408-419): a sell stop sized at its
            // level and priced at the higher close cannot fund 100 % of
            // equity, so TradingView closes the long at the stop and opens
            // nothing (lane TVDEF-DROPS, tests/fixtures/tvdef_drops R1).
            snapshot.affordability_close_only = true;
        } else if (unfunded) {
            // Legacy replacement first removes the prior same-id resting
            // stop, then leaves the rejected re-issue absent from the book.
            std::optional<native_order::RequestHandle> prior_handle;
            if (const auto prior = live_by_source_key_.find(checked_live_key(id));
                prior != live_by_source_key_.end()) {
                prior_handle = prior->second;
            }
            if (prior_handle) {
                const auto result = require_host().cancel(*prior_handle);
                if (result.status == native_order::CancelStatus::Cancelled) retire(*prior_handle);
            }
            return;
        }
    }
    if (const auto point = detail::callback_point(require_host())) {
        snapshot.placement_script_open_ms = point->decision.script_bar_open_ms;
        snapshot.placement_sub_open_ms = point->decision.sub_bar_open_ms;
        if (default_sized && reverses && !snapshot.replaced_opening) {
            for (auto it = live_handles_.rbegin(); it != live_handles_.rend(); ++it) {
                const auto prior = placement_.find(it->incarnation);
                if (prior == placement_.end()) continue;
                auto& prior_snapshot = prior->second;
                if (!prior_snapshot.opening || prior_snapshot.family != PineOrderFamily::Entry
                    || prior_snapshot.is_long != is_long
                    || prior_snapshot.placement_script_open_ms != point->decision.script_bar_open_ms) {
                    continue;
                }
                const std::uint64_t group = prior_snapshot.sequential_group != 0
                    ? prior_snapshot.sequential_group : ++next_sequential_group_;
                prior_snapshot.sequential_group = group; invalidate_retirement();
                if (prior_snapshot.sequential_rank == 0) prior_snapshot.sequential_rank = 1;
                snapshot.sequential_group = group;
                snapshot.sequential_rank = 2;
                break;
            }
        }
    }
    if (current == 0.0 && config_.process_orders_on_close
        && !config_.calc_on_order_fills && default_sized
        && std::holds_alternative<native_order::Stop>(request.trigger)
        && !finite_positive(limit_price) && oca_name.empty() && source_point) {
        stage_flat_children_before_parent(
            id, source_point->decision.coordinate.interval_index,
            source_point->decision.script_bar_open_ms);
    }
    const EntrySubmissionContext submission_context{
        current, limit_price, stop_price, default_sized, priced, reverses,
        opposite_opening_pending, pure_stop_entry, coof_market_next_open,
        coof_priced_next_open, coof_market_at_second_extreme, paired_all_in_reentry};
    if (close_all_precedes && preceding_close_all.incarnation != 0) {
        // A full close moved the prior entry out of the live/batched book.
        // Replace it where it waits for that close, before selecting a new
        // batch or appending a second definition behind the same parent.
        auto queued = std::find_if(pending_entries_.begin(), pending_entries_.end(),
            [&](const PendingEntry& prior) {
                return prior.replacement_key == id
                    && prior.snapshot.paired_reversal_parent == preceding_close_all;
            });
        if (queued != pending_entries_.end()) {
            pending_write(*queued) = PendingEntry{std::move(request), std::move(snapshot), id};
            return;
        }
    }
    if (same_bar_market_candidate && fixed_market_batch_candidate
        && !close_precedes_entry && pending_same_bar_close_qty_ == 0.0
        && !close_all_precedes) {
        auto unbatched_request = request;
        auto unbatched_snapshot = snapshot;
        const double own_units = default_sized
            ? floor_quantity_grid(config_.default_qty_value, staged_.quantity_grid)
            : explicit_entry_quantity_floor(std::abs(qty), staged_.quantity_grid);
        if (!finite_positive(own_units)) return;
        double projected_units = current;
        std::size_t projected_entries = current == 0.0 ? 0U
            : accepted_entries_in_cycle(current > 0.0, id);
        // A same-id reissue replaces its earlier row; project only the remaining rows.
        for (const auto& pending : pending_same_bar_commands_) {
            const auto& prior = pending.snapshot;
            if (pending.replacement_key == id || !pending.opening
                || prior.family != PineOrderFamily::Entry
                || !prior.frozen_market_instruction) {
                continue;
            }
            const bool opposite = projected_units != 0.0
                && ((projected_units > 0.0) != prior.is_long);
            projected_entries = opposite ? 1U : projected_entries + 1U;
            projected_units += prior.is_long ? prior.frozen_market_transaction_units
                                            : -prior.frozen_market_transaction_units;
        }
        const bool same_side = projected_units != 0.0
            && ((projected_units > 0.0) == is_long);
        const auto entry_cap = static_cast<std::size_t>(std::max(1, config_.pyramiding));
        if (same_side && projected_entries >= entry_cap) return;
        const double held_opposite = projected_units != 0.0 && !same_side
            ? std::abs(projected_units) : 0.0;
        const double transaction = own_units + held_opposite;
        request.intent = native_order::Transact{is_long ? transaction : -transaction};
        snapshot.reverse_to = false;
        snapshot.projection_over_pyramiding = false;
        snapshot.frozen_market_instruction = true;
        snapshot.frozen_market_own_units = own_units;
        snapshot.frozen_market_transaction_units = transaction;
        auto existing = std::find_if(pending_same_bar_commands_.begin(),
            pending_same_bar_commands_.end(), [&](const PendingSameBarCommand& pending) {
                return !pending.snapshot.frozen_market_targeted_close
                    && pending.replacement_key == id;
            });
        PendingSameBarCommand pending{std::move(request), std::move(snapshot), id, true};
        pending.unbatched_request = std::move(unbatched_request);
        pending.unbatched_snapshot = std::move(unbatched_snapshot);
        pending.unbatched_context = submission_context;
        if (existing == pending_same_bar_commands_.end()) {
            pending_write(pending_same_bar_commands_).push_back(std::move(pending));
        } else {
            source_batch_mutated_ = true;
            pending_write(*existing) = std::move(pending);
        }
        return;
    }
    if (same_bar_market_candidate) {
        // Default percent/cash commands are already frozen at their source
        // call boundary.  The batch's topology must use that physical own
        // size, never the public percentage/cash scalar, just as the fixed
        // branch uses its explicit unit value.
        const double default_own = finite_positive(snapshot.sizing.frozen_units)
            ? snapshot.sizing.frozen_units : config_.default_qty_value;
        const double own_units = default_sized
            ? floor_quantity_grid(default_own, staged_.quantity_grid)
            : explicit_entry_quantity_floor(std::abs(qty), staged_.quantity_grid);
        bool opposite_market_pending = false;
        bool opposite_entry_pending = false;
        double opposite_pending_own = 0.0;
        const auto inspect_pending = [&](const PlacementSnapshot& prior) {
            if (!prior.opening || prior.source_id == id || prior.is_long == is_long) {
                return;
            }
            if (prior.frozen_market_instruction
                && finite_positive(prior.frozen_market_own_units)) {
                opposite_market_pending = true;
                opposite_pending_own += prior.frozen_market_own_units;
            } else {
                opposite_entry_pending = true;
            }
        };
        for (const auto& pending : pending_same_bar_commands_) inspect_pending(pending.snapshot);
        for (const auto& pending : pending_entries_) inspect_pending(pending.snapshot);
        if (const auto point = detail::callback_point(require_host())) {
            for (const auto& handle : live_handles_) {
                const auto prior = placement_.find(handle.incarnation);
                if (prior == placement_.end()
                    || prior->second.placement_script_open_ms
                        != point->decision.script_bar_open_ms) {
                    continue;
                }
                inspect_pending(prior->second);
            }
        }
        std::size_t same_side_pending = 0;
        for (const auto& pending : pending_same_bar_commands_) {
            if (pending.opening && pending.snapshot.is_long == is_long
                && pending.snapshot.source_id != id
                && !pending.snapshot.projection_over_pyramiding) {
                ++same_side_pending;
            }
        }
        for (const auto& pending : pending_entries_) {
            if (pending.snapshot.opening && pending.snapshot.is_long == is_long
                && pending.snapshot.source_id != id
                && !pending.snapshot.projection_over_pyramiding) {
                ++same_side_pending;
            }
        }
        if (const auto point = detail::callback_point(require_host())) {
            for (const auto& handle : live_handles_) {
                const auto prior = placement_.find(handle.incarnation);
                if (prior == placement_.end()
                    || prior->second.placement_script_open_ms
                        != point->decision.script_bar_open_ms) {
                    continue;
                }
                // R4-D L10z review fix 2: a live row whose cancellation was
                // already recorded no longer competes for the pyramiding cap.
                if (prior->second.opening && prior->second.is_long == is_long
                    && prior->second.source_id != id
                    && !prior->second.projection_over_pyramiding
                    && prior->second.cancellation.cause
                        == PineCancellationCause::None) {
                    ++same_side_pending;
                }
            }
        }
        const bool same_side = (current != 0.0 && ((current > 0.0) == is_long))
            || (current == 0.0 && same_side_pending > 0);
        const std::size_t current_lots =
            (current != 0.0 && ((current > 0.0) == is_long))
                ? detail::run_position(require_host()).lot_count
                : 0U;
        // ab9714be pine_orders.cpp:737-740: add_to_pyramid_market rejects entry when position_entry_count_ >= pyramiding
        const std::size_t total_entries = current_lots + same_side_pending;
        const bool over_cap = same_side
            && ((config_.pyramiding == 0 && total_entries >= 1U)
                || (config_.pyramiding > 0
                    && total_entries >= static_cast<std::size_t>(config_.pyramiding)));
        snapshot.projection_over_pyramiding = over_cap;
        if (current == 0.0) {
            for (const auto& handle : live_handles_) {
                const auto found = placement_.find(handle.incarnation);
                if (found == placement_.end()) continue;
                auto& candidate = found->second;
                const bool exit = candidate.family == PineOrderFamily::ExitLimit
                    || candidate.family == PineOrderFamily::ExitStop
                    || candidate.family == PineOrderFamily::ExitTrail;
                if (exit && candidate.from_entry == id
                    && !(cohort_exposure_for(id) > 0.0)) {
                    candidate.reservation_deferred_to_pending_entry = true;
                    candidate.projection_remaining_qty = kNaN;
                }
            }
        }
        if (over_cap && !opposite_market_pending && !opposite_entry_pending) return;
        if (!(over_cap && !opposite_market_pending)
            && finite_positive(own_units)) {
            // R1: a staged reversal's same-id reissue transacts its own units
            // only; it does not carry the held opposite side.
            const double held_opposite_units = current != 0.0 && ((current > 0.0) != is_long)
                ? std::max(0.0, std::abs(current) - preceding_close_qty) : 0.0;
            const double held_opposite = staged_reversal_replacement ? 0.0 : held_opposite_units;
            const double transaction = own_units + held_opposite + opposite_pending_own;
            if (finite_positive(transaction)) {
                if (over_cap && opposite_market_pending
                    && config_.default_qty_type == static_cast<int>(QtyType::FIXED)) {
                    // The kept over-cap member is admitted at its source
                    // call as the whole frozen broker movement: held side,
                    // this member's own leg, and every opposite pending
                    // MARKET leg.  The eventual net position is smaller,
                    // but using it here would incorrectly admit famS's
                    // 3-lot ES/NQ census rows.
                    const double gross_units = std::abs(current) + own_units
                        + opposite_pending_own;
                    const double margin = is_long ? config_.margin_long : config_.margin_short;
                    const double required = gross_units * snapshot.sizing.price
                        * staged_.syminfo.pointvalue * snapshot.sizing.fx * margin / 100.0;
                    if (!std::isfinite(required) || !std::isfinite(snapshot.sizing.equity)
                        || required > snapshot.sizing.equity) {
                        return;
                    }
                }
                snapshot.opening = true;
                snapshot.frozen_market_instruction = true;
                snapshot.frozen_market_own_units = own_units;
                snapshot.frozen_market_transaction_units = transaction;
                auto existing = std::find_if(pending_same_bar_commands_.begin(),
                    pending_same_bar_commands_.end(), [&](const PendingSameBarCommand& row) {
                        return !row.snapshot.frozen_market_targeted_close
                            && row.replacement_key == id;
                    });
                PendingSameBarCommand pending{std::move(request), std::move(snapshot), id, true};
                if (staged_reversal_replacement) {
                    pending.staged_reversal = true;
                    pending.staged_reversal_held_units = held_opposite_units;
                }
                if (existing == pending_same_bar_commands_.end()) {
                    pending_write(pending_same_bar_commands_).push_back(std::move(pending));
                } else {
                    source_batch_mutated_ = true;
                    pending_write(*existing) = std::move(pending);
                }
                return;
            }
        }
    }
    if (preceding_close_all.incarnation != 0) {
        pending_write(pending_entries_).push_back({std::move(request), std::move(snapshot), id});
        return;
    }
    submit_entry_with_policy(std::move(request), std::move(snapshot), id, submission_context);
}
 
void PineExecutionAdapter::submit_entry_with_policy(
        native_order::Request request, PlacementSnapshot snapshot, const SourceId& id,
        const EntrySubmissionContext& context) {
    const double current = context.current;
    const double limit_price = context.limit_price;
    const double stop_price = context.stop_price;
    const bool default_sized = context.default_sized;
    const bool priced = context.priced;
    const bool reverses = context.reverses;
    const bool opposite_opening_pending = context.opposite_opening_pending;
    const bool pure_stop_entry = context.pure_stop_entry;
    const bool coof_market_next_open = context.coof_market_next_open;
    const bool coof_priced_next_open = context.coof_priced_next_open;
    const bool coof_market_at_second_extreme = context.coof_market_at_second_extreme;
    const bool paired_all_in_reentry = context.paired_all_in_reentry;
    const bool is_long = snapshot.is_long;
    const auto oca_name = snapshot.oca_name;
    const auto source_point = detail::callback_point(require_host());
    const bool source_same_side_market_add = default_sized
        && config_.default_qty_type == static_cast<int>(QtyType::FIXED)
        && !config_.calc_on_order_fills
        && (config_.process_orders_on_close || !opposite_opening_pending)
        && current != 0.0
        && ((current > 0.0) == is_long)
        && std::holds_alternative<native_order::Market>(request.trigger);
    const bool close_first_percent_add = default_sized
        && config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        && std::abs(config_.default_qty_value - 100.0) < 1e-12
        && !config_.calc_on_order_fills && !config_.process_orders_on_close
        && config_.pyramiding > 1 && current != 0.0
        && ((current > 0.0) == is_long)
        && std::holds_alternative<native_order::Market>(request.trigger);
    if (source_same_side_market_add || close_first_percent_add) {
        auto queued = std::find_if(pending_entries_.begin(), pending_entries_.end(),
            [&](const PendingEntry& value) { return value.replacement_key == id; });
        PendingEntry pending{std::move(request), std::move(snapshot), id};
        if (queued == pending_entries_.end()) pending_write(pending_entries_).push_back(std::move(pending));
        else pending_write(*queued) = std::move(pending);
        return;
    }
    if (current == 0.0 && config_.process_orders_on_close && default_sized
        && std::holds_alternative<native_order::Stop>(request.trigger)
        && !finite_positive(limit_price) && oca_name.empty()) {
        const auto token = named_entry_cancel_tokens_.find(id);
        if (token != named_entry_cancel_tokens_.end()
            && token->second.entry_incarnation != 0
            && token->second.surviving_exit_incarnation != 0) {
            std::vector<std::uint64_t> child_families;
            for (const auto& handle : live_handles_) {
                const auto child = placement_.find(handle.incarnation);
                if (child == placement_.end() || child->second.from_entry != id) continue;
                const auto family = child->second.family;
                if (family != PineOrderFamily::ExitLimit
                    && family != PineOrderFamily::ExitStop
                    && family != PineOrderFamily::ExitTrail) {
                    continue;
                }
                const auto key = key_for(child->second.source_id, child->second.from_entry);
                if (std::find(child_families.begin(), child_families.end(), key)
                    == child_families.end()) {
                    child_families.push_back(key);
                }
            }
            if (child_families.size() == 1) {
                snapshot.recreated_after_named_cancelled_entry_incarnation =
                    token->second.entry_incarnation;
                snapshot.named_cancel_surviving_exit_incarnation =
                    token->second.surviving_exit_incarnation;
            }
            snapshot.retained_parent_topology = true;
            if (const auto point = detail::callback_point(require_host())) {
                snapshot.projection_created_bar = projection_bar_index(point->decision);
                snapshot.projection_position_side = static_cast<std::int32_t>(PositionSide::FLAT);
            }
            snapshot.source_sequence = source_sequence_ + 1;
            if (child_families.size() != 1) named_entry_cancel_tokens_.erase(token);
            pending_write(pending_entries_).push_back({std::move(request), std::move(snapshot), id});
            return;
        }
    }
    if (!priced && reverses) {
        auto queued = std::find_if(pending_entries_.begin(), pending_entries_.end(),
            [&](const PendingEntry& value) { return value.replacement_key == id; });
        if (queued != pending_entries_.end()) {
            // A same-callback MARKET reissue replaces the staged priced
            // reversal before either definition reaches the generic core.
            // Flushing the old priced row after submitting this one reverses
            // the replacement and leaves the market instruction unreachable.
            pending_write(*queued) = PendingEntry{std::move(request), std::move(snapshot), id};
            return;
        }
    }
    if (priced && reverses && !config_.process_orders_on_close
        && !config_.calc_on_order_fills) {
        auto queued = std::find_if(pending_entries_.begin(), pending_entries_.end(),
            [&](const PendingEntry& value) { return value.replacement_key == id; });
        PendingEntry pending{std::move(request), std::move(snapshot), id};
        if (queued == pending_entries_.end()) pending_write(pending_entries_).push_back(std::move(pending));
        else pending_write(*queued) = std::move(pending);
        return;
    }
    if (config_.process_orders_on_close && !close_batch_callsites_.empty()
        && !priced && !coof_recalc_active_) {
        pending_write(pending_entries_).push_back({std::move(request), std::move(snapshot), id});
        return;
    }
    // The legacy source selector orders a flat COOF book by the first
    // reachable priced trigger, not by statement insertion.  Queue only this
    // bounded source shape until the enclosing source evaluation ends, then
    // materialize it in source-policy order before the generic core receives
    // any request.  Recalc-born entries retain their existing callback path.
    const bool coof_flat_priced = config_.calc_on_order_fills && current == 0.0
        && priced && !coof_recalc_active_ && oca_name.empty();
    const bool ordinary_flat_pure_stop = [&]() {
        if (config_.process_orders_on_close || config_.calc_on_order_fills
            || current != 0.0 || !pure_stop_entry || !oca_name.empty()
            || !source_point) {
            return false;
        }
        const auto* pine_host = pine_view_of(&require_host());
        const auto next = pine_host
            ? pine_host->scheduler_.next_source_bar(
                source_point->decision.coordinate.interval_index)
            : std::optional<Bar>{};
        return next && source_bar_fill_tick(next->open, staged_.syminfo.mintick)
            == stop_price;
    }();
    if (coof_flat_priced || ordinary_flat_pure_stop) {
        pending_write(pending_entries_).push_back({std::move(request), std::move(snapshot), id});
        return;
    }
    if (coof_market_next_open || coof_priced_next_open) {
        pending_write(pending_coof_requests_).push_back(
            {std::move(request), std::move(snapshot), id, true, 0, true});
        return;
    }
    if (defer_coof_tail() && !coof_market_at_second_extreme) {
        pending_write(pending_coof_requests_).push_back({std::move(request), std::move(snapshot), id, true, 0});
        return;
    }
    const auto accepted = submit_or_replace(std::move(request), std::move(snapshot), true, id);
    if (accepted) {
        if (current < 0.0 && is_long) short_seed_long_candidate_ = *accepted;
        const auto entry = placement_.find(accepted->incarnation);
        if (entry != placement_.end()) {
            const std::uint64_t entry_sequence = entry->second.command_sequence;
            // A source entry accepted after a captured POOC global exit is
            // outside that exit's live population.  Keep any already-bound
            // pre-exit add eligible to grow the finite reservation at fill,
            // but close the open-population marker now so later entries never
            // acquire that reservation merely by arriving before the match.
            for (const auto& handle : live_handles_) {
                if (handle == *accepted) continue;
                const auto existing = placement_.find(handle.incarnation);
                if (existing == placement_.end()) continue;
                auto& prior = existing->second;
                if (!prior.reservation_expansion.capture()
                    || prior.command_sequence >= entry_sequence) {
                    continue;
                }
                prior.pooc_global_full_exit_dynamic_qty = false;
                prior.pooc_global_full_exit_tracks_bound_adds = false;
                prior.reservation_expansion.close_population(accepted->incarnation);
            }
        }
        if (default_sized && !priced && reverses && source_point
            && config_.default_qty_type
                == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
            && config_.default_qty_value <= 100.0) {
            if (auto* pine_host = pine_view_of(&require_host())) {
                if (const auto next = pine_host->scheduler_.next_source_bar(
                        source_point->decision.coordinate.interval_index)) {
                    NativeDecisionContext next_context = source_point->decision;
                    ++next_context.coordinate.interval_index;
                    next_context.coordinate.path_phase = NativePathPhase::Open;
                    next_context.script_bar_open_ms = next->timestamp;
                    next_context.sub_bar_open_ms = next->timestamp;
                    apply_reversal_gap_bracket_policy(
                        *next, next_context, /*defer_trails=*/true);
                }
            }
        }
    } else if (paired_all_in_reentry) {
        // The source call is still observable in its current script pass,
        // although native max-lot admission has already terminally refused
        // it. Preserve that truthful source observer row until the next
        // broker open, without retaining a second executable order.
        // (The copy is made from the source snapshot before the next call.)
        SourceShadowPending shadow;
        shadow.snapshot.family = PineOrderFamily::Entry;
        shadow.snapshot.source_id = id;
        shadow.snapshot.is_long = is_long;
        shadow.snapshot.opening = true;
        shadow.snapshot.sizing = sizing_snapshot();
        shadow.label = id;
        pending_write(source_shadow_pending_).push_back(std::move(shadow));
    }
}
 
bool PineExecutionAdapter::enqueue_pooc_fifo_close(
        const SourceId& id, const std::string& comment,
        std::uint64_t token, std::uint64_t) {
    const auto point = detail::callback_point(require_host());
    const int bar = point ? point->decision.coordinate.interval_index : -1;
    if (close_batch_bar_ != bar) {
        close_batch_bar_ = bar;
        close_batch_queue_sequence_ = 0;
        close_batch_callsites_.clear();
        close_batch_pending_debt_ = 0.0;
        close_batch_admitted_total_ = 0.0;
    }
 
    auto existing = close_batch_callsites_.find(token);
    const CloseCallsiteState* prior = existing == close_batch_callsites_.end()
        ? nullptr : &existing->second;
    const auto logical = close_logical_units_.find(id);
    const double unclosed = logical == close_logical_units_.end()
        ? 0.0 : logical->second;
 
    // A call is sized against the position less what the bar's other close
    // orders already hold; a site re-sizing its own order counts its own
    // claim back unless another site closes that id as well.
    double pending_reserved = 0.0;
    for (const auto& row : close_batch_callsites_) {
        if (row.second.active) pending_reserved += row.second.target;
    }
    const bool same_id_reissue = prior && prior->active && prior->id == id;
    bool replacement_can_reuse_own_claim = false;
    if (prior && prior->active && prior->id != id) {
        const bool another_targets_prior = std::any_of(
            close_batch_callsites_.begin(), close_batch_callsites_.end(),
            [&](const auto& row) {
                return row.first != token && row.second.active
                    && row.second.id == prior->id;
            });
        replacement_can_reuse_own_claim = !another_targets_prior;
    }
    if (same_id_reissue || replacement_can_reuse_own_claim)
        pending_reserved -= prior->target;
 
    const double held = std::abs(detail::run_position(require_host()).signed_units);
    const double available = std::max(0.0, held - pending_reserved);
    const double target = std::min(unclosed, available);
    // A call with nothing to close -- its id has no unbooked units, or the
    // bar's other closes hold the whole position -- places nothing and
    // leaves its site's order as it was (tapes w3bf02-c1, -c2, -c3).
    if (!(target > internal::kQtyEpsilon)) return false;
 
    const double replaced_target = prior && prior->active ? prior->target : 0.0;
    close_batch_pending_debt_ += target;
    pending_same_bar_close_qty_ += target;
    if (token != 0) close_batch_admitted_total_ += target - replaced_target;
 
    auto& site = close_batch_callsites_[token];
    if (!site.active) {
        site.active = true;
        site.token = token;
        site.calls = 1;
        site.first_id = id;
        site.id = id;
        site.comment = comment;
        site.target = target;
        site.queue_sequence = ++close_batch_queue_sequence_;
        return true;
    }
    // A later call of the site re-sizes the site's one order for its own id
    // and comment; the fill still books against the site's first id.
    if (site.id != id) ++site.calls;
    site.id = id;
    site.comment = comment;
    site.target = target;
    return true;
}
 
void PineExecutionAdapter::flush_pending_closes() {
    if (close_batch_callsites_.empty()) return;
    std::vector<CloseCallsiteState> sites;
    sites.reserve(close_batch_callsites_.size());
    for (const auto& row : close_batch_callsites_)
        if (row.second.active) sites.push_back(row.second);
    std::stable_sort(sites.begin(), sites.end(),
        [](const CloseCallsiteState& left, const CloseCallsiteState& right) {
            return left.queue_sequence < right.queue_sequence;
        });
 
    std::vector<std::pair<std::uint64_t, double>> fifo_lots;
    if (const auto* pine = pine_view_of(&require_host())) {
        fifo_lots.reserve(pine->pyramid_entries_.size());
        for (const auto& lot : pine->pyramid_entries_)
            fifo_lots.emplace_back(lot.entry_incarnation, lot.qty);
    }
    std::size_t fifo_prefix_size = 0;
    // ab9714be pine_orders.cpp:29-70 source_fifo_prefix_membership, with its
    // accumulation and endpoint ordering; openings resolve to their receipts.
    const auto source_fifo_prefix_openings = [&](
            const std::vector<std::pair<std::uint64_t, double>>& lots,
            double qty_limit) -> std::optional<native_order::BindOpenings> {
        fifo_prefix_size = 0;
        if (current_position_cycle_ <= 0 || !std::isfinite(qty_limit) || qty_limit <= 0.0)
            return std::nullopt;
        double qty_closed = 0.0;
        std::size_t prefix_size = 0;
        for (const auto& lot : lots) {
            if (qty_closed >= qty_limit - internal::kQtyEpsilon) break;
            if (!std::isfinite(lot.second) || lot.second <= 0.0) return std::nullopt;
            const double close_qty = std::min(lot.second, qty_limit - qty_closed);
            if (lot.second - close_qty > internal::kQtyEpsilon) return std::nullopt;
            ++prefix_size;
            qty_closed += close_qty;
        }
        if (prefix_size == 0 || prefix_size == lots.size()) return std::nullopt;
        // The selection is resolved at submission, while the owner resolves
        // it at the fill.  Keep the late-bound FIFO Reduce whenever it drains
        // exactly that prefix anyway; only a drain that would keep a
        // sub-epsilon fragment or take one from the next lot needs the
        // explicit whole-lot selection.
        {
            double closed = 0.0;
            double left = qty_limit;
            bool exact = true;
            for (std::size_t index = 0; exact && index < prefix_size; ++index) {
                const double amount = std::min(lots[index].second, left);
                exact = amount == lots[index].second;
                closed += amount;
                left = qty_limit - closed;
            }
            if (exact && left == 0.0) return std::nullopt;
        }
        native_order::BindOpenings selection{{}, current_position_cycle_};
        std::unordered_set<std::uint64_t> included;
        for (std::size_t index = 0; index < prefix_size; ++index) {
            const auto incarnation = lots[index].first;
            if (incarnation == 0) return std::nullopt;
            if (!included.insert(incarnation).second) continue;
            const native_order::RequestHandle* receipt = nullptr;
            for (const auto& cohort : cohorts_by_id_.held_rows()) {
                for (const auto& opened : cohort.second.opened)
                    if (opened.incarnation == incarnation) receipt = &opened;
            }
            if (!receipt) return std::nullopt;
            selection.openings.push_back(*receipt);
        }
        // Every live fragment of a selected opening must belong to the
        // prefix; otherwise the owner settles the close as a Reduce.
        for (std::size_t index = prefix_size; index < lots.size(); ++index)
            if (included.count(lots[index].first) != 0) return std::nullopt;
        fifo_prefix_size = prefix_size;
        return selection;
    };
    // Settlement FIFO arithmetic of one queued close over the local lot view.
    const auto drain_source_fifo_lots = [&](
            std::vector<std::pair<std::uint64_t, double>>& lots, double qty) {
        if (fifo_prefix_size != 0) {
            lots.erase(lots.begin(), lots.begin()
                       + static_cast<std::ptrdiff_t>(fifo_prefix_size));
            return;
        }
        double closed = 0.0;
        double left = qty;
        std::size_t consumed = 0;
        for (auto& lot : lots) {
            if (!(left > 0.0)) break;
            const double amount = std::min(lot.second, left);
            lot.second -= amount;
            closed += amount;
            left = qty - closed;
            if (lot.second == 0.0) ++consumed;
        }
        lots.erase(lots.begin(), lots.begin() + static_cast<std::ptrdiff_t>(consumed));
        // The host drops sub-epsilon survivors after every applied fill.
        lots.erase(std::remove_if(lots.begin(), lots.end(), [](const auto& lot) {
            return lot.second <= internal::kQtyEpsilon;
        }), lots.end());
    };
    // A carried short's follow-up owed to this close is booked after the script,
    // ahead of the close's fills (book_owed_close_follow_up): a close of the
    // whole book the script saw keeps that size, the transaction that crosses
    // zero on the smaller book and opens the excess long as its own lot
    // (switches close_follow_up_after_script and frozen_reversal_close; lab tv
    // tapes tests/fixtures/margin_open_rules lots/close-id-*: "Close entry(s)
    // order S"). Placed here it keeps its place ahead of the script's later
    // orders; where nothing is booked it closes the book exactly.
    bool frozen_close = false;
    if (PF_RARE(owed_follow_up_bar_ != std::numeric_limits<std::int64_t>::min())) {
        const auto point = detail::callback_point(require_host());
        const auto& schedule = detail::margin_schedule_switches();
        frozen_close = point && owed_follow_up_bar_ == point->decision.script_bar_open_ms
            && owed_follow_up_point_ == 3 && config_.process_orders_on_close
            && schedule.close_follow_up_after_script && schedule.frozen_reversal_close;
    }
    for (const auto& site : sites) {
        const auto physical = detail::run_position(require_host());
        // ab9714be pine_strategy_commands.cpp:694-696: strategy_close returns immediately when position is flat (<= kQtyEpsilon)
        if (std::abs(physical.signed_units) <= internal::kQtyEpsilon) continue;
        const double available = std::abs(physical.signed_units);
        const double target = std::min(site.target, available);
        // ab9714be pine_orders.cpp:344: close within kQtyEpsilon of held position executes Flatten action
        const bool closes_full = target >= available - internal::kQtyEpsilon;
        if (PF_RARE(frozen_close) && closes_full && fifo_lots.size() <= 1) {
            cancel_exit_orders_for_full_close(site.id);
            native_order::Request request;
            request.intent = native_order::Transact{-physical.signed_units};
            request.label = "__close__" + site.id;
            request.comment = site.comment;
            request.owner = native_order::Independent{};
            fifo_lots.clear();
            PlacementSnapshot snapshot;
            snapshot.family = PineOrderFamily::Close;
            snapshot.source_id = site.id;
            snapshot.comment = site.comment;
            snapshot.requested_qty = kNaN;
            snapshot.projection_remaining_qty = available;
            snapshot.qty_percent = 100.0;
            snapshot.is_long = false;
            snapshot.crosses_zero = true;
            snapshot.sizing = sizing_snapshot();
            snapshot.close_callsite_token = site.token;
            snapshot.close_batch_calls = static_cast<std::uint32_t>(site.calls);
            snapshot.close_first_id = site.first_id;
            const SourceId key = "__pine_close_flush__" + std::to_string(site.token);
            (void)submit_or_replace(std::move(request), std::move(snapshot), false, key);
            continue;
        }
        if (closes_full) {
            // The pass's entries on the closed side survive the close and open
            // after it, whichever call came first: entry() already refused the
            // ones over the cap (lane W8A-SIGSTATE-1 R2,
            // tests/fixtures/pooc_same_pass_close).
            cancel_exit_orders_for_full_close(site.id);
        }
 
        // ab9714be pine_orders.cpp:29-70 / :340-347: a partial close whose
        // FIFO drain consumes only whole lots settles as a Flatten of exactly
        // that lot prefix.  A binary64 Reduce of the same target can keep a
        // one-ULP fragment of the last lot, which moves every later binary64
        // availability/ledger target off the owner's arithmetic.
        std::optional<native_order::BindOpenings> prefix;
        fifo_prefix_size = 0;
        if (!closes_full) prefix = source_fifo_prefix_openings(fifo_lots, target);
 
        // A partial target is the owner's binary64 ledger/availability
        // arithmetic (ab9714be pine_strategy_commands.cpp:1397-1408), which
        // execute_partial_exit_qty drains without re-quantizing.  An off-grid
        // target cannot be an ExplicitUnits request, so resolve_terms books
        // it as explicit units at the fill instead.
        const bool off_grid = staged_.quantity_grid
            && !native_order::quantity_on_grid(target, *staged_.quantity_grid);
        native_order::Request request;
        request.intent = closes_full || prefix
            ? native_order::OrderIntent{native_order::Flatten{}}
            : off_grid
            ? native_order::OrderIntent{native_order::HostSized{
                  native_order::HostSizedKind::Close, std::nullopt}}
            : native_order::OrderIntent{native_order::Reduce{native_order::ExplicitUnits{target}}};
        request.label = "__close__" + site.id;
        request.comment = site.comment;
        request.owner = native_order::Independent{};
        if (prefix) request.owner = std::move(*prefix);
        // Earlier sites of this flush settle first (queue order), so a later
        // site's prefix is judged against the lots that survive them.
        if (closes_full) fifo_lots.clear();
        else drain_source_fifo_lots(fifo_lots, target);
        PlacementSnapshot snapshot;
        snapshot.family = PineOrderFamily::Close;
        snapshot.source_id = site.id;
        snapshot.comment = site.comment;
        snapshot.requested_qty = closes_full ? kNaN : target;
        snapshot.projection_remaining_qty = target;
        snapshot.qty_percent = closes_full ? 100.0 : (target / available * 100.0);
        snapshot.is_long = false;
        snapshot.sizing = sizing_snapshot();
        snapshot.close_callsite_token = site.token;
        snapshot.close_batch_calls = static_cast<std::uint32_t>(site.calls);
        snapshot.close_first_id = site.first_id;
        const SourceId key = "__pine_close_flush__" + std::to_string(site.token);
        (void)submit_or_replace(
            std::move(request), std::move(snapshot), false, key);
    }
    close_batch_callsites_.clear();
    close_batch_bar_ = -1;
    close_batch_queue_sequence_ = 0;
    close_batch_pending_debt_ = 0.0;
    close_batch_admitted_total_ = 0.0;
}
 
void PineExecutionAdapter::observe_close_ledger(
        const native_order::ExecutionAppliedEvent& event,
        const PlacementSnapshot* snapshot) {
    // The ledger only sizes the default FIFO close; under the ANY rule a
    // close is bound to its id's own entries.
    if (config_.close_entries_rule_any) return;
    // A fill books against the entry it names -- a close site's first call's
    // id, whichever id its last call sized the order for (tapes w3f02-x1,
    // -x2, w3bf02-a1, -a2, -b1); strategy.close(id, qty) and strategy.exit's
    // from_entry name theirs (w3bf02-f3, -f2) -- and what that id's ledger
    // cannot cover spills over the oldest entries'. A fill that names none (a
    // strategy.order sell, a margin call) takes the oldest entries' units
    // (w3bf02-f1).
    SourceId named{};
    if (snapshot) {
        switch (snapshot->family) {
        case PineOrderFamily::Close:
            named = snapshot->close_first_id.empty() ? snapshot->source_id
                                                     : snapshot->close_first_id;
            break;
        case PineOrderFamily::ExitLimit:
        case PineOrderFamily::ExitStop:
        case PineOrderFamily::ExitTrail:
            named = snapshot->from_entry;
            break;
        default:
            break;
        }
    }
    book_close_ledger(named, event.closed_units);
    // An exit leg armed for one opening of its id books that opening's record
    // first (bracket_origin; test_exit_bracket_pending_entry_leg's capped
    // entry: the re-issued T1 armed over the pending second L books it).
    const std::uint64_t armed_for = snapshot
            && (snapshot->family == PineOrderFamily::ExitLimit
                || snapshot->family == PineOrderFamily::ExitStop
                || snapshot->family == PineOrderFamily::ExitTrail)
        ? snapshot->bracket_origin.incarnation : 0;
    book_pyramiding_records(named, armed_for, event.closed_units);
}
 
void PineExecutionAdapter::credit_close_ledger(const SourceId& id, double units) {
    close_logical_units_[id] += units;
    if (config_.close_entries_rule_any) return;
    if (!close_ledger_records_.empty() && close_ledger_records_.back().id == id)
        close_ledger_records_.back().units += units;
    else
        close_ledger_records_.push_back({id, units});
}
 
void PineExecutionAdapter::book_close_ledger(const SourceId& id, double units) {
    if (!(units > 0.0) || close_ledger_records_.empty()) return;
    double left = units;
    const auto take = [&left](CloseLedgerRecord& record) {
        if (!(left > internal::kQtyEpsilon) || !(record.units > 0.0)) return;
        const double amount = std::min(record.units, left);
        record.units -= amount;
        left -= amount;
    };
    // The id's own entries first, oldest first; then, for what they cannot
    // cover, every id's entries in the order they filled.
    for (auto& record : close_ledger_records_)
        if (record.id == id) take(record);
    for (auto& record : close_ledger_records_) take(record);
    std::vector<CloseLedgerRecord> kept;
    kept.reserve(close_ledger_records_.size());
    for (auto& record : close_ledger_records_) {
        if (!(record.units > internal::kQtyEpsilon)) continue;
        if (!kept.empty() && kept.back().id == record.id)
            kept.back().units += record.units;
        else
            kept.push_back(std::move(record));
    }
    close_ledger_records_ = std::move(kept);
    close_logical_units_.clear();
    for (const auto& record : close_ledger_records_)
        close_logical_units_[record.id] += record.units;
}
 
// The pyramiding cap (pyramiding_ledger_records): TradingView caps
// pyramiding on the open records of its close ledger -- one per entry fill
// whose units are not all booked yet, counted at the fill after the bar's
// earlier fills -- not on the physical lots: a strategy.close(id) books its
// id's own record while the book drains first in first out
// (tests/fixtures/admission_rules pyr1-records-below-lots,
// -pyr2-records-above-lots; pyramiding_count's P8 tape). Kept unmerged, one
// record per fill with the incarnation of the opening that filled it, and
// booked as the close ledger is -- an exit armed for one opening of its id
// books that opening's record first, then the named id's records oldest
// first, then every record in fill order. Only under pyramiding above one,
// where it can decide.
// Pyramiding above one, a close rule other than ANY and a pinned lot grid are
// ledger_records_configured_, formed once per configuration.
void PineExecutionAdapter::credit_pyramiding_record(const SourceId& id, std::uint64_t incarnation,
                                                    double units) {
    if (!ledger_records_configured_ || !(units > 0.0)) return;
    pyramiding_records_.push_back({id, incarnation, units});
}
 
void PineExecutionAdapter::book_pyramiding_records(const SourceId& id, std::uint64_t armed_for,
                                                   double units) {
    if (!(units > 0.0) || pyramiding_records_.empty()) return;
    double left = units;
    const auto take = [&left](PyramidingRecord& record) {
        if (!(left > internal::kQtyEpsilon) || !(record.units > 0.0)) return;
        const double amount = std::min(record.units, left);
        record.units -= amount;
        left -= amount;
    };
    if (armed_for != 0) {
        for (auto& record : pyramiding_records_)
            if (record.incarnation == armed_for && record.id == id) take(record);
    }
    for (auto& record : pyramiding_records_)
        if (record.id == id) take(record);
    for (auto& record : pyramiding_records_) take(record);
    pyramiding_records_.erase(
        std::remove_if(pyramiding_records_.begin(), pyramiding_records_.end(),
                       [](const PyramidingRecord& record) {
                           return !(record.units > internal::kQtyEpsilon);
                       }),
        pyramiding_records_.end());
}
 
// The open close-ledger records the pyramiding cap counts, or nullopt where
// the rule does not decide: its switch off, pyramiding of one or less, the
// ANY close rule, or a ledger out of step with the physical book.
[[gnu::always_inline]] inline std::optional<std::size_t>
PineExecutionAdapter::open_ledger_records() const {
    if (!ledger_records_configured_ || !detail::margin_rule_switches().pyramiding_ledger_records)
        return std::nullopt;
    return held_ledger_records();
}
 
// The records against the physical book, inside the rule's configuration.
[[gnu::noinline]]
std::optional<std::size_t> PineExecutionAdapter::held_ledger_records() const {
    const double held = std::abs(detail::run_position(require_host()).signed_units);
    double units = 0.0;
    for (const auto& record : pyramiding_records_) units += record.units;
    if (!(std::abs(units - held) <= std::max(1e-9, held * 1e-12))) return std::nullopt;
    return pyramiding_records_.size();
}
 
// The incarnation of the newest opening of `from_entry` this cycle, 0 when
// it has none: the entry incarnation an exit's tombstone is keyed on.
std::uint64_t PineExecutionAdapter::entry_incarnation_of(const SourceId& from_entry) const {
    const auto cohort = cohorts_by_id_.find(from_entry);
    if (cohort == cohorts_by_id_.end() || cohort->second.opened.empty()) return 0;
    return cohort->second.opened.back().incarnation;
}
 
// Out of line and cold: a narrow scope's body, kept off the per-bar
// path, which is front-end bound (CMakeLists.txt, -falign-functions).
[[gnu::noinline, gnu::cold]]
bool PineExecutionAdapter::exit_tombstoned(const SourceId& exit_id,
                                           const SourceId& from_entry) const {
    if (!detail::margin_rule_switches().exit_child_tombstones || from_entry.empty()
        || !pinned_lot_grid()) {
        return false;
    }
    const auto found = exit_tombstones_.find(exit_id + "\x1f" + from_entry);
    return found != exit_tombstones_.end() && found->second != 0
        && found->second == entry_incarnation_of(from_entry);
}
 
// Records the close-first fact entry() reads: on this script bar the script
// closed the whole open position -- strategy.close(<held id>) or
// strategy.close_all(), not a partial or an `immediately` close -- while it
// was open. An entry the same bar then places against that position is a
// close-first entry (MarginRuleSwitches::close_first_admission).
void PineExecutionAdapter::record_close_first(bool whole_position) {
    if (!whole_position) return;
    const auto point = detail::callback_point(require_host());
    if (!point) return;
    const double held = detail::run_position(require_host()).signed_units;
    if (held == 0.0) return;
    close_first_script_bar_ = point->decision.script_bar_open_ms;
    close_first_side_ = held > 0.0 ? 1 : -1;
}
 
void PineExecutionAdapter::close(const SourceId& id, const std::string& comment, double qty,
                                 double qty_percent, bool immediately, std::uint64_t callsite_token) {
    if (intraday_loss_orders_blocked()) return;
    if (const auto point = detail::callback_point(require_host());
        point && cap_placement_denied(point->decision)) {
        return;
    }
    require_cohort_ticket();
    record_close_first(!immediately && !std::isfinite(qty)
                       && (!std::isfinite(qty_percent) || qty_percent >= 100.0)
                       && (id.empty() || open_lot_of(id)));
    reroute_fixed_entries_before_request();
    // The calc_on_order_fills recalculation of a fill inside a leg has no
    // current price to close at: TradingView fills its `immediately` close
    // where the same close placed without it fills, at the end of that leg
    // (lab tv tapes tests/fixtures/coof_immediate_close td-m1a, -c and -d
    // are one trade list; lane TAIL-D). A fill on a point of the path keeps
    // the close at that point.
    if (immediately && coof_recalc_active_ && !coof_first_open_
        && !coof_fill_on_path_point()) {
        immediately = false;
    }
    // The public empty-id spelling is the source route's full-position
    // strategy.close form.  It is not a cohort lookup (there is no empty
    // entry-id cohort), and it retains its caller-supplied report comment.
    if (id.empty()) {
        // ab9714be pine_strategy_commands.cpp:694-696: strategy_close returns immediately when physical position is flat
        if (detail::run_position(require_host()).signed_units == 0.0) return;
        const std::uint64_t command_ordinal = ++command_ordinal_;
        if (const auto point = detail::callback_point(require_host())) {
            close_all_pending_script_bar_ = point->decision.script_bar_open_ms;
        }
        bool empty_entry = false;
        bool opposite_entry = false;
        bool empty_is_long = false;
        for (const auto& pending : pending_same_bar_commands_) {
            if (!pending.opening || pending.snapshot.family != PineOrderFamily::Entry) continue;
            if (pending.snapshot.source_id.empty()) {
                empty_entry = true;
                empty_is_long = pending.snapshot.is_long;
            }
        }
        if (empty_entry) {
            for (const auto& pending : pending_same_bar_commands_) {
                if (!pending.opening || pending.snapshot.family != PineOrderFamily::Entry) continue;
                if (pending.snapshot.is_long != empty_is_long) {
                    opposite_entry = true;
                    break;
                }
            }
        }
        // A close_all placed after the same bar's default-size reversal entry
        // at 100 % of equity belongs to that reversal, as a strategy.close()
        // of the held id does (opposite_reversal_pair): TradingView flattens
        // the held position through neither. The next open funds the
        // reversal, which closes the position and opens the other side, or
        // declines it (declined_reversal_at_open) and the position is held;
        // the close_all fills in neither case (lab tv tapes
        // tests/fixtures/reversal_close_all int28fix-ca2-rev and -frosty;
        // The reversal-close rule, on a fractional lot grid; a whole-unit grid
        // is not measured). A close_all placed before the entry flattens at
        // the open (-first).
        bool all_in_reversal = false;
        if (!empty_entry && !config_.process_orders_on_close && !config_.calc_on_order_fills
            && config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
            && config_.default_qty_value >= 100.0 - 1e-9
            && (!staged_.quantity_grid || *staged_.quantity_grid < 1.0)) {
            const bool held_long = detail::run_position(require_host()).signed_units > 0.0;
            const auto point = detail::callback_point(require_host());
            const auto reverses = [&](const PlacementSnapshot& candidate) {
                return candidate.opening && candidate.family == PineOrderFamily::Entry
                    && candidate.is_long != held_long && std::isnan(candidate.requested_qty)
                    && (!point || candidate.placement_script_open_ms
                        == point->decision.script_bar_open_ms);
            };
            for (const auto& pending : pending_same_bar_commands_)
                all_in_reversal = all_in_reversal || reverses(pending.snapshot);
            for (const auto& pending : pending_entries_)
                all_in_reversal = all_in_reversal || reverses(pending.snapshot);
            for (const auto& handle : live_handles_) {
                const auto found = placement_.find(handle.incarnation);
                if (found != placement_.end())
                    all_in_reversal = all_in_reversal || reverses(found->second);
            }
        }
        if ((empty_entry && opposite_entry) || all_in_reversal) {
            SourceShadowPending shadow;
            shadow.snapshot.family = PineOrderFamily::CloseAll;
            shadow.snapshot.source_id = "__pine_close_all";
            shadow.snapshot.sizing = sizing_snapshot();
            shadow.label = shadow.snapshot.source_id;
            pending_write(source_shadow_pending_).push_back(std::move(shadow));
            return;
        }
        native_order::Request request;
        request.intent = native_order::Flatten{};
        request.label = "__pine_close_all";
        request.comment = comment;
        // Under process_orders_on_close TradingView checks the book at the
        // close after the script, and executes a call there ahead of the
        // orders the script placed at that close: a close_all keeps the size
        // it was placed with and opens the called unit on the other side
        // (w5b-sz-eur-p100-10m; synthetic OANDA:EURUSD close for 6 units, then a
        // 2-unit money call at the close, leaves 4 held and opens a short of
        // 2 when that unchanged close executes). A call the
        // path fired earlier stands before the script, and the close closes
        // what it left.
        bool close_sized_before_call = false;
        if (config_.process_orders_on_close && !immediately && !config_.calc_on_order_fills
            && !coof_recalc_active_ && policy_script_bar_valid_) {
            if (const auto point = detail::callback_point(require_host())) {
                const double held = detail::run_position(require_host()).signed_units;
                if (held != 0.0 && last_margin_call_at_script_close_
                    && last_margin_call_script_bar_ == point->decision.script_bar_open_ms
                    && last_margin_call_position_cycle_ == current_position_cycle_) {
                    request.intent = native_order::Transact{
                        -(held + (held > 0.0 ? 1.0 : -1.0) * last_margin_call_closed_units_)};
                    close_sized_before_call = true;
                }
            }
        }
        double coof_close_all_fill = kNaN;
        double coof_close_all_target = kNaN;
        if (coof_recalc_active_ && !coof_first_open_ && !immediately
            && coof_script_bar_valid_) {
            int next_extreme_index = -1;
            const double next_extreme = coof_next_waypoint(&next_extreme_index);
            coof_close_all_target = next_extreme;
            const auto point = detail::callback_point(require_host());
            const double current_quote = point ? point->price : kNaN;
            const bool buy = detail::run_position(require_host()).signed_units < 0.0;
            coof_close_all_fill = source_bar_fill_tick(
                next_extreme, staged_.syminfo.mintick)
                + (buy ? 1.0 : -1.0) * config_.slippage
                    * staged_.syminfo.mintick;
            if (finite_positive(coof_close_all_fill)
                && finite_positive(current_quote)
                && !source_same_point(current_quote, coof_close_all_fill,
                                      staged_.syminfo.mintick)) {
                // As the close of one id does: the trigger rests at the raw
                // extreme the path reaches, and the booked tick rides
                // forced_execution_price. An OFF-grid extreme (H 9.445 booked
                // 9.45) is otherwise never touched on this bar (lab tv tape
                // tests/fixtures/coof_immediate_close td-m1h on NYSE:F; lane
                // TAIL-D).
                const bool extreme_target = next_extreme_index == 1
                    || next_extreme_index == 2;
                const double level = extreme_target ? next_extreme : coof_close_all_fill;
                const native_order::Limit limit{level,
                    extreme_target && coof_close_all_fill != level};
                const bool falling = coof_close_all_fill < current_quote;
                if (buy) {
                    request.trigger = falling
                        ? native_order::Trigger{limit}
                        : native_order::Trigger{native_order::Stop{level}};
                } else {
                    request.trigger = falling
                        ? native_order::Trigger{native_order::Stop{level}}
                        : native_order::Trigger{limit};
                }
            }
        }
        PlacementSnapshot snapshot;
        snapshot.family = PineOrderFamily::CloseAll;
        snapshot.source_id = request.label;
        snapshot.comment = comment;
        snapshot.command_ordinal = command_ordinal;
        snapshot.immediately = immediately;
        snapshot.sizing = sizing_snapshot();
        if (immediately && config_.slippage > 0 && coof_recalc_active_
            && coof_first_open_ && coof_script_bar_valid_) {
            const auto callback_state = detail::run_state(require_host());
            if ((!callback_state.spec || callback_state.spec->intrabar.is_none()) && detail::callback_point(require_host()) && detail::callback_point(require_host())->decision.coordinate.path_phase == NativePathPhase::Open) {
                const bool close_is_buy = detail::run_position(require_host()).signed_units < 0.0;
                coof_close_all_fill = source_bar_fill_tick(
                    coof_script_bar_.open, staged_.syminfo.mintick)
                    + (close_is_buy ? 1.0 : -1.0) * config_.slippage * staged_.syminfo.mintick;
            }
        }
        snapshot.forced_execution_price = coof_close_all_fill;
        snapshot.forced_waypoint_print = coof_close_all_target;
        snapshot.crosses_zero = close_sized_before_call;
        (void)qty;
        (void)qty_percent;
        (void)callsite_token;
        const auto accepted = submit_or_replace(
            std::move(request), std::move(snapshot), false, "__pine_close_all");
        // ab9714be pine_strategy_commands.cpp:789-801: an ordinary POOC
        // close_all fills at the call (execute_immediate_close), ahead of any
        // same-bar market entry the script placed before it; an under-cap add
        // issued earlier in the pass therefore survives the flat
        // (pine_strategy_commands.cpp:2437-2446) instead of being flattened
        // with the book.  The script keeps the pre-close position view.
        const bool pooc_ordinary_close_all = config_.process_orders_on_close
            && !immediately && !config_.calc_on_order_fills && !coof_recalc_active_;
        if (pooc_ordinary_close_all && accepted) {
            if (auto* pine_host = pine_view_of(&require_host()))
                pine_host->freeze_script_position_view();
        }
        if ((immediately || pooc_ordinary_close_all) && accepted) {
            (void)require_host().execute_current(
                {*accepted, NativeCurrentPriceRule::NearestTick});
        }
        if (!accepted || config_.process_orders_on_close) return;
        const auto close = placement_.find(accepted->incarnation);
        if (close == placement_.end()) return;
        const auto side = static_cast<PositionSide>(close->second.projection_position_side);
        for (const auto& handle : live_handles_) {
            if (handle == *accepted) continue;
            const auto found = placement_.find(handle.incarnation);
            if (found == placement_.end()) continue;
            auto& pending = found->second;
            const bool pure_prior_stop = pending.opening
                && pending.family == PineOrderFamily::Entry
                && finite_positive(pending.exit_levels.stop)
                && !finite_positive(pending.exit_levels.limit)
                && !finite_positive(pending.exit_levels.trail_points)
                && !finite_positive(pending.exit_levels.trail_price)
                && !finite_positive(pending.exit_levels.trail_offset)
                && !pending.stop_limit_activated
                && pending.projection_created_bar < close->second.projection_created_bar
                && pending.projection_position_side == static_cast<std::int32_t>(side)
                && pending.is_long == (side == PositionSide::LONG)
                && !pending.projection_over_pyramiding;
            const auto* pine_host = pine_view_of(&require_host());
            const bool has_physical_id = pine_host
                && pine_host->adapter_has_open_entry_id(pending.source_id);
            if (!pure_prior_stop || !has_physical_id) continue;
            pending.preserved_by_close_all = *accepted; invalidate_retirement();
            pending.preserved_close_all_bar = close->second.projection_created_bar;
        }
        const double cur_pos = detail::run_position(require_host()).signed_units;
        const auto cur_pt = detail::callback_point(require_host());
        if (cur_pos != 0.0 && cur_pt) {
            std::vector<native_order::RequestHandle> opposite_entries;
            for (const auto& handle : live_handles_) {
                if (handle == *accepted) continue;
                const auto found = placement_.find(handle.incarnation);
                if (found == placement_.end()) continue;
                const auto& pend = found->second;
                const bool unpriced_market = !finite_positive(pend.exit_levels.limit)
                    && !finite_positive(pend.exit_levels.stop)
                    && !finite_positive(pend.exit_levels.trail_points)
                    && !finite_positive(pend.exit_levels.trail_price)
                    && !finite_positive(pend.exit_levels.trail_offset);
                if (pend.opening && pend.family == PineOrderFamily::Entry
                    && unpriced_market
                    && !pend.projection_over_pyramiding
                    && pend.placement_script_open_ms == cur_pt->decision.script_bar_open_ms) {
                    opposite_entries.push_back(handle);
                }
            }
            for (const auto& handle : opposite_entries) {
                const auto found = placement_.find(handle.incarnation);
                if (found == placement_.end()) continue;
                PlacementSnapshot entry_snapshot = found->second;
                // ab9714be pine_fills.cpp:3848-3856: full market close processes before opposite entry so entry executes after close
                entry_snapshot.paired_reversal_parent = *accepted;
                entry_snapshot.market_admission = {};
                const auto result = require_host().cancel(handle);
                if (result.status == native_order::CancelStatus::Cancelled) {
                    retire(handle);
                    native_order::Request req;
                    const double target = entry_snapshot.is_long
                        ? entry_snapshot.requested_qty : -entry_snapshot.requested_qty;
                    req.intent = std::isnan(target)
                        ? native_order::OrderIntent{native_order::HostSized{native_order::HostSizedKind::Open,
                            entry_snapshot.is_long ? native_order::Side::Long : native_order::Side::Short}}
                        : native_order::OrderIntent{native_order::Transact{target}};
                    req.label = entry_snapshot.source_id;
                    req.comment = entry_snapshot.comment;
                    const SourceId replacement_key = entry_snapshot.source_id;
                    pending_write(pending_entries_).push_back({std::move(req), std::move(entry_snapshot), replacement_key});
#ifdef PINEFORGE_CR277_DIAGNOSTIC
                    cr277_pending_close_pushes[0].fetch_add(1, std::memory_order_relaxed);
#endif
                }
            }
            for (auto it = pending_same_bar_commands_.begin(); it != pending_same_bar_commands_.end();) {
                if (it->opening && it->snapshot.family == PineOrderFamily::Entry
                    && !it->snapshot.projection_over_pyramiding
                    && it->snapshot.placement_script_open_ms == cur_pt->decision.script_bar_open_ms) {
                    it->snapshot.paired_reversal_parent = *accepted;
                    it->snapshot.market_admission = {};
                    pending_write(pending_entries_).push_back({std::move(it->request), std::move(it->snapshot), it->replacement_key});
                    it = pending_write(pending_same_bar_commands_).erase(it);
                } else {
                    ++it;
                }
            }
        }
        return;
    }
    const auto openings = openings_for(id);
    // A default FIFO close sizes from the id's close ledger: the units
    // entered under the id that no fill has booked, whether or not the FIFO
    // rule has already closed the lots that carried it (tapes w3f02-g1,
    // w3bf02-d1, -d2, -f2).
    const bool ledger_sized = !config_.close_entries_rule_any && !immediately
        && std::isnan(qty) && std::isnan(qty_percent);
    // The ledger is a running sum of fills: where it differs from the id's own
    // live lots only by rounding, the lots are the quantity, so the close
    // leaves no dust behind them.
    const double ledger_units = [&] {
        if (!ledger_sized) return 0.0;
        const double ledger = fixture_close_logical_units(id);
        const double own = cohort_exposure_for(id);
        return own > 0.0 && std::abs(ledger - own) <= internal::kQtyEpsilon ? own : ledger;
    }();
    // P-DA3: strategy.close against an empty cohort is dropped at the command.
    if (openings.empty() && !(ledger_units > 0.0)) {
        record_dropped_close(id, comment, qty, qty_percent, immediately, callsite_token);
        return;
    }
    const bool has_pending_entry = std::any_of(
        pending_entries_.begin(), pending_entries_.end(),
        [&](const PendingEntry& pe) { return pe.snapshot.source_id == id; })
        || std::any_of(
        pending_same_bar_commands_.begin(), pending_same_bar_commands_.end(),
        [&](const PendingSameBarCommand& pc) { return pc.snapshot.source_id == id; });
    // ab9714be pine_strategy_commands.cpp:2254-2256: compute_close_target_qty drops close when target unclosed quantity is zero
    const double closable = ledger_sized ? ledger_units : cohort_exposure_for(id);
    if (!config_.process_orders_on_close && !id.empty() && !(closable > 0.0)
        && !has_pending_entry) {
        record_dropped_close(id, comment, qty, qty_percent, immediately, callsite_token);
        return;
    }
    const std::uint64_t command_ordinal = ++command_ordinal_;
    // A same-side fixed market add is tentatively held until a later
    // strategy.exit can contribute its priced legs to the source-priority
    // batch.  A named strategy.close terminates that command shape instead:
    // publish the already-issued add before placing the close, exactly as the
    // legacy broker book did.  Leaving it staged would make the public
    // command-boundary projection lose one of the two surviving rows and
    // would incorrectly make the close race an unsubmitted add.
    if (!config_.calc_on_order_fills && !config_.process_orders_on_close
        && !pending_entries_.empty()) {
        const double live = detail::run_position(require_host()).signed_units;
        const bool has_opposite = std::any_of(
            pending_entries_.begin(), pending_entries_.end(), [&](const PendingEntry& entry) {
                return live != 0.0 && entry.snapshot.is_long != (live > 0.0);
            });
        const bool close_first_percent_add =
            config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
            && std::abs(config_.default_qty_value - 100.0) < 1e-12
            && std::all_of(pending_entries_.begin(), pending_entries_.end(),
                [](const PendingEntry& entry) {
                    return entry.snapshot.family == PineOrderFamily::Entry
                        && !std::isfinite(entry.snapshot.requested_qty)
                        && !finite_positive(entry.snapshot.exit_levels.limit)
                        && !finite_positive(entry.snapshot.exit_levels.stop);
                });
        if (!has_opposite && !close_first_percent_add) flush_pending_entries();
    }
    double requested_percent = std::isnan(qty_percent) ? 100.0 : qty_percent;
    double effective_qty = qty;
    const double current = detail::run_position(require_host()).signed_units;
    if (config_.close_entries_rule_any && !immediately && std::isfinite(qty)) {
        const double matching = cohort_exposure_for(id);
        requested_percent = matching > 1e-10
            ? std::clamp(std::abs(qty) / matching * 100.0, 0.0, 100.0)
            : 100.0;
        // ab9714be:pine_strategy_commands.cpp:2522-2590.  An ANY close keeps
        // the already-resolved claim as a percentage-bound deferred order;
        // its public pending qty remains NaN and the live cohort is resolved
        // at the eventual candidate.
        effective_qty = kNaN;
    }
    const bool default_fifo_close = !config_.close_entries_rule_any
        && std::isnan(qty) && std::isnan(qty_percent);
    bool paired_reversal_close = false;
    bool paired_reversal_whole_drop = false;
    std::optional<native_order::RequestHandle> paired_reversal_parent;
    if (default_fifo_close && current != 0.0) {
        const auto point = detail::callback_point(require_host());
        for (const auto& handle : live_handles_) {
            const auto pending = placement_.find(handle.incarnation);
            if (pending == placement_.end()) continue;
            const auto& row = pending->second;
            if (row.opening && row.family == PineOrderFamily::Entry
                && row.is_long != (current > 0.0)
                && (!point || row.placement_script_open_ms
                    == point->decision.script_bar_open_ms)) {
                paired_reversal_close = true;
                paired_reversal_parent = handle;
                // A reversal the unified placement half refused at its
                // signal does not take the close with it (entry()).
                if (row.signal_price_refused) {
                    paired_reversal_whole_drop = true;
                    break;
                }
                const bool rule5_scope =
                    config_.default_qty_type
                        == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
                    && std::abs(config_.default_qty_value - 100.0) < 1e-12
                    && staged_.quantity_grid && *staged_.quantity_grid > 0.0
                    && *staged_.quantity_grid < 1.0
                    && staged_.syminfo.pointvalue == 1.0
                    && row.sizing.fx == 1.0
                    && staged_.account_fx_effective_from_ms.empty()
                    && config_.commission_value == 0.0 && config_.slippage == 0
                    && !config_.process_orders_on_close
                    && !config_.calc_on_order_fills
                    && finite_positive(row.sizing.frozen_units)
                    && finite_positive(row.sizing.equity)
                    && finite_positive(row.sizing.price);
                if (rule5_scope) {
                    const double notional_per_price = row.sizing.frozen_units
                        * staged_.syminfo.pointvalue * row.sizing.fx;
                    const double rounded_cost = source_money_round(
                        notional_per_price * row.sizing.price);
                    const double affordable_price = source_money_round(
                        source_money_round(row.sizing.equity)
                        / notional_per_price);
                    paired_reversal_whole_drop =
                        row.sizing.equity + 1e-9 >= rounded_cost
                        && std::isfinite(affordable_price)
                        && affordable_price < row.sizing.price;
                }
                break;
            }
        }
    }
    if (immediately) {
        const double current = detail::run_position(require_host()).signed_units;
        if (current != 0.0) {
            pending_write(pending_entries_).erase(std::remove_if(pending_entries_.begin(), pending_entries_.end(),
                [&](const PendingEntry& entry) {
                    return (current > 0.0) == entry.snapshot.is_long;
                }), pending_entries_.end());
        }
    }
    // P-DA2: an explicitly percentage-sized deferred ANY close retains
    // HostSized and resolves from the live selected cohort at its candidate.
    // FIFO's logical id ledger retains its command-time claim; so does the
    // separately specified same-bar market transaction artifact.
    const bool frozen_same_bar_close = same_bar_market_tx_scope() && !immediately
        && current != 0.0;
    const bool deferred_percentage = config_.close_entries_rule_any
        && std::isnan(effective_qty) && std::isfinite(requested_percent)
        && !immediately;
    const bool pooc_close_basis = config_.process_orders_on_close;
    double frozen_qty = effective_qty;
    if (std::isnan(effective_qty) && (!deferred_percentage || immediately || frozen_same_bar_close
                            || pooc_close_basis)) {
        const auto point = detail::callback_point(require_host());
        const std::int64_t bar_key = point ? point->decision.script_bar_open_ms
                                           : require_host().native_decision_floor();
        const double fallback_basis = std::abs(detail::run_position(require_host()).signed_units);
        const bool ledger_basis = ledger_sized && !config_.process_orders_on_close;
        const double source_basis = ledger_basis
            ? std::min(ledger_units, fallback_basis) : cohort_exposure_for(id);
        const double script_basis = source_basis > 0.0 ? source_basis : fallback_basis;
        if (pooc_close_basis_count_ == 0 || bar_key != pooc_close_basis_last_bar_) {
            BrokerStateHashSink fold;
            fold.h = pooc_close_basis_digest_;
            fold.i(bar_key);
            fold.d(script_basis);
            pooc_close_basis_digest_ = fold.h;
            pooc_close_basis_last_bar_ = bar_key;
            ++pooc_close_basis_count_;
        }
        frozen_qty = quantize_close_units(script_basis, requested_percent);
    }
    const double close_basis = ledger_sized && !config_.process_orders_on_close
        && ledger_units > 0.0
        ? std::min(ledger_units, std::abs(current))
        : cohort_exposure_for(id) > 0.0 ? cohort_exposure_for(id) : std::abs(current);
    const bool closes_full_position = close_basis > 0.0
        && ((std::isfinite(frozen_qty) && frozen_qty >= close_basis - 1e-10)
            || (std::isnan(effective_qty) && requested_percent >= 100.0 - 1e-9));
    bool reversal_pair = false;
    if (closes_full_position && current != 0.0) {
        const auto opposite_entry = [&](const PlacementSnapshot& candidate) {
            return candidate.opening && candidate.family == PineOrderFamily::Entry
                && candidate.is_long != (current > 0.0)
                && (!finite_positive(candidate.exit_levels.limit)
                    && !finite_positive(candidate.exit_levels.stop));
        };
        for (const auto& pending : pending_same_bar_commands_)
            reversal_pair = reversal_pair || opposite_entry(pending.snapshot);
        for (const auto& handle : live_handles_) {
            const auto found = placement_.find(handle.incarnation);
            if (found != placement_.end())
                reversal_pair = reversal_pair || opposite_entry(found->second);
        }
    }
    const bool batched_pooc_fifo = default_fifo_close
        && !immediately && config_.process_orders_on_close
        && !config_.calc_on_order_fills
        && !coof_recalc_active_ && !cap.active()
        && !reversal_pair;
    if (batched_pooc_fifo) {
        const bool enqueued = enqueue_pooc_fifo_close(
            id, comment, callsite_token, command_ordinal);
        if (enqueued && closes_full_position)
            cancel_exit_orders_for_full_close(id);
        return;
    }
    if (closes_full_position && !reversal_pair) {
        cancel_exit_orders_for_full_close(id);
    }
    // A partial source close breaks the exact ShortSeed transaction book.
    // Its legacy effect is to leave the two frozen reversal commands on the
    // ordinary broker pass; the stale close itself owns no surviving broker
    // object.  Detect that complete paired batch by source facts rather than
    // a generic id heuristic.
    if (same_bar_market_tx_scope() && !immediately && current != 0.0
        && (!std::isnan(qty) || !std::isnan(qty_percent))) {
        const bool variable_default = config_.default_qty_type
            != static_cast<int>(QtyType::FIXED);
        if (variable_default) {
            bool held_reentry = false;
            bool opposite_reversal = false;
            const bool held_long = current > 0.0;
            for (const auto& pending : pending_same_bar_commands_) {
                if (!pending.opening || pending.snapshot.family != PineOrderFamily::Entry) continue;
                if (pending.snapshot.source_id == id && pending.snapshot.is_long == held_long)
                    held_reentry = true;
                if (pending.snapshot.is_long != held_long) opposite_reversal = true;
            }
            if (held_reentry && opposite_reversal) {
                // The partial close has no executable artifact in the source
                // transaction pass.  Retain an accepted, dormant source
                // handle so the ShortSeed role projection remains truthful;
                // its unreachable buy limit prevents it from changing the
                // ordinary two-reversal outcome.
                if (short_seed_context_is_live() && current < 0.0) {
                    native_order::Request placeholder;
                    placeholder.intent = native_order::HostSized{
                        native_order::HostSizedKind::Close, std::nullopt};
                    placeholder.label = "__close__" + id;
                    placeholder.trigger = native_order::Limit{
                        std::numeric_limits<double>::min()};
                    placeholder.owner = owner_for_close(id, true);
                    PlacementSnapshot placeholder_snapshot;
                    placeholder_snapshot.family = PineOrderFamily::Close;
                    placeholder_snapshot.source_id = id;
                    placeholder_snapshot.from_entry = id;
                    placeholder_snapshot.requested_qty = frozen_qty;
                    placeholder_snapshot.qty_percent = requested_percent;
                    placeholder_snapshot.is_long = false;
                    placeholder_snapshot.deferred_cohort = true;
                    placeholder_snapshot.command_ordinal = command_ordinal;
                    placeholder_snapshot.sizing = sizing_snapshot();
                    (void)submit_or_replace(std::move(placeholder), std::move(placeholder_snapshot),
                                            false, "__short_seed_partial_hold__" + id);
                }
                return;
            }
        }
    }
    if (same_bar_market_tx_scope() && !immediately && id.size() != 0
        && std::isnan(qty) && std::isnan(qty_percent) && current != 0.0
        && finite_positive(frozen_qty)) {
        native_order::Request request;
        request.label = "__close__" + id;
        request.comment = comment;
        PlacementSnapshot snapshot;
        snapshot.family = PineOrderFamily::Close;
        snapshot.source_id = id;
        snapshot.from_entry = id;
        snapshot.comment = comment;
        snapshot.requested_qty = frozen_qty;
        snapshot.qty_percent = requested_percent;
        snapshot.command_ordinal = command_ordinal;
        snapshot.is_long = false;
        snapshot.frozen_market_instruction = true;
        snapshot.frozen_market_transaction_units = frozen_qty;
        snapshot.frozen_market_targeted_close = true;
        snapshot.frozen_market_target_was_long = current > 0.0;
        snapshot.birth = capture_order_birth();
        snapshot.sizing = sizing_snapshot();
        // ab9714be pine_orders.cpp:599-601: exit/close orders bind owner to active position_cycle_seq_
        snapshot.placement_cycle = current_position_cycle_;
        if (const auto point = detail::callback_point(require_host())) {
            snapshot.placement_script_open_ms = point->decision.script_bar_open_ms;
            snapshot.placement_sub_open_ms = point->decision.sub_bar_open_ms;
        }
        const SourceId replacement_key = callsite_token == 0
            ? SourceId{}
            : "__pine_close_site__" + std::to_string(callsite_token);
        pending_write(pending_same_bar_commands_).push_back(
            {std::move(request), std::move(snapshot), replacement_key, false});
        pending_same_bar_close_qty_ += frozen_qty;
        return;
    }
    // P-DA4: immediate closes keep their command-time cohort. Only an
    // ambiguous FIFO boundary uses HostSized to re-read the physical roster
    // at fill time; the Pine mirror can hide a <= kQtyEpsilon native fragment.
    // Preserve literal Reduce requests for every non-ambiguous FIFO close.
    const auto* close_pine_view = pine_view_of(host_);
    std::vector<double> preceding_fifo_closes;
    if (default_fifo_close && !immediately && close_pine_view
        && close_pine_view->pyramid_entries_.size() > 1U) {
        const auto point = detail::callback_point(require_host());
        for (const auto& handle : live_handles_) {
            const auto found = placement_.find(handle.incarnation);
            if (found == placement_.end()) continue;
            const auto& pending = found->second;
            if (pending.family != PineOrderFamily::Close || pending.immediately
                || !pending.from_entry.empty()
                || pending.frozen_market_instruction
                || !point || pending.placement_script_open_ms
                    != point->decision.script_bar_open_ms) continue;
            if (callsite_token != 0) {
                const auto prior = live_by_source_key_.find(checked_live_key(
                    "__pine_close_site__" + std::to_string(callsite_token)));
                if (prior != live_by_source_key_.end() && prior->second == handle) continue;
            }
            preceding_fifo_closes.push_back(pending.projection_remaining_qty);
        }
    }
    const bool fractional_fifo_book = default_fifo_close && close_pine_view
        && close_pine_view->pyramid_entries_.size() > 1U
        && source_fifo_close_needs_resolution(
            frozen_qty, close_pine_view->pyramid_entries_, preceding_fifo_closes);
    const bool host_sized = !immediately
        && (fractional_fifo_book || (std::isnan(frozen_qty) && !default_fifo_close));
    const bool default_full_any = config_.close_entries_rule_any
        && std::isnan(qty) && std::isnan(qty_percent) && !immediately;
    const bool pooc_cap_full_close = default_fifo_close
        && config_.process_orders_on_close && cap.active();
    native_order::Request request;
    request.intent = host_sized
        ? native_order::OrderIntent{native_order::HostSized{native_order::HostSizedKind::Close, std::nullopt}}
        : native_order::OrderIntent{native_order::Reduce{native_order::ExplicitUnits{frozen_qty}}};
    // The generic request label is the legacy close transaction signal while
    // PlacementSnapshot keeps the public source id for cohorts/readback.
    request.label = "__close__" + id;
    request.comment = comment;
    double coof_close_fill = kNaN;
    double coof_close_target = kNaN;
    // A matcher fill AT the bar's second extreme: the close fills there, at
    // that extreme, as the market entry does (H-MEASURE Finding 6d). ab9714be
    // advanced it to the close point, which admits no cascade order, and so to
    // the next open; TradingView books it on the fill's own bar at the extreme
    // (lab tv pa2-i4-close-w2-long / -pooc). A fill the adapter forced there
    // still advances (coof_fill_at_second_extreme; the recalculation fill-order correction).
    bool coof_close_next_open = false;
    bool coof_close_at_second_extreme = false;
    bool coof_close_next_sub_bar = false;
    if (coof_recalc_active_ && !coof_first_open_ && !immediately) {
        const auto state = detail::run_state(require_host());
        const bool lower_path = state.spec && state.spec->intrabar.lower();
        if (!lower_path && coof_fill_at_second_extreme()) {
            coof_close_next_open = coof_fill_forced_;
            coof_close_at_second_extreme = !coof_fill_forced_;
            if (coof_close_at_second_extreme) {
                const double endpoint = source_path_uses_high_first(coof_script_bar_)
                    ? coof_script_bar_.low : coof_script_bar_.high;
                const bool buy = current < 0.0;
                coof_close_target = endpoint;
                coof_close_fill = source_bar_fill_tick(endpoint, staged_.syminfo.mintick)
                    + (buy ? 1.0 : -1.0) * config_.slippage * staged_.syminfo.mintick;
            }
        } else if (lower_path) {
            coof_close_next_sub_bar = coof_waits_for_next_sub_bar();
        }
    }
    if (coof_recalc_active_ && !coof_first_open_ && !immediately
        && !coof_close_next_open && !coof_close_at_second_extreme
        && !coof_close_next_sub_bar
        && coof_script_bar_valid_) {
        int next_waypoint_index = -1;
        const double next_waypoint = coof_next_waypoint(&next_waypoint_index);
        const auto point = detail::callback_point(require_host());
        const double current_quote = point ? point->price : kNaN;
        const bool buy = current < 0.0;
        coof_close_target = next_waypoint;
        coof_close_fill = source_bar_fill_tick(
            next_waypoint, staged_.syminfo.mintick)
            + (buy ? 1.0 : -1.0) * config_.slippage
                * staged_.syminfo.mintick;
#ifdef PINEFORGE_VALUE_INVALID_FIXTURES
        coof_close_fill = fixture_adapter_execution_value("slippage.recalc.close", coof_close_fill);
#endif
        check_slippage_fill_price(coof_close_fill, std::isfinite(next_waypoint));
        if (finite_positive(coof_close_fill) && finite_positive(current_quote)
            && !source_same_point(current_quote, coof_close_fill, staged_.syminfo.mintick)) {
            // ab9714be pine_scheduler.cpp:541-563 fills the recalc's market
            // close AT the next EXTREME waypoint POINT (W1/W2) and books
            // bar_fill_price(waypoint) (pine_fills.cpp:7962-7966).  Arm that
            // trigger at the raw extreme the path actually reaches; the
            // booked tick-grid price rides forced_execution_price.  An
            // off-grid extreme (H 11.445 booked 11.45) is otherwise never
            // touched on this bar and the close rolls to the next open.
            // The C point admits no cascade order (pine_scheduler.cpp:
            // 541-544, 616-620), so a C target keeps the booked level.
            // The booked tick may lie on the wrong side of that raw level,
            // so an extreme limit is a touch trigger (fill-through).
            const bool extreme_target = next_waypoint_index == 1
                || next_waypoint_index == 2;
            const double level = extreme_target ? next_waypoint : coof_close_fill;
            const native_order::Limit limit{level,
                extreme_target && coof_close_fill != level};
            const bool falling = coof_close_fill < current_quote;
            if (buy) {
                request.trigger = falling
                    ? native_order::Trigger{limit}
                    : native_order::Trigger{native_order::Stop{level}};
            } else {
                request.trigger = falling
                    ? native_order::Trigger{native_order::Stop{level}}
                    : native_order::Trigger{limit};
            }
        }
    }
    // ab9714be pine_strategy_commands.cpp:2222-2278 and :2522-2590:
    // the default close-entries rule freezes the id's logical quantity, then
    // drains the physical book in FIFO order.  It is deliberately not bound
    // to that id's opening cohort (the ANY rule below is).
    request.owner = pooc_cap_full_close
        ? native_order::Owner{native_order::Independent{}}
        : default_fifo_close
        ? (paired_reversal_close && !paired_reversal_whole_drop
               && paired_reversal_parent
               ? native_order::Owner{native_order::WaitForApplied{
                     *paired_reversal_parent}}
                                 : native_order::Owner{native_order::Independent{}})
        : owner_for_close(id, host_sized && !default_full_any);
    PlacementSnapshot snapshot;
    snapshot.family = PineOrderFamily::Close; snapshot.source_id = id;
    snapshot.from_entry = default_fifo_close
        && (!paired_reversal_close || paired_reversal_whole_drop) ? SourceId{} : id;
    const bool exact_full_dynamic_close = host_sized && std::isnan(qty)
        && requested_percent >= 100.0;
    snapshot.comment = comment;
    snapshot.requested_qty = exact_full_dynamic_close ? kNaN : frozen_qty;
    snapshot.qty_percent = requested_percent;
    snapshot.projection_remaining_qty = frozen_qty;
    snapshot.command_ordinal = command_ordinal;
    snapshot.is_long = false;
    if ((immediately || cohort_exposure_for(id) >= std::abs(current) - internal::kQtyEpsilon) && config_.slippage > 0 && coof_recalc_active_
        && coof_first_open_ && coof_script_bar_valid_) {
        const auto callback_state = detail::run_state(require_host());
        if ((!callback_state.spec || callback_state.spec->intrabar.is_none()) && detail::callback_point(require_host()) && detail::callback_point(require_host())->decision.coordinate.path_phase == NativePathPhase::Open) {
            coof_close_fill = source_bar_fill_tick(
                coof_script_bar_.open, staged_.syminfo.mintick)
                + (current < 0.0 ? 1.0 : -1.0) * config_.slippage * staged_.syminfo.mintick;
        }
    }
    snapshot.forced_execution_price = coof_close_fill;
    snapshot.forced_waypoint_print = coof_close_target;
    snapshot.immediately = immediately; snapshot.deferred_cohort = host_sized; snapshot.sizing = sizing_snapshot();
    if (paired_reversal_parent && !paired_reversal_whole_drop)
        snapshot.paired_reversal_parent = *paired_reversal_parent;
    // The all-in source collision retains a same-side re-entry which may be
    // rejected only at the next opening.  Its close must be a child of that
    // candidate: if the re-entry is refused, the legacy close is suppressed
    // rather than flattening the carried seed on its own.
    const bool all_in_percent = std::isnan(effective_qty)
        && requested_percent >= 100.0 - 1e-9
        && config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        && config_.default_qty_value >= 100.0;
    bool opposite_reversal_pair = false;
    if (all_in_percent && current != 0.0 && !staged_.quantity_grid) {
        const bool held_long = current > 0.0;
        const auto point = detail::callback_point(require_host());
        const auto same_bar = [&](const PlacementSnapshot& candidate) {
            return candidate.opening && candidate.family == PineOrderFamily::Entry
                && candidate.is_long != held_long
                && (!point || candidate.placement_script_open_ms
                    == point->decision.script_bar_open_ms);
        };
        for (const auto& pending : pending_same_bar_commands_)
            opposite_reversal_pair = opposite_reversal_pair || same_bar(pending.snapshot);
        for (const auto& pending : pending_entries_)
            opposite_reversal_pair = opposite_reversal_pair || same_bar(pending.snapshot);
        for (const auto& pending : pending_coof_requests_)
            opposite_reversal_pair = opposite_reversal_pair || same_bar(pending.snapshot);
        for (const auto& handle : live_handles_) {
            const auto found = placement_.find(handle.incarnation);
            if (found != placement_.end())
                opposite_reversal_pair = opposite_reversal_pair || same_bar(found->second);
        }
    }
    if (opposite_reversal_pair) {
        // pine_fills.cpp:5509-5519 treats the entry/strategy.close pair as one
        // reversal decision.  The entry's native ReverseTo owns the admitted
        // close; if it is declined, the paired close must not flatten the held
        // cohort independently.  Keep only the source observation and place
        // the standing bracket behind the pair's lifecycle barrier.
        hold_reversal_pair_brackets(id);
        pending_write(source_shadow_pending_).push_back({snapshot, "__close__" + id});
        return;
    }
    bool all_in_dependent_close = false;
    if (all_in_percent) {
        const auto point = detail::callback_point(require_host());
        if (point) {
            std::optional<native_order::RequestHandle> reentry;
            for (const auto& handle : live_handles_) {
                const auto found = placement_.find(handle.incarnation);
                if (found == placement_.end() || !found->second.opening
                    || found->second.family != PineOrderFamily::Entry
                    || found->second.placement_script_open_ms
                        != point->decision.script_bar_open_ms
                    || found->second.source_id != id) {
                    continue;
                }
                reentry = handle;
            }
            // ab9714be pine_fills.cpp:2991-3009: a same-side call placed at
            // the pyramiding cap moves nothing at the next opening, and the
            // open-boundary admission retires it unless an earlier opposite
            // same-bar command can move the account first.  A close bound to
            // that doomed row would be cancelled with it, while the owner's
            // close (an ordinary exit order) still flattens the held side.
            if (reentry) {
                const auto found = placement_.find(reentry->incarnation);
                if (found != placement_.end() && found->second.projection_over_pyramiding) {
                    const auto& held = found->second;
                    bool earlier_opposite = false;
                    for (const auto& handle : live_handles_) {
                        const auto prior = placement_.find(handle.incarnation);
                        if (prior == placement_.end()) continue;
                        const auto& row = prior->second;
                        if (row.opening && row.family == PineOrderFamily::Entry
                            && row.is_long != held.is_long
                            && row.placement_script_open_ms == held.placement_script_open_ms
                            && row.source_sequence < held.source_sequence) {
                            earlier_opposite = true;
                            break;
                        }
                    }
                    if (!earlier_opposite) reentry.reset();
                }
            }
            if (reentry) {
                request.owner = native_order::WaitForApplied{*reentry};
                all_in_dependent_close = true;
                hold_reversal_pair_brackets(id);
            }
        }
    }
    if (coof_recalc_active_ && !coof_first_open_ && !immediately
        && !finite_positive(coof_close_fill)
        && coof_script_bar_valid_
        && std::holds_alternative<native_order::Market>(request.trigger)) {
        const auto point = detail::callback_point(require_host());
        const double current_quote = point ? point->price : kNaN;
        const double next_waypoint = next_source_path_waypoint(
            coof_script_bar_, coof_context_.coordinate.path_phase, current_quote,
            source_path_uses_high_first(coof_script_bar_),
            staged_.syminfo.mintick, config_.slippage);
        const bool buy = detail::run_position(require_host()).signed_units < 0.0;
        const double next_fill = nearest_tick(
            next_waypoint + (buy ? 1.0 : -1.0) * config_.slippage
                * staged_.syminfo.mintick,
            staged_.syminfo.mintick);
        if (finite_positive(next_fill) && finite_positive(current_quote)
            && next_fill != current_quote) {
            const bool falling = next_fill < current_quote;
            if (buy) {
                request.trigger = falling
                    ? native_order::Trigger{native_order::Limit{next_fill}}
                    : native_order::Trigger{native_order::Stop{next_fill}};
            } else {
                request.trigger = falling
                    ? native_order::Trigger{native_order::Stop{next_fill}}
                    : native_order::Trigger{native_order::Limit{next_fill}};
            }
            snapshot.forced_execution_price = next_fill;
        }
    }
    // Only the generated callsite-token form represents source replacement.
    // Independent close statements in one evaluation must coexist (P1/P2).
    const SourceId replacement_key = default_fifo_close
        ? (callsite_token == 0
               ? SourceId{}
               : "__pine_close_site__" + std::to_string(callsite_token))
        : (callsite_token == 0 ? SourceId{}
                               : id + "#close#" + std::to_string(callsite_token));
    if (coof_close_next_open) {
        snapshot.forced_execution_price = kNaN;
        request.trigger = native_order::Market{};
        pending_write(pending_coof_requests_).push_back({
            std::move(request), std::move(snapshot), replacement_key,
            false, 0, true});
        return;
    }
    // A later call of the same call site on this bar re-sizes the site's
    // order; its fill books against the id of the site's first call (tape
    // w3bf02-d1).
    if (default_fifo_close && !config_.process_orders_on_close && callsite_token != 0) {
        const auto prior = live_by_source_key_.find(checked_live_key(replacement_key));
        const auto point = detail::callback_point(require_host());
        if (prior != live_by_source_key_.end() && point) {
            const auto row = placement_.find(prior->second.incarnation);
            if (row != placement_.end() && row->second.family == PineOrderFamily::Close
                && row->second.placement_script_open_ms == point->decision.script_bar_open_ms) {
                const SourceId& first = row->second.close_first_id.empty()
                    ? row->second.source_id : row->second.close_first_id;
                if (first != id) snapshot.close_first_id = first;
            }
        }
    }
    const PlacementSnapshot shadow_snapshot = snapshot;
    const auto accepted = submit_or_replace(std::move(request), std::move(snapshot), false, replacement_key);
    if (!accepted && all_in_dependent_close) {
        pending_write(source_shadow_pending_).push_back({shadow_snapshot, "__close__" + id});
    }
    const bool pooc_immediate_fifo = config_.process_orders_on_close
        && !coof_recalc_active_
        && !config_.close_entries_rule_any && closes_full_position
        && !reversal_pair;
    if ((immediately || (config_.process_orders_on_close
                         && (cap.active() || pooc_immediate_fifo))) && accepted) {
        const auto outcome = require_host().execute_current(
            {*accepted, NativeCurrentPriceRule::NearestTick});
        if (const auto* applied = std::get_if<native_order::ExecutionAppliedEvent>(&outcome)) {
            consume_cohort_units(id, *applied);
            current_debited_applied_ordinals_.insert(applied->ordinal);
            if (applied->terminal) retire(*accepted);
        }
    }
}
 
void PineExecutionAdapter::close_all() {
    if (intraday_loss_orders_blocked()) return;
    require_cohort_ticket();
    reroute_fixed_entries_before_request();
    const double held = detail::run_position(require_host()).signed_units;
    if (held == 0.0) return;
    const auto* const point = detail::callback_point(require_host());
    if (point && cap_placement_denied(point->decision)) return;
    // The close-first fact (record_close_first: a whole close of the open
    // position) and the bar of the pending close_all, from the point and the
    // position read above; nothing between them moves either.
    if (point) {
        close_first_script_bar_ = point->decision.script_bar_open_ms;
        close_first_side_ = held > 0.0 ? 1 : -1;
        close_all_pending_script_bar_ = point->decision.script_bar_open_ms;
    }
    if (config_.calc_on_order_fills) {
        const auto point = detail::callback_point(require_host());
        const std::int64_t script_open = point ? point->decision.script_bar_open_ms
                                               : require_host().native_decision_floor();
        std::vector<native_order::RequestHandle> newborns;
        for (const auto& handle : live_handles_) {
            const auto placement = placement_.find(handle.incarnation);
            if (placement != placement_.end() && placement->second.opening
                && placement->second.family == PineOrderFamily::Entry
                && placement->second.placement_script_open_ms == script_open) {
                newborns.push_back(handle);
            }
        }
        for (const auto& handle : newborns) {
            const auto result = require_host().cancel(handle);
            if (result.status == native_order::CancelStatus::Cancelled) retire(handle);
        }
    }
    native_order::Request request;
    request.intent = native_order::Flatten{}; request.label = "__close__";
    PlacementSnapshot snapshot;
    snapshot.family = PineOrderFamily::CloseAll;
    snapshot.source_id = request.label;
    snapshot.sizing = sizing_snapshot();
    // A carried short's follow-up owed to this process_orders_on_close close
    // is booked after the script (book_owed_close_follow_up): the close_all
    // keeps the book the script saw, placed as the transaction that crosses
    // zero on the smaller book, ahead of the script's later orders (lab tv
    // tape tests/fixtures/margin_open_rules lots/close-all-overfill-gap).
    if (PF_RARE(owed_follow_up_bar_ != std::numeric_limits<std::int64_t>::min()) && point
        && owed_follow_up_bar_ == point->decision.script_bar_open_ms && owed_follow_up_point_ == 3
        && config_.process_orders_on_close && held < 0.0
        && detail::margin_schedule_switches().close_follow_up_after_script) {
        request.intent = native_order::Transact{-held};
        snapshot.crosses_zero = true;
    }
    const auto accepted = submit_or_replace(
        std::move(request), std::move(snapshot), false, "__pine_close_all");
    if (!accepted || config_.process_orders_on_close) return;
    const auto close = placement_.find(accepted->incarnation);
    if (close == placement_.end()) return;
    const auto side = static_cast<PositionSide>(close->second.projection_position_side);
    for (const auto& handle : live_handles_) {
        if (handle == *accepted) continue;
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        auto& pending = found->second;
        const bool pure_prior_stop = pending.opening
            && pending.family == PineOrderFamily::Entry
            && finite_positive(pending.exit_levels.stop)
            && !finite_positive(pending.exit_levels.limit)
            && !finite_positive(pending.exit_levels.trail_points)
            && !finite_positive(pending.exit_levels.trail_price)
            && !finite_positive(pending.exit_levels.trail_offset)
            && !pending.stop_limit_activated
            && pending.projection_created_bar < close->second.projection_created_bar
            && pending.projection_position_side == static_cast<std::int32_t>(side)
            && pending.is_long == (side == PositionSide::LONG)
            && !pending.projection_over_pyramiding;
        const auto* pine_host = pine_view_of(&require_host());
        const bool has_physical_id = pine_host
            && pine_host->adapter_has_open_entry_id(pending.source_id);
        if (!pure_prior_stop || !has_physical_id) continue;
        pending.preserved_by_close_all = *accepted; invalidate_retirement();
        pending.preserved_close_all_bar = close->second.projection_created_bar;
    }
    const double cur_pos = detail::run_position(require_host()).signed_units;
    const auto cur_pt = detail::callback_point(require_host());
    if (cur_pos != 0.0 && cur_pt) {
        std::vector<native_order::RequestHandle> opposite_entries;
        for (const auto& handle : live_handles_) {
            if (handle == *accepted) continue;
            const auto found = placement_.find(handle.incarnation);
            if (found == placement_.end()) continue;
            const auto& pend = found->second;
            const bool unpriced_market = !finite_positive(pend.exit_levels.limit)
                && !finite_positive(pend.exit_levels.stop)
                && !finite_positive(pend.exit_levels.trail_points)
                && !finite_positive(pend.exit_levels.trail_price)
                && !finite_positive(pend.exit_levels.trail_offset);
                if (pend.opening && pend.family == PineOrderFamily::Entry
                    && unpriced_market
                    && !pend.projection_over_pyramiding
                    && pend.placement_script_open_ms == cur_pt->decision.script_bar_open_ms) {
                    opposite_entries.push_back(handle);
                }
            }
            for (const auto& handle : opposite_entries) {
                const auto found = placement_.find(handle.incarnation);
                if (found == placement_.end()) continue;
                PlacementSnapshot entry_snapshot = found->second;
                // ab9714be pine_fills.cpp:3848-3856: full market close processes before opposite entry so entry executes after close
                entry_snapshot.paired_reversal_parent = *accepted;
                entry_snapshot.market_admission = {};
                const auto result = require_host().cancel(handle);
                if (result.status == native_order::CancelStatus::Cancelled) {
                    retire(handle);
                    native_order::Request req;
                    const double target = entry_snapshot.is_long
                        ? entry_snapshot.requested_qty : -entry_snapshot.requested_qty;
                    req.intent = std::isnan(target)
                        ? native_order::OrderIntent{native_order::HostSized{native_order::HostSizedKind::Open,
                            entry_snapshot.is_long ? native_order::Side::Long : native_order::Side::Short}}
                        : native_order::OrderIntent{native_order::Transact{target}};
                    req.label = entry_snapshot.source_id;
                    req.comment = entry_snapshot.comment;
                    const SourceId replacement_key = entry_snapshot.source_id;
                    pending_write(pending_entries_).push_back({std::move(req), std::move(entry_snapshot), replacement_key});
#ifdef PINEFORGE_CR277_DIAGNOSTIC
                    cr277_pending_close_pushes[1].fetch_add(1, std::memory_order_relaxed);
#endif
                }
            }
            for (auto it = pending_same_bar_commands_.begin(); it != pending_same_bar_commands_.end();) {
                if (it->opening && it->snapshot.family == PineOrderFamily::Entry
                    && !it->snapshot.projection_over_pyramiding
                    && it->snapshot.placement_script_open_ms == cur_pt->decision.script_bar_open_ms) {
                    it->snapshot.paired_reversal_parent = *accepted;
                    it->snapshot.market_admission = {};
                    pending_write(pending_entries_).push_back({std::move(it->request), std::move(it->snapshot), it->replacement_key});
                    it = pending_write(pending_same_bar_commands_).erase(it);
                } else {
                    ++it;
                }
            }
    }
}
 
// The account the binding rule's tapes run on: margin requirements off
// (margin_long = margin_short = 0, Pine v5's default), so no margin call ever
// acts on the exits the rule keeps. Every tape and its reference model run
// there; with a margin requirement the rule is unpinned and the adapter
// keeps its former course.
bool PineExecutionAdapter::margins_disabled() const noexcept {
    return config_.margin_long == 0.0 && config_.margin_short == 0.0;
}
 
// The exits the binding rule's tapes cover: the whole position at absolute
// levels -- no quantity, no partial percent, no trail, no tick offsets --
// without calc_on_order_fills.
bool PineExecutionAdapter::whole_level_exit(double limit_price, double stop_price,
                                            double trail_points, double trail_price,
                                            double profit_ticks, double loss_ticks, double qty,
                                            double qty_percent) const noexcept {
    return !config_.calc_on_order_fills && std::isnan(qty)
        && (std::isnan(qty_percent) || qty_percent >= 100.0)
        && std::isnan(trail_points) && std::isnan(trail_price)
        && std::isnan(profit_ticks) && std::isnan(loss_ticks)
        && (finite_positive(limit_price) || finite_positive(stop_price));
}
 
void PineExecutionAdapter::observe_pending_scan(PendingScanCounter& work) const noexcept {
    ++work.calls;
    work.max_live_handles = std::max<std::uint64_t>(work.max_live_handles, live_handles_.size());
    work.max_placement = std::max<std::uint64_t>(work.max_placement, placement_.size());
    work.max_pending_bracket_legs = std::max<std::uint64_t>(
        work.max_pending_bracket_legs, pending_bracket_legs_.size());
    work.max_resident_cohorts = std::max<std::uint64_t>(
        work.max_resident_cohorts, cohorts_by_id_.resident_size());
    work.max_logical_cohorts = std::max(work.max_logical_cohorts, cohorts_by_id_.size());
}
 
// Whether a limit or stop entry order works -- of `id`, or of any id when
// `id` is null: a live opening request or one the adapter still holds.
bool PineExecutionAdapter::priced_entry_order_working(const SourceId* id) const {
    auto& work = pending_scan_work_.priced_entry;
    observe_pending_scan(work);
    const auto entry_of = [&](const PlacementSnapshot& row) {
        return row.opening
            && (row.family == PineOrderFamily::Entry || row.family == PineOrderFamily::Order)
            && (id == nullptr || row.source_id == *id)
            && (finite_positive(row.exit_levels.limit) || finite_positive(row.exit_levels.stop));
    };
    for (const auto& pending : pending_entries_)
        if (entry_of(pending.snapshot)) return true;
    for (const auto& pending : pending_same_bar_commands_)
        if (entry_of(pending.snapshot)) return true;
    for (const auto& handle : live_handles_) {
        ++work.live_handle_iterations;
        ++work.placement_find_calls;
        const auto row = placement_.find(handle.incarnation);
        if (row != placement_.end() && entry_of(row->second)) return true;
    }
    return false;
}
 
bool PineExecutionAdapter::entry_order_pending(const SourceId& id) const {
    return entry_order_working(&id);
}
 
// Whether an entry order of any trigger works -- of `id`, or of any id when
// `id` is null: a live opening request or one the adapter still holds.
bool PineExecutionAdapter::entry_order_working(const SourceId* id) const {
    auto& work = pending_scan_work_.entry;
    observe_pending_scan(work);
    const auto entry_of = [&](const PlacementSnapshot& row) {
        return row.opening && (id == nullptr || row.source_id == *id)
            && (row.family == PineOrderFamily::Entry || row.family == PineOrderFamily::Order);
    };
    for (const auto& pending : pending_entries_)
        if (entry_of(pending.snapshot)) return true;
    for (const auto& pending : pending_same_bar_commands_)
        if (entry_of(pending.snapshot)) return true;
    for (const auto& pending : pending_coof_requests_)
        if (entry_of(pending.snapshot)) return true;
    for (const auto& delayed : delayed_market_orders_)
        if (entry_of(delayed.snapshot)) return true;
    for (const auto& handle : live_handles_) {
        ++work.live_handle_iterations;
        ++work.placement_find_calls;
        const auto row = placement_.find(handle.incarnation);
        if (row != placement_.end() && entry_of(row->second)) return true;
    }
    return false;
}
 
// Whether the book holds a lot `id` opened. The cohort facts cannot answer
// alone: a reversal by an entry of the reversed side's own id clears them
// after its opening records the new lot (purge_brackets_after_applied_reversal).
bool PineExecutionAdapter::open_lot_of(const SourceId& id) const {
    auto& work = pending_scan_work_.open_lot;
    observe_pending_scan(work);
    const auto& host = require_host();
    if (detail::run_position(host).lot_count == 0) return false;
    for (const auto& lot : host.native_open_lots(kNaN)) {
        ++work.open_lot_iterations;
        if (lot.entry_label == id) return true;
    }
    return false;
}
 
// Whether the pair (exit_id, from_entry) has an exit a call made while its
// entry rested or was open: working, staged for a later submission, or a
// relative leg waiting for its entry's fill.
bool PineExecutionAdapter::standing_exit(const SourceId& exit_id,
                                         const SourceId& from_entry) const {
    auto& work = pending_scan_work_.standing_exit;
    observe_pending_scan(work);
    const auto standing = [&](const PlacementSnapshot& row) {
        const bool exit = row.family == PineOrderFamily::ExitLimit
            || row.family == PineOrderFamily::ExitStop
            || row.family == PineOrderFamily::ExitTrail;
        return exit && !row.void_issue && row.source_id == exit_id
            && row.from_entry == from_entry;
    };
    for (const auto& handle : live_handles_) {
        ++work.live_handle_iterations;
        ++work.placement_find_calls;
        const auto row = placement_.find(handle.incarnation);
        if (row != placement_.end() && standing(row->second)) return true;
    }
    for (const auto& pending : pending_bracket_legs_)
        if (standing(pending.snapshot)) return true;
    for (const auto& pending : pending_coof_requests_)
        if (standing(pending.snapshot)) return true;
    for (const auto& delayed : delayed_market_orders_)
        if (standing(delayed.snapshot)) return true;
    return std::any_of(pending_relative_exits_.begin(), pending_relative_exits_.end(),
        [&](const PendingRelativeExit& value) {
            return value.exit_id == exit_id && value.from_entry == from_entry;
        });
}
 
// A call made once its entry exists that leaves a void request of its pair
// unchanged makes that request its own, as a re-issue that replaced it would
// be: no longer void, and queued from this call (exit_queue_rank).
void PineExecutionAdapter::unvoid_exit(PlacementSnapshot& row) {
    if (source_sequence_ == std::numeric_limits<std::uint64_t>::max())
        throw coded<std::overflow_error>(RunFailureCode::engine_invariant, {},
                                         "Pine source sequence exhausted");
    row.void_issue = false;
    row.chain_origin_sequence = ++source_sequence_;
}
 
// A same-close fill of an exit leg (process_orders_on_close). A void call's
// request acts on nothing (PlacementSnapshot::void_issue): its close is
// placed as the leg's successor, as any other, so every later request keeps
// its incarnation, and withdrawn instead of executed.
void PineExecutionAdapter::execute_or_withdraw_close(native_order::RequestHandle close,
                                                     bool void_issue) {
    if (!void_issue) {
        (void)require_host().execute_current({close, NativeCurrentPriceRule::NearestTick});
        return;
    }
    const auto result = require_host().cancel(close);
    if (result.status == native_order::CancelStatus::Cancelled) retire(close);
}
 
// The opening of `entry_id` withdraws the exits TradingView voided for it
// (PlacementSnapshot::void_issue): their calls ran while the entry neither
// existed nor rested, so none of them binds to the lot this fill opens.
void PineExecutionAdapter::withdraw_void_exits(const SourceId& entry_id) {
    const auto voided = [&](const PlacementSnapshot& row) {
        return row.void_issue && row.from_entry == entry_id;
    };
    pending_write(pending_bracket_legs_).erase(
        std::remove_if(pending_bracket_legs_.begin(), pending_bracket_legs_.end(),
            [&](const PendingBracketLeg& row) { return voided(row.snapshot); }),
        pending_bracket_legs_.end());
    pending_write(pending_coof_requests_).erase(
        std::remove_if(pending_coof_requests_.begin(), pending_coof_requests_.end(),
            [&](const PendingCoofRequest& row) { return voided(row.snapshot); }),
        pending_coof_requests_.end());
    delayed_market_orders_.erase(
        std::remove_if(delayed_market_orders_.begin(), delayed_market_orders_.end(),
            [&](const DelayedMarketOrder& row) { return voided(row.snapshot); }),
        delayed_market_orders_.end());
    std::vector<native_order::RequestHandle> handles;
    for (const auto& handle : live_handles_) {
        const auto row = placement_.find(handle.incarnation);
        if (row != placement_.end() && voided(row->second)) handles.push_back(handle);
    }
    if (handles.empty()) return;
    for (const auto& handle : handles) {
        const auto result = require_host().cancel(handle);
        if (result.status == native_order::CancelStatus::Cancelled) retire(handle);
    }
    for (auto family = bracket_families_.begin(); family != bracket_families_.end();) {
        family->second.remove_all(handles);
        if (family->second.empty()) family = bracket_families_.erase(family);
        else ++family;
    }
    refresh_pending_view();
}
 
// Under process_orders_on_close TradingView never fills a priced add called
// while the position holds `pyramiding` entries, even once the position
// shrinks or goes flat (tests/fixtures/exit_binding pyr1, pyr1-close-sibling).
// The adapter places it at the call, over the cap (projection_over_pyramiding),
// as a later close of the bar may free a slot. At the next opening, that bar's
// closes done, an add the position still holds `pyramiding` entries against
// leaves the book; each add is judged at that one opening. The tapes pin an
// add of an id that holds no lot, without calc_on_order_fills; a same-id add
// keeps its course. Where a close of the add's bar frees the slot TradingView
// is not pinned (the pin's model rejects the add at the call); the add stays.
void PineExecutionAdapter::withdraw_unplaced_cap_adds(const NativeDecisionContext& context) {
    const auto physical = detail::run_position(require_host());
    if (physical.signed_units == 0.0) return;
    const auto records = open_ledger_records();
    if ((records ? *records : physical.lot_count)
        < static_cast<std::size_t>(config_.pyramiding)) {
        return;
    }
    std::vector<native_order::RequestHandle> unplaced;
    for (const auto& handle : live_handles_) {
        const auto row = placement_.find(handle.incarnation);
        if (row == placement_.end()) continue;
        const auto& entry = row->second;
        if (!entry.opening || entry.family != PineOrderFamily::Entry
            || !entry.projection_over_pyramiding
            || entry.is_long != (physical.signed_units > 0.0)
            || !(finite_positive(entry.exit_levels.limit)
                 || finite_positive(entry.exit_levels.stop))
            || entry.placement_script_open_ms >= context.script_bar_open_ms
            || entry.placement_script_open_ms != last_broker_open_ms_
            || cohort_exposure_for(entry.source_id) > 0.0 || open_lot_of(entry.source_id)) {
            continue;
        }
        unplaced.push_back(handle);
    }
    for (const auto& handle : unplaced) {
        const auto result = require_host().cancel(handle);
        if (result.status == native_order::CancelStatus::Cancelled) retire(handle);
    }
}
 
// The fill of `entry_id` ends the binding of its exits to the id
// (PlacementSnapshot::pending_bound_exit): from now on they are exits of the
// lot this fill opens, and end with it.
void PineExecutionAdapter::bind_pending_exits_to_fill(const SourceId& entry_id) {
    const auto bind = [&](PlacementSnapshot& row) {
        if (row.pending_bound_exit && row.from_entry == entry_id) { row.pending_bound_exit = false; invalidate_retirement(); }
    };
    for (auto& pending : pending_bracket_legs_) bind(pending.snapshot);
    for (auto& pending : pending_coof_requests_) bind(pending.snapshot);
    for (auto& delayed : delayed_market_orders_) bind(delayed.snapshot);
    for (auto& shadow : source_shadow_pending_) bind(shadow.snapshot);
    for (const auto& handle : live_handles_) {
        const auto row = placement_.find(handle.incarnation);
        if (row != placement_.end()) bind(row->second);
    }
}
 
// A strategy.cancel of `entry_id` withdraws its working entry order, and the
// native requests of the exits bound to the id end with it. TradingView keeps
// those exits bound to the id (tests/fixtures/exit_binding cancel-replace,
// cancel-flat-replace): their calls are kept and the id's next entry order
// re-arms them (rearm_id_bound_exits).
void PineExecutionAdapter::stash_id_bound_exits(const SourceId& entry_id) {
    if (!detail::exit_binding_rule_switches().pending_bound_exit_survives_flat
        || entry_id.empty() || !entry_order_pending(entry_id)) {
        return;
    }
    std::vector<native_order::RequestHandle> handles;
    for (const auto& handle : live_handles_) {
        const auto row = placement_.find(handle.incarnation);
        if (row == placement_.end()) continue;
        const auto& snapshot = row->second;
        const bool exit = snapshot.family == PineOrderFamily::ExitLimit
            || snapshot.family == PineOrderFamily::ExitStop
            || snapshot.family == PineOrderFamily::ExitTrail;
        if (!exit || !snapshot.pending_bound_exit || snapshot.from_entry != entry_id) continue;
        handles.push_back(handle);
        const bool kept = std::any_of(id_bound_exits_.begin(), id_bound_exits_.end(),
            [&](const IdBoundExit& stashed) {
                return stashed.exit_id == snapshot.source_id
                    && stashed.from_entry == snapshot.from_entry;
            });
        if (!kept) {
            id_bound_exits_.push_back({snapshot.source_id, snapshot.from_entry,
                                       snapshot.exit_levels, snapshot.qty_percent,
                                       snapshot.requested_qty, snapshot.comment,
                                       snapshot.oca_name});
        }
    }
    if (handles.empty()) return;
    for (const auto& handle : handles) {
        const auto result = require_host().cancel(handle);
        if (result.status == native_order::CancelStatus::Cancelled) retire(handle);
    }
    for (auto family = bracket_families_.begin(); family != bracket_families_.end();) {
        family->second.remove_all(handles);
        if (family->second.empty()) family = bracket_families_.erase(family);
        else ++family;
    }
    refresh_pending_view();
}
 
// The first opening fill settles every strategy.exit TradingView voided as
// called while flat with no entry order working (PlacementSnapshot::
// void_global_issue). A market entry's fill, which the tapes pin, withdraws
// them: none binds to the lot it opens, whatever its id. Only the legs still
// working are cancelled. The kernel already ended a leg it reached while the
// book was flat, and the opening check skips that leg
// (priced_exit_precedes_opening). A stop or limit entry's fill, which no tape
// covers, clears the flag instead and leaves the legs their former course.
void PineExecutionAdapter::settle_void_global_exits(bool market_entry) {
    const auto voided = [](const PlacementSnapshot& row) { return row.void_global_issue; };
    if (!market_entry) {
        for (auto& row : pending_bracket_legs_) row.snapshot.void_global_issue = false;
        for (auto& row : pending_coof_requests_) row.snapshot.void_global_issue = false;
        for (auto& row : delayed_market_orders_) row.snapshot.void_global_issue = false;
        for (const auto& handle : live_handles_) {
            const auto row = placement_.find(handle.incarnation);
            if (row != placement_.end() && voided(row->second))
                row->second.void_global_issue = false;
        }
        return;
    }
    pending_write(pending_bracket_legs_).erase(
        std::remove_if(pending_bracket_legs_.begin(), pending_bracket_legs_.end(),
            [&](const PendingBracketLeg& row) { return voided(row.snapshot); }),
        pending_bracket_legs_.end());
    pending_write(pending_coof_requests_).erase(
        std::remove_if(pending_coof_requests_.begin(), pending_coof_requests_.end(),
            [&](const PendingCoofRequest& row) { return voided(row.snapshot); }),
        pending_coof_requests_.end());
    delayed_market_orders_.erase(
        std::remove_if(delayed_market_orders_.begin(), delayed_market_orders_.end(),
            [&](const DelayedMarketOrder& row) { return voided(row.snapshot); }),
        delayed_market_orders_.end());
    std::vector<native_order::RequestHandle> handles;
    for (const auto& handle : live_handles_) {
        const auto row = placement_.find(handle.incarnation);
        if (row != placement_.end() && voided(row->second)) handles.push_back(handle);
    }
    if (handles.empty()) return;
    const auto working = require_host().native_working_requests();
    handles.erase(std::remove_if(handles.begin(), handles.end(),
        [&](const native_order::RequestHandle& handle) {
            return std::none_of(working.begin(), working.end(),
                [&](const NativeWorkingRequest& request) {
                    return request.definition->handle == handle;
                });
        }), handles.end());
    if (handles.empty()) return;
    for (const auto& handle : handles) {
        const auto result = require_host().cancel(handle);
        if (result.status == native_order::CancelStatus::Cancelled) retire(handle);
    }
    for (auto family = bracket_families_.begin(); family != bracket_families_.end();) {
        family->second.remove_all(handles);
        if (family->second.empty()) family = bracket_families_.erase(family);
        else ++family;
    }
    refresh_pending_view();
}
 
// The entry order just placed for `entry_id` takes the exits its id kept
// bound through a cancel, each called again as it was called.
void PineExecutionAdapter::rearm_id_bound_exits(const SourceId& entry_id) {
    if (!entry_order_pending(entry_id)) return;
    std::vector<IdBoundExit> rearm;
    for (auto row = id_bound_exits_.begin(); row != id_bound_exits_.end();) {
        if (row->from_entry == entry_id) {
            rearm.push_back(std::move(*row));
            row = id_bound_exits_.erase(row);
        } else {
            ++row;
        }
    }
    for (const auto& row : rearm) {
        exit(row.exit_id, row.from_entry, row.levels.limit, row.levels.stop,
             row.levels.trail_points, row.levels.trail_offset, row.levels.trail_price,
             row.qty_percent, row.comment, row.qty, row.oca_name, row.levels.profit_ticks,
             row.levels.loss_ticks);
    }
}
 
void PineExecutionAdapter::exit(const SourceId& exit_id, const SourceId& from_entry,
                                double limit_price, double stop_price, double trail_points,
                                double trail_offset, double trail_price, double qty_percent,
                                const std::string& comment, double qty,
                                const std::string& oca_name, double profit_ticks,
                                double loss_ticks) {
    const double requested_qty_percent = qty_percent;
    if (intraday_loss_orders_blocked()) return;
    if (const auto point = detail::callback_point(require_host());
        point && cap_placement_denied(point->decision)) {
        return;
    }
    const bool cohort_candidate = !from_entry.empty()
        && (!std::isnan(limit_price) || !std::isnan(stop_price)
            || !std::isnan(profit_ticks) || !std::isnan(loss_ticks)
            || !std::isnan(trail_points) || !std::isnan(trail_price));
    require_cohort_ticket(cohort_candidate ? &from_entry : nullptr);
    reroute_fixed_entries_before_request();
    if (!from_entry.empty()) {
        const auto token = named_entry_cancel_tokens_.find(from_entry);
        if (token != named_entry_cancel_tokens_.end()) {
            bool recreated_parent = std::any_of(
                pending_entries_.begin(), pending_entries_.end(),
                [&](const PendingEntry& pending) {
                    return pending.snapshot.opening
                        && pending.snapshot.source_id == from_entry;
                });
            for (const auto& handle : live_handles_) {
                const auto parent = placement_.find(handle.incarnation);
                if (parent != placement_.end() && parent->second.opening
                    && parent->second.family == PineOrderFamily::Entry
                    && parent->second.source_id == from_entry) {
                    recreated_parent = true;
                    break;
                }
            }
            // The cancellation token belongs only to a retained child that
            // survives until the fresh parent is declared.  Reissuing the
            // child first creates a fresh topology and consumes that token.
            if (!recreated_parent) named_entry_cancel_tokens_.erase(token);
        }
    }
    const bool actionable = !std::isnan(limit_price) || !std::isnan(stop_price)
        || !std::isnan(profit_ticks) || !std::isnan(loss_ticks)
        || !std::isnan(trail_points) || !std::isnan(trail_price);
    if (!actionable) {
        // ab9714be:pine_strategy_commands.cpp:1637-1660: an all-NaN
        // strategy.exit is inert, but a matching reissue still removes the
        // prior bracket before returning.  trail_offset alone is not an
        // actionable leg.
        exit_cancel_bracket(exit_id, from_entry, comment);
        return;
    }
    // TradingView voids a strategy.exit whose entry has neither an open
    // trade nor an entry order waiting to fill when the call runs: the exit
    // does not wait for a later entry of that id (lab tv w3f05-s17, -s19,
    // and w3f05-s12, whose exit re-issued while flat would otherwise take
    // the queue place of the next trade's first exit). An exit issued while
    // its entry's order rests binds to it when it fills (w3f05-s20). The
    // void call's request still waits in the book, so every later request
    // keeps its incarnation; the entry's opening withdraws it before it can
    // bind (withdraw_void_exits).
    // A pair that still has an exit issued while its entry rested or was
    // open keeps the call's former effect, a re-issue of that exit.
    // TradingView leaves the standing exit as it is instead (lab tv
    // w3bf05-v1, 04-08: its first level fills, not the void call's), but the
    // adapter withdraws an exit together with its cancelled entry, so that
    // shape is not reached here (tests/fixtures/exit_queue/README.md).
    const bool void_issue = !from_entry.empty() && !(cohort_exposure_for(from_entry) > 0.0)
        && !(!config_.close_entries_rule_any
             && fixture_close_logical_units(from_entry) > 0.0)
        && !entry_order_pending(from_entry) && !open_lot_of(from_entry)
        && !standing_exit(exit_id, from_entry);
    // A call made in position for an entry that holds no lot but has a limit
    // or stop order working binds the exit to the entry id: it waits for that
    // id's next fill through closes and the flat (PlacementSnapshot::
    // pending_bound_exit; tests/fixtures/exit_binding). The tapes pin a whole
    // exit at absolute levels for a parent resting at a level, without
    // calc_on_order_fills and with margins off (whole_level_exit,
    // margins_disabled); other exits keep their course.
    const bool pending_bound_exit = !from_entry.empty() && !void_issue
        && detail::exit_binding_rule_switches().pending_bound_exit_survives_flat
        && margins_disabled()
        && whole_level_exit(limit_price, stop_price, trail_points, trail_price, profit_ticks,
                            loss_ticks, qty, requested_qty_percent)
        && detail::run_position(require_host()).signed_units != 0.0
        && !(cohort_exposure_for(from_entry) > 0.0)
        && !(!config_.close_entries_rule_any && fixture_close_logical_units(from_entry) > 0.0)
        && priced_entry_order_working(&from_entry) && !open_lot_of(from_entry);
    // TradingView voids a strategy.exit without from_entry called while no
    // position is held and no entry order of any id is working: an entry
    // placed after it opens a book with no exit, whose opening check is
    // booked as with none, and none of its legs ever fills, the
    // process_orders_on_close close included (lab tv tapes tests/fixtures/
    // margin_open_rules exit-before-entry/). With an entry order working the
    // exit binds, and the first fill takes it. As a void named exit's, the
    // call's request still waits in the book, so every later request keeps
    // its incarnation; the first opening fill, a market entry's, withdraws
    // it (settle_void_global_exits). Not under calc_on_order_fills, nor
    // where a stop or limit entry fills first: no tape covers either.
    const bool void_global_issue = from_entry.empty()
        && detail::margin_opening_switches().void_flat_global_exit
        && !config_.calc_on_order_fills
        && detail::run_position(require_host()).signed_units == 0.0
        && !entry_order_working(nullptr);
    // A pending variable short-context entry is only tentatively held for the
    // three-object ShortSeed command book.  A bracket call proves it belongs
    // to an ordinary entry family, so materialize that entry before binding
    // the bracket just as the legacy source callback did.
    if (!pending_same_bar_commands_.empty()
        && config_.default_qty_type != static_cast<int>(QtyType::FIXED)
        && detail::run_position(require_host()).signed_units < 0.0) {
        flush_pending_same_bar_commands();
    }
    if (source_command_sequence_ == std::numeric_limits<std::uint64_t>::max()) {
        throw coded<std::overflow_error>(RunFailureCode::engine_invariant, {},
                                         "Pine source command sequence exhausted");
    }
    const std::uint64_t command_sequence = ++source_command_sequence_;
    // Trail point and offset operands are source tick counts, whereas the
    // generic native Trail carries prices.  Preserve the source operands in
    // the placement projection and lower only the executable request here.
    // Points ceil away from entry (with the established source tolerance);
    // offsets truncate exactly, including the explicit-zero trail shape.
    const double source_trail_points = trail_points;
    const double source_trail_offset = trail_offset;
    const double source_trail_price = trail_price;
    const bool has_trail_request = !std::isnan(source_trail_points)
        || !std::isnan(source_trail_price);
 
    // Relative levels resolve against a live source cohort. The original tick
    // facts remain in the snapshot for deferred/observer projections.
    const auto physical = detail::run_position(require_host());
    const SourceId partial_exit_key = exit_id + "\x1f" + from_entry;
    // ab9714be pine_strategy_commands.cpp:1661-1692: only a re-issue that is
    // itself explicitly partial against the live position (net of a same-bar
    // pending close) is suppressed; an explicit qty covering the whole
    // remaining position is a full exit and re-arms.
    const double live_exit_units = std::max(
        0.0, std::abs(physical.signed_units) - pending_same_bar_close_qty_);
    double reissue_percent = std::isnan(qty_percent)
        ? 100.0 : std::clamp(qty_percent, 0.0, 100.0);
    if (!std::isnan(qty) && live_exit_units > internal::kQtyEpsilon)
        reissue_percent = std::min(qty, live_exit_units) / live_exit_units * 100.0;
    const bool partial_reissue = reissue_percent < 100.0 - internal::kFullPercentEps;
    if (const auto consumed = consumed_partial_exit_cycles_.lookup(partial_exit_key);
        consumed && partial_reissue
        && live_exit_units > internal::kQtyEpsilon
        && *consumed == current_position_cycle_) {
        return;
    }
    if (partial_reissue && exit_tombstoned(exit_id, from_entry)) return;
    // A held global exit with relative legs over two or more entries covers
    // them entry by entry (per_entry_exit_call).
    if (from_entry.empty()
        && per_entry_exit_call(exit_id, from_entry, limit_price, stop_price, source_trail_points,
                               source_trail_offset, source_trail_price, qty_percent, comment,
                               qty, oca_name, profit_ticks, loss_ticks, command_sequence)) {
        return;
    }
    double entry_price = require_host().position_avg_price();
    const double tick = staged_.syminfo.mintick;
    bool parent_long = physical.signed_units > 0.0;
    bool known_parent_level = physical.signed_units != 0.0;
    // ab9714be src/source/pine_fills.cpp:4560-4564 (pending_order_level_resolved)
    // and 7208-7229: an exit's relative operands resolve against the LIVE
    // position once its from_entry filled this cycle (W23b); an empty from_entry
    // means "every entry", so the entry-bar priced-exit gate reads the opening
    // lot (W32a, ab9714be src/source/pine_strategy_commands.cpp:2595-2606,
    // pine_fills.cpp:7695-7728).
    const bool parent_filled_this_cycle = physical.signed_units != 0.0
        && !from_entry.empty()
        && [&] {
            const auto filled = cohorts_by_id_.find(from_entry);
            return filled != cohorts_by_id_.end() && !filled->second.opened.empty();
        }();
    const auto observe_staged_parent = [&](const PlacementSnapshot& parent) {
        if (parent_filled_this_cycle) return;
        if (!parent.opening || parent.family != PineOrderFamily::Entry) {
            return;
        }
        if (!from_entry.empty() && parent.source_id != from_entry) {
            return;
        }
        // A global exit called while a position is held binds to that
        // position, so an entry order of either side working beside it is
        // not its parent. Taking an order of the other side put the limit and
        // stop thresholds on the wrong side of the leg that closes the
        // position (settled outside its trigger, MatchRejected InvalidTerms);
        // taking a same-side add made its resting price the basis of a profit
        // or trail leg; and either deferred a leg to a fill that never came.
        // lab tv synthetics, NYSE:F 15m: each exit with the resting entry is
        // the exit without it, row for row (tests/fixtures/cross_side_exit:
        // the other side, with and without a margin requirement;
        // tests/fixtures/same_side_exit: a same-side limit, stop or capped
        // market add).
        if (from_entry.empty() && physical.signed_units != 0.0
            && detail::exit_binding_rule_switches().global_exit_binds_held_position) {
            return;
        }
        // A pending same-bar parent is the level basis only while its cohort
        // has no live exposure.  With a lot of that id still open the exit
        // resolves against the LIVE position: ab9714be
        // materialize_relative_exit_prices_for_live_position (pine_fills.cpp:
        // 7208-7230) binds relative operands to position_entry_price_ of the
        // current cycle, never to a not-yet-filled re-entry's resting price.
        if (cohort_exposure_for(from_entry) > 0.0
            && ((physical.signed_units > 0.0) == parent.is_long)) {
            return;
        }
        parent_long = parent.is_long;
        known_parent_level = finite_positive(parent.exit_levels.limit);
        if (known_parent_level) entry_price = parent.exit_levels.limit;
    };
    for (const auto& parent : pending_same_bar_commands_)
        observe_staged_parent(parent.snapshot);
    for (const auto& parent : pending_entries_)
        observe_staged_parent(parent.snapshot);
    for (const auto& parent : pending_coof_requests_)
        observe_staged_parent(parent.snapshot);
    const auto cohort = cohorts_by_id_.find(from_entry);
    for (const auto& handle : live_handles_) {
        const auto parent = placement_.find(handle.incarnation);
        const bool already_opened = cohort != cohorts_by_id_.end()
            && std::find(cohort->second.opened.begin(), cohort->second.opened.end(), handle)
                != cohort->second.opened.end();
        if (parent != placement_.end() && !already_opened)
            observe_staged_parent(parent->second);
    }
    // ab9714be src/source/pine_fills.cpp:4560-4564: a pending same-id origin
    // never defers the levels once the id has filled in this cycle.
    if (cohort != cohorts_by_id_.end() && !parent_filled_this_cycle) {
        for (const auto position : live_origin_positions(cohort->second)) {
            const auto& origin = cohort->second.origins[position];
            const auto parent = placement_.find(origin.incarnation);
            if (parent == placement_.end() || !parent->second.opening
                || !origin_is_pending(origin)
                || std::find(cohort->second.opened.begin(), cohort->second.opened.end(), origin)
                    != cohort->second.opened.end()) {
                continue;
            }
            // A prearmed bracket follows its pending MARKET/reversal parent,
            // not the opposite physical position still held at placement.
            // ab9714be pine_fills.cpp:7788-7800 then evaluates the child with
            // the parent's eventual close side and exact-touch direction.
            // The prearm serves the FLAT-to-position transition only: while a
            // lot of that id is live and the physical side already matches it,
            // the bracket resolves against the live position
            // (pine_fills.cpp:7208-7230), not against the same-id re-entry that
            // is still pending on this bar.
            const bool same_side_live = physical.signed_units != 0.0
                && (physical.signed_units > 0.0) == parent->second.is_long
                && cohort_exposure_for(from_entry) > 0.0;
            if (same_side_live) continue;
            parent_long = parent->second.is_long;
            // Relative profit/loss/trail operands bind to the parent's actual
            // fill, not its resting limit.  An opening gap may improve that
            // fill, so keep these operands unresolved until the Applied event.
            known_parent_level = false;
            break;
        }
    }
    if (known_parent_level && finite_positive(entry_price) && finite_positive(tick)) {
        const bool long_side = physical.signed_units != 0.0 ? physical.signed_units > 0.0 : parent_long;
        if (!finite_positive(limit_price) && finite_positive(profit_ticks)) {
            limit_price = entry_price + (long_side ? 1.0 : -1.0) * profit_ticks * tick;
            if (!std::isfinite(limit_price)) {
                engine_command_value_invalid_or_count("relative_price.level",
                    EngineValueStage::relative_price, EngineValueReason::numeric_overflow);
            }
        }
        if (!finite_positive(stop_price) && finite_positive(loss_ticks)) {
            stop_price = entry_price - (long_side ? 1.0 : -1.0) * loss_ticks * tick;
            if (!std::isfinite(stop_price)) {
                engine_command_value_invalid_or_count("relative_price.level",
                    EngineValueStage::relative_price, EngineValueReason::numeric_overflow);
            }
        }
        if (std::isfinite(source_trail_points)) {
            const double trail_ticks = source_trail_points_ticks(
                source_trail_points, tick, value_field::exit_trail_points);
            trail_price = directional_tick(entry_price
                + (long_side ? 1.0 : -1.0) * trail_ticks * tick,
                tick, long_side);
            if (std::isfinite(trail_ticks) && !std::isfinite(trail_price)) {
                engine_command_value_invalid_or_count("relative_price.level",
                    EngineValueStage::relative_price, EngineValueReason::numeric_overflow);
            }
        }
    }
    limit_price = source_level_on_price_grid(limit_price, tick);
    stop_price = source_level_on_price_grid(stop_price, tick);
    // A source trail offset is a tick count, which is the kernel's own
    // native_order::TrailTicks spelling: acceptance resolves it against the
    // run's price tick — the same syminfo mintick this adapter projects into
    // NativeRunSpec::price_tick (project()) — and stores a plain price
    // distance, so the adapter never multiplies a tick count by a tick.
    // Only the explicit-zero shape stays adapter policy: the legacy broker
    // rides the TICK-QUANTIZED running best, whereas the kernel's zero offset
    // rides the raw best and exits on any adverse ULP. Half a tick is exactly
    // that quantization boundary, and it is now spelled in ticks as well.
    std::optional<double> native_trail_offset_ticks;
    if (has_trail_request && std::isfinite(source_trail_offset)
        && source_trail_offset >= 0.0 && finite_positive(tick)) {
        const double offset_ticks = std::floor(source_trail_offset);
        native_trail_offset_ticks = offset_ticks == 0.0 ? 0.5 : offset_ticks;
    }
    const bool unresolved_trail = has_trail_request
        && !finite_positive(trail_price) && std::isfinite(source_trail_points);
    const bool unresolved_ticks =
        (!finite_positive(limit_price) && finite_positive(profit_ticks))
        || (!finite_positive(stop_price) && finite_positive(loss_ticks));
    const bool unresolved_relative = unresolved_trail || unresolved_ticks;
    // A void call leaves no relative leg for the entry's fill to resolve.
    if (unresolved_relative && !void_issue) {
        PendingRelativeExit pending;
        pending.exit_id = exit_id; pending.from_entry = from_entry;
        pending.trail_points = source_trail_points; pending.trail_offset = source_trail_offset;
        pending.trail_price = source_trail_price; pending.qty_percent = qty_percent;
        pending.comment = comment; pending.qty = qty; pending.oca_name = oca_name;
        pending.profit_ticks = profit_ticks; pending.loss_ticks = loss_ticks;
        pending.void_global = void_global_issue;
        auto existing = std::find_if(pending_relative_exits_.begin(), pending_relative_exits_.end(),
            [&](const PendingRelativeExit& value) {
                return value.exit_id == exit_id && value.from_entry == from_entry;
        });
        if (existing == pending_relative_exits_.end()) {
            pending_relative_exits_.push_back(std::move(pending));
        } else {
            const auto same = [](double left, double right) {
                return same_double_bits(left, right) || (std::isnan(left) && std::isnan(right));
            };
            const bool unchanged = same(existing->trail_points, pending.trail_points)
                && same(existing->trail_offset, pending.trail_offset)
                && same(existing->trail_price, pending.trail_price)
                && same(existing->qty_percent, pending.qty_percent)
                && same(existing->qty, pending.qty)
                && same(existing->profit_ticks, pending.profit_ticks)
                && same(existing->loss_ticks, pending.loss_ticks)
                && existing->comment == pending.comment
                && existing->oca_name == pending.oca_name;
            // The kernel child carries the definition it was anchored from.
            if (!unchanged) withdraw_anchored_relative_legs(&exit_id, &from_entry);
            *existing = std::move(pending);
        }
    }
    if (unresolved_relative) {
        pending_write(source_shadow_pending_).erase(
            std::remove_if(source_shadow_pending_.begin(), source_shadow_pending_.end(),
                [&](const SourceShadowPending& row) {
                    return row.snapshot.source_id == exit_id
                        && row.snapshot.from_entry == from_entry;
                }),
            source_shadow_pending_.end());
        // A known absolute sibling remains executable while the relative
        // trail/profit/loss component waits for its MARKET parent's fill.
        // ab9714be pine_strategy_commands.cpp:533-537: 0.0 is a present level.
        // Kernel validate_levels still refuses non-finite and negative
        // levels (A43); those stay command projections.
        if (finite_non_negative(limit_price) || finite_non_negative(stop_price)) {
            // Continue below and submit the known absolute sibling.
        } else {
        if (void_issue) return;
        PlacementSnapshot shadow;
        shadow.family = has_trail_request ? PineOrderFamily::ExitTrail
            : (finite_positive(loss_ticks) ? PineOrderFamily::ExitStop
                                           : PineOrderFamily::ExitLimit);
        shadow.source_id = exit_id;
        shadow.from_entry = from_entry;
        shadow.comment = comment;
        shadow.oca_name = oca_name;
        shadow.requested_qty = qty;
        shadow.qty_percent = qty_percent;
        shadow.command_sequence = command_sequence;
        shadow.source_sequence = ++source_sequence_;
        shadow.projection_position_side = static_cast<std::int32_t>(PositionSide::FLAT);
        shadow.exit_levels = {limit_price, stop_price, source_trail_points,
                              source_trail_offset, source_trail_price,
                              profit_ticks, loss_ticks};
        shadow.sizing = sizing_snapshot();
        pending_write(source_shadow_pending_).push_back({std::move(shadow), exit_id});
        return;
        }
    }
    if (std::isnan(qty) && qty_percent == 100.0) {
        const auto cohort = cohorts_by_id_.find(from_entry);
        if (cohort != cohorts_by_id_.end() && !cohort->second.origins.members().empty()) {
            const auto origin = cohort->second.origins.back();
            // An erased origin's flag is read by nobody: a sequential group's
            // entries are kept while the group has a live or queued member,
            // and only a live entry lets a new one join it
            // (erase_retired_rows, K7).
            const auto parent = placement_.contains(origin.incarnation)
                ? placement_.find(origin.incarnation) : placement_.end();
            if (parent != placement_.end() && parent->second.family == PineOrderFamily::Entry)
                parent->second.has_full_entry_bracket = true;
        }
    }
    const bool dynamic = std::isnan(qty);
    const auto family_key = key_for(exit_id, from_entry);
    const bool defer_for_same_bar_priority = !config_.calc_on_order_fills
        && std::any_of(pending_entries_.begin(), pending_entries_.end(),
            [](const PendingEntry& pending) {
                return pending.snapshot.retained_parent_topology;
            });
    const bool defer_for_same_bar_add_exit = dynamic
        && !config_.calc_on_order_fills && !coof_recalc_active_
        && physical.signed_units != 0.0 && !from_entry.empty()
        && (!std::isfinite(qty_percent) || qty_percent >= 100.0)
        && std::any_of(pending_entries_.begin(), pending_entries_.end(),
            [&](const PendingEntry& pending) {
                const auto& add = pending.snapshot;
                return add.opening && add.family == PineOrderFamily::Entry
                    && add.source_id == from_entry
                    && add.is_long == (physical.signed_units > 0.0)
                    && !finite_positive(add.exit_levels.limit)
                    && !finite_positive(add.exit_levels.stop)
                    && !finite_positive(add.exit_levels.trail_offset)
                    && add.oca_name.empty();
            });
    // The legacy pending book leaves an identical resting bracket untouched.
    // In the ordinary source-bar path, a dynamic exit resolves against its
    // live cohort only when it fills, so reissuing unchanged levels cannot
    // alter its executable terms. Avoid rebuilding two requests, snapshots,
    // and replacement events on the common every-bar bracket pattern.
    // A normalized full-percent reservation is `units / basis * 100`, which
    // can land a few binary64 ULPs below the literal 100% request. The owner
    // still treats the re-issued default bracket as the same full-position
    // reservation, so those representations are equivalent here.
    const auto same_dynamic_percent = [](double prior_percent, double request_percent) {
        if (std::isfinite(prior_percent) && std::isfinite(request_percent)
            && prior_percent >= 100.0 - 1e-12
            && request_percent >= 100.0 - 1e-12) {
            return true;
        }
        return same_double_bits(prior_percent, request_percent);
    };
    const auto unchanged_dynamic_leg = [&](PineOrderFamily family, double level) {
        const SourceId replacement_key = exit_id + "\x1f" + from_entry
            + std::to_string(static_cast<int>(family));
        const auto live = live_by_source_key_.find(checked_live_key(replacement_key));
        if (live == live_by_source_key_.end()) return false;
        const auto placement = placement_.find(live->second.incarnation);
        if (placement == placement_.end()) return false;
        const auto& prior = placement->second;
        if (prior.family != family || !prior.deferred_cohort || !std::isnan(prior.requested_qty)
            || prior.source_id != exit_id || prior.from_entry != from_entry
            || prior.comment != comment || prior.oca_name != oca_name
            || prior.oca_type != 0
            || !same_dynamic_percent(prior.qty_percent, qty_percent)
            || prior.bracket_origin.incarnation != 0
            || !same_double_bits(prior.exit_levels.limit, limit_price)
            || !same_double_bits(prior.exit_levels.stop, stop_price)
            || !std::isnan(prior.exit_levels.trail_points)
            || !std::isnan(prior.exit_levels.trail_offset)
            || !std::isnan(prior.exit_levels.trail_price)
            || !std::isnan(prior.exit_levels.profit_ticks)
            || !std::isnan(prior.exit_levels.loss_ticks)
            || reissue_revives_declined_exit(prior)) {
            return false;
        }
        return (family == PineOrderFamily::ExitLimit
                    && same_double_bits(prior.exit_levels.limit, level))
            || (family == PineOrderFamily::ExitStop
                    && same_double_bits(prior.exit_levels.stop, level));
    };
    // Only a live bracket: a leg whose from_entry holds no lot rested dormant
    // on the bars before, so re-issuing it on the calculation that places its
    // entry is a new exit of that entry, decided with it (lab tv
    // w4-f08r-pooc cells X and Y; wayward-bison's every-bar "Short Stop";
    // lane W4-ENG-POOC-SAMEPASS).
    const bool plain_dynamic_bracket = dynamic && !coof_recalc_active_
        && !materializing_relative_ && !config_.calc_on_order_fills
        && (from_entry.empty() || cohort_exposure_for(from_entry) > 0.0)
        && physical.signed_units != 0.0 && std::isnan(trail_points)
        && std::isnan(trail_offset) && std::isnan(trail_price)
        && std::isnan(profit_ticks) && std::isnan(loss_ticks)
        && (finite_positive(limit_price) || finite_positive(stop_price));
    if (plain_dynamic_bracket
        && (!finite_positive(limit_price)
            || unchanged_dynamic_leg(PineOrderFamily::ExitLimit, limit_price))
        && (!finite_positive(stop_price)
            || unchanged_dynamic_leg(PineOrderFamily::ExitStop, stop_price))) {
        // Made once the entry exists, the call takes over a void request it
        // leaves unchanged (unvoid_exit).
        for (const auto family : {PineOrderFamily::ExitLimit, PineOrderFamily::ExitStop}) {
            if (void_issue) break;
            const auto live = live_by_source_key_.find(checked_live_key(
                exit_id + "\x1f" + from_entry + std::to_string(static_cast<int>(family))));
            if (live == live_by_source_key_.end()) continue;
            if (const auto row = placement_.find(live->second.incarnation);
                row != placement_.end() && row->second.void_issue) {
                unvoid_exit(row->second);
            }
        }
        return;
    }
    // Every leg emitted by one source strategy.exit shares its placement-time
    // sizing facts. Submitting the first resting sibling cannot alter the
    // physical account, so capture them once rather than re-marking equity
    // for each leg.
    const PineSizingSnapshot exit_sizing = sizing_snapshot();
    const native_order::Owner dynamic_owner = dynamic
        ? owner_for_close(from_entry, !materializing_relative_)
        : native_order::Owner{native_order::Independent{}};
    const SourceId dynamic_group_name = dynamic
        ? (oca_name.empty() ? exit_id + "\x1f" + from_entry : oca_name) : SourceId{};
    const SourceId dynamic_key_prefix = dynamic ? exit_id + "\x1f" + from_entry : SourceId{};
    const auto pending_default_reversal_parent = [&](const PlacementSnapshot& parent) {
        if (!parent.opening || parent.family != PineOrderFamily::Entry
            || parent.source_id != from_entry) {
            return false;
        }
        // A flat, ordinarily pending parent remains cohort-bound: the
        // deferred-ANY contract requires its child to survive a same-id
        // parent replacement and grow with the replacement. WaitForApplied
        // is only the source reversal-parent relation below.
        if (physical.signed_units == 0.0) return false;
        return !std::isfinite(parent.requested_qty)
            && parent.is_long != (physical.signed_units > 0.0);
    };
    bool binds_pending_reversal_entry = false;
    for (const auto& pending : pending_same_bar_commands_)
        binds_pending_reversal_entry = binds_pending_reversal_entry
            || pending_default_reversal_parent(pending.snapshot);
    for (const auto& pending : pending_entries_)
        binds_pending_reversal_entry = binds_pending_reversal_entry
            || pending_default_reversal_parent(pending.snapshot);
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found != placement_.end()
            && pending_default_reversal_parent(found->second)) {
            binds_pending_reversal_entry = true;
        }
    }
    double reserved_exit_qty = kNaN;
    double pending_parent_units = 0.0;
    const auto reservation_point = detail::callback_point(require_host());
    const auto observe_pending_parent = [&](const PlacementSnapshot& parent) {
        if (!reservation_point || !parent.opening
            || parent.family != PineOrderFamily::Entry
            || parent.source_id != from_entry
            || parent.placement_script_open_ms
                != reservation_point->decision.script_bar_open_ms
            || parent.projection_over_pyramiding) {
            return;
        }
        const double units = finite_positive(parent.requested_qty)
            ? std::abs(parent.requested_qty) : parent.frozen_market_own_units;
        if (finite_positive(units)) pending_parent_units += units;
    };
    for (const auto& handle : live_handles_) {
        const auto parent = placement_.find(handle.incarnation);
        if (parent != placement_.end()) observe_pending_parent(parent->second);
    }
    for (const auto& parent : pending_entries_) observe_pending_parent(parent.snapshot);
    // TradingView's default strategy.exit(from_entry) under FIFO closes the
    // entry's own quantity -- the oldest lots first -- not the whole book
    // (tests/test_pyramiding_count_differential.cpp, P10 on its lab tv tape).
    const bool fifo_named_entry = !config_.close_entries_rule_any && !from_entry.empty();
    // The tests/fixtures/percent_entry_reservation tapes prove named, absolute,
    // limit-only targets size from still-live entry ancestry after partial/runner and
    // margin slices complete; reservation capacity remains live exposure.
    // Two-sided brackets retain main's pending-close/margin basis: those tapes
    // do not cover their completed-partial sizing, and the broader rule changed
    // physical outcomes in 36 frozen live-state transcripts without TV proof.
    const bool ancestry_sized_target = !from_entry.empty() && std::isfinite(limit_price)
        && std::isnan(stop_price) && std::isnan(profit_ticks)
        && std::isnan(loss_ticks) && !has_trail_request;
    // The non-ancestry path keeps W5's margin rule: percent exits include the
    // entry's margin slices (tests/fixtures/margin_v6 w5-qp-*; 35% of 62.3911
    // despite prior slices of 0.0028 and 1.6712; lane W5-ENG-MARGIN-V6).
    double completed_entry_units = 0.0;
    if (std::isnan(qty) && std::isfinite(requested_qty_percent)
        && requested_qty_percent < 100.0 && physical.signed_units != 0.0
        && position_open_script_bar_ != std::numeric_limits<std::int64_t>::min()) {
        const auto& host = require_host();
        const auto* pine = pine_view_of(host_);
        const std::size_t base = pine ? pine->trades_.base() : 0;
        observe_position_tail_rows();
        if (!position_tail_summary_)
            position_tail_summary_ = std::make_shared<detail::AdapterPositionTailSummary>();
        auto& summary = *position_tail_summary_;
#ifdef PINEFORGE_POSITION_TAIL_BEFORE_QUERY
        PINEFORGE_POSITION_TAIL_BEFORE_QUERY(summary);
#endif
        const bool certified = ancestry_sized_target
            ? summary.ancestry(physical.signed_units > 0.0, [&](const auto& include) {
                // Membership is the CURRENT live map, not the opening
                // roster or a subtotal minus the most recently drained lot.
                using CohortRow = std::remove_reference_t<decltype(*cohorts_by_id_.begin())>;
                summary.for_each_live_cohort([&](const void* row) {
                    const auto& cohort = *static_cast<const CohortRow*>(row);
                    if (fifo_named_entry && cohort.first != from_entry) return;
                    for (const auto& origin : cohort.second.live_units_by_origin)
                        include(origin.first);
                });
              }, completed_entry_units, PINEFORGE_POSITION_TAIL_DIAGNOSTICS{})
            : summary.margin(physical.signed_units > 0.0,
                             fifo_named_entry ? &from_entry : nullptr, completed_entry_units,
                             PINEFORGE_POSITION_TAIL_DIAGNOSTICS{});
        const auto include_completed = [&](bool is_long, std::uint64_t incarnation,
                                            bool margin_call, const auto& named_entry_matches) {
            if (is_long != (physical.signed_units > 0.0)) return false; const auto held = cohorts_by_id_.held_rows(); // one range: one exactness assert
            return ancestry_sized_target
                ? std::any_of(held.begin(), held.end(),
                    [&](const auto& cohort) {
                        return (!fifo_named_entry || cohort.first == from_entry)
                            && cohort.second.live_units_by_origin.count(
                                incarnation) != 0;
                    })
                : margin_call && (!fifo_named_entry || named_entry_matches());
        };
        if (!certified)
            completed_entry_units = detail::replay_position_tail(
                host.closed_trade_count(), base,
                [&](std::size_t index) -> Trade {
                    return host.get_trade(static_cast<int>(index));
                }, position_tail_spill_.get(), position_open_script_bar_,
                include_completed, from_entry, summary.work,
                PINEFORGE_POSITION_TAIL_DIAGNOSTICS{});
#ifdef PINEFORGE_POSITION_TAIL_OBSERVE
        // Test-TU observer: the reference walk is never linked into runtime.
        PINEFORGE_POSITION_TAIL_OBSERVE(completed_entry_units, certified);
#endif
    }
    const double book_basis = (fifo_named_entry
        ? std::min(std::abs(physical.signed_units), cohort_exposure_for(from_entry))
        : std::abs(physical.signed_units)) + (ancestry_sized_target ? 0.0 : completed_entry_units);
    const double live_reservation_basis = binds_pending_reversal_entry ? 0.0
        : std::max(0.0, book_basis
                         - pending_same_bar_close_qty_ + pending_parent_units);
    const double percentage_basis = ancestry_sized_target
        ? book_basis + completed_entry_units + pending_parent_units
        : live_reservation_basis;
    const bool reservation_ok = compute_exit_reservation(exit_id, from_entry, qty, qty_percent,
        live_reservation_basis, percentage_basis, reserved_exit_qty);
    if (!reservation_ok) {
        // clear_existing_exit_order ran before sizing on the legacy route:
        // a zero-capacity reissue removes its predecessor as well as refusing
        // the replacement (ab9714be:pine_strategy_commands.cpp:1688-1699,
        // :2739-2811).
        exit_cancel_bracket(exit_id, from_entry, comment);
        return;
    }
    const auto source_point = detail::callback_point(require_host());
    const OrderBirth exit_birth = capture_order_birth();
    const auto exit_birth_reach = compat::pine::select_historical_birth_reach(
        exit_birth, has_trail_request);
    const bool historical_cascade =
        compat::pine::historical_cascade_reach(exit_birth_reach);
    const bool pooc_short_tick_scope = source_point
        && config_.process_orders_on_close && !config_.calc_on_order_fills
        && modeled_input() && source_point->decision.sub_count <= 1
        && physical.signed_units < 0.0 && physical.lot_count == 1
        && position_open_script_bar_ < source_point->decision.script_bar_open_ms
        && config_.pyramiding == 0 && config_.slippage == 0
        && config_.commission_type == static_cast<int>(CommissionType::PERCENT)
        && std::abs(staged_.syminfo.pointvalue - 1.0) < 1e-12
        && active_staged_fx(source_point->decision.sub_bar_open_ms) == 1.0
        && staged_.account_fx_effective_from_ms.empty()
        && std::isnan(qty)
        && (!std::isfinite(qty_percent) || qty_percent >= 100.0 - 1e-9)
        && oca_name.empty() && !has_trail_request
        && finite_positive(staged_.syminfo.mintick);
    PineOrderFamily pooc_current_close_family = PineOrderFamily::Entry;
    if (pooc_short_tick_scope && source_point) {
        const double close = nearest_tick(source_point->price, staged_.syminfo.mintick);
        if (finite_positive(stop_price) && close >= stop_price)
            pooc_current_close_family = PineOrderFamily::ExitStop;
        else if (finite_positive(limit_price) && close <= limit_price)
            pooc_current_close_family = PineOrderFamily::ExitLimit;
    }
    auto submit_leg = [&](PineOrderFamily family, native_order::Trigger trigger) {
        bool defer_marketable_coof_stop = false;
        // A stop reached at the point its recalculating fill ended the leg on:
        // executed there, so never staged behind the recalculation.
        bool coof_stop_at_leg_end = false;
        bool coof_limit_waypoint_qualified = false;
        double coof_limit_waypoint_price = kNaN;
        double coof_stop_waypoint_price = kNaN;
        if (coof_recalc_active_ && !coof_first_open_ && historical_cascade
            && coof_script_bar_valid_) {
            const auto native = detail::run_state(require_host());
            const bool ordinary_path = !native.spec || native.spec->intrabar.is_none();
            const auto point = detail::callback_point(require_host());
            if (ordinary_path && point && finite_positive(point->price)) {
                const auto phase = coof_context_.coordinate.path_phase;
                const bool high_first = source_path_uses_high_first(coof_script_bar_);
                double endpoint = next_source_path_waypoint(
                    coof_script_bar_, phase, point->price, high_first,
                    staged_.syminfo.mintick, config_.slippage);
                // The recalculating fill AT its leg's extreme: the matcher's
                // fill at a resting request's own level there ends the leg, so
                // no remainder of it is left in flight and a marketable level
                // is reached at the point itself (lab tv pa2-i2-level-w1-*,
                // pa3-f4-level-w1-xstop-*); a fill the adapter forced onto it
                // starts the next leg -- read from the extreme itself, whose
                // booked tick an off-grid extreme (11.425 -> 11.43) does not
                // equal (pa2-i2-point-w2-long*; the extreme-point fill correction).
                const double own_extreme = phase == NativePathPhase::High
                    ? coof_script_bar_.high
                    : (phase == NativePathPhase::Low ? coof_script_bar_.low : kNaN);
                const bool at_own_extreme = finite_positive(own_extreme)
                    && coof_fill_at_path_point(own_extreme);
                const bool fill_ends_leg = at_own_extreme && !coof_fill_forced_;
                if (at_own_extreme && coof_fill_forced_) {
                    endpoint = next_source_path_waypoint(
                        coof_script_bar_, phase, own_extreme, high_first,
                        staged_.syminfo.mintick, config_.slippage);
                }
 
                const bool closing_long = physical.signed_units > 0.0;
                if (family == PineOrderFamily::ExitLimit
                    && finite_positive(limit_price) && finite_positive(endpoint)) {
                    // ab9714be pine_fills.cpp:563-583 (cascade Model S): a priced
                    // exit born in a mid-bar fill recalculation is held on the
                    // remainder of its in-flight leg.  It gap-fills at the
                    // leg-end waypoint when its level lies in that remainder
                    // (engine_path_resolve.cpp:1016-1046) or when it is the
                    // marketable LIMIT born from the second fill at O
                    // (pine_strategy_commands.cpp:2009-2015), which is held
                    // through O->W1 and gets one gap attempt at W1.
                    const bool marketable = closing_long
                        ? point->price >= limit_price : point->price <= limit_price;
                    // The leg end is reached on its tick-built print, the
                    // level staying raw: a buy limit at 11.608273 is not
                    // reached by an L of 11.605, which prints 11.61, and a
                    // sell limit at 10.145 is not reached by an H of 10.145,
                    // which prints 10.14 (`lab tv` synthetics
                    // tests/fixtures/callback_lifecycle runner-target-r1,
                    // long-high-raw and short-low-raw, NYSE:F 15m, 4 identical
                    // exports each).
                    const double reach_level =
                        detail::pine_callback_lifecycle_rule(detail::PineCallbackLifecycleRule::CallbackLimitTickReach)
                        ? source_trigger_threshold(limit_price, staged_.syminfo.mintick,
                                                   !closing_long, true)
                        : limit_price;
                    const bool endpoint_satisfies = closing_long
                        ? endpoint >= reach_level : endpoint <= reach_level;
                    const bool endpoint_ahead = closing_long
                        ? endpoint > point->price : endpoint < point->price;
                    // An exit the recalculation re-issues unchanged was not
                    // born there: it rests at its own level on the rest of the
                    // leg, whatever fill recalculated -- a margin call's at the
                    // high, an add's on the way down (lab tv w4-rex-coof cells
                    // MC and ADD; lane W4-ENG-POOC-SAMEPASS). One the
                    // recalculation places first is held (cell NEW).
                    const bool in_flight_remainder = !fill_ends_leg && !marketable
                        && endpoint_satisfies && endpoint_ahead
                        && !unchanged_dynamic_leg(PineOrderFamily::ExitLimit, limit_price);
                    const bool later_same_open = phase == NativePathPhase::Open
                        && marketable;
                    if (in_flight_remainder
                        || (later_same_open && endpoint_satisfies && endpoint_ahead)) {
                        // The waypoint fill books bar_fill_price(endpoint)
                        // (pine_fills.cpp:7962-7966); past an OFF-grid
                        // endpoint (L 11.195 booked 11.20) the limit is a
                        // touch trigger or the kernel refuses the booking.
                        const bool off_grid_endpoint = finite_positive(staged_.syminfo.mintick)
                            && source_bar_fill_tick(endpoint, staged_.syminfo.mintick) != endpoint;
                        trigger = native_order::Limit{endpoint, off_grid_endpoint};
                        coof_limit_waypoint_qualified = true;
                        coof_limit_waypoint_price = endpoint;
                    } else if (later_same_open) {
                        // Armed at W1: it fills there when W1 satisfies the
                        // level, otherwise on a later leg's cross.
                        const auto* threshold = std::get_if<native_order::Limit>(&trigger);
                        trigger = native_order::StopLimit{
                            endpoint, threshold ? threshold->price : limit_price};
                        coof_limit_waypoint_qualified = endpoint_satisfies;
                    } else if (marketable && !endpoint_ahead && !endpoint_satisfies
                               && coof_remaining_recrosses(limit_price, closing_long)) {
                        // Any other marketable level is held on the in-flight
                        // leg and fills only on a later leg's exact cross
                        // (pine_fills.cpp:576); the recross scope below decides
                        // whether it stays on this bar.
                        const auto* threshold = std::get_if<native_order::Limit>(&trigger);
                        trigger = native_order::StopLimit{
                            endpoint, threshold ? threshold->price : limit_price};
                    }
                } else if (family == PineOrderFamily::ExitStop
                           && finite_positive(stop_price)) {
                    const bool marketable = closing_long
                        ? point->price <= stop_price : point->price >= stop_price;
                    if (marketable && fill_ends_leg) {
                        // Reached at the point the fill ended its leg on: it
                        // fills there, as a market close does.  A stop at the
                        // point itself, not a market leg: the recalculation
                        // executes market newborns at their point, which a
                        // cohort-bound leg (close_entries_rule "any") cannot
                        // take, so it would book this price on a later bar.
                        trigger = native_order::Stop{point->price};
                        coof_stop_waypoint_price = point->price;
                        coof_stop_at_leg_end = true;
                    } else if (marketable && phase != NativePathPhase::Open
                        && std::isfinite(qty) && finite_positive(endpoint)
                        && !source_same_point(point->price, endpoint, staged_.syminfo.mintick)) {
                        trigger = native_order::Stop{endpoint};
                        coof_stop_waypoint_price = endpoint;
                    } else if (marketable && phase == NativePathPhase::Open
                               && finite_positive(endpoint)) {
                        // The recalculation of a LATER fill at the bar's open
                        // (a market newborn the first fill's recalculation
                        // executed there) places it already through: live
                        // from the first extreme, not the open -- filled at
                        // the extreme's print when still through there, at
                        // the open when that extreme is the open, otherwise
                        // at its own level from the extreme on (lab tv
                        // tailc-1856-open-newborn cells A/B/C; after the
                        // first open fill's recalculation it fills at the
                        // open, cell D and the long-add/short-add comparison; the placement and recalculation correction).
                        const double tick = staged_.syminfo.mintick;
                        const bool through_at_extreme = closing_long
                            ? endpoint <= stop_price : endpoint >= stop_price;
                        if (source_same_point(point->price, endpoint, tick)) {
                            trigger = native_order::Stop{point->price};
                            coof_stop_waypoint_price = point->price;
                            coof_stop_at_leg_end = true;
                        } else if (through_at_extreme) {
                            trigger = native_order::Stop{endpoint};
                            coof_stop_waypoint_price = endpoint;
                        } else {
                            trigger = native_order::Trail{std::abs(stop_price - endpoint), endpoint};
                            coof_stop_waypoint_price = nearest_tick(stop_price
                                + (closing_long ? -1.0 : 1.0) * config_.slippage * tick, tick);
                        }
                        // Live on this bar: never delayed as a wrong-side stop.
                        coof_stop_at_leg_end = true;
                    } else {
                        defer_marketable_coof_stop = marketable;
                    }
                }
            }
        }
        // An ordinary opening market-entry callback, including a carried
        // parent or a parent born in that callback, executes a wrong-side
        // stop at the coincident opening high for an unslipped short,
        // with or without margin
        // (tests/fixtures/coof_marketable_stop).
        // Other sides, slipped fills and magnified paths keep their existing
        // Stop projection; the older first-fill cells stay at their level.
        // Both activation and Market conversion use this same taped scope.
        const auto opening_parent = placement_.find(coof_market_entry_recalc_incarnation_);
        const auto opening_point = detail::callback_point(require_host());
        const bool carried_opening_parent = opening_point && opening_parent != placement_.end()
            && opening_parent->second.placement_script_open_ms
                < opening_point->decision.script_bar_open_ms;
        const bool opening_high = coof_script_bar_valid_
            && source_decimal_tick(coof_script_bar_.open, staged_.syminfo.mintick)
                == source_decimal_tick(coof_script_bar_.high, staged_.syminfo.mintick);
        const bool opening_market_short = opening_market_short_scope(family);
        if (coof_recalc_active_ && (coof_first_open_ || opening_market_short)
            && family == PineOrderFamily::ExitStop
            && finite_positive(stop_price) && physical.signed_units != 0.0) {
            const auto native = detail::run_state(require_host());
            const auto point = detail::callback_point(require_host());
            const bool ordinary_path = !native.spec || native.spec->intrabar.is_none();
            if (ordinary_path && point && finite_positive(point->price)
                && (coof_first_open_ || point->decision.coordinate.path_phase == NativePathPhase::Open)
                && (physical.signed_units > 0.0 ? stop_price > point->price
                                                : stop_price < point->price)) {
                trigger = native_order::Stop{point->price};
                coof_stop_waypoint_price = point->price;
                coof_stop_at_leg_end = true;
                if (opening_market_short) {
                    trigger = native_order::Market{};
                    defer_marketable_coof_stop = false;
                }
            }
        }
        // A limit that recalculation places at or through the bar's open
        // print fills there at once, at the print and without slippage; one
        // short of the print rests at its level on the rest of the entry
        // bar. The adapter held both for the next bar: it judged them against
        // the slipped fill (lab tv tape tests/fixtures/coof_open_limit
        // td-fp17-coof-open cells LA, SB, LE and LG; lane TAIL-D).
        bool coof_open_limit_rests = false;
        if (coof_recalc_active_ && coof_first_open_ && family == PineOrderFamily::ExitLimit
            && finite_positive(limit_price) && physical.signed_units != 0.0
            && coof_script_bar_valid_) {
            const auto native = detail::run_state(require_host());
            const auto point = detail::callback_point(require_host());
            const bool ordinary_path = !native.spec || native.spec->intrabar.is_none();
            const double open_print = coof_script_bar_.open;
            if (ordinary_path && point && finite_positive(point->price)
                && finite_positive(open_print)) {
                const bool closing_long = physical.signed_units > 0.0;
                if (closing_long ? limit_price <= open_print : limit_price >= open_print) {
                    trigger = native_order::Limit{limit_price};
                    coof_limit_waypoint_price =
                        source_bar_fill_tick(open_print, staged_.syminfo.mintick);
                    coof_stop_at_leg_end = true;
                } else {
                    coof_open_limit_rests = true;
                }
            }
        }
        if (pooc_short_tick_scope) {
            const double tick = staged_.syminfo.mintick;
            // The short exit is a buy.  rounded(low) <= limit and
            // rounded(high) >= stop are compared on the grid INDEX of the
            // quantized extreme (ab9714be include/pineforge/engine.hpp:1268-
            // 1312, tick_grid_price: k / (1/mintick), so an on-grid level
            // equals its grid point).  The k * mintick product sits one ULP
            // above a decimal on-grid level, which made an unbounded ULP walk
            // toward the level cross a whole tick; source_trigger_threshold
            // resolves the same half-tick boundary with a bounded walk.
            if (family == PineOrderFamily::ExitLimit && finite_positive(limit_price)) {
                trigger = native_order::Limit{source_trigger_threshold(
                    limit_price, tick, /*is_buy=*/true, /*is_limit=*/true)};
            } else if (family == PineOrderFamily::ExitStop
                       && finite_positive(stop_price)) {
                trigger = native_order::Stop{source_trigger_threshold(
                    stop_price, tick, /*is_buy=*/true, /*is_limit=*/false)};
            }
        }
        auto submit_one = [&](native_order::Owner owner, bool host_sized,
                              const SourceId& replacement_key, native_order::Group group,
                              bool defer_new_instance,
                              native_order::RequestHandle bracket_origin = {}) {
            native_order::Request request;
            request.intent = host_sized
                ? native_order::OrderIntent{native_order::HostSized{
                    native_order::HostSizedKind::Close, std::nullopt}}
                : native_order::OrderIntent{native_order::Reduce{
                    native_order::ExplicitUnits{qty}}};
            request.label = exit_id; request.comment = comment; request.trigger = trigger;
            request.owner = std::move(owner);
            request.group = std::move(group);
            PlacementSnapshot snapshot;
            snapshot.family = family;
            snapshot.source_id = exit_id;
            snapshot.from_entry = from_entry;
            snapshot.comment = comment;
            snapshot.oca_name = oca_name;
            snapshot.requested_qty = qty;
            snapshot.qty_percent = qty_percent; snapshot.deferred_cohort = host_sized;
            snapshot.reservation_deferred_to_pending_entry =
                binds_pending_reversal_entry;
            snapshot.void_issue = void_issue;
            snapshot.void_global_issue = void_global_issue;
            snapshot.pending_bound_exit = pending_bound_exit;
            snapshot.is_long = false;
            snapshot.command_sequence = command_sequence;
            snapshot.bracket_origin = std::move(bracket_origin);
            snapshot.exit_levels = {limit_price, stop_price, source_trail_points,
                                    source_trail_offset, source_trail_price,
                                    profit_ticks, loss_ticks};
            snapshot.birth = exit_birth;
            snapshot.birth_reach = exit_birth_reach;
            snapshot.trail_activation_level = trail_price;
            snapshot.sizing = exit_sizing;
            // ab9714be pine_fills.cpp:2680-2696: update_trail_best_for_bar_open initializes running extreme from placement bar close
            if (family == PineOrderFamily::ExitTrail && std::isfinite(exit_sizing.price))
                snapshot.retained_trail_best = exit_sizing.price;
            snapshot.placement_cycle = current_position_cycle_;
            if (source_point) {
                snapshot.projection_created_bar =
                    projection_bar_index(source_point->decision);
                snapshot.projection_position_side = physical.signed_units > 0.0
                    ? static_cast<std::int32_t>(PositionSide::LONG)
                    : (physical.signed_units < 0.0
                        ? static_cast<std::int32_t>(PositionSide::SHORT)
                        : static_cast<std::int32_t>(PositionSide::FLAT));
                snapshot.placement_script_open_ms =
                    source_point->decision.script_bar_open_ms;
                snapshot.placement_sub_open_ms = source_point->decision.sub_bar_open_ms;
            }
            initialize_l4c_policy(snapshot, {});
            if (finite_positive(coof_limit_waypoint_price))
                snapshot.forced_execution_price = coof_limit_waypoint_price;
            else if (finite_positive(coof_stop_waypoint_price))
                snapshot.forced_execution_price = coof_stop_waypoint_price;
            // A stop leg the recalculation re-issues at the level its live
            // order already rests at was not born there: it stays live at
            // that level on the rest of the leg, whatever else the re-issue
            // changes -- the bracket a resting entry carried, re-issued by
            // the recalculation of that entry's mid-leg fill (lab tv tapes
            // tests/fixtures/coof_resting_bracket td-m2a and td-m2b; lane
            // TAIL-D). One an earlier recalculation holds stays held.
            const auto live_stop = live_by_source_key_.find(checked_live_key(replacement_key));
            const bool stop_leg_rests = live_stop != live_by_source_key_.end() && [&] {
                const auto prior = placement_.find(live_stop->second.incarnation);
                return prior != placement_.end()
                    && prior->second.family == PineOrderFamily::ExitStop
                    && same_double_bits(prior->second.exit_levels.stop, stop_price)
                    && !finite_positive(prior->second.forced_execution_price);
            }();
            if (coof_recalc_active_ && !coof_first_open_ && historical_cascade
                && family == PineOrderFamily::ExitStop
                && finite_positive(stop_price) && !stop_leg_rests) {
                const auto point = detail::callback_point(require_host());
                const double birth = point ? point->price : kNaN;
                const double waypoint = coof_next_waypoint();
                const bool long_position = physical.signed_units > 0.0;
                const bool reached_on_next_leg = long_position
                    ? (birth > stop_price && waypoint <= stop_price)
                    : (birth < stop_price && waypoint >= stop_price);
                if (reached_on_next_leg) {
                    snapshot.forced_execution_price = source_bar_fill_tick(
                        waypoint, staged_.syminfo.mintick)
                        + (long_position ? -1.0 : 1.0) * config_.slippage
                            * staged_.syminfo.mintick;
                }
            }
            const double source_position = std::abs(detail::run_position(require_host()).signed_units);
            if (std::isfinite(reserved_exit_qty)) {
                snapshot.projection_remaining_qty = reserved_exit_qty;
                const bool foreign_pending_opening = std::any_of(
                    live_handles_.begin(), live_handles_.end(), [&](const auto& handle) {
                        const auto candidate = placement_.find(handle.incarnation);
                        return candidate != placement_.end()
                            && candidate->second.opening
                            && candidate->second.source_id != from_entry;
                    }) || std::any_of(
                    pending_entries_.begin(), pending_entries_.end(),
                    [&](const PendingEntry& candidate) {
                        return candidate.snapshot.opening
                            && candidate.snapshot.source_id != from_entry;
                    });
                const double percent = std::isfinite(requested_qty_percent)
                    ? requested_qty_percent : 100.0;
                snapshot.fixed_exit_reservation = std::isfinite(snapshot.requested_qty)
                    || (!binds_pending_reversal_entry
                        && physical.signed_units != 0.0
                        && (percent < 100.0 - 1e-9
                            || reserved_exit_qty < live_reservation_basis - 1e-9
                            || (source_position > 0.0
                                && reserved_exit_qty < source_position - 1e-9)
                            || foreign_pending_opening));
            } else if (!binds_pending_reversal_entry && host_sized
                       && !std::isfinite(snapshot.requested_qty)
                       && source_position > 0.0) {
                const double percent = std::isfinite(snapshot.qty_percent)
                    ? snapshot.qty_percent : 100.0;
                snapshot.projection_remaining_qty = quantize_close_units(source_position, percent);
                if (!from_entry.empty()) {
                    std::map<SourceId, double> reserved_by_exit;
                    for (const auto& handle : live_handles_) {
                        const auto existing = placement_.find(handle.incarnation);
                        if (existing == placement_.end()) continue;
                        const auto& prior = existing->second;
                        const bool exit = prior.family == PineOrderFamily::ExitLimit
                            || prior.family == PineOrderFamily::ExitStop
                            || prior.family == PineOrderFamily::ExitTrail;
                        if (!exit || prior.from_entry != from_entry
                            || prior.source_id == exit_id || prior.void_issue
                            || !std::isfinite(prior.projection_remaining_qty)) {
                            continue;
                        }
                        auto& held = reserved_by_exit[prior.source_id];
                        held = std::max(held, prior.projection_remaining_qty);
                    }
                    double reserved = 0.0;
                    for (const auto& row : reserved_by_exit) reserved += row.second;
                    const double available = std::max(0.0, source_position - reserved);
                    snapshot.projection_remaining_qty = std::min(
                        snapshot.projection_remaining_qty, available);
                    snapshot.fixed_exit_reservation = percent < 100.0
                        || !reserved_by_exit.empty();
                }
            }
            if (config_.process_orders_on_close && from_entry.empty() && source_position > 0.0) {
                double requested = std::isfinite(snapshot.requested_qty)
                    ? std::abs(snapshot.requested_qty)
                    : (std::isfinite(snapshot.projection_remaining_qty)
                        ? snapshot.projection_remaining_qty : source_position);
                double reserved = 0.0;
                for (const auto& handle : live_handles_) {
                    const auto existing = placement_.find(handle.incarnation);
                    if (existing == placement_.end()) continue;
                    const auto& prior = existing->second;
                    const bool global_exit = prior.from_entry.empty()
                        && (prior.family == PineOrderFamily::ExitLimit
                            || prior.family == PineOrderFamily::ExitStop
                            || prior.family == PineOrderFamily::ExitTrail);
                    if (!global_exit || prior.source_id == exit_id
                        || !std::isfinite(prior.projection_remaining_qty)) {
                        continue;
                    }
                    reserved += std::max(0.0, prior.projection_remaining_qty);
                }
                const double available = std::max(0.0, source_position - reserved);
                requested = std::min(requested, available);
                if (!(requested > 0.0)) return;
                snapshot.projection_remaining_qty = requested;
            }
            if (defer_marketable_coof_stop) {
                if (broker_open_epoch_ == std::numeric_limits<std::uint64_t>::max())
                    throw coded<std::overflow_error>(RunFailureCode::engine_invariant, {},
                                                     "source delayed market epoch exhausted");
                if (const auto point = detail::callback_point(require_host())) {
                    snapshot.projection_created_bar =
                        projection_bar_index(point->decision);
                    snapshot.placement_script_open_ms =
                        point->decision.script_bar_open_ms;
                    snapshot.placement_sub_open_ms = point->decision.sub_bar_open_ms;
                }
                snapshot.projection_created_during_coof = true;
                snapshot.projection_coof_at_terminal = coof_context_.is_terminal_sub_bar;
                snapshot.projection_coof_mid_bar = !coof_context_.is_terminal_sub_bar;
                delayed_market_orders_.push_back({
                    std::move(request), std::move(snapshot), replacement_key,
                    broker_open_epoch_ + 1U, true});
                return;
            }
            if (coof_recalc_active_ && physical.signed_units != 0.0) {
                const auto point = detail::callback_point(require_host());
                const double birth = point ? point->price : kNaN;
                const bool long_position = physical.signed_units > 0.0;
                const bool wrong_stop = family == PineOrderFamily::ExitStop
                    && finite_positive(stop_price)
                    && (long_position ? stop_price > birth : stop_price < birth);
                const bool wrong_limit = family == PineOrderFamily::ExitLimit
                    && finite_positive(limit_price)
                    && (long_position ? limit_price < birth : limit_price > birth);
                // Evaluated only for a wrong-side limit that can still hold:
                // the book scans below are otherwise dead on every reissue.
                const auto qualified_recross = [&] {
                    if (coof_limit_waypoint_qualified) return true;
                    if (!coof_remaining_recrosses(limit_price, long_position)) return false;
                    const PlacementSnapshot* parent = nullptr;
                    native_order::RequestHandle parent_handle{};
                    if (const auto cohort = cohorts_by_id_.find(from_entry);
                        cohort != cohorts_by_id_.end() && !cohort->second.opened.empty()) {
                        parent_handle = cohort->second.opened.back();
                        const auto found = placement_.find(parent_handle.incarnation);
                        if (found != placement_.end()) parent = &found->second;
                    }
                    const bool plain_market_parent = parent
                        && parent->family == PineOrderFamily::Entry
                        && !finite_positive(parent->exit_levels.limit)
                        && !finite_positive(parent->exit_levels.stop)
                        && !finite_positive(parent->exit_levels.trail_offset)
                        && !finite_positive(parent->exit_levels.trail_price);
                    if (!plain_market_parent) return false;
                    const double next_waypoint = coof_next_waypoint();
                    const bool reachable_stop = finite_positive(stop_price)
                        && (long_position
                            ? (next_waypoint <= stop_price
                               || coof_script_bar_.close <= stop_price)
                            : (next_waypoint >= stop_price
                               || coof_script_bar_.close >= stop_price));
                    if (reachable_stop) return false;
                    const bool competing_opening = std::any_of(
                        live_handles_.begin(), live_handles_.end(), [&](const auto& handle) {
                            if (handle == parent_handle) return false;
                            const auto candidate = placement_.find(handle.incarnation);
                            return candidate != placement_.end()
                                && candidate->second.opening;
                        });
                    if (competing_opening) return false;
                    const bool direct_partial = point && immediate_close_placed_on(
                        point->decision.coordinate.interval_index);
                    return !direct_partial;
                };
                if ((wrong_stop || (wrong_limit && !coof_open_limit_rests))
                    && !coof_stop_at_leg_end
                    && (coof_first_open_ || wrong_stop || !qualified_recross())) {
                    snapshot.defer_until_post_parent_calculation = true;
                    delayed_market_orders_.push_back({
                        std::move(request), std::move(snapshot), replacement_key,
                        broker_open_epoch_ + 1U});
                    return;
                }
            }
            const auto native = detail::run_state(require_host());
            const bool stage_chart_tick_scope = config_.calc_on_order_fills
                && !config_.process_orders_on_close
                && coof_recalc_active_ && !defer_coof_tail() && !coof_stop_at_leg_end
                && (!native.spec || native.spec->intrabar.is_none())
                && (family == PineOrderFamily::ExitLimit
                    || family == PineOrderFamily::ExitStop);
            if (stage_chart_tick_scope) {
                snapshot.projection_created_during_coof = true;
                snapshot.projection_coof_at_terminal = coof_context_.is_terminal_sub_bar;
                snapshot.projection_coof_mid_bar = !coof_context_.is_terminal_sub_bar;
                auto queued = std::find_if(
                    pending_bracket_legs_.begin(), pending_bracket_legs_.end(),
                    [&](const PendingBracketLeg& row) {
                        return row.replacement_key == replacement_key;
                    });
                PendingBracketLeg staged{std::move(request), std::move(snapshot),
                                         replacement_key, family_key};
                if (queued == pending_bracket_legs_.end())
                    pending_write(pending_bracket_legs_).push_back(std::move(staged));
                else
                    pending_write(*queued) = std::move(staged);
                return;
            }
            if (auto queued = std::find_if(
                    pending_bracket_legs_.begin(), pending_bracket_legs_.end(),
                    [&](const PendingBracketLeg& row) {
                        return row.replacement_key == replacement_key
                            && row.snapshot.defer_until_post_parent_calculation;
                    }); queued != pending_bracket_legs_.end()) {
                const std::uint64_t predecessor =
                    queued->snapshot.legs.target().incarnation != 0
                    ? queued->snapshot.legs.target().incarnation
                    : queued->snapshot.projection_predecessor;
                snapshot.projection_predecessor = predecessor;
                if (!queued->snapshot.void_issue || snapshot.void_issue)
                    snapshot.source_sequence = queued->snapshot.source_sequence;
                snapshot.defer_until_post_parent_calculation = true;
                if (const auto point = detail::callback_point(require_host())) {
                    snapshot.projection_created_bar =
                        projection_bar_index(point->decision);
                    snapshot.projection_position_side =
                        static_cast<std::int32_t>(PositionSide::FLAT);
                }
                pending_write(*queued) = PendingBracketLeg{std::move(request), std::move(snapshot),
                                            replacement_key, family_key};
                return;
            }
            if (defer_coof_tail() && !finite_positive(coof_stop_waypoint_price)) {
                pending_write(pending_coof_requests_).push_back({std::move(request), std::move(snapshot), replacement_key,
                                                  false, family_key, true});
                return;
            }
            if (snapshot.reservation_deferred_to_pending_entry
                && physical.signed_units == 0.0
                && !(cohort_exposure_for(snapshot.from_entry) > 0.0)) {
                auto queued = std::find_if(pending_bracket_legs_.begin(),
                    pending_bracket_legs_.end(), [&](const PendingBracketLeg& row) {
                        return row.replacement_key == replacement_key;
                    });
                PendingBracketLeg staged{std::move(request), std::move(snapshot),
                                         replacement_key, family_key};
                if (queued == pending_bracket_legs_.end())
                    pending_write(pending_bracket_legs_).push_back(std::move(staged));
                else
                    pending_write(*queued) = std::move(staged);
                return;
            }
            bool defer_for_live_parent = false;
            // ab9714be src/source/pine_fills.cpp:7461-7468: while flat, an exit
            // created while flat is skipped rather than removed, and waits in
            // the book for the position to open. Defer the leg until its parent
            // entry applies so the native core does not erase it while flat.
            // src/source/pine_strategy_commands.cpp:2595-2606 makes an empty
            // from_entry mean "every entry", so any pending opening entry is
            // its parent; a named parent keeps the (id, from_entry) key that
            // carries the queue position across a reissue
            // (src/source/pine_strategy_commands.cpp:2627-2648).
            const auto existing_leg = live_by_source_key_.find(checked_live_key(replacement_key));
            if (!defer_for_same_bar_priority
                && detail::run_position(require_host()).signed_units == 0.0) {
                const auto matches_parent = [&](const PlacementSnapshot& row) {
                    return row.opening && row.family == PineOrderFamily::Entry
                        && (snapshot.from_entry.empty()
                            || row.source_id == snapshot.from_entry);
                };
                bool has_pending_parent = false;
                for (const auto& entry : pending_entries_) {
                    if (matches_parent(entry.snapshot)) {
                        has_pending_parent = true;
                        break;
                    }
                }
                for (const auto& entry : pending_same_bar_commands_) {
                    if (matches_parent(entry.snapshot)) {
                        has_pending_parent = true;
                        break;
                    }
                }
                for (const auto& live : live_handles_) {
                    const auto parent = placement_.find(live.incarnation);
                    if (parent == placement_.end()) continue;
                    if (!matches_parent(parent->second)) continue;
                    has_pending_parent = true;
                    break;
                }
                if (has_pending_parent
                    && (existing_leg != live_by_source_key_.end()
                        || snapshot.from_entry.empty())) {
                    defer_for_live_parent = true;
                }
            }
            if (defer_for_same_bar_priority || defer_for_live_parent) {
                if (const auto existing = live_by_source_key_.find(checked_live_key(replacement_key));
                    existing != live_by_source_key_.end()) {
                    const auto predecessor = existing->second;
                    const auto previous = placement_.find(predecessor.incarnation);
                    if (previous != placement_.end()) {
                        snapshot.projection_predecessor = predecessor.incarnation;
                        if (!previous->second.void_issue || snapshot.void_issue)
                            snapshot.source_sequence = previous->second.source_sequence;
                    }
                    (void)require_host().cancel(predecessor);
                    retire(predecessor);
                }
                if (const auto point = detail::callback_point(require_host())) {
                    snapshot.projection_created_bar = projection_bar_index(point->decision);
                    snapshot.projection_created_bar_pinned = true;
                    snapshot.projection_position_side = static_cast<std::int32_t>(PositionSide::FLAT);
                }
                auto queued = std::find_if(pending_bracket_legs_.begin(), pending_bracket_legs_.end(),
                    [&](const PendingBracketLeg& row) {
                        return row.replacement_key == replacement_key;
                    });
                PendingBracketLeg staged{std::move(request), std::move(snapshot), replacement_key,
                                         family_key};
                if (queued == pending_bracket_legs_.end())
                    pending_write(pending_bracket_legs_).push_back(std::move(staged));
                else
                    pending_write(*queued) = std::move(staged);
                return;
            }
            if (defer_new_instance && live_by_source_key_.find(checked_live_key(replacement_key))
                == live_by_source_key_.end()) {
                auto queued = std::find_if(pending_bracket_legs_.begin(), pending_bracket_legs_.end(),
                    [&](const PendingBracketLeg& row) { return row.replacement_key == replacement_key; });
                PendingBracketLeg staged{std::move(request), std::move(snapshot), replacement_key, family_key};
                if (queued == pending_bracket_legs_.end()) pending_write(pending_bracket_legs_).push_back(std::move(staged));
                else pending_write(*queued) = std::move(staged);
                return;
            }
            // ab9714be src/source/pine_strategy_commands.cpp:2627-2648 keys a
            // source bracket by (exit id, from_entry) and a reissue replaces
            // the stored leg rather than adding a second one.  A leg that was
            // staged for a pending parent is that stored leg, so the freshly
            // submitted instance supersedes it; otherwise the stale staged
            // levels resurrect when a later parent entry applies.
            for (auto stale = pending_bracket_legs_.begin();
                 stale != pending_bracket_legs_.end();) {
                if (stale->replacement_key == replacement_key)
                    stale = pending_write(pending_bracket_legs_).erase(stale);
                else
                    ++stale;
            }
            const std::uint64_t placement_high_water = placement_.high_water();
            const bool opening_stop_now = family == PineOrderFamily::ExitStop
                && opening_market_short && coof_stop_at_leg_end
                && opening_point && opening_point->decision.coordinate.path_phase == NativePathPhase::Open && std::holds_alternative<native_order::Market>(request.trigger);
            snapshot.coof_open_stop_next_waypoint = opening_stop_now && !coof_first_open_
                && opening_high && !carried_opening_parent;
            const bool continue_after_open = snapshot.coof_open_stop_next_waypoint;
            const auto accepted = submit_or_replace(std::move(request), std::move(snapshot), false,
                                                    replacement_key);
            if (accepted) {
                auto& family = bracket_family(family_key);
                // Every family member was remembered before this submission,
                // so a successor above the prior placement high-water cannot
                // already be present; only a returned existing handle needs
                // the membership scan.
                if (accepted->incarnation > placement_high_water || !family.holds(*accepted)) {
                    family.push_back(*accepted);
                }
                if (opening_stop_now) {
                    const auto outcome = require_host().execute_current(
                        {*accepted, NativeCurrentPriceRule::NearestTick});
                    if (continue_after_open
                        && std::holds_alternative<native_order::ExecutionAppliedEvent>(outcome)) {
                        coof_open_stop_next_waypoint_ = true;
                    }
                }
            }
        };
 
        if (dynamic) {
            native_order::RequestHandle pending_origin{};
            bool defer_until_parent = false;
            if (!from_entry.empty()) {
                const auto cohort = cohorts_by_id_.find(from_entry);
                if (cohort != cohorts_by_id_.end() && cohort->second.opened.empty()) {
                    for (const auto position : live_origin_positions(cohort->second)) {
                        const auto& origin = cohort->second.origins[position];
                        if (origin_is_pending(origin)) {
                            pending_origin = origin;
                            defer_until_parent = true;
                            break;
                        }
                    }
                }
            }
            native_order::Owner owner = dynamic_owner;
            if (defer_until_parent) {
                const auto cohort = cohorts_by_id_.find(from_entry);
                if (cohort != cohorts_by_id_.end())
                    owner = native_order::BindCohort{cohort->second.handle};
                defer_until_parent = false;
            }
            submit_one(std::move(owner), true,
                dynamic_key_prefix + std::to_string(static_cast<int>(family)),
                group_for(dynamic_group_name, 1, static_cast<std::int64_t>(family)),
                defer_until_parent || defer_for_same_bar_add_exit,
                pending_origin);
            return;
        }
 
        // An explicit global exit is still a source-sized close over the
        // generic book.  There is no empty-id cohort to bind; terms supplies
        // the literal units at the native candidate.
        if (from_entry.empty()) {
            const auto group_name = oca_name.empty() ? exit_id + "\x1f" + from_entry : oca_name;
            submit_one(native_order::Independent{}, true,
                exit_id + "\x1f" + from_entry + std::to_string(static_cast<int>(family)),
                group_for(group_name, 1, static_cast<std::int64_t>(family)), false);
            return;
        }
 
        // An explicit bracket quantity is one independently persistent leg
        // for every source entry provenance, including an origin that is
        // still pending.  BindCohort keeps that pending-origin leg deferred
        // without inventing a source id in the generic core; the source key
        // gives re-issues replacement semantics per (exit, from_entry, leg,
        // origin) rather than accidentally replacing a carried instance.
        const auto cohort = cohort_for(from_entry);
        const auto found = cohorts_by_id_.find(from_entry);
        std::vector<native_order::RequestHandle> origins;
        if (found != cohorts_by_id_.end()) {
            // ab9714be keys (exit id, from_entry) per position cycle
            // (cycle_filled_entry_ids_ is cleared on flat). Stale origins
            // from a prior cycle are neither pending nor opened; keeping
            // them prevents the empty-origins origin-zero fallback a first
            // cycle uses while the new parent is still in
            // pending_same_bar_commands_ (probe9 A v0 / the pending-parent probe).
            // Retired origins cannot be pending or opened; collect global
            // positions from the retained index and keep roster order.
            const auto& roster = found->second.origins;
            std::vector<std::size_t> positions;
            if (const auto* zero = roster.positions_of(0))
                positions.insert(positions.end(), zero->begin(), zero->end());
            for (const auto& live : live_handles_)
                if (origin_is_pending(live)) roster.append_positions_of(live, positions);
            for (const auto& opened : found->second.opened)
                roster.append_positions_of(opened, positions);
            std::sort(positions.begin(), positions.end());
            positions.erase(std::unique(positions.begin(), positions.end()), positions.end());
            for (const auto position : positions) origins.push_back(roster[position]);
        }
        if (origins.empty()) origins.push_back({});
        for (const auto& origin : origins) {
            const std::string origin_key = std::to_string(origin.incarnation);
            const auto replacement_key = exit_id + "\x1f" + from_entry + "\x1f"
                + std::to_string(static_cast<int>(family)) + "\x1f" + origin_key;
            const auto group_name = oca_name.empty()
                ? exit_id + "\x1f" + from_entry + "\x1f" + origin_key
                : oca_name + (origin.incarnation != 0 ? "\x1f" + origin_key : "");
            const bool has_live_leg = live_by_source_key_.find(checked_live_key(replacement_key))
                != live_by_source_key_.end();
            const bool origin_opened = found != cohorts_by_id_.end()
                && std::find(found->second.opened.begin(), found->second.opened.end(), origin)
                    != found->second.opened.end();
            // The consumed-leg lookup decides the skip only: a bracket
            // reissued on every bar keeps its live leg and never reaches it.
            const auto consumed_origin_leg = [&] {
                if (const auto archived = settled_bracket_families_.find(family_key);
                    archived != settled_bracket_families_.end()) {
                    PINEFORGE_LOOKUP_INDEX_WORK("archived_family_probe", this, run_counter_, 1);
                    PINEFORGE_LOOKUP_INDEX_WORK("archived_family_index_eligible", this, run_counter_,
                                               archived->second.count > kIndexedFrom ? 1 : 0);
                    // Restore only the requested immutable prefix, as an append
                    // does. Its logical size selects the existing index path;
                    // no retired handles or placement rows are materialized.
                    (void)bracket_family(family_key);
                }
                return origin_leg_consumed(family_key, family, origin);
            };
            if (origin.incarnation != 0 && !has_live_leg && !origin_is_pending(origin)
                && (!origin_opened || consumed_origin_leg())) {
                continue;
            }
            native_order::Owner owner = !void_issue && !config_.close_entries_rule_any
                    && origin_opened
                ? native_order::Owner{native_order::Independent{}}
                : native_order::Owner{native_order::BindCohort{cohort}};
            // ab9714be pine_orders.cpp:483-488: cancel_oca_group scopes cancellation strictly to matching oca_name group
            submit_one(std::move(owner), true, replacement_key,
                       group_for(group_name, 1, static_cast<std::int64_t>(family)),
                       !has_live_leg, origin);
        }
    };
    const bool exit_is_buy = !parent_long;
    // ab9714be pine_fills.cpp:7672-7675: an EXIT whose ``from_entry`` never
    // filled in the CURRENT position cycle is Removed before it can rest, and
    // the id set is cleared the moment the book goes flat or flips.  A limit
    // level that is only marketable against the side held at issue time is
    // therefore never a live leg while its parent id belongs to a cycle that
    // has not opened yet; without the removal the leg rests on its cohort
    // binding and flattens the reversal's fresh lot at that lot's own entry
    // price on the same bar.
    const auto cycle_cohort = from_entry.empty()
        ? cohorts_by_id_.end() : cohorts_by_id_.find(from_entry);
    const bool from_entry_filled_this_cycle = from_entry.empty()
        || (cycle_cohort != cohorts_by_id_.end()
            && !cycle_cohort->second.opened.empty());
    bool placed_absolute_leg = false;
    if (finite_non_negative(limit_price)) {
        submit_leg(PineOrderFamily::ExitLimit, native_order::Limit{
            exit_limit_trigger(limit_price, tick, exit_is_buy)});
        placed_absolute_leg = true;
    } else if (std::isfinite(limit_price) && limit_price < 0.0
               && physical.signed_units > 0.0 && from_entry_filled_this_cycle) {
        // Sell limit < 0 is always marketable; A43 still refuses negatives.
        submit_leg(PineOrderFamily::ExitLimit, native_order::Market{});
        placed_absolute_leg = true;
    }
    // ab9714be pine_strategy_commands.cpp:1933 stores a negative stop level
    // verbatim: a buy stop below zero is crossed by every print and fills at
    // the next reachable point like any gapped stop.  A43 refuses negative
    // triggers, so it rests at 0.0 (source_trigger_threshold's floor), which
    // every print also crosses.  A negative sell stop is never reachable, yet
    // the legacy book still rests it and it reserves its share of the
    // position against later partial exits (ab9714be pine_strategy_commands.cpp:
    // 1929-1953); at 0.0 it rests the same way and no positive print crosses it.
    if (finite_non_negative(stop_price)
        || (std::isfinite(stop_price) && stop_price < 0.0)) {
        const double native_stop = source_trigger_threshold(
            stop_price, tick, exit_is_buy, false);
        submit_leg(PineOrderFamily::ExitStop, native_order::Stop{native_stop});
        placed_absolute_leg = true;
    }
    bool trail_one_shot = false;
    if (has_trail_request && finite_positive(trail_price)) {
        // The legacy broker compares trail activation against tick-quantized
        // OHLC extremes while retaining the raw running best.  The native
        // geometric matcher receives raw segments, so move only the arm
        // threshold by half a tick (toward the reachable side); placement
        // facts and the eventual source fill remain on the original level.
        double native_trail_price = trail_price;
        bool trail_already_reached = false;
        double placement_print = kNaN;
        const bool zero_distance = native_trail_offset_ticks
            && std::isfinite(source_trail_offset)
            && std::floor(source_trail_offset) == 0.0;
        if (finite_positive(tick)) {
            // ab9714be pine_fills.cpp:4592-4593: exit direction uses physical position side or exit intent direction
            const bool buy_close = physical.signed_units != 0.0
                ? physical.signed_units < 0.0 : exit_is_buy;
            const auto point = detail::callback_point(require_host());
            // The placement print is tested on the quantized path like every
            // later one: a close whose tick is the activation has reached it.
            const bool already_reached = point
                && source_trail_reached_at(point->price, trail_price, tick, buy_close);
            trail_already_reached = already_reached;
            if (point) placement_print = point->price;
            const bool no_trailing_distance = !native_trail_offset_ticks || zero_distance;
            // An omitted offset and an explicit offset that truncates to zero
            // are both one-shot activation legs until the activation is
            // reached.  Once a zero-distance trail is already armed at the
            // placement point, retain the generic Trail so its raw best can
            // ride subsequent bars.
            trail_one_shot = no_trailing_distance && !already_reached;
            if (zero_distance && point) {
                // Once the activation is already reached at placement, the
                // explicit-zero trail's first live print is its carried
                // running best.  Arm on that print's grid image so a later
                // adverse leg does not incorrectly ride a raw sub-tick high.
                if (already_reached) {
                    native_trail_price = nearest_tick(point->price, tick);
                }
            }
        }
        if (trail_one_shot) {
            const double one_shot_level = one_shot_trail_trigger(
                native_trail_price, source_trail_offset, tick, exit_is_buy,
                !std::isfinite(source_trail_offset) || zero_distance);
            // ab9714be engine_path_resolve.cpp:984-987 books the crossed
            // activation as a TRAIL event (fill.is_limit = false), and
            // pine_fills.cpp:4396-4411 / pine_policy_members.cpp:45-53 then
            // route it through apply_slippage, not apply_limit_fill: the fill
            // lands slippage ticks WORSE than the activation.  An explicit
            // sub-tick offset keeps the unslipped activation as its touch
            // level (a slipped level would fire early), so the leg is a
            // fill-through limit whose settlement may pass that level.
            const bool slipped_touch = zero_distance && config_.slippage > 0
                && finite_positive(tick);
            submit_leg(PineOrderFamily::ExitTrail,
                       native_order::Limit{one_shot_level, slipped_touch});
        } else if (native_trail_offset_ticks) {
            // The trailing leg's arm is reached on the quantized path too
            // (source_trail_arm_level); the source level stays the activation
            // every placement fact and booking reads.
            std::optional<double> native_arm_price =
                source_trail_arm_level(native_trail_price, tick, exit_is_buy);
            // ab9714be engine_path_resolve.cpp:464-479: trailing exit already reached at placement arms immediately
            if (trail_already_reached)
                native_arm_price.reset();
            native_order::Trail native_trail{
                0.0, native_arm_price,
                native_order::TrailTicks{*native_trail_offset_ticks}};
            // TradingView's running best starts AT the activation, never
            // short of it: every exit of lane E5's six NYSE:F tapes books
            // activation +/- 1 tick, not the raw extreme snapped. The generic
            // arm gives the kernel a worse start in both shapes -- the arm
            // threshold, half a tick short, when a crossing arms it, and the
            // next bar's first print when the placement close already reached
            // it (lane E9's eight tapes) -- so the leg names the level its
            // ride starts at. Already armed, the placement print is part of
            // that ride and joins it on the favourable side: the same carried
            // best the explicit-zero trail's sibling stop rests at, raw.
            // The NYSE:F short controls pin the raw reading: synthetic
            // placement closes sit half a tick past the activation (25.005
            // under 25.01, 26.005 under 26.01) and TradingView's stop is
            // that close + the offset, reached by a high the activation's own
            // stop never would be.
            double best_seed = trail_price;
            if (trail_already_reached && std::isfinite(placement_print)) {
                best_seed = exit_is_buy ? std::min(best_seed, placement_print)
                                        : std::max(best_seed, placement_print);
            }
            if (finite_positive(best_seed)) native_trail.best_seed = best_seed;
            submit_leg(PineOrderFamily::ExitTrail, native_trail);
        } else if (trail_already_reached) {
            // ab9714be engine_path_resolve.cpp:634-639: omitted-offset trail already active at placement is marketable at next open
            // An omitted offset that was already activated at placement is
            // marketable at the next open.
            submit_leg(PineOrderFamily::ExitTrail, native_order::Market{});
        } else {
            // An omitted source offset exits at activation.  A generic limit
            // is the same one-shot direction for either close side. Its
            // executable level includes the legacy stop-style slippage so
            // the generic limit constraint and the source fill agree.
            const double slipped = trail_price + (exit_is_buy ? 1.0 : -1.0)
                * config_.slippage * tick;
            submit_leg(PineOrderFamily::ExitTrail, native_order::Limit{
                directional_tick(slipped, tick, exit_is_buy)});
        }
    }
    const bool exit_at_activation_trail = has_trail_request
        && (!std::isfinite(source_trail_offset)
            || std::floor(source_trail_offset) == 0.0);
    if (!trail_one_shot && exit_at_activation_trail && !finite_positive(stop_price)
        && finite_positive(trail_price)) {
        if (const auto point = detail::callback_point(require_host())) {
            const bool long_side = detail::run_position(require_host()).signed_units > 0.0;
            const bool already_armed = source_trail_reached_at(
                point->price, trail_price, tick, !long_side);
            if (already_armed) {
                // The explicit-zero trail is already active at the source
                // placement close.  A sibling generic stop preserves the
                // next-open print decision; the Trail request still owns a
                // favourable-gap ride and all later path tracking.  Its level
                // is the carried best, which never starts short of the
                // activation (a close reaching it only on its tick).
                const double carried_best = long_side
                    ? std::max(point->price, trail_price)
                    : std::min(point->price, trail_price);
                submit_leg(PineOrderFamily::ExitStop, native_order::Stop{carried_best});
            }
        }
    }
    // A call that names a level replaces the whole exit order: the price leg
    // it leaves na (neither the absolute level nor its tick distance) is
    // withdrawn, not carried from the previous call (lab tv tape
    // tests/fixtures/exit_reissue_na fran-x1-exit-reissue-na-limit: a re-issue
    // with stop = na or limit = na drops that leg; lane TAIL-D). Trailing legs
    // are left as they are.
    if (placed_absolute_leg && !has_trail_request) {
        const bool drop_limit = std::isnan(limit_price) && std::isnan(profit_ticks);
        const bool drop_stop = std::isnan(stop_price) && std::isnan(loss_ticks);
        const auto dropped = [&](const PlacementSnapshot& row) {
            return row.source_id == exit_id && row.from_entry == from_entry
                && !std::isfinite(row.trail_activation_level)
                && ((drop_limit && row.family == PineOrderFamily::ExitLimit)
                    || (drop_stop && row.family == PineOrderFamily::ExitStop));
        };
        if (drop_limit || drop_stop) {
            std::vector<native_order::RequestHandle> withdrawn;
            for (const auto& handle : live_handles_) {
                const auto found = placement_.find(handle.incarnation);
                if (found != placement_.end() && dropped(found->second))
                    withdrawn.push_back(handle);
            }
            for (const auto& handle : withdrawn) {
                const auto result = require_host().cancel(handle);
                if (result.status == native_order::CancelStatus::Cancelled) retire(handle);
            }
            pending_write(pending_bracket_legs_).erase(std::remove_if(pending_bracket_legs_.begin(),
                pending_bracket_legs_.end(), [&](const PendingBracketLeg& leg) {
                    return dropped(leg.snapshot);
                }), pending_bracket_legs_.end());
            delayed_market_orders_.erase(std::remove_if(delayed_market_orders_.begin(),
                delayed_market_orders_.end(), [&](const DelayedMarketOrder& order) {
                    return dropped(order.snapshot);
                }), delayed_market_orders_.end());
        }
    }
    if (defer_for_same_bar_priority && !from_entry.empty())
        named_entry_cancel_tokens_.erase(from_entry);
    if (pooc_short_tick_scope && source_point) {
        bool competing_entry = false;
        for (const auto& handle : live_handles_) {
            const auto found = placement_.find(handle.incarnation);
            if (found != placement_.end() && found->second.opening) {
                competing_entry = true;
                break;
            }
        }
        if (!competing_entry) {
            const double close = nearest_tick(
                source_point->price, staged_.syminfo.mintick);
            const PineOrderFamily selected = pooc_current_close_family;
            if (selected != PineOrderFamily::Entry) {
                const SourceId replacement_key = exit_id + "\x1f" + from_entry
                    + std::to_string(static_cast<int>(selected));
                const auto live = live_by_source_key_.find(checked_live_key(replacement_key));
                if (live != live_by_source_key_.end()) {
                    const auto found = placement_.find(live->second.incarnation);
                    if (found != placement_.end()
                        && found->second.projection_predecessor != 0
                        && cohort_exposure_for(from_entry) > 0.0) {
                        PlacementSnapshot immediate = found->second;
                        cancel_bracket_siblings(live->second);
                        native_order::Request request;
                        request.intent = native_order::Flatten{};
                        request.label = exit_id;
                        request.comment = comment;
                        request.trigger = native_order::Market{};
                        immediate.forced_execution_price = close;
                        immediate.projection_predecessor = live->second.incarnation;
                        immediate.projection_predecessor_exit = true;
                        const auto accepted = submit_or_replace(
                            std::move(request), std::move(immediate), false,
                            "__pooc_current_exit__" + exit_id + "\x1f" + from_entry);
                        if (accepted) {
                            // TradingView fills this exit at the close, after
                            // the pass that placed it: the rest of the pass
                            // keeps the pre-fill strategy.position_size and
                            // strategy.position_avg_price, as an ordinary
                            // close_all keeps the size. lab tv
                            // synthetics tests/fixtures/pooc_close_fill_view.
                            const auto& view = detail::pooc_close_fill_view_switches();
                            auto* pine_host = view.current_exit_keeps_position_view
                                ? pine_view_of(&require_host()) : nullptr;
                            const double pre_fill_average = require_host().position_avg_price();
                            if (pine_host) pine_host->freeze_script_position_view();
                            (void)require_host().execute_current(
                                {*accepted, NativeCurrentPriceRule::NearestTick});
                            if (pine_host && view.current_exit_keeps_average_price)
                                pine_host->hold_script_average_price(pre_fill_average);
                        }
                    }
                }
            }
        }
    }
 
    if (!placed_absolute_leg
        && !(has_trail_request && finite_positive(trail_price))) {
        // ab9714be pine_strategy_commands.cpp:533-537: only a NaN operand is
        // absent. Preserve a command projection for all-NaN absolute levels
        // with no trail arm; it never participates in matching or settlement.
        exit_cancel_bracket(exit_id, from_entry, comment);
        pending_write(source_shadow_pending_).erase(
            std::remove_if(source_shadow_pending_.begin(), source_shadow_pending_.end(),
                [&](const SourceShadowPending& row) {
                    return row.snapshot.source_id == exit_id
                        && row.snapshot.from_entry == from_entry;
                }),
            source_shadow_pending_.end());
        PlacementSnapshot snapshot;
        snapshot.family = has_trail_request ? PineOrderFamily::ExitTrail
            : (!std::isnan(stop_price) || !std::isnan(loss_ticks)
                ? PineOrderFamily::ExitStop : PineOrderFamily::ExitLimit);
        snapshot.source_id = exit_id;
        snapshot.from_entry = from_entry;
        snapshot.comment = comment;
        snapshot.oca_name = oca_name;
        snapshot.requested_qty = qty;
        snapshot.projection_remaining_qty = reserved_exit_qty;
        snapshot.qty_percent = qty_percent;
        snapshot.command_sequence = command_sequence;
        snapshot.source_sequence = ++source_sequence_;
        snapshot.projection_created_bar = detail::callback_point(require_host())
            ? projection_bar_index(detail::callback_point(require_host())->decision) : -1;
        snapshot.projection_position_side = physical.signed_units > 0.0
            ? static_cast<std::int32_t>(PositionSide::LONG)
            : (physical.signed_units < 0.0
                ? static_cast<std::int32_t>(PositionSide::SHORT)
                : static_cast<std::int32_t>(PositionSide::FLAT));
        snapshot.placement_cycle = current_position_cycle_;
        snapshot.exit_levels = {limit_price, stop_price, source_trail_points,
                                source_trail_offset, source_trail_price,
                                profit_ticks, loss_ticks};
        snapshot.sizing = sizing_snapshot();
        pending_write(source_shadow_pending_).push_back({std::move(snapshot), exit_id});
    }
}
 
void PineExecutionAdapter::flush_pending_bracket_legs(
        native_order::RequestHandle just_applied, bool post_calculation,
        bool pre_script_drain) {
    auto queued = std::move(pending_write(pending_bracket_legs_));
    pending_write(pending_bracket_legs_).clear();
    // ab9714be src/source/pine_scheduler.cpp:242 runs step 1 over the orders
    // that were already resting, and that pass walks a shared fill phase in
    // creation order (src/source/pine_fills.cpp:3782-3788). A resting bracket
    // settles on this bar ahead of the source body only when that walk reaches
    // its parent entry first: a leg the pass visits while the position is still
    // flat is skipped there (src/source/pine_fills.cpp:7461-7468) and only
    // revisited later, which on this route is the flush below the body.
    const auto point = detail::callback_point(require_host());
    // A parent that filled in the open phase sat in phase 0 with the open-tick
    // marketables, so the pass walked it ahead of every priced bracket of the
    // bar. A parent that filled later on the path shares the bracket's phase,
    // and there only the book's creation order decides.
    const bool parent_walked_after_leg
        = point != nullptr
          && position_open_bar_index_
              == point->decision.coordinate.interval_index
          && position_open_phase_ != NativePathPhase::Open;
    const auto resolve_parent_handle
        = [&](const PlacementSnapshot& row)
            -> std::optional<native_order::RequestHandle> {
        auto origin = row.bracket_origin;
        if (origin.incarnation == 0 && !row.from_entry.empty()) {
            const auto cohort = cohorts_by_id_.find(row.from_entry);
            if (cohort != cohorts_by_id_.end()
                && !cohort->second.opened.empty()) {
                origin = cohort->second.opened.back();
            }
        }
        if (placement_.find(origin.incarnation) == placement_.end()) return std::nullopt;
        return origin;
    };
    const auto resolve_parent = [&](const PlacementSnapshot& row)
            -> const PlacementSnapshot* {
        const auto handle = resolve_parent_handle(row);
        if (!handle) return nullptr;
        return &placement_.find(handle->incarnation)->second;
    };
    // The owner's pass orders a shared fill phase by the order's creation
    // sequence (ab9714be src/source/pine_fills.cpp:3779-3785), the stamp the
    // book keeps across a same-id replacement
    // (src/source/pine_strategy_commands.cpp:481-482,
    // src/source/pine_strategy_commands.cpp:2627-2648). This route carries the
    // same fact on the snapshot's source sequence, which a re-issued bracket
    // inherits (src/source/pine_adapter.cpp:6601) and the book walk already
    // ranks on (src/source/pine_adapter.cpp:11288).
    const auto parent_precedes_leg
        = [](const PlacementSnapshot& leg, const PlacementSnapshot& parent) {
        return parent.source_sequence < leg.source_sequence;
    };
    // A parent recreated after a named entry cancellation is the retained
    // topology: its surviving bracket keeps the pre-cancellation book slot, so
    // the creation-order walk reaches the leg first and skips it while the
    // position is still flat (src/source/pine_fills.cpp:7461-7468). The owner's
    // one exception ranks that fresh parent ahead of the retained child
    // (ab9714be src/compat/pine/order_priority.cpp:31-85, declared by the
    // flat_retained_child_fresh_parent_order metadata). The child of that pair
    // has no native handle while this route still stages it, so the pair is
    // read from the placement snapshots and the three evidence boundaries of
    // the owner's predicate are carried as their source facts: the pass-time
    // gates of ab9714be src/compat/pine/order_priority.cpp:11-15 become "this
    // bar's position opened on this bar" (the owner ranks the pair while the
    // broker is still flat, and here the walk ran ahead of this drain) plus
    // "the pair is the whole book this route carries"; the incarnation
    // adjacency of src/compat/pine/order_priority.cpp:85 becomes two
    // consecutive source commands; and the owner's single exit order is the
    // pair of legs this route splits it into, so either leg may carry the
    // surviving-slot stamp for its bracket.
    const bool retained_parent_first
        = priority.attached() && priority.retained_parent_first();
    const auto exact_retained_child = [&](const PlacementSnapshot& row,
                                          std::uint64_t surviving) {
        const double percent = std::isfinite(row.qty_percent)
            ? row.qty_percent : 100.0;
        return (row.family == PineOrderFamily::ExitStop
                || row.family == PineOrderFamily::ExitLimit)
            && !row.from_entry.empty()
            && row.projection_predecessor != 0
            && row.projection_predecessor == surviving
            && row.projection_position_side
                == static_cast<std::int32_t>(PositionSide::FLAT)
            && point && row.projection_created_bar
                == point->decision.coordinate.interval_index - 1
            && !row.birth.from_fill()
            && !row.projection_after_close
            && !row.projection_over_pyramiding
            && !std::isfinite(row.requested_qty)
            && percent >= 100.0 - internal::kFullPercentEps
            && std::isfinite(row.exit_levels.stop)
            && std::isfinite(row.exit_levels.limit)
            && !std::isfinite(row.exit_levels.profit_ticks)
            && !std::isfinite(row.exit_levels.loss_ticks)
            && !std::isfinite(row.exit_levels.trail_points)
            && !std::isfinite(row.exit_levels.trail_price)
            && !std::isfinite(row.exit_levels.trail_offset)
            && row.oca_name.empty() && row.oca_type == 0;
    };
    const auto exact_fresh_parent = [&](const PlacementSnapshot& parent,
                                        std::uint64_t parent_incarnation,
                                        std::uint64_t child_predecessor) {
        const auto cancelled
            = parent.recreated_after_named_cancelled_entry_incarnation;
        const auto surviving
            = parent.named_cancel_surviving_exit_incarnation;
        return parent.opening
            && parent.family == PineOrderFamily::Entry
            && parent.projection_position_side
                == static_cast<std::int32_t>(PositionSide::FLAT)
            && parent.projection_predecessor == 0
            && cancelled != 0 && cancelled < parent_incarnation
            && cancelled != child_predecessor
            && surviving > cancelled && surviving < parent_incarnation
            && point && parent.projection_created_bar
                == point->decision.coordinate.interval_index - 1
            && !std::isfinite(parent.requested_qty)
            && !parent.birth.from_fill()
            && !parent.projection_after_close
            && !parent.projection_over_pyramiding
            && !parent.stop_limit_activated
            && std::isfinite(parent.exit_levels.stop)
            && !std::isfinite(parent.exit_levels.limit)
            && !std::isfinite(parent.exit_levels.trail_points)
            && !std::isfinite(parent.exit_levels.trail_price)
            && !std::isfinite(parent.exit_levels.trail_offset)
            && parent.oca_name.empty() && parent.oca_type == 0;
    };
    // The staged brackets of this drain that are the ranked child of a fresh
    // parent entry.
    std::vector<std::pair<std::string, std::string>> ranked_retained_brackets;
    if (pre_script_drain && retained_parent_first && point
        && position_open_bar_index_
            == point->decision.coordinate.interval_index
        && config_.process_orders_on_close && !config_.calc_on_order_fills
        && !coof_recalc_active_ && point->decision.sub_count <= 1) {
        std::vector<std::pair<std::string, std::string>> book_keys;
        // TradingView's close-time script sees the stop entry AND its bracket
        // exit filled inside the bar whatever exit the book still holds for an
        // entry that is neither open nor working -- a strategy.exit re-issued
        // after its entry closed, or kept after the entry was cancelled
        // ("Sell Exit" of a cancelled "Sell" re-arm on 2025-08-02;
        // tests/fixtures/pooc_close_bar_fills, the two dormant-exit-history
        // tapes on BINANCE:BTCUSDT 15m). Such an exit cannot fill before its
        // entry does, so it is not part of the book this pair is ranked
        // against (ScriptRuleSwitches).
        const auto inert_exit = [&](const PlacementSnapshot& row) {
            if (!detail::script_rule_switches().pooc_bracket_skips_inert_exits)
                return false;
            if (row.family != PineOrderFamily::ExitLimit
                && row.family != PineOrderFamily::ExitStop
                && row.family != PineOrderFamily::ExitTrail)
                return false;
            const auto held = from_entry_units(row.from_entry);
            if (!held || *held > 0.0) return false;
            const auto names_entry = [&](const PlacementSnapshot& other) {
                return other.source_id == row.from_entry;
            };
            for (const auto& live : live_handles_) {
                const auto other = placement_.find(live.incarnation);
                if (other != placement_.end() && names_entry(other->second)) return false;
            }
            for (const auto& staged : queued)
                if (names_entry(staged.snapshot)) return false;
            for (const auto& entry : pending_entries_)
                if (names_entry(entry.snapshot)) return false;
            for (const auto& command : pending_same_bar_commands_)
                if (names_entry(command.snapshot)) return false;
            for (const auto& pending : pending_coof_requests_)
                if (names_entry(pending.snapshot)) return false;
            for (const auto& delayed : delayed_market_orders_)
                if (names_entry(delayed.snapshot)) return false;
            return true;
        };
        const auto carry_key = [&](const PlacementSnapshot& row) {
            if (inert_exit(row)) return;
            const auto key = std::make_pair(row.source_id, row.from_entry);
            if (std::find(book_keys.begin(), book_keys.end(), key)
                == book_keys.end())
                book_keys.push_back(key);
        };
        for (const auto& live : live_handles_) {
            const auto row = placement_.find(live.incarnation);
            if (row != placement_.end()) carry_key(row->second);
        }
        for (const auto& staged : queued) carry_key(staged.snapshot);
        for (const auto& entry : pending_entries_) carry_key(entry.snapshot);
        for (const auto& command : pending_same_bar_commands_)
            carry_key(command.snapshot);
        for (const auto& pending : pending_coof_requests_)
            carry_key(pending.snapshot);
        for (const auto& delayed : delayed_market_orders_)
            carry_key(delayed.snapshot);
        for (const auto& leg : queued) {
            const auto bracket = std::make_pair(leg.snapshot.source_id,
                                               leg.snapshot.from_entry);
            if (book_keys.size() != 1 || book_keys.front() != bracket) continue;
            const auto handle = resolve_parent_handle(leg.snapshot);
            if (!handle) continue;
            const auto parent = placement_.find(handle->incarnation);
            if (parent == placement_.end()
                || !parent->second.retained_parent_topology) continue;
            if (leg.snapshot.from_entry != parent->second.source_id) continue;
            if (leg.snapshot.command_sequence
                != parent->second.command_sequence + 1) continue;
            if (!exact_fresh_parent(parent->second, handle->incarnation,
                                    leg.snapshot.projection_predecessor))
                continue;
            for (const auto& sibling : queued) {
                if (sibling.snapshot.source_id != bracket.first
                    || sibling.snapshot.from_entry != bracket.second) continue;
                if (!exact_retained_child(sibling.snapshot,
                        parent->second.named_cancel_surviving_exit_incarnation))
                    continue;
                if (std::find(ranked_retained_brackets.begin(),
                              ranked_retained_brackets.end(), bracket)
                    == ranked_retained_brackets.end())
                    ranked_retained_brackets.push_back(bracket);
                break;
            }
        }
    }
    // True when the owner's step-1 walk reaches this leg's parent entry before
    // the leg, so the leg settles with the position open ahead of the body. A
    // leg whose parent entry was the fill that opened the position has already
    // had that parent's calculation, so the walk also satisfies the deferred
    // post-parent-calculation parking flag (pine_adapter.cpp:7393).
    const auto parent_walks_first
        = [&](const PlacementSnapshot& leg) {
        if (!pre_script_drain) return false;
        const auto* parent = resolve_parent(leg);
        if (parent == nullptr) return false;
        if (parent->retained_parent_topology) {
            return std::find(ranked_retained_brackets.begin(),
                             ranked_retained_brackets.end(),
                             std::make_pair(leg.source_id, leg.from_entry))
                != ranked_retained_brackets.end();
        }
        return !parent_walked_after_leg
            || parent_precedes_leg(leg, *parent);
    };
    if (pre_script_drain) {
        std::vector<PendingBracketLeg> resting;
        resting.reserve(queued.size());
        for (auto& leg : queued) {
            const bool has_parent = resolve_parent(leg.snapshot) != nullptr;
            if (has_parent && !parent_walks_first(leg.snapshot)) {
                pending_write(pending_bracket_legs_).push_back(std::move(leg));
            } else {
                resting.push_back(std::move(leg));
            }
        }
        queued = std::move(resting);
    }
    // Re-issued explicit brackets are one leg family per entry instance.
    // The legacy book walked instances first (T1/T2 for opening A, then
    // T1/T2 for opening B), not every T1 across all openings before T2.
    // Preserve original order for unbound/deferred rows (origin zero).
    std::stable_sort(queued.begin(), queued.end(), [](const PendingBracketLeg& left,
                                                       const PendingBracketLeg& right) {
        const auto left_origin = left.snapshot.bracket_origin.incarnation;
        const auto right_origin = right.snapshot.bracket_origin.incarnation;
        if (left_origin == right_origin) return false;
        return left_origin < right_origin;
    });
    // A stop or limit leg staged in a fill recalculation keeps the trigger
    // exit() installed whatever else the book holds: TradingView has no
    // "competing chart tick" exclusion, so beside another order it reaches
    // what it reaches alone (lab tv synthetics tests/fixtures/
    // coof_competing_tick).
    for (auto& leg : queued) {
        // A global exit called while the book is flat is bound to the limit
        // and stop entry orders working then and waits for their fill
        // (materialized by the opening, materialize_pending_bracket_legs):
        // submitted to a flat book it would end at once (tests/fixtures/
        // global_exit_children pending-89). One beside a market entry keeps
        // its course (tests/fixtures/exit_queue w3f05-s11).
        if (leg.snapshot.from_entry.empty() && leg.snapshot.bracket_origin.incarnation == 0
            && detail::exit_binding_rule_switches().global_exit_binds_working_entries
            && margins_disabled()
            && whole_level_exit(leg.snapshot.exit_levels.limit, leg.snapshot.exit_levels.stop,
                                leg.snapshot.exit_levels.trail_points,
                                leg.snapshot.exit_levels.trail_price,
                                leg.snapshot.exit_levels.profit_ticks,
                                leg.snapshot.exit_levels.loss_ticks,
                                leg.snapshot.requested_qty, leg.snapshot.qty_percent)
            && detail::run_position(require_host()).signed_units == 0.0
            && priced_entry_order_working(nullptr)) {
            pending_write(pending_bracket_legs_).push_back(std::move(leg));
            continue;
        }
        if (leg.snapshot.reservation_deferred_to_pending_entry
            && !(cohort_exposure_for(leg.snapshot.from_entry) > 0.0)) {
            pending_write(pending_bracket_legs_).push_back(std::move(leg));
            continue;
        }
        // ab9714be pine_fills.cpp:7679-7700 evaluates a filled parent's priced
        // exits on its entry bar, whichever source batch placed the parent.
        // An explicit leg issued after its flat pyramiding=2 MARKET parent,
        // while that parent was still held in the same-bar batch, took origin
        // zero; the batch has now submitted the parent, so bind the leg to it
        // exactly as exit() binds a leg issued after a live pending parent:
        // it waits for the parent's opening instead of pre-arming on the
        // signal bar.
        if (leg.snapshot.bracket_origin.incarnation == 0 && config_.pyramiding == 2
            && std::isfinite(leg.snapshot.requested_qty)
            && !leg.snapshot.from_entry.empty()) {
            const auto cohort = cohorts_by_id_.find(leg.snapshot.from_entry);
            if (cohort != cohorts_by_id_.end() && cohort->second.opened.empty()) {
                for (const auto& origin : cohort->second.origins) {
                    // Only a pending (live) origin qualifies, and its row is held.
                    if (!origin_is_pending(origin)) continue;
                    const auto parent = placement_.find(origin.incarnation);
                    if (parent == placement_.end() || !parent->second.opening
                        || parent->second.family != PineOrderFamily::Entry
                        || parent->second.placement_script_open_ms
                            != leg.snapshot.placement_script_open_ms
                        || parent->second.command_sequence
                            >= leg.snapshot.command_sequence) {
                        continue;
                    }
                    const std::string origin_key = std::to_string(origin.incarnation);
                    const std::string family_tag = std::to_string(
                        static_cast<int>(leg.snapshot.family));
                    leg.snapshot.bracket_origin = origin;
                    leg.replacement_key = leg.snapshot.source_id + "\x1f"
                        + leg.snapshot.from_entry + "\x1f" + family_tag + "\x1f" + origin_key;
                    const auto group_name = leg.snapshot.oca_name.empty()
                        ? leg.snapshot.source_id + "\x1f" + leg.snapshot.from_entry
                            + "\x1f" + origin_key
                        : leg.snapshot.oca_name + "\x1f" + origin_key;
                    leg.request.group = group_for(group_name, 1,
                        static_cast<std::int64_t>(leg.snapshot.family));
                    break;
                }
            }
            // The parent may not be in the book yet: the reversal entry the
            // same bar places beside strategy.close() of the position it
            // reverses is still held (pending_entries_). The leg waits for it
            // as for a live pending parent, and the parent's opening
            // materializes it against the whole position (FIFO); submitted
            // now it binds the id's cohort, and a FIFO close by another id's
            // exit then leaves it no lot, where TradingView still fills it on
            // its own reservation (lab tv tape tests/fixtures/exit_fifo_cross
            // td-m6g; lane TAIL-D).
            const bool parent_held = cohort != cohorts_by_id_.end()
                && cohort->second.opened.empty()
                && leg.snapshot.bracket_origin.incarnation == 0
                && std::any_of(pending_entries_.begin(), pending_entries_.end(),
                    [&](const PendingEntry& held) {
                        return held.snapshot.opening
                            && held.snapshot.family == PineOrderFamily::Entry
                            && held.snapshot.source_id == leg.snapshot.from_entry
                            && held.snapshot.placement_script_open_ms
                                == leg.snapshot.placement_script_open_ms
                            && held.snapshot.command_sequence
                                < leg.snapshot.command_sequence;
                    });
            if (parent_held) {
                // It keeps the bar the script placed it on, as a leg staged
                // for a flat book's pending parent does, whatever bar the
                // held parent reaches the book on.
                leg.snapshot.projection_created_bar_pinned = true;
                pending_write(pending_bracket_legs_).push_back(std::move(leg));
                continue;
            }
        }
        bool retained_parent_pending = false;
        if ((leg.snapshot.projection_predecessor != 0
             || leg.snapshot.defer_until_post_parent_calculation)
            && !leg.snapshot.from_entry.empty()) {
            const auto cohort = cohorts_by_id_.find(leg.snapshot.from_entry);
            if (cohort != cohorts_by_id_.end()) {
                // A physically flat book has no open lot for this id even
                // when the Applied of the fill that flattened it (a bracket
                // executed at its level in the pre-script drain) is not yet
                // observed, so the cohort's opened roster is still stale.
                // ab9714be pine_fills.cpp:7464-7467 only Skips an exit
                // created while flat, and the flat purge keeps it for its
                // pending parent (pine_fills.cpp:431-437,
                // pine_orders.cpp:507-527): it waits here for that parent.
                const bool no_open_lot = cohort->second.opened.empty()
                    || detail::run_position(require_host()).signed_units == 0.0;
                const auto live = no_open_lot
                    ? live_origin_positions(cohort->second) : std::vector<std::size_t>{};
                retained_parent_pending = std::any_of(live.begin(), live.end(),
                    [&](std::size_t position) {
                        return origin_is_pending(cohort->second.origins[position]);
                    });
            }
        }
        if ((leg.snapshot.bracket_origin.incarnation != 0
             && leg.snapshot.bracket_origin != just_applied
             && origin_is_pending(leg.snapshot.bracket_origin))
            || retained_parent_pending) {
            pending_write(pending_bracket_legs_).push_back(std::move(leg));
            continue;
        }
        if (leg.snapshot.defer_until_post_parent_calculation
            && !post_calculation && !parent_walks_first(leg.snapshot)) {
            pending_write(pending_bracket_legs_).push_back(std::move(leg));
            continue;
        }
        bool execute_after_calculation = false;
        // ab9714be src/source/pine_fills.cpp:7695-7728 evaluates a priced exit on
        // the bar its parent entry fills, and a leg this route parked until
        // post-calculation still gets that bar's touch at its level price. The
        // stop sits on the far leg of the assumed intrabar path, so it only
        // fires when the parent's fill leg came first; the limit sits beyond the
        // fill on the parent's own leg, so the fill always precedes it. A level
        // on the wrong side of the fill price is skipped, as in the entry-bar
        // gate of src/source/pine_fills.cpp:7715-7727.
        const bool priced_exit_leg
            = leg.snapshot.family == PineOrderFamily::ExitStop
              || leg.snapshot.family == PineOrderFamily::ExitLimit;
        if ((leg.snapshot.projection_predecessor != 0
             || leg.snapshot.defer_until_post_parent_calculation)
            && priced_exit_leg && policy_script_bar_valid_ && !leg.snapshot.void_issue) {
            const auto cohort = cohorts_by_id_.find(leg.snapshot.from_entry);
            if (cohort != cohorts_by_id_.end() && !cohort->second.opened.empty()) {
                const auto parent = placement_.find(cohort->second.opened.back().incarnation);
                if (parent != placement_.end() && parent->second.opening) {
                    const bool is_stop_leg
                        = leg.snapshot.family == PineOrderFamily::ExitStop;
                    const double level = is_stop_leg
                        ? leg.snapshot.exit_levels.stop
                        : leg.snapshot.exit_levels.limit;
                    const bool high_first = source_path_uses_high_first(policy_script_bar_);
                    const bool parent_before_child = is_stop_leg
                        ? (parent->second.is_long ? high_first : !high_first) : true;
                    // ab9714be pine_fills.cpp:7711-7713 + pine_policy_members.cpp:11-17
                    // + engine.hpp:1374-1381: the entry-bar exit is tested
                    // against the tick-quantized bar, so an on-grid level is
                    // touched by a raw extreme half a tick short of it
                    // (synthetic NYSE:F high 25.045 -> 25.05 reaches a 25.05 sell limit).
                    // Only the calc_on_order_fills scheduler compares raw.
                    const double tick = staged_.syminfo.mintick;
                    const bool raw_bar = config_.calc_on_order_fills
                        || !finite_positive(tick);
                    const double bar_high = raw_bar ? policy_script_bar_.high
                        : source_decimal_tick(policy_script_bar_.high, tick);
                    const double bar_low = raw_bar ? policy_script_bar_.low
                        : source_decimal_tick(policy_script_bar_.low, tick);
                    const bool touched = is_stop_leg
                        ? (parent->second.is_long ? bar_low <= level
                                                  : bar_high >= level)
                        : (parent->second.is_long ? bar_high >= level
                                                  : bar_low <= level);
                    const double fill_price
                        = detail::run_position(require_host()).average_price;
                    const bool right_side = is_stop_leg
                        || (parent->second.is_long ? level >= fill_price
                                                   : level <= fill_price);
                    execute_after_calculation = parent_before_child && touched && right_side;
                    if (execute_after_calculation) {
                        const double units = std::abs(
                            detail::run_position(require_host()).signed_units);
                        leg.snapshot.forced_execution_price = level;
                        leg.snapshot.immediately = true;
                        leg.snapshot.requested_qty = units;
                        leg.snapshot.deferred_cohort = false;
                        leg.request.intent = native_order::Reduce{
                            native_order::ExplicitUnits{units}};
                        leg.request.trigger = native_order::Market{};
                        leg.request.owner = native_order::Independent{};
                        leg.request.group = native_order::NoGroup{};
                    }
                }
            }
        }
        const auto accepted = submit_or_replace(std::move(leg.request), std::move(leg.snapshot), false,
                                                leg.replacement_key);
        if (accepted) {
            bracket_family(leg.family_key).push_back(*accepted);
            if (execute_after_calculation) {
                (void)require_host().execute_current(
                    {*accepted, NativeCurrentPriceRule::NearestTick});
            }
        }
    }
}
 
void PineExecutionAdapter::materialize_pending_bracket_legs(
        const native_order::ExecutionAppliedEvent& event) {
    const auto parent_it = placement_.find(event.handle().incarnation);
    const PlacementSnapshot* parent = parent_it == placement_.end()
        ? nullptr : &parent_it->second;
    const bool retained_parent = parent && parent->opening
        && parent->retained_parent_topology;
    if (parent && parent->opening && parent->oca_type == 1
        && !parent->oca_name.empty()) {
        pending_write(pending_bracket_legs_).erase(std::remove_if(
            pending_bracket_legs_.begin(), pending_bracket_legs_.end(),
            [&](const PendingBracketLeg& leg) {
                return leg.snapshot.oca_name == parent->oca_name;
            }), pending_bracket_legs_.end());
    }
    std::uint64_t retained_family = 0;
    bool materialize_retained = false;
    if (retained_parent && parent->recreated_after_named_cancelled_entry_incarnation != 0
        && parent->named_cancel_surviving_exit_incarnation != 0
        && priority.attached() && priority.retained_parent_first()) {
        const PendingBracketLeg* representative = nullptr;
        bool one_family = true;
        for (const auto& leg : pending_bracket_legs_) {
            if (leg.snapshot.from_entry != parent->source_id) continue;
            if (!representative) {
                representative = &leg;
                retained_family = leg.family_key;
            } else if (leg.family_key != retained_family) {
                one_family = false;
            }
        }
        bool foreign = false;
        if (representative) {
            // Every placement ever made: the retained rows, and the source
            // ids the erased ones leave in the table (the retired-row compaction).
            foreign = placement_.erased_non_margin_id_outside(
                parent->source_id, representative->snapshot.source_id);
            // The record answers for every erased row the scan would accept.
            if (!foreign) {
                PINEFORGE_AUDIT_PLACEMENT_SCAN(placement_,
                    [&](std::uint64_t, const PlacementSnapshot& snapshot) {
                        return snapshot.source_id != parent->source_id
                            && snapshot.source_id != representative->snapshot.source_id
                            && snapshot.family != PineOrderFamily::Margin;
                    });
            }
            for (const auto& row : placement_) {
                if (foreign) break;
                const auto& snapshot = row.second;
                if (snapshot.source_id != parent->source_id
                    && snapshot.source_id != representative->snapshot.source_id
                    && snapshot.family != PineOrderFamily::Margin) {
                    foreign = true;
                }
            }
        }
        const bool exact_child = representative
            && representative->snapshot.projection_predecessor
                == parent->named_cancel_surviving_exit_incarnation
            && representative->snapshot.source_sequence < parent->source_sequence
            && !std::isfinite(representative->snapshot.requested_qty)
            && (!std::isfinite(representative->snapshot.qty_percent)
                || representative->snapshot.qty_percent >= 100.0)
            && finite_positive(representative->snapshot.exit_levels.stop)
            && finite_positive(representative->snapshot.exit_levels.limit)
            && representative->snapshot.oca_name.empty()
            && representative->snapshot.oca_type == 0;
        materialize_retained = one_family && !foreign && exact_child
            && live_handles_.size() == 1 && live_handles_.front() == event.handle();
    }
    if (retained_parent && !materialize_retained) {
        for (auto& leg : pending_bracket_legs_) {
            if (leg.snapshot.from_entry == parent->source_id)
                leg.snapshot.defer_until_post_parent_calculation = true;
        }
    }
    std::vector<PendingBracketLeg> ready;
    for (auto it = pending_bracket_legs_.begin(); it != pending_bracket_legs_.end();) {
        const bool matches_parent = it->snapshot.from_entry.empty()
            || (parent && it->snapshot.from_entry == parent->source_id);
        const bool selected = retained_parent
            ? (materialize_retained && it->family_key == retained_family
               && it->snapshot.from_entry == parent->source_id)
            : (!it->snapshot.defer_until_post_parent_calculation
               && (it->snapshot.bracket_origin == event.handle()
                   || (it->snapshot.bracket_origin.incarnation == 0 && matches_parent)));
        if (selected) {
            pending_write(it->snapshot).bracket_origin = event.handle();
            ready.push_back(std::move(*it));
            it = pending_write(pending_bracket_legs_).erase(it);
        } else {
            ++it;
        }
    }
    for (auto& leg : ready) {
        // ab9714be pine_fills.cpp:7650-7674 (finding-347), as in
        // flush_pending_bracket_legs: the opened parent leaves FIFO to settle
        // an explicit leg against the whole position.
        if (!retained_parent && leg.snapshot.bracket_origin == event.handle()
            && std::isfinite(leg.snapshot.requested_qty)
            && std::holds_alternative<native_order::BindCohort>(leg.request.owner)
            && !config_.close_entries_rule_any) {
            leg.request.owner = owner_for_close(leg.snapshot.from_entry, false);
        }
        const auto accepted = submit_or_replace(std::move(leg.request), std::move(leg.snapshot),
                                                false, leg.replacement_key);
        if (accepted) bracket_family(leg.family_key).push_back(*accepted);
    }
}
 
void PineExecutionAdapter::release_delayed_orders(
        bool explicit_brackets_only, double current_open) {
    require_cohort_ticket();
    auto delayed = std::move(delayed_market_orders_);
    delayed_market_orders_.clear();
    for (auto& order : delayed) {
        const auto family = order.snapshot.family;
        const bool explicit_bracket = (order.snapshot.defer_until_post_parent_calculation
            || (std::isfinite(order.snapshot.requested_qty)
                && order.snapshot.bracket_origin.incarnation != 0))
            && (family == PineOrderFamily::ExitLimit
                || family == PineOrderFamily::ExitStop);
        const bool coof_delayed_price = order.snapshot.projection_created_during_coof
            && (family == PineOrderFamily::ExitStop
                || family == PineOrderFamily::ExitLimit);
        if (order.release_open_epoch <= broker_open_epoch_
            && (!explicit_brackets_only || explicit_bracket || coof_delayed_price)) {
            // A newer same-(id, from_entry) placement already superseded this
            // delayed leg: the owner drops same-id pending orders at replacement
            // time (ab9714be pine_strategy_commands.cpp:446), so the stale
            // command never reaches the book and must not resurrect a finished
            // cycle's levels against the new lot.
            const auto live_existing = live_by_source_key_.find(checked_live_key(order.replacement_key));
            if (live_existing != live_by_source_key_.end()) {
                const auto found_p = placement_.find(live_existing->second.incarnation);
                if (found_p != placement_.end()
                    && found_p->second.command_sequence > order.snapshot.command_sequence) {
                    continue;
                }
            }
            const bool execute_coof_open = order.execute_at_open
                && finite_positive(current_open) && !order.snapshot.void_issue;
            if (execute_coof_open) {
                order.request.trigger = native_order::Market{};
                order.snapshot.forced_execution_price = current_open;
            }
            const auto family_key = key_for(
                order.snapshot.source_id, order.snapshot.from_entry);
            const auto accepted = submit_or_replace(
                std::move(order.request), std::move(order.snapshot),
                family == PineOrderFamily::Entry || family == PineOrderFamily::Order,
                order.replacement_key);
            if (accepted && (family == PineOrderFamily::ExitLimit
                             || family == PineOrderFamily::ExitStop
                             || family == PineOrderFamily::ExitTrail)) {
                bracket_family(family_key).push_back(*accepted);
            }
            if (accepted && execute_coof_open) {
                (void)require_host().execute_current(
                    {*accepted, NativeCurrentPriceRule::NearestTick});
            }
        } else {
            delayed_market_orders_.push_back(std::move(order));
        }
    }
}
 
void PineExecutionAdapter::flush_pending_entries() {
    require_cohort_ticket();
    // Quiet (pine_quiet_bar.hpp): no delayed order, same-bar batch or held
    // entry is queued; the batch's close total is still reset, as the flush
    // below always does.
    if (detail::skip_quiet(detail::QuietHook::PendingEntries,
                           host_ != nullptr && delayed_market_orders_.empty()
                           && pending_same_bar_commands_.empty()
                           && pending_entries_.empty())) {
        pending_same_bar_close_qty_ = 0.0;
        return;
    }
    reroute_incomplete_fixed_batch(false);
    release_delayed_orders();
    flush_pending_same_bar_commands(false, false);
    auto queued = std::move(pending_write(pending_entries_));
    pending_write(pending_entries_).clear();
    auto deferred = std::remove_if(queued.begin(), queued.end(), [&](PendingEntry& entry) {
        const auto parent = entry.snapshot.paired_reversal_parent;
        if (parent.incarnation == 0) return false;
        const auto found = placement_.find(parent.incarnation);
        if (found == placement_.end()
            || (found->second.family != PineOrderFamily::Close
                && found->second.family != PineOrderFamily::CloseAll)) {
            return false;
        }
        pending_write(pending_entries_).push_back(std::move(entry));
        return true;
    });
    queued.erase(deferred, queued.end());
    const bool recreated_parent = std::any_of(queued.begin(), queued.end(),
        [](const PendingEntry& entry) {
            return entry.snapshot.retained_parent_topology;
        });
    if (recreated_parent) {
        for (auto& entry : queued) {
            (void)submit_or_replace(std::move(entry.request), std::move(entry.snapshot), true,
                                    entry.replacement_key);
        }
        return;
    }
    if (!queued.empty() && !pending_bracket_legs_.empty()) {
        auto brackets = std::move(pending_write(pending_bracket_legs_));
        pending_write(pending_bracket_legs_).clear();
        struct Candidate {
            int rank = 4;
            std::size_t index = 0;
            bool entry = false;
        };
        std::vector<Candidate> ordered;
        ordered.reserve(queued.size() + brackets.size());
        for (std::size_t index = 0; index < queued.size(); ++index) {
            ordered.push_back({queued[index].snapshot.is_long ? 1 : 2, index, true});
        }
        const double queued_position = detail::run_position(require_host()).signed_units;
        for (std::size_t index = 0; index < brackets.size(); ++index) {
            const auto& snapshot = brackets[index].snapshot;
            int rank = 4;
            if (snapshot.family == PineOrderFamily::ExitStop) {
                rank = queued_position < 0.0 ? 1 : 2;
            } else if (snapshot.family == PineOrderFamily::ExitLimit) {
                rank = 3;
            }
            ordered.push_back({rank, index, false});
        }
        std::stable_sort(ordered.begin(), ordered.end(), [](const Candidate& left,
                                                             const Candidate& right) {
            return left.rank < right.rank;
        });
        for (const auto& candidate : ordered) {
            if (candidate.entry) {
                auto& entry = queued[candidate.index];
                (void)submit_or_replace(std::move(entry.request), std::move(entry.snapshot), true,
                                        entry.replacement_key);
                continue;
            }
            auto& leg = brackets[candidate.index];
            const auto accepted = submit_or_replace(std::move(leg.request), std::move(leg.snapshot),
                                                    false, leg.replacement_key);
            if (accepted) bracket_family(leg.family_key).push_back(*accepted);
        }
        return;
    }
    std::stable_sort(queued.begin(), queued.end(), [](const PendingEntry& left,
                                                       const PendingEntry& right) {
        const auto* left_stop = std::get_if<native_order::Stop>(&left.request.trigger);
        const auto* right_stop = std::get_if<native_order::Stop>(&right.request.trigger);
        const int left_rank = !left_stop ? 2 : (left.snapshot.is_long ? 0 : 1);
        const int right_rank = !right_stop ? 2 : (right.snapshot.is_long ? 0 : 1);
        return left_rank < right_rank;
    });
    for (auto& entry : queued) {
        (void)submit_or_replace(std::move(entry.request), std::move(entry.snapshot), true,
                                entry.replacement_key);
    }
}
 
void PineExecutionAdapter::reroute_fixed_entries_before_request(bool invalidate_batch) {
    require_cohort_ticket();
    const auto point = detail::callback_point(require_host());
    if (!point) return;
    const auto script_open = point->decision.script_bar_open_ms;
    const bool frozen_entry = std::any_of(pending_same_bar_commands_.begin(),
        pending_same_bar_commands_.end(), [&](const PendingSameBarCommand& command) {
            return command.unbatched_request && command.unbatched_snapshot
                && command.snapshot.placement_script_open_ms == script_open;
        });
    if (!frozen_entry) return;
    if (invalidate_batch) source_batch_mutated_ = true;
    auto queued = std::move(pending_write(pending_same_bar_commands_));
    pending_write(pending_same_bar_commands_).clear();
    pending_same_bar_close_qty_ = 0.0;
    // Dependent requests break the entry-only projection. Restore exact placement
    // requests in source order; begin_source_evaluation resets the invalidation.
    for (auto& command : queued) {
        const bool restore_command = command.unbatched_request && command.unbatched_snapshot
            && command.snapshot.placement_script_open_ms == script_open;
        if (restore_command) {
            command.request = std::move(*command.unbatched_request);
            command.snapshot = std::move(*command.unbatched_snapshot);
            // Restore the ordinary flat-pair sizing against preceding restored
            // requests, which were not live when this batch member was staged.
            const auto& snapshot = command.snapshot;
            if (detail::run_position(require_host()).signed_units == 0.0
                && finite_positive(snapshot.requested_qty)
                && (snapshot.qty_type < 0
                    || snapshot.qty_type == static_cast<int>(QtyType::FIXED))
                && same_point_pair_scope() && same_point_two_leg_book(
                    snapshot.source_id, snapshot.placement_script_open_ms)) {
                const double pending = pending_opposite_market_units(
                    snapshot.is_long, snapshot.placement_script_open_ms,
                    snapshot.source_id);
                if (finite_positive(pending)) {
                    const double transaction = floor_quantity_grid(
                        snapshot.requested_qty, staged_.quantity_grid) + pending;
                    command.request.intent = native_order::Transact{
                        snapshot.is_long ? transaction : -transaction};
                }
            }
        }
        if (restore_command) {
            auto context = command.unbatched_context;
            context.opposite_opening_pending = opposite_entry_opening_pending(
                command.snapshot.is_long);
            submit_entry_with_policy(std::move(command.request), std::move(command.snapshot),
                                     command.replacement_key, context);
        } else {
            (void)submit_or_replace(std::move(command.request), std::move(command.snapshot),
                                    command.opening, command.replacement_key);
        }
    }
}
 
void PineExecutionAdapter::reroute_incomplete_fixed_batch(bool invalidate_batch) {
    bool fixed_long = false;
    bool fixed_short = false;
    for (const auto& command : pending_same_bar_commands_) {
        if (!command.unbatched_request) continue;
        if (command.snapshot.is_long) fixed_long = true;
        else fixed_short = true;
    }
    if ((fixed_long || fixed_short)
        && (!(fixed_long && fixed_short) || !fixed_unmargined_market_batch_scope())) {
        reroute_fixed_entries_before_request(invalidate_batch);
    }
}
 
void PineExecutionAdapter::flush_pending_same_bar_commands(
        bool flat_pair_follows, bool invalidate_batch) {
    require_cohort_ticket();
    reroute_incomplete_fixed_batch(invalidate_batch);
    std::vector<PendingSameBarCommand> queued;
    queued.swap(pending_write(pending_same_bar_commands_));
    // The queue's storage goes back to the member when the flush ends (its
    // commands, submitted, are destroyed as before), so the next bar's
    // commands do not allocate it again -- unless a command was queued
    // meanwhile.
    struct KeepStorage {
        std::vector<PendingSameBarCommand>& queued;
        std::vector<PendingSameBarCommand>& member;
        ~KeepStorage() {
            queued.clear();
            if (member.empty() && member.capacity() == 0) member.swap(queued);
        }
    } keep_storage{queued, pending_same_bar_commands_};
    pending_same_bar_close_qty_ = 0.0;
    if (queued.empty()) return;
 
    const double batch_start = detail::run_position(require_host()).signed_units;
    const auto apply_known_reversal_gap = [&](const auto& accepted) {
        if (!accepted || batch_start == 0.0
            || config_.default_qty_type
                != static_cast<int>(QtyType::PERCENT_OF_EQUITY)
            || config_.default_qty_value > 100.0) {
            return;
        }
        const auto placed = placement_.find(accepted->incarnation);
        if (placed == placement_.end()
            || ((batch_start > 0.0) == placed->second.is_long)) {
            return;
        }
        const auto point = detail::callback_point(require_host());
        auto* pine_host = pine_view_of(&require_host());
        if (!point || !pine_host) return;
        const auto next = pine_host->scheduler_.next_source_bar(
            point->decision.coordinate.interval_index);
        if (!next) return;
        NativeDecisionContext next_context = point->decision;
        ++next_context.coordinate.interval_index;
        next_context.coordinate.path_phase = NativePathPhase::Open;
        next_context.script_bar_open_ms = next->timestamp;
        next_context.sub_bar_open_ms = next->timestamp;
        apply_reversal_gap_bracket_policy(
            *next, next_context, /*defer_trails=*/true);
    };
    const bool variable_short_context = batch_start < 0.0
        && config_.default_qty_type != static_cast<int>(QtyType::FIXED);
    const bool full_short_seed = queued.size() == 3U
        && queued[0].opening && queued[0].snapshot.family == PineOrderFamily::Entry
        && queued[0].snapshot.is_long
        && queued[1].opening && queued[1].snapshot.family == PineOrderFamily::Entry
        && !queued[1].snapshot.is_long
        && queued[2].snapshot.frozen_market_targeted_close
        && queued[0].snapshot.source_id != queued[1].snapshot.source_id
        && queued[0].snapshot.source_id != queued[2].snapshot.source_id
        && queued[1].snapshot.source_id == queued[2].snapshot.source_id;
    const bool partial_short_seed = queued.size() == 2U
        && queued[0].opening && queued[0].snapshot.family == PineOrderFamily::Entry
        && queued[0].snapshot.is_long
        && queued[1].opening && queued[1].snapshot.family == PineOrderFamily::Entry
        && !queued[1].snapshot.is_long
        && std::any_of(live_handles_.begin(), live_handles_.end(), [&](const auto& handle) {
            const auto found = placement_.find(handle.incarnation);
            if (found == placement_.end()) return false;
            const auto& placeholder = found->second;
            return placeholder.family == PineOrderFamily::Close
                && placeholder.deferred_cohort
                && placeholder.source_id == queued[1].snapshot.source_id
                && placeholder.from_entry == queued[1].snapshot.source_id
                && placeholder.command_ordinal > queued[1].snapshot.command_ordinal;
        });
    const bool potential_short_seed = full_short_seed || partial_short_seed;
    // R1 stays outside the round-8 short-seed book: its model yields
    // TradingView's close-lot artifact only from the full reversal
    // (tests/oracle/test_oracle_short_seed.cpp, GateControl::SameIdReplacement),
    // so a Long reissued over the seed gets back the held units R1 left out.
    if (potential_short_seed && batch_start < 0.0) {
        for (auto& command : queued) {
            if (!command.staged_reversal) continue;
            command.snapshot.frozen_market_transaction_units += command.staged_reversal_held_units;
            command.snapshot.replaced_opening = false;
            command.snapshot.replacement_predecessor_market = false;
        }
    }
    // ab9714be src/compat/pine/market_admission.cpp:33-37 (explicit_pair_scope)
    // carries no commission term.
    const bool p2_candidate_scope = config_.pyramiding == 2
        && !config_.process_orders_on_close && !config_.calc_on_order_fills
        && !coof_recalc_active_ && config_.slippage == 0
        && config_.default_qty_type == static_cast<int>(QtyType::FIXED)
        && std::abs(config_.margin_long - 100.0) < 1e-12
        && std::abs(config_.margin_short - 100.0) < 1e-12
        && risk_.direction == 0 && risk_.max_cons_loss_days == 0
        && risk_.max_drawdown <= 0.0 && risk_.max_intraday_loss <= 0.0
        && risk_.max_position_size <= 0.0 && !risk_.halted && !cap.active();
    const bool prior_entry_like = std::any_of(
        live_handles_.begin(), live_handles_.end(), [&](const auto& handle) {
            const auto found = placement_.find(handle.incarnation);
            return found != placement_.end()
                && (found->second.family == PineOrderFamily::Entry
                    || found->second.family == PineOrderFamily::Order);
        });
    const bool p2_explicit_pair = p2_candidate_scope && !source_batch_mutated_
        && !prior_entry_like && queued.size() == 2U
        && queued[0].opening && queued[1].opening
        && queued[0].snapshot.family == PineOrderFamily::Entry
        && queued[1].snapshot.family == PineOrderFamily::Entry
        && queued[0].snapshot.source_id != queued[1].snapshot.source_id
        && queued[0].snapshot.is_long != queued[1].snapshot.is_long
        && queued[0].snapshot.command_ordinal < queued[1].snapshot.command_ordinal
        && finite_positive(queued[0].snapshot.requested_qty)
        && finite_positive(queued[1].snapshot.requested_qty)
        && queued[0].snapshot.oca_name.empty()
        && queued[1].snapshot.oca_name.empty()
        && queued[0].snapshot.frozen_market_instruction
        && queued[1].snapshot.frozen_market_instruction;
    if (config_.pyramiding == 2 && !p2_explicit_pair && !potential_short_seed
        && !fixed_unmargined_market_batch_scope()) {
        // Exact pair finalization is a whole-source-batch decision. Any
        // replacement/cancel, third entry-like instruction, prior resting
        // entry, or live risk/config deviation sends every survivor through
        // ordinary source order with only its own frozen quantity.
        std::stable_sort(queued.begin(), queued.end(), [&](const auto& left,
                                                           const auto& right) {
            const bool left_replaces = live_by_source_key_.find(
                checked_live_key(left.snapshot.source_id)) != live_by_source_key_.end();
            const bool right_replaces = live_by_source_key_.find(
                checked_live_key(right.snapshot.source_id)) != live_by_source_key_.end();
            return left_replaces && !right_replaces;
        });
        // From flat, a call with an opposite entry on its bar trades its
        // frozen transaction -- its own quantity plus any pending opposite
        // market's -- and is never re-sized at the fill into a reversal of
        // what the other leg opened first (lab tv w6b-p2a-open-pair-pyramiding2
        // SM-LF and MS-SF, the tape of w6-f10a-open-pair; lane W6B-ENG-PAIRS).
        // Only the exact book the tapes measure: one market call beside one
        // priced opposite call of its bar, nothing replaced or cancelled and
        // no entry resting from an earlier bar; every other book keeps the
        // ordinary route below.
        std::vector<bool> flat_pair_member(queued.size(), false);
        if (batch_start == 0.0 && same_point_pair_scope() && !source_batch_mutated_
            && queued.size() == 1U && queued[0].opening
            && queued[0].snapshot.family == PineOrderFamily::Entry) {
            const auto& row = queued[0].snapshot;
            std::size_t opposite = 0;
            bool foreign = false;
            for (const auto& handle : live_handles_) {
                const auto found = placement_.find(handle.incarnation);
                if (found == placement_.end() || !found->second.opening
                    || (found->second.family != PineOrderFamily::Entry
                        && found->second.family != PineOrderFamily::Order)) {
                    continue;
                }
                const auto& leg = found->second;
                const bool priced_leg = finite_positive(leg.exit_levels.stop)
                    != finite_positive(leg.exit_levels.limit);
                const bool this_bar = leg.family == PineOrderFamily::Entry
                    && leg.placement_script_open_ms == row.placement_script_open_ms
                    && leg.is_long != row.is_long && priced_leg
                    && finite_positive(leg.requested_qty) && leg.oca_name.empty()
                    && !leg.birth.from_fill()
                    && (leg.qty_type < 0 || leg.qty_type == static_cast<int>(QtyType::FIXED));
                if (this_bar) ++opposite;
                else foreign = true;
            }
            flat_pair_member[0] = !foreign
                && (flat_pair_follows ? opposite == 0 : opposite == 1);
        }
        for (std::size_t i = 0; i < queued.size(); ++i) {
            auto& command = queued[i];
            auto request = std::move(command.request);
            auto snapshot = std::move(command.snapshot);
            snapshot.paired_flat_market_candidate = false;
            snapshot.paired_flat_market_own_qty = kNaN;
            snapshot.paired_flat_market_peer_seq = 0;
            snapshot.paired_flat_market_transaction_qty = kNaN;
            snapshot.frozen_market_instruction = false;
            const double own = finite_positive(snapshot.frozen_market_own_units)
                ? snapshot.frozen_market_own_units : snapshot.requested_qty;
            if (command.opening && finite_positive(own) && flat_pair_member[i]) {
                const double units = finite_positive(snapshot.frozen_market_transaction_units)
                    ? snapshot.frozen_market_transaction_units : own;
                request.intent = native_order::Transact{snapshot.is_long ? units : -units};
                snapshot.reverse_to = false;
            } else if (command.opening && finite_positive(own)) {
                request.intent = native_order::HostSized{
                    native_order::HostSizedKind::Open,
                    snapshot.is_long ? native_order::Side::Long
                                     : native_order::Side::Short};
                snapshot.reverse_to = true;
            }
            (void)submit_or_replace(std::move(request), std::move(snapshot),
                                    command.opening, command.replacement_key);
        }
        return;
    }
    if (variable_short_context && !potential_short_seed) {
        // A variable-size source callback is tentatively staged because the
        // exact ShortSeed book is only recognizable after all commands return.
        // A nonmatching batch must go back through ordinary native requests in
        // source order; it must never inherit the frozen transaction behavior.
        for (auto& command : queued) {
            auto request = std::move(command.request);
            auto snapshot = std::move(command.snapshot);
            if (snapshot.frozen_market_targeted_close) {
                request.intent = native_order::HostSized{
                    native_order::HostSizedKind::Close, std::nullopt};
                request.owner = owner_for_close(snapshot.from_entry, true);
                snapshot.deferred_cohort = true;
                snapshot.frozen_market_targeted_close = false;
                snapshot.frozen_market_instruction = false;
            } else {
                snapshot.frozen_market_instruction = false;
            }
            const auto accepted = submit_or_replace(
                std::move(request), std::move(snapshot), command.opening,
                command.replacement_key);
            apply_known_reversal_gap(accepted);
        }
        return;
    }
 
    // Legacy `finalize_same_bar_market_tx_book` retains command order within
    // each broker-side pass but moves every BUY member before every SELL
    // member.  The generic request core keeps submission order on an equal
    // point, so materialising the source batch in that order is sufficient
    // and does not add a source branch to generic matching.
    const bool cap_close_continuation =
        cap.configuration().count_pooc_full_close && queued.size() == 2U
        && std::count_if(queued.begin(), queued.end(), [](const auto& command) {
            return command.snapshot.frozen_market_targeted_close;
        }) == 1;
    // A single command keeps its place; std::stable_sort would still take a
    // temporary buffer and move the command through it and back.
    if (queued.size() > 1) {
        std::stable_sort(queued.begin(), queued.end(), [&](const PendingSameBarCommand& left,
                                                           const PendingSameBarCommand& right) {
            const auto buy_rank = [](const PendingSameBarCommand& command) {
                if (command.snapshot.frozen_market_targeted_close)
                    return command.snapshot.frozen_market_target_was_long ? 1 : 0;
                return command.snapshot.is_long ? 0 : 1;
            };
            const int left_rank = buy_rank(left);
            const int right_rank = buy_rank(right);
            if (left_rank != right_rank) return left_rank < right_rank;
            if (cap_close_continuation
                && left.snapshot.frozen_market_targeted_close
                    != right.snapshot.frozen_market_targeted_close) {
                return left.snapshot.frozen_market_targeted_close;
            }
            return false;
        });
    }
 
    const bool single_entry = queued.size() == 1
        && !queued.front().snapshot.frozen_market_targeted_close;
    const bool one_entry_one_close = queued.size() == 2U
        && std::count_if(queued.begin(), queued.end(), [](const auto& command) {
            return command.opening && !command.snapshot.frozen_market_targeted_close;
        }) == 1
        && std::count_if(queued.begin(), queued.end(), [](const auto& command) {
            return command.snapshot.frozen_market_targeted_close;
        }) == 1;
    double simulated = batch_start;
    std::optional<native_order::RequestHandle> short_seed_long;
    std::optional<native_order::RequestHandle> short_seed_materialize;
    std::optional<native_order::RequestHandle> short_seed_final;
    std::optional<native_order::RequestHandle> cap_close_parent;
    for (std::size_t i = 0; i < queued.size(); ++i) {
        auto& command = queued[i];
        auto request = std::move(command.request);
        const bool targeted_close = command.snapshot.frozen_market_targeted_close;
        auto snapshot = std::move(command.snapshot);
        bool opening = command.opening;
        const bool long_candidate = batch_start < 0.0 && opening
            && snapshot.family == PineOrderFamily::Entry && snapshot.is_long;
        const bool final_short_candidate = batch_start < 0.0 && opening
            && snapshot.family == PineOrderFamily::Entry && !snapshot.is_long;
        const bool materialize_candidate = batch_start < 0.0
            && snapshot.frozen_market_targeted_close
            && !snapshot.frozen_market_target_was_long;
 
        if (!snapshot.frozen_market_targeted_close) {
            double units = snapshot.frozen_market_transaction_units;
            if (cap_close_continuation && simulated == 0.0
                && finite_positive(snapshot.frozen_market_own_units)) {
                units = snapshot.frozen_market_own_units;
            }
            if (!finite_positive(units)) continue;
            if (p2_explicit_pair
                && units > snapshot.frozen_market_own_units + 1e-10) {
                const double margin = snapshot.is_long
                    ? config_.margin_long : config_.margin_short;
                const double required = units * snapshot.sizing.price
                    * staged_.syminfo.pointvalue * snapshot.sizing.fx
                    * margin / 100.0;
                if (!std::isfinite(required) || !std::isfinite(snapshot.sizing.equity)
                    || required > snapshot.sizing.equity) {
                    continue;
                }
            }
            if (single_entry && !fixed_unmargined_market_batch_scope()) {
                const auto accepted = submit_or_replace(std::move(request), std::move(snapshot), opening,
                                                        command.replacement_key);
                apply_known_reversal_gap(accepted);
                if (accepted && long_candidate) short_seed_long = *accepted;
                if (accepted && final_short_candidate) short_seed_final = *accepted;
                continue;
            }
            const bool affordability_reversal = snapshot.affordability_policy_active
                && batch_start != 0.0
                && ((batch_start > 0.0) != snapshot.is_long)
                && (snapshot.affordability_close_only || one_entry_one_close);
            if (affordability_reversal) {
                request.intent = native_order::HostSized{
                    native_order::HostSizedKind::Open,
                    snapshot.is_long ? native_order::Side::Long
                                     : native_order::Side::Short};
            } else {
                request.intent = native_order::Transact{
                    snapshot.is_long ? units : -units};
            }
            simulated += snapshot.is_long ? units : -units;
        } else {
            const double target = snapshot.requested_qty;
            if (!finite_positive(target) || simulated == 0.0) continue;
            const bool target_long = snapshot.frozen_market_target_was_long;
            const bool still_target_side = (simulated > 0.0) == target_long;
            const double units = std::min(target, std::abs(simulated));
            if (!finite_positive(units)) continue;
            if (still_target_side) {
                request.intent = cap_close_continuation
                    && units >= std::abs(simulated) - 1e-10
                    ? native_order::OrderIntent{native_order::Flatten{}}
                    : native_order::OrderIntent{native_order::Reduce{
                        native_order::ExplicitUnits{units}}};
                simulated += simulated > 0.0 ? -units : units;
            } else {
                // A default-FIFO close whose original side was consumed may
                // become the legacy artifact only when its same-id frozen
                // MARKET entry is still later in the sorted broker pass.
                bool artifact = false;
                for (std::size_t later = i + 1; later < queued.size(); ++later) {
                    const auto& sibling = queued[later];
                    if (!sibling.snapshot.frozen_market_targeted_close
                        && sibling.snapshot.frozen_market_instruction
                        && sibling.snapshot.source_id == snapshot.source_id
                        && sibling.snapshot.is_long == target_long) {
                        artifact = true;
                        break;
                    }
                }
                if (!artifact) continue;
                const double signed_units = simulated > 0.0 ? units : -units;
                request.intent = native_order::Transact{signed_units};
                simulated += signed_units;
                // This is a broker-created artifact lot carrying the close
                // label, not a new source-id cohort member.
                opening = false;
            }
        }
        if (cap_close_continuation && opening && cap_close_parent)
            request.owner = native_order::WaitForApplied{*cap_close_parent};
        const auto accepted = submit_or_replace(std::move(request), std::move(snapshot), opening,
                                                command.replacement_key);
        if (accepted && targeted_close)
            cap_close_parent = *accepted;
        apply_known_reversal_gap(accepted);
        if (accepted && long_candidate) short_seed_long = *accepted;
        if (accepted && materialize_candidate) short_seed_materialize = *accepted;
        if (accepted && final_short_candidate) short_seed_final = *accepted;
    }
    if (short_seed_long && short_seed_materialize && short_seed_final) {
        const auto materialize_snapshot = placement_.find(short_seed_materialize->incarnation);
        const auto long_snapshot = placement_.find(short_seed_long->incarnation);
        const auto final_snapshot = placement_.find(short_seed_final->incarnation);
        if (materialize_snapshot != placement_.end() && long_snapshot != placement_.end()
            && final_snapshot != placement_.end()) {
            ShortSeedPlan plan;
            plan.long_entry = *short_seed_long;
            plan.materialize_long = *short_seed_materialize;
            plan.final_short = *short_seed_final;
            plan.seed_id = materialize_snapshot->second.source_id;
            plan.long_entry_id = long_snapshot->second.source_id;
            plan.final_short_id = final_snapshot->second.source_id;
            plan.materialize_label = "__close__" + plan.seed_id;
            plan.seed_qty = std::abs(batch_start);
            plan.seed_cycle = current_position_cycle_;
            pending_short_seed_ = {std::move(plan), broker_open_epoch_ + 1U, true};
            // This immutable receipt is available to the fixture's historical
            // handle probe even when a finite run ends before the next broker
            // open.  PendingIntentView still exposes roles only after the
            // next-open live qualification below.
            short_seed_ = pending_short_seed_.plan;
            maybe_activate_short_seed_plan();
        }
    }
}
 
void PineExecutionAdapter::materialize_relative_exits(
        PlacementSnapshot opening, const native_order::ExecutionAppliedEvent& event) {
    if (pending_relative_exits_.empty() || !finite_positive(staged_.syminfo.mintick)) {
        // No queued definition is served by this fill, so no child the
        // kernel armed on it has a source request to become.
        withdraw_anchored_relative_legs(nullptr, &opening.source_id);
        return;
    }
    std::vector<PendingRelativeExit> pending;
    std::vector<PendingRelativeExit> global_pending;
    // An unnamed relative exit binds to the first market opening after its call,
    // unless the call was void (made flat with no entry order working): the flag is
    // kept on the definition because the shadow rows of the calling execution are
    // gone when the entry fills. Not under calc_on_order_fills: no tape covers it.
    const bool market_opening = !config_.calc_on_order_fills
        && !finite_positive(opening.exit_levels.limit) && !finite_positive(opening.exit_levels.stop);
    for (auto it = pending_relative_exits_.begin(); it != pending_relative_exits_.end();) {
        if (it->from_entry == opening.source_id) {
            pending.push_back(std::move(*it));
            it = pending_relative_exits_.erase(it);
        } else if (market_opening && it->from_entry.empty() && !it->void_global) {
            global_pending.push_back(std::move(*it));
            it = pending_relative_exits_.erase(it);
        } else {
            ++it;
        }
    }
    // Decided once for the whole parent: either every armed child is the
    // request this fill point submits, or all of them leave first and the
    // re-run below is the unchanged source pipeline.
    if (!armed_relative_legs_adoptable(opening, event, pending))
        withdraw_anchored_relative_legs(nullptr, &opening.source_id);
    for (auto& value : global_pending) pending.push_back(std::move(value));
    const double tick = staged_.syminfo.mintick;
    for (const auto& value : pending) {
        double limit = kNaN;
        double stop = kNaN;
        double offset = value.trail_offset;
        // `ticks` from the parent's fill, snapped to the grid on the side that
        // keeps the level at least that far away (the kernel's Directional
        // anchor rounding spells the same ladder point for an armed child).
        const double side = opening.is_long ? 1.0 : -1.0;
        if (finite_positive(value.profit_ticks)) {
            limit = directional_tick(event.resolved_price + side * value.profit_ticks * tick,
                                     tick, opening.is_long);
            if (std::isfinite(event.resolved_price) && !std::isfinite(limit)) {
                engine_command_value_invalid_or_count("relative_price.level",
                    EngineValueStage::relative_price, EngineValueReason::numeric_overflow);
            }
        }
        if (finite_positive(value.loss_ticks)) {
            stop = directional_tick(event.resolved_price - side * value.loss_ticks * tick,
                                    tick, !opening.is_long);
            if (std::isfinite(event.resolved_price) && !std::isfinite(stop)) {
                engine_command_value_invalid_or_count("relative_price.level",
                    EngineValueStage::relative_price, EngineValueReason::numeric_overflow);
            }
        }
        // An omitted trail_offset is a one-shot activation leg in Pine.  Do
        // not synthesize a trailing distance from trail_points here; an
        // explicit zero/sub-tick offset remains distinguishable and is
        // lowered by exit()'s native sentinel policy.
        materializing_relative_ = true;
        materializing_parent_ = event.handle();
        try {
            exit(value.exit_id, value.from_entry, limit, stop, value.trail_points, offset,
                 value.trail_price, value.qty_percent, value.comment, value.qty, value.oca_name,
                 value.from_entry.empty() ? value.profit_ticks : kNaN,
                 value.from_entry.empty() ? value.loss_ticks : kNaN);
        } catch (...) {
            materializing_relative_ = false;
            materializing_parent_ = {};
            throw;
        }
        materializing_relative_ = false;
        materializing_parent_ = {};
    }
    // Structural, not counted: no child armed on this parent outlives the
    // parent's own fill notification. One the re-run did not adopt is not the
    // request this fill point asks for (another trigger, a staged or refused
    // leg), the source pipeline above already did what it does, and a kernel
    // request without a placement row must never reach a match.
    withdraw_anchored_relative_legs(nullptr, &opening.source_id);
}
 
void PineExecutionAdapter::withdraw_anchored_relative_legs(
        const SourceId* exit_id, const SourceId* from_entry) {
    const SourceId empty;
    const auto exit_text = detail::exit_scratch_text(exit_id ? *exit_id : empty);
    const auto entry_text = detail::exit_scratch_text(from_entry ? *from_entry : empty);
    withdraw_anchored_relative_readers(exit_id ? &exit_text : nullptr,
                                      from_entry ? &entry_text : nullptr);
}
 
void PineExecutionAdapter::withdraw_anchored_relative_readers(
        const detail::ScratchByteSource* exit_id, const detail::ScratchByteSource* from_entry) {
    for (std::size_t index = 0; index < anchored_relative_legs_.size();) {
        const auto& leg = anchored_relative_legs_[index];
        if ((exit_id && !detail::exit_scratch_equal(
                detail::exit_scratch_text(leg.exit_id), *exit_id))
            || (from_entry && !detail::exit_scratch_equal(
                detail::exit_scratch_text(leg.from_entry), *from_entry))) {
            ++index;
            continue;
        }
        // Cancel first: a host that refuses the command throws, and the
        // record of a child that may still be live must survive that.
        const native_order::RequestHandle handle = leg.handle;
        (void)require_host().cancel(handle);
        anchored_relative_legs_.erase(anchored_relative_legs_.begin()
                                      + static_cast<std::ptrdiff_t>(index));
        ++anchored_relative_stats_.withdrawn;
    }
}
 
bool PineExecutionAdapter::anchorable_relative_exit(
        const PendingRelativeExit& value, native_order::RequestHandle& parent,
        bool& parent_long) const {
    // The kernel arms the child as a host-sized close of the book its
    // parent's fill leaves (NativeArmScope::Book), which is this adapter's
    // fill-point leg under the FIFO close rule. The ANY rule binds that leg
    // to the named cohort instead, a scope the arm does not spell; and an
    // explicit quantity is not born at the fill point at all -- exit() stages
    // it per origin (pending_bracket_legs_) and submits it at a later flush.
    if (value.from_entry.empty() || config_.close_entries_rule_any || !std::isnan(value.qty))
        return false;
    if (!finite_positive(staged_.syminfo.mintick)) return false;
    const auto staged_same_id = [&](const PlacementSnapshot& row) {
        return row.opening && row.source_id == value.from_entry;
    };
    for (const auto& row : pending_same_bar_commands_)
        if (staged_same_id(row.snapshot)) return false;
    for (const auto& row : pending_entries_)
        if (staged_same_id(row.snapshot)) return false;
    for (const auto& row : pending_coof_requests_)
        if (staged_same_id(row.snapshot)) return false;
    for (const auto& row : delayed_market_orders_)
        if (staged_same_id(row.snapshot)) return false;
    std::size_t parents = 0;
    native_order::RequestHandle only{};
    bool only_long = true;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end() || !found->second.opening
            || found->second.source_id != value.from_entry) {
            continue;
        }
        if (found->second.family != PineOrderFamily::Entry) return false;
        only = handle;
        only_long = found->second.is_long;
        ++parents;
    }
    if (parents != 1) return false;
    // A trailing offset of a tick or more is the one relative leg exit()
    // seeds: its running best starts AT the activation (Trail::best_seed), as
    // TradingView's does on 13 of 13 pending-entry tapes
    // (tests/test_pending_entry_trail_tapes.cpp). The anchored child cannot
    // carry that seed -- the kernel's FromOwnerFill anchor installs the arm
    // level alone -- and adopted, it rode from the raw arm print and exited 1
    // to 24 bars late. So the definition is not anchorable, and the parent's
    // fill point submits the seeded leg (the order-schedule correction).
    for (const auto& shape : relative_leg_shapes(value, only_long))
        if (std::holds_alternative<native_order::Trail>(shape.trigger)) return false;
    parent = only;
    parent_long = only_long;
    return true;
}
 
std::vector<PineExecutionAdapter::RelativeLegShape>
PineExecutionAdapter::relative_leg_shapes(const PendingRelativeExit& value,
                                          bool parent_long) const {
    // The legs exit() emits for the relative operands once they resolve, in
    // its own order (limit, stop, trail), each spelled as an anchored trigger:
    // the level placeholder the kernel fills at the arm and the signed tick
    // distance from the parent's fill.
    std::vector<RelativeLegShape> shapes;
    const double side = parent_long ? 1.0 : -1.0;
    if (finite_positive(value.profit_ticks)) {
        shapes.push_back({PineOrderFamily::ExitLimit, native_order::Limit{0.0},
                          side * value.profit_ticks, value.profit_ticks});
    }
    if (finite_positive(value.loss_ticks)) {
        shapes.push_back({PineOrderFamily::ExitStop, native_order::Stop{0.0},
                          -side * value.loss_ticks, value.loss_ticks});
    }
    if (std::isfinite(value.trail_points) && !finite_positive(value.trail_price)) {
        const double trail_ticks = source_trail_points_ticks(
            value.trail_points, staged_.syminfo.mintick);
        const bool has_offset = std::isfinite(value.trail_offset) && value.trail_offset >= 0.0;
        const double offset_ticks = has_offset ? std::floor(value.trail_offset) : kNaN;
        if (trail_ticks >= 1.0 && has_offset && offset_ticks >= 1.0) {
            // Never placed: exit() seeds this leg, which the anchored child
            // cannot carry, so anchorable_relative_exit refuses its definition.
            shapes.push_back({PineOrderFamily::ExitTrail,
                              native_order::Trail{0.0, 0.0,
                                                  native_order::TrailTicks{offset_ticks}},
                              side * trail_ticks, trail_ticks});
        } else if (trail_ticks >= 1.0 && (has_offset || !std::isfinite(value.trail_offset))) {
            // Omitted or explicit-zero offset: the one-shot activation touch,
            // a fill-through limit when the zero shape slips.
            shapes.push_back({PineOrderFamily::ExitTrail,
                              native_order::Limit{0.0, has_offset && config_.slippage > 0},
                              side * trail_ticks, trail_ticks});
        }
    }
    return shapes;
}
 
void PineExecutionAdapter::anchor_relative_exits() {
    if (anchored_relative_legs_.empty() && pending_relative_exits_.empty()) return;
    // An armed child is adopted or withdrawn inside its parent's own fill
    // notification. One that is still here was armed by a fill this adapter
    // never materialized, and a kernel request without a placement row must
    // never reach a match.
    for (std::size_t index = 0; index < anchored_relative_legs_.size();) {
        if (!anchored_relative_legs_[index].armed) { ++index; continue; }
        const SourceId exit_id = anchored_relative_legs_[index].exit_id;
        const SourceId from_entry = anchored_relative_legs_[index].from_entry;
        withdraw_anchored_relative_legs(&exit_id, &from_entry);
        index = 0;
    }
    // A child whose definition is gone waits for nothing.
    for (std::size_t index = 0; index < anchored_relative_legs_.size();) {
        const auto& leg = anchored_relative_legs_[index];
        const bool queued = std::any_of(
            pending_relative_exits_.begin(), pending_relative_exits_.end(),
            [&](const PendingRelativeExit& value) {
                return value.exit_id == leg.exit_id && value.from_entry == leg.from_entry;
            });
        if (queued) { ++index; continue; }
        const SourceId exit_id = leg.exit_id;
        const SourceId from_entry = leg.from_entry;
        withdraw_anchored_relative_legs(&exit_id, &from_entry);
        index = 0;
    }
    if (pending_relative_exits_.empty()) return;
    // One decision per parent id: the armed children of a fill are adopted
    // together or not at all, so every queued exit of that id must be
    // expressible, or none is anchored and the fill point submits them all.
    std::vector<SourceId> parents;
    for (const auto& value : pending_relative_exits_) {
        if (std::find(parents.begin(), parents.end(), value.from_entry) == parents.end())
            parents.push_back(value.from_entry);
    }
    for (const auto& from_entry : parents) {
        native_order::RequestHandle parent{};
        bool parent_long = true;
        bool anchorable = true;
        for (const auto& value : pending_relative_exits_) {
            if (value.from_entry != from_entry) continue;
            anchorable = anchorable && anchorable_relative_exit(value, parent, parent_long);
        }
        const bool anchored = std::any_of(
            anchored_relative_legs_.begin(), anchored_relative_legs_.end(),
            [&](const AnchoredRelativeLeg& leg) { return leg.from_entry == from_entry; });
        if (anchored) {
            // A changed definition already withdrew its legs in exit(); what
            // is left here waits on this parent or on a parent that is gone.
            const bool complete = anchorable && std::all_of(
                pending_relative_exits_.begin(), pending_relative_exits_.end(),
                [&](const PendingRelativeExit& value) {
                    if (value.from_entry != from_entry) return true;
                    const auto shapes = relative_leg_shapes(value, parent_long);
                    const auto legs = static_cast<std::size_t>(std::count_if(
                        anchored_relative_legs_.begin(), anchored_relative_legs_.end(),
                        [&](const AnchoredRelativeLeg& leg) {
                            return leg.exit_id == value.exit_id
                                && leg.from_entry == from_entry && leg.parent == parent;
                        }));
                    return legs == shapes.size();
                });
            if (complete) continue;
            withdraw_anchored_relative_legs(nullptr, &from_entry);
        }
        if (!anchorable) continue;
        for (const auto& value : pending_relative_exits_) {
            if (value.from_entry != from_entry) continue;
            const SourceId group_name = value.oca_name.empty()
                ? value.exit_id + "\x1f" + value.from_entry : value.oca_name;
            for (auto& shape : relative_leg_shapes(value, parent_long)) {
                AnchoredRelativeLeg leg;
                leg.exit_id = value.exit_id;
                leg.from_entry = value.from_entry;
                leg.family = shape.family;
                leg.parent = parent;
                leg.parent_long = parent_long;
                leg.operand_ticks = shape.operand_ticks;
                leg.trail_offset = value.trail_offset;
                leg.request.intent = native_order::HostSized{
                    native_order::HostSizedKind::Close, std::nullopt};
                leg.request.label = value.exit_id;
                leg.request.comment = value.comment;
                leg.request.trigger = std::move(shape.trigger);
                // The leg exit() submits in the parent's fill callback is
                // born after the fill print and closes the book; so does this
                // child (AfterArmPrint, Book).
                leg.request.owner = native_order::WaitForApplied{
                    parent, native_order::NativeArmVisibility::PendingUntilArmed,
                    native_order::NativeArmFirstMatch::AfterArmPrint,
                    native_order::NativeArmScope::Book};
                leg.request.group = group_for(group_name, 1,
                                              static_cast<std::int64_t>(shape.family));
                if (auto* member = std::get_if<native_order::Member>(&leg.request.group)) {
                    // The kernel tells OCA siblings apart by cohort, so every
                    // member needs its own. A submitted sibling carries its
                    // source sequence (counting up from one); an anchored one
                    // counts down from minus one.
                    if (anchored_cohort_sequence_
                        == std::numeric_limits<std::int64_t>::max()) {
                        throw coded<std::overflow_error>(RunFailureCode::engine_invariant, {},
                            "Pine anchored OCA member sequence exhausted");
                    }
                    member->cohort = -(++anchored_cohort_sequence_);
                }
                leg.request.anchor = native_order::FromOwnerFill{
                    shape.signed_ticks, true, native_order::NativeAnchorRounding::Directional};
                const auto result = require_host().submit(leg.request);
                if (result.status != native_order::SubmitStatus::Accepted || !result.handle)
                    continue;
                leg.handle = *result.handle;
                anchored_relative_legs_.push_back(std::move(leg));
                ++anchored_relative_stats_.anchored;
            }
        }
    }
}
 
bool PineExecutionAdapter::armed_relative_legs_adoptable(
        const PlacementSnapshot& opening, const native_order::ExecutionAppliedEvent& event,
        const std::vector<PendingRelativeExit>& pending) const {
    // The fill-point re-run submits exactly the queued legs, at once, only
    // when nothing it would stage them behind is waiting.
    if (!pending_entries_.empty() || !pending_same_bar_commands_.empty()
        || !delayed_market_orders_.empty() || !pending_coof_requests_.empty()
        || coof_recalc_active_) {
        return false;
    }
    // Leg for leg: every shape of every queued definition has its own armed
    // child on this parent, and this parent carries no other child.
    std::size_t expected = 0;
    for (const auto& value : pending) {
        for (const auto& shape : relative_leg_shapes(value, opening.is_long)) {
            const auto children = std::count_if(
                anchored_relative_legs_.begin(), anchored_relative_legs_.end(),
                [&](const AnchoredRelativeLeg& leg) {
                    return leg.exit_id == value.exit_id && leg.from_entry == value.from_entry
                        && leg.family == shape.family
                        && leg.request.trigger.index() == shape.trigger.index();
                });
            if (children != 1) return false;
            ++expected;
        }
    }
    std::size_t armed = 0;
    for (const auto& leg : anchored_relative_legs_) {
        if (leg.from_entry != opening.source_id) continue;
        if (leg.parent != event.handle() || !leg.armed || leg.parent_long != opening.is_long
            || !std::isfinite(leg.installed_level)) {
            return false;
        }
        ++armed;
    }
    return armed == expected && armed != 0;
}
 
namespace {
// resting_limit_tick_reach's scope (exit_limit_trigger): an on-grid limit
// under calc_on_order_fills rests at its tick-built threshold only here.
bool resting_limit_tick_reach(const NativeStrategyHost* host, double threshold,
                              bool exit_is_buy) noexcept {
    if (!host || !detail::pine_callback_lifecycle_rule(
                     detail::PineCallbackLifecycleRule::RestingLimitTickReach)) {
        return false;
    }
    // The threshold sits half a tick toward the side the leg closes, so it
    // holds only for the position held now: a leg placed for a parent not held
    // on that side keeps the raw level, which reads the same from either side.
    // Held the other way, the threshold would take the pending parent's side.
    // Placed flat, the leg is re-armed at its parent's opening, where this is
    // decided again with the side known.
    const double held = detail::run_position(*host).signed_units;
    if (held == 0.0 || (held < 0.0) != exit_is_buy) return false;
    // Pinned on the chart path, as the in-flight reach is (exit()); a
    // magnifier's intrabars keep the raw level.
    const auto native = detail::run_state(*host);
    if (native.spec && !native.spec->intrabar.is_none()) return false;
    // A limit the point it is placed at already reaches is decided there by
    // the raw level, as before. For a point that stands on the raw level the
    // matcher books the level at that point, while a threshold the point has
    // passed would wait for the next one. A point that is a fill booked at the
    // print of a half-tick-short open is not on the raw path, which then never
    // reaches the level; TradingView fills such a limit at once
    // (callback_lifecycle repeated-rounded, its trades 18-19, recorded).
    const auto* point = detail::callback_point(*host);
    if (point && finite_positive(point->price)
        && (exit_is_buy ? point->price <= threshold : point->price >= threshold)) {
        return false;
    }
    return true;
}
} // namespace
 
double PineExecutionAdapter::exit_limit_trigger(double limit_price, double tick,
                                                bool exit_is_buy) const noexcept {
    // ab9714be pine_policy_members.cpp:11-17 + engine.hpp:1374-1381: an
    // exit limit is tested against the tick-quantized bar, so an ON-grid
    // level is reached by a raw extreme half a tick short of it (NYSE:F
    // synthetic high 25.045 -> 25.05 fills a 25.05 sell limit).  Under
    // calc_on_order_fills an on-grid level stays raw, except for a limit
    // left resting on the chart path that closes the position held when it
    // is placed (resting_limit_tick_reach): a synthetic 25.05 sell limit born in the
    // opening fill's recalculation fills on that bar, whose H of 25.045
    // prints 25.05 (`lab tv` synthetics tests/fixtures/callback_lifecycle
    // newborn-limit-*, NYSE:F 15m, 4 identical exports each).
    if (!finite_positive(tick)) return limit_price;
    const double threshold = source_trigger_threshold(limit_price, tick, exit_is_buy, true);
    if (config_.calc_on_order_fills && nearest_tick(limit_price, tick) == limit_price
        && !resting_limit_tick_reach(host_, threshold, exit_is_buy)) {
        return limit_price;
    }
    return threshold;
}
 
double PineExecutionAdapter::one_shot_trail_trigger(double activation, double source_trail_offset,
                                                    double tick, bool exit_is_buy,
                                                    bool quantized_activation) const noexcept {
    double one_shot_level = activation;
    if (!std::isfinite(source_trail_offset)) {
        const double slipped = one_shot_level
            + (exit_is_buy ? 1.0 : -1.0) * config_.slippage * tick;
        one_shot_level = directional_tick(slipped, tick, exit_is_buy);
    }
    // A sell one-shot keeps the k / (1 / mintick) grid spelling so a
    // chart print sitting exactly on the activation satisfies the
    // generic `print >= level` bit-for-bit.  A buy one-shot keeps the
    // directional k * mintick spelling instead: ab9714be books the
    // crossed activation as a TRAIL event (engine_path_resolve.cpp:
    // 984-987, fill.is_limit = false), so apply_slippage snaps it
    // with round_to_mintick_directional, which materializes that same
    // product, and the immutable generic buy limit accepts it because
    // fill <= level holds by construction.  Re-spelling the buy level
    // onto the division grid handed back a value one binary64 ULP
    // away from the owner's fill and that ULP rode the equity path
    // into printed PnL
    // (a synthetic illustration of the one-shot trailing-stop rule:
    // tick count 115 at tick 0.01 gives the product 1.1500000000000001,
    // while the division grid re-spells it as 1.15).
    // ab9714be pine_fills.cpp:4607-4610: snap_trail_level_to_tick_grid
    // aligns the trail level to the tick grid (sell one-shot).
    if (!exit_is_buy) one_shot_level = source_level_on_price_grid(one_shot_level, tick);
    // ab9714be engine_path_resolve.cpp:297-308 and 746-766: an
    // omitted-offset trail's dormant activation is reached on the
    // tick-quantized path (design-trail-activation-tick-bar), so a
    // raw extreme half a tick short of the level already fires it.
    // Only the arm threshold moves; settlement books the source
    // level (source_trail_one_shot_fill).
    // ab9714be engine_path_resolve.cpp:292-308 + 746-766 test the
    // explicit-zero trail's dormant activation on the same
    // tick-quantized path, so its arm threshold is the same half-up
    // projection boundary: a buy one-shot is reached only strictly
    // below activation + half a tick (synthetic NYSE:F low
    // 25.005 prints 25.01 and does not reach the 25.00 activation).
    if (quantized_activation && finite_positive(tick)) {
        one_shot_level = source_trigger_threshold(one_shot_level, tick, exit_is_buy, true);
    }
    return one_shot_level;
}
 
std::optional<double> PineExecutionAdapter::resolve_anchored_level(
        const NativeAnchoredLevelView& view) const {
    const auto found = std::find_if(
        anchored_relative_legs_.begin(), anchored_relative_legs_.end(),
        [&](const AnchoredRelativeLeg& leg) { return leg.handle == view.leg; });
    if (found == anchored_relative_legs_.end()) return std::nullopt;
    auto& leg = *found;
    const double tick = staged_.syminfo.mintick;
    leg.armed = true;
    leg.installed_level = kNaN;
    // Without a usable tick there is no projection to restate; the kernel
    // keeps its own level and the fill point withdraws the child.
    if (!finite_positive(tick)) return std::nullopt;
    // The kernel owns the fill-relative arithmetic: view.kernel_level is
    // fill + ticks on the tick ladder (FromOwnerFill, Directional), the very
    // ladder point materialize_relative_exits hands the fill-point exit().
    // What stays here is TradingView's spelling of that point and its
    // trigger projection, shared with exit().
    const bool exit_is_buy = !leg.parent_long;
    double installed = kNaN;
    if (leg.family == PineOrderFamily::ExitLimit) {
        installed = exit_limit_trigger(
            source_level_on_price_grid(view.kernel_level, tick), tick, exit_is_buy);
    } else if (leg.family == PineOrderFamily::ExitStop) {
        installed = source_trigger_threshold(
            source_level_on_price_grid(view.kernel_level, tick), tick, exit_is_buy, false);
    } else {
        const double trail_price = directional_tick(view.kernel_level, tick, leg.parent_long);
        installed = std::holds_alternative<native_order::Trail>(leg.request.trigger)
            ? source_trail_arm_level(trail_price, tick, exit_is_buy)
            : one_shot_trail_trigger(trail_price, leg.trail_offset, tick, exit_is_buy, true);
    }
    // The kernel refuses a level its trigger cannot hold and fails the run.
    // A projection that lands there (a short's relative level below zero) is
    // never the request the fill-point re-run submits, so the child is armed
    // on a representable placeholder. That is safe for one reason only: its
    // NaN installed level makes it unadoptable, and materialize_relative_exits
    // withdraws every unadopted child inside this same fill notification,
    // before the path resumes.
    const bool trail_arm = std::holds_alternative<native_order::Trail>(leg.request.trigger);
    if (!(trail_arm ? finite_positive(installed) : finite_non_negative(installed))) {
        leg.installed_level = kNaN;
        return tick;
    }
    leg.installed_level = installed;
    return installed;
}
 
void PineExecutionAdapter::exit_cancel_bracket(const SourceId& exit_id,
                                               const SourceId& from_entry,
                                               const std::string&) {
    reroute_fixed_entries_before_request();
    const auto key = key_for(exit_id, from_entry);
    pending_relative_exits_.erase(std::remove_if(pending_relative_exits_.begin(), pending_relative_exits_.end(),
        [&](const PendingRelativeExit& value) {
            return value.exit_id == exit_id && value.from_entry == from_entry;
        }), pending_relative_exits_.end());
    if (!materializing_relative_) withdraw_anchored_relative_legs(&exit_id, &from_entry);
    pending_write(pending_bracket_legs_).erase(std::remove_if(pending_bracket_legs_.begin(), pending_bracket_legs_.end(),
        [&](const PendingBracketLeg& leg) { return leg.family_key == key; }), pending_bracket_legs_.end());
    // Cancellation can synchronously change source state. Copy the family
    // roster and release the map iterator before issuing any host operation.
    std::vector<native_order::RequestHandle> handles;
    std::size_t settled = 0;
    native_order::RunIdentity settled_run{};
    bool found_family = false;
    if (const auto found = bracket_families_.find(key); found != bracket_families_.end()) {
        handles = found->second.members();
        settled = found->second.settled_count();
        settled_run = found->second.run_identity();
        bracket_families_.erase(found);
        found_family = true;
    } else if (const auto archived = settled_bracket_families_.find(key);
               archived != settled_bracket_families_.end()) {
        settled = archived->second.count;
        settled_run = archived->second.run;
        settled_bracket_digest_ ^= settled_bracket_hash(key, archived->second);
        settled_bracket_families_.erase(archived);
        found_family = true;
    }
    if (!found_family) return;
    // Source bracket-cancel target contract (L19h). The pin below covers the
    // non-working tail, archived prefix, and mixed filled/live rosters.
    // Every non-working member, including the settled prefix, records one
    // NotWorking outcome targeting same-run UINT64_MAX in roster order.
    // Settled members retain only count/digest state, so normalize the tail: the
    // recorded target must not depend on placement-retirement timing.
    // Working members still target their own handles. Pinned by
    // test_bracket_cancel_not_working_target; no hash domain is changed.
    constexpr std::uint64_t kNeverIssued = std::numeric_limits<std::uint64_t>::max();
    for (std::size_t index = 0; index < settled; ++index)
        (void)require_host().cancel(native_order::RequestHandle{settled_run, kNeverIssued});
    IExecutionConsumer* consumer = bound_consumer();
    for (const auto& handle : handles) {
        const bool working = consumer == nullptr
            || as_native_consumer(*consumer).request_core().find_live(handle) != nullptr;
        const auto target = working ? handle
            : native_order::RequestHandle{handle.run, kNeverIssued};
        const auto result = require_host().cancel(target);
        if (result.status == native_order::CancelStatus::Cancelled) retire(handle);
    }
}
 
void PineExecutionAdapter::cancel(const SourceId& id) {
    reroute_fixed_entries_before_request();
    stash_id_bound_exits(id);
    if (PF_RARE(!id_bound_exits_.empty())) {
        id_bound_exits_.erase(std::remove_if(id_bound_exits_.begin(), id_bound_exits_.end(),
            [&](const IdBoundExit& row) { return row.exit_id == id; }), id_bound_exits_.end());
    }
    NamedEntryCancelToken token;
    for (const auto& handle : live_handles_) {
        const auto snapshot = placement_.find(handle.incarnation);
        if (snapshot == placement_.end()) continue;
        const auto family = snapshot->second.family;
        if (family == PineOrderFamily::Entry && snapshot->second.source_id == id) {
            token.entry_incarnation = handle.incarnation;
        } else if ((family == PineOrderFamily::ExitLimit || family == PineOrderFamily::ExitStop
                    || family == PineOrderFamily::ExitTrail)
                   && snapshot->second.from_entry == id
                   && token.surviving_exit_incarnation == 0) {
            token.surviving_exit_incarnation = handle.incarnation;
        }
    }
    if (token.entry_incarnation != 0) named_entry_cancel_tokens_[id] = token;
    else named_entry_cancel_tokens_.erase(id);
    const auto same_bar_before = pending_same_bar_commands_.size();
    pending_write(pending_same_bar_commands_).erase(std::remove_if(pending_same_bar_commands_.begin(),
        pending_same_bar_commands_.end(), [&](const PendingSameBarCommand& command) {
            return command.snapshot.source_id == id;
        }), pending_same_bar_commands_.end());
    if (pending_same_bar_commands_.size() != same_bar_before)
        source_batch_mutated_ = true;
    pending_same_bar_close_qty_ = 0.0;
    for (const auto& command : pending_same_bar_commands_) {
        if (command.snapshot.frozen_market_targeted_close)
            pending_same_bar_close_qty_ += command.snapshot.requested_qty;
    }
    pending_relative_exits_.erase(std::remove_if(pending_relative_exits_.begin(), pending_relative_exits_.end(),
        [&](const PendingRelativeExit& value) { return value.exit_id == id || value.from_entry == id; }),
        pending_relative_exits_.end());
    withdraw_anchored_relative_legs(&id, nullptr);
    withdraw_anchored_relative_legs(nullptr, &id);
    pending_write(pending_entries_).erase(std::remove_if(pending_entries_.begin(), pending_entries_.end(),
        [&](const PendingEntry& entry) { return entry.snapshot.source_id == id; }), pending_entries_.end());
    pending_write(pending_bracket_legs_).erase(std::remove_if(pending_bracket_legs_.begin(), pending_bracket_legs_.end(),
        [&](const PendingBracketLeg& leg) { return leg.snapshot.source_id == id; }),
        pending_bracket_legs_.end());
    // A gapped stop waiting for a margin-call revival is withdrawn with the
    // rest of the id (retire_cancelled_exits).
    pending_margin_revivals_.erase(std::remove_if(pending_margin_revivals_.begin(),
        pending_margin_revivals_.end(), [&](const PendingMarginRevival& revival) {
            return revival.snapshot.source_id == id;
        }), pending_margin_revivals_.end());
    std::vector<native_order::RequestHandle> matches;
    for (const auto& handle : live_handles_) {
        const auto snapshot = placement_.find(handle.incarnation);
        if (snapshot != placement_.end() && snapshot->second.source_id == id
            && !coof_leg_reaches_exit(snapshot->second)) {
            matches.push_back(handle);
        }
    }
    std::vector<std::pair<std::uint64_t, std::uint64_t>> cancelled;
    for (const auto& handle : matches) {
        const auto result = require_host().cancel(handle);
        if (result.status == native_order::CancelStatus::Cancelled) {
            retire(handle);
            cancelled.emplace_back(handle.incarnation, result.event_ordinal);
        }
    }
    retire_cancelled_exits(&id, cancelled);
    // A cancelled exit's entry brackets went with its orders above.
    per_entry_exits_.erase(std::remove_if(per_entry_exits_.begin(), per_entry_exits_.end(),
        [&](const PerEntryExit& exit) { return exit.exit_id == id; }), per_entry_exits_.end());
}
 
void PineExecutionAdapter::cancel_all() {
    reroute_fixed_entries_before_request();
    id_bound_exits_.clear();
    // The margin call a breach at this bar's close owes is an order the
    // script's cancel_all() withdraws too (close_point_margin_call).
    if (const auto point = detail::callback_point(require_host()))
        close_margin_cancelled_bar_ = point->decision.script_bar_open_ms;
    const auto handles = live_handles_;
    std::vector<std::pair<std::uint64_t, std::uint64_t>> cancelled;
    for (const auto& handle : handles) {
        const auto row = placement_.find(handle.incarnation);
        if (row != placement_.end() && coof_leg_reaches_exit(row->second)) continue;
        const auto result = require_host().cancel(handle);
        if (result.status == native_order::CancelStatus::Cancelled) {
            retire(handle);
            cancelled.emplace_back(handle.incarnation, result.event_ordinal);
        }
    }
    retire_cancelled_exits(nullptr, cancelled);
    pending_margin_revivals_.clear();
    clear_bracket_families();
    pending_write(pending_bracket_legs_).clear();
    pending_write(pending_entries_).clear();
    delayed_market_orders_.clear();
    deferred_open_marketable_sells_.clear();
    throttled_reopen_rearm_.clear();
    pending_write(pending_same_bar_commands_).clear();
    pending_same_bar_close_qty_ = 0.0;
    pending_relative_exits_.clear();
    withdraw_anchored_relative_legs(nullptr, nullptr);
    per_entry_exits_.clear();
}
 
void PineExecutionAdapter::order(const SourceId& id, bool is_long, double qty,
                                 double limit_price, double stop_price,
                                 const std::string& oca_name, int oca_type) {
    if (intraday_loss_orders_blocked()) return;
    if (const auto point = detail::callback_point(require_host());
        point && cap_placement_denied(point->decision)) {
        return;
    }
    require_cohort_ticket(&id);
    reroute_fixed_entries_before_request();
    // ab9714be pine_strategy_commands.cpp:2120-2203: strategy.order appends to pending book after earlier script commands
    if (!pending_same_bar_commands_.empty()) {
        source_batch_mutated_ = true;
        flush_pending_same_bar_commands();
    }
    // ab9714be pine_strategy_commands.cpp:2120-2203: strategy.order commits after preceding pending entries in source order
    if (!pending_entries_.empty()) {
        flush_pending_entries();
    }
    if (id == "__close__") {
        const auto point = detail::callback_point(require_host());
        std::vector<native_order::RequestHandle> replaced_close_all;
        for (const auto& handle : live_handles_) {
            const auto found = placement_.find(handle.incarnation);
            if (found != placement_.end()
                && found->second.family == PineOrderFamily::CloseAll
                && (!point || found->second.placement_script_open_ms
                    == point->decision.script_bar_open_ms)) {
                replaced_close_all.push_back(handle);
            }
        }
        for (const auto& handle : replaced_close_all) {
            const auto result = require_host().cancel(handle);
            if (result.status != native_order::CancelStatus::Cancelled) continue;
            for (auto row : placement_) {
                if (row.second.preserved_by_close_all == handle) {
                    row.second.preserved_by_close_all = {}; invalidate_retirement();
                    row.second.preserved_close_all_bar = -1;
                }
            }
            retire(handle);
        }
    }
    if (has_live_exit_policy()) for (const auto& handle : live_handles_) {
        const auto existing = placement_.find(handle.incarnation);
        if (existing != placement_.end()
            && existing->second.pooc_global_full_exit_dynamic_qty) {
            existing->second.pooc_global_full_exit_dynamic_qty = false;
            existing->second.pooc_global_full_exit_tracks_bound_adds = false;
        }
    }
    native_order::Request request;
    double risk_coof_forced_price = kNaN;
    double coof_market_fill = kNaN;
    bool delay_after_default_pair = false;
    limit_price = source_level_on_price_grid(
        limit_price, staged_.syminfo.mintick, value_field::order_limit_price);
    stop_price = source_level_on_price_grid(
        stop_price, staged_.syminfo.mintick, value_field::order_stop_price);
    const bool default_sized = std::isnan(qty);
    const double normalized_qty = default_sized ? qty
        : floor_quantity_grid(std::abs(qty), staged_.quantity_grid);
    // The CANCEL group is source-gated by its original requested quantity:
    // an opposite-side partial fill must not erase its sibling.  Resolve that
    // shape through host terms so the adapter can retain the source operand.
    // Existing explicit non-cancel RAW orders stay on the generic Transact
    // path, including native OCA-reduce's working-reservation semantics.
    request.intent = (default_sized || oca_type == 1)
        ? native_order::OrderIntent{native_order::HostSized{native_order::HostSizedKind::Open,
            is_long ? native_order::Side::Long : native_order::Side::Short}}
        : native_order::OrderIntent{native_order::Transact{is_long ? normalized_qty : -normalized_qty}};
    request.label = id;
    double native_limit = limit_price;
    double native_stop = stop_price;
    if (finite_positive(limit_price) && !finite_positive(stop_price)) {
        native_limit = source_trigger_threshold(
            limit_price, staged_.syminfo.mintick, is_long, true, value_field::order_limit_price);
    } else if (finite_positive(stop_price) && !finite_positive(limit_price)
               && !config_.calc_on_order_fills) {
        native_stop = source_trigger_threshold(
            stop_price, staged_.syminfo.mintick, is_long, false, value_field::order_stop_price);
    }
    request.trigger = trigger_for(native_limit, native_stop);
    if (coof_recalc_active_ && coof_first_open_) {
        const auto point = detail::callback_point(require_host());
        if (point && finite_positive(limit_price)
            && (is_long ? limit_price >= point->price
                        : limit_price <= point->price)) {
            coof_market_fill = source_bar_fill_tick(
                point->price, staged_.syminfo.mintick);
        }
    }
    if (std::holds_alternative<native_order::Market>(request.trigger)) {
        const auto point = detail::callback_point(require_host());
        if (coof_recalc_active_ && !coof_first_open_) {
            const double next_waypoint = coof_next_waypoint();
            const double current_quote = point ? point->price : kNaN;
            coof_market_fill = source_bar_fill_tick(
                next_waypoint, staged_.syminfo.mintick)
                + (is_long ? 1.0 : -1.0) * config_.slippage
                    * staged_.syminfo.mintick;
#ifdef PINEFORGE_VALUE_INVALID_FIXTURES
            coof_market_fill = fixture_adapter_execution_value("slippage.recalc.order", coof_market_fill);
#endif
            check_slippage_fill_price(coof_market_fill, std::isfinite(next_waypoint));
            if (finite_positive(next_waypoint) && finite_positive(current_quote)
                && !source_same_point(current_quote, next_waypoint, staged_.syminfo.mintick)) {
                const bool falling = next_waypoint < current_quote;
                if (is_long) {
                    request.trigger = falling
                        ? native_order::Trigger{native_order::Limit{next_waypoint}}
                        : native_order::Trigger{native_order::Stop{next_waypoint}};
                } else {
                    request.trigger = falling
                        ? native_order::Trigger{native_order::Stop{next_waypoint}}
                        : native_order::Trigger{native_order::Limit{next_waypoint}};
                }
            }
        }
        if (coof_recalc_active_ && !coof_first_open_
            && risk_.max_intraday_loss > 0.0) {
            double target = kNaN;
            if (point) {
                switch (point->decision.coordinate.path_phase) {
                case NativePathPhase::Open: {
                    const bool high_first = source_path_uses_high_first(coof_script_bar_);
                    target = high_first ? coof_script_bar_.high : coof_script_bar_.low;
                    break;
                }
                case NativePathPhase::High: target = coof_script_bar_.high; break;
                case NativePathPhase::Low: target = coof_script_bar_.low; break;
                default: break;
                }
                if (finite_positive(target)
                    && !source_same_point(point->price, target, staged_.syminfo.mintick)
                    && risk_coof_direct_script_bar_
                        != point->decision.script_bar_open_ms) {
                    risk_coof_forced_price = target;
                    risk_coof_direct_script_bar_ = point->decision.script_bar_open_ms;
                }
            }
        }
        std::vector<std::pair<std::uint64_t, native_order::RequestHandle>> same_bar_defaults;
        for (const auto& handle : live_handles_) {
            const auto pending = placement_.find(handle.incarnation);
            if (pending == placement_.end()) continue;
            const auto& row = pending->second;
            if (row.opening && row.family == PineOrderFamily::Entry
                && !std::isfinite(row.requested_qty)
                && (!point || row.placement_script_open_ms
                    == point->decision.script_bar_open_ms)
                && !finite_positive(row.exit_levels.limit)
                && !finite_positive(row.exit_levels.stop)) {
                same_bar_defaults.push_back({row.source_sequence, handle});
            }
        }
        if (same_bar_defaults.size() >= 2) {
            delay_after_default_pair = true;
        }
    }
    request.group = group_for(oca_name, oca_type);
    if (oca_type == 1) {
        // A Pine RAW cancel group fires only when the source request itself
        // completely fills. The generic request has no source requested-size
        // operand once an opposite close is bounded to live exposure, so the
        // adapter applies that source receipt from on_applied instead.
        request.group = native_order::NoGroup{};
    }
    if (default_sized && oca_type == 2) {
        if (auto* member = std::get_if<native_order::Member>(&request.group)) {
            // Pine's default-sized RAW sibling is cancelled after an OCA
            // reduce member fills; only an explicit quantity consumes the
            // group reduction as a residual working amount.
            member->effect = native_order::GroupEffect::Cancel;
        }
    }
    PlacementSnapshot snapshot;
    snapshot.family = PineOrderFamily::Order; snapshot.source_id = id; snapshot.oca_name = oca_name;
    snapshot.oca_type = oca_type;
    // strategy.order's source quantity is verbatim (unlike strategy.entry's
    // lot-grid floor); retain that literal in the adapter projection even
    // when the generic accepted request needs its separately normalized
    // executable operand.
    snapshot.requested_qty = qty;
    snapshot.is_long = is_long;
    snapshot.exit_levels.limit = limit_price;
    snapshot.exit_levels.stop = stop_price;
    snapshot.forced_execution_price = finite_positive(risk_coof_forced_price)
        ? risk_coof_forced_price : coof_market_fill;
    if (source_command_sequence_ == std::numeric_limits<std::uint64_t>::max()) {
        throw coded<std::overflow_error>(RunFailureCode::engine_invariant, {},
                                         "Pine source command sequence exhausted");
    }
    snapshot.command_sequence = ++source_command_sequence_;
    snapshot.sizing = sizing_snapshot();
    if (default_sized && finite_positive(snapshot.sizing.price)
        && (config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
            || config_.default_qty_type == static_cast<int>(QtyType::CASH))) {
        snapshot.sizing.frozen_units = default_sizing_units(snapshot.sizing);
        snapshot.sizing.at_fill = config_.calc_on_order_fills && coof_recalc_active_;
    }
    if (delay_after_default_pair) {
        if (broker_open_epoch_ == std::numeric_limits<std::uint64_t>::max())
            throw coded<std::overflow_error>(RunFailureCode::engine_invariant, {},
                                             "source delayed market epoch exhausted");
        if (const auto point = detail::callback_point(require_host())) {
            snapshot.projection_created_bar = projection_bar_index(point->decision);
            snapshot.placement_script_open_ms = point->decision.script_bar_open_ms;
            snapshot.placement_sub_open_ms = point->decision.sub_bar_open_ms;
        }
        snapshot.projection_position_side = static_cast<std::int32_t>(PositionSide::FLAT);
        delayed_market_orders_.push_back({std::move(request), std::move(snapshot), id,
                                          broker_open_epoch_ + 1U});
        return;
    }
    const auto accepted = submit_or_replace(std::move(request), std::move(snapshot), true, id);
    if (!accepted) return;
    const auto entry = placement_.find(accepted->incarnation);
    if (entry == placement_.end()) return;
    const std::uint64_t entry_sequence = entry->second.command_sequence;
    if (has_live_exit_policy()) for (const auto& handle : live_handles_) {
        if (handle == *accepted) continue;
        const auto existing = placement_.find(handle.incarnation);
        if (existing == placement_.end()) continue;
        auto& prior = existing->second;
        if (!prior.reservation_expansion.capture()
            || prior.command_sequence >= entry_sequence) {
            continue;
        }
        prior.pooc_global_full_exit_dynamic_qty = false;
        prior.pooc_global_full_exit_tracks_bound_adds = false;
        prior.reservation_expansion.close_population(accepted->incarnation);
    }
}
 
native_order::ExecutionTerms PineExecutionAdapter::resolve_terms(
        const NativeExecutionTermsFacts& facts) const {
    auto result = resolve_source_terms(facts);
    if (PF_RARE(close_call_after_script_bar_ != std::numeric_limits<std::int64_t>::min())) {
        const auto snapshot = placement_.find(facts.target.incarnation);
        if (snapshot != placement_.end())
            apply_frozen_reversal_close(snapshot->second, facts, result);
    }
    return result;
}
 
// A reversal strategy.entry the script placed at a close where a margin call
// was then booked after the script keeps the close quantity the script saw
// (switch frozen_reversal_close): at its fill it buys that quantity against
// the smaller book and the excess opens on the other side, its own open leg
// on top when that leg was affordable. Synthetic NYSE:F at slippage 1: a short of
// 400 shares that a reversal long of 700 (unaffordable) was placed against
// gives up 4 to a follow-up at the close; the next open closes 396 and
// opens a long of 4, and an affordable reversal of 50 opens 54 (lab tv tapes
// tests/fixtures/margin_schedule_rules frozen/; the analogous rule for a
// close_all).
void PineExecutionAdapter::apply_frozen_reversal_close(
        const PlacementSnapshot& source, const NativeExecutionTermsFacts& facts,
        native_order::ExecutionTerms& result) const {
    if (!detail::margin_schedule_switches().frozen_reversal_close
        || source.family != PineOrderFamily::Entry || !source.opening
        || source.placement_script_open_ms != close_call_after_script_bar_
        || !result.units || !std::isfinite(*result.units)
        || facts.position.signed_units == 0.0
        || (facts.position.signed_units > 0.0) == source.is_long
        || (result.shape != native_order::OpeningShape::CloseOpposite
            && result.shape != native_order::OpeningShape::ReverseTo)) {
        return;
    }
    const auto placed = static_cast<PositionSide>(source.projection_position_side);
    if (placed == PositionSide::FLAT || (placed == PositionSide::LONG) == source.is_long) return;
    const double frozen = close_call_after_script_book_;
    const double book = std::abs(facts.position.signed_units);
    const double guard = std::max(1e-9, frozen * 1e-12);
    // Only the book that call shrank: nothing else filled since.
    if (!finite_positive(frozen) || !(frozen > book + guard)
        || std::abs(frozen - close_call_after_script_units_ - book) > guard) {
        return;
    }
    const double own = result.shape == native_order::OpeningShape::ReverseTo ? *result.units : 0.0;
    result.units = frozen + own;
    result.shape = native_order::OpeningShape::Transact;
}
 
native_order::ExecutionTerms PineExecutionAdapter::resolve_source_terms(
        const NativeExecutionTermsFacts& facts) const {
    native_order::ExecutionTerms result{facts.default_resolved_price, std::nullopt,
                                        native_order::OpeningShape::Transact};
    const auto snapshot = placement_.find(facts.target.incarnation);
    if (snapshot == placement_.end()) {
        // R5: a kernel-originated liquidation carries no source placement row.
        // Its fill price is still TradingView's: the fire price it was rested
        // at, on the chart tick ladder, plus the EXIT side's own market
        // slippage (ab9714be pine_fills.cpp:1712-1726). A short's checkpoint
        // marked on the ladder, so its fire price is rounded there first.
        if (facts.definition
            && facts.definition->origin == native_order::RequestOrigin::KernelLiquidation) {
            double fire = facts.trigger_level ? *facts.trigger_level : facts.raw_price;
            if (facts.is_buy) fire = nearest_tick(fire, staged_.syminfo.mintick);
            if (finite_positive(fire))
                result.resolved_price = source_margin_fill_price(fire, facts.is_buy);
        }
        return result;
    }
    const auto& source = snapshot->second;
    // The already-armed explicit-zero trail's sibling generic stop (exit():
    // "A sibling generic stop preserves the next-open print decision") is the
    // same owner TRAIL leg (ab9714be engine_path_resolve.cpp:620-705,
    // try_exit_open_gap_fill), so it settles on the zero-offset trail policy.
    const bool zero_trail_sibling_stop = source.family == PineOrderFamily::ExitStop
        && !price_present(source.exit_levels.stop)
        && finite_positive(source.trail_activation_level);
    const bool explicit_zero_trail =
        (source.family == PineOrderFamily::ExitTrail || zero_trail_sibling_stop)
        && std::isfinite(source.exit_levels.trail_offset)
        && std::floor(source.exit_levels.trail_offset) == 0.0;
    const auto host_state = detail::run_state(require_host());
    const bool sampled_one_price_gap = host_state.spec
        && !host_state.spec->intrabar.is_none()
        && facts.cursor.point.provenance == NativePriceProvenance::ModeledOHLCOpen
        && facts.price_kind == native_order::NativeCandidatePriceKind::PointPrice;
    const bool trail_limit_one_shot = source.family == PineOrderFamily::ExitTrail
        && std::holds_alternative<native_order::Limit>(facts.definition->request.trigger);
    const auto* one_shot_rest = trail_limit_one_shot
        ? std::get_if<native_order::Limit>(&facts.definition->request.trigger) : nullptr;
    const auto* trail_active = std::get_if<native_order::TrailActive>(&facts.trigger_state);
    const auto retained_trail_source_price = [&]() -> std::optional<double> {
        // ab9714be engine_path_resolve.cpp:494-510: explicit zero trail rides running best and does not offset trigger level
        if (!std::isfinite(source.retained_trail_best)
            || !std::isfinite(source.exit_levels.trail_offset)
            || source.exit_levels.trail_offset < 0.0
            || explicit_zero_trail
            || !finite_positive(staged_.syminfo.mintick)
            || facts.cursor.point.path_phase == NativePathPhase::Open) {
            return std::nullopt;
        }
        double best = source.retained_trail_best;
        if (trail_active && std::isfinite(trail_active->best_at_trigger)) {
            best = facts.is_buy ? std::min(best, trail_active->best_at_trigger)
                                : std::max(best, trail_active->best_at_trigger);
        }
        // An armed trail's running best starts at its activation: the E5
        // tapes book activation -/+ offset while the raw extreme stays inside
        // the activation's tick cell (synthetic 26.041 -> 26.05, 25.049 -> 25.04),
        // whereas the kernel's best starts at the half-tick arm
        // (source_trail_arm_level). On the grid the two never differ.
        if (std::isfinite(source.trail_activation_level)) {
            best = facts.is_buy ? std::min(best, source.trail_activation_level)
                                : std::max(best, source.trail_activation_level);
        }
        const double offset = std::floor(source.exit_levels.trail_offset)
            * staged_.syminfo.mintick;
        const double level = best + (facts.is_buy ? offset : -offset);
        const double slipped = level + (facts.is_buy ? 1.0 : -1.0)
            * config_.slippage * staged_.syminfo.mintick;
        return directional_tick(slipped, staged_.syminfo.mintick, facts.is_buy);
    }();
    const auto observed_tick_trail_price = [&]() -> std::optional<double> {
        if (source.family != PineOrderFamily::ExitTrail
            || facts.cursor.point.provenance != NativePriceProvenance::ObservedPrint) {
            return std::nullopt;
        }
        return facts.default_resolved_price;
    }();
    const bool placement_reached_trail_activation =
        std::isfinite(source.sizing.price) && std::isfinite(source.trail_activation_level)
        && source_trail_reached_at(source.sizing.price, source.trail_activation_level,
                                   staged_.syminfo.mintick, facts.is_buy);
    const bool zero_trail_first_activation = explicit_zero_trail && trail_active
        && !placement_reached_trail_activation
        && std::isfinite(source.trail_activation_level)
        && ((facts.is_buy
             && trail_active->best_at_trigger <= source.trail_activation_level
                    + staged_.syminfo.mintick * 1e-6)
            || (!facts.is_buy
                && trail_active->best_at_trigger >= source.trail_activation_level
                    - staged_.syminfo.mintick * 1e-6));
    const auto zero_trail_source_price = [&]() -> std::optional<double> {
        if (!explicit_zero_trail || sampled_one_price_gap || !facts.trigger_level
            || !policy_script_bar_valid_ || !std::isfinite(source.trail_activation_level)) {
            return std::nullopt;
        }
        const double open = policy_script_bar_.open;
        const double placement = source.sizing.price;
        const double activation = source.trail_activation_level;
        const bool reached_at_placement = source_trail_reached_at(
            placement, activation, staged_.syminfo.mintick, facts.is_buy);
        const bool open_beyond = facts.is_buy
            ? open <= activation : open >= activation;
        const bool high_first = source_path_uses_high_first(policy_script_bar_);
        const bool adverse_first = facts.is_buy ? high_first : !high_first;
        const bool same_open = std::isfinite(placement)
            && std::abs(open - placement) <= staged_.syminfo.mintick * 0.5;
        if (reached_at_placement && same_open)
            return nearest_tick(open, staged_.syminfo.mintick);
        if (!reached_at_placement && !open_beyond)
            return nearest_tick(activation, staged_.syminfo.mintick);
        if (!reached_at_placement && open_beyond && adverse_first)
            return directional_tick(open, staged_.syminfo.mintick, facts.is_buy);
        return std::nullopt;
    };
    const auto zero_trail_policy_price = [&]() -> std::optional<double> {
        if (!explicit_zero_trail || !policy_script_bar_valid_
            || !std::isfinite(source.trail_activation_level)
            || !finite_positive(staged_.syminfo.mintick)) {
            return std::nullopt;
        }
        const double tick = staged_.syminfo.mintick;
        const bool long_side = !facts.is_buy;
        const double open = policy_script_bar_.open;
        const double activation = source.trail_activation_level;
        const double placement = source.sizing.price;
        const auto print = [&](double value) {
            return std::floor(value / tick + 0.5) * tick;
        };
        const auto level = [&](double value) {
            return directional_tick(value, tick, facts.is_buy);
        };
        const bool placement_armed = std::isfinite(placement)
            && (long_side ? nearest_tick(placement, tick) >= activation
                          : nearest_tick(placement, tick) <= activation);
        const bool open_reaches = long_side
            ? open >= activation : open <= activation;
        const bool open_favorable = std::isfinite(placement)
            && (long_side ? open > placement : open < placement);
        const auto preopen = trail_state_at_open_.find(facts.target.incarnation);
        if (preopen != trail_state_at_open_.end() && preopen->second.activated
            && std::isfinite(preopen->second.current_level)) {
            const bool adverse_gap = long_side
                ? open <= preopen->second.current_level
                : open >= preopen->second.current_level;
            if (adverse_gap)
                return directional_tick(open, tick, facts.is_buy);
        }
        const bool high_first = source_path_uses_high_first(policy_script_bar_);
        const bool favorable_first = long_side ? high_first : !high_first;
        const double open_print = source_bar_fill_tick(open, tick);
        // A placement close that reached the activation only on its tick
        // carries the activation as its best: TradingView's starts there.
        const double placement_best = placement_armed
            ? (long_side ? std::max(placement, activation) : std::min(placement, activation))
            : placement;
        const double carried_best = preopen != trail_state_at_open_.end()
                && preopen->second.activated
                && std::isfinite(preopen->second.best_price)
            ? preopen->second.best_price : placement_best;
        const bool carried_armed = (preopen != trail_state_at_open_.end()
            && preopen->second.activated) || placement_armed;
        if (carried_armed && std::isfinite(carried_best)) {
            const bool adverse_gap = long_side ? open <= carried_best
                                               : open >= carried_best;
            if (adverse_gap) return open_print;
        }
        const bool zero_offset_open_arms = carried_armed
            ? (long_side ? open > carried_best : open < carried_best)
            : open_reaches;
        const bool print_at_open_level = zero_offset_open_arms
            && (long_side ? open_print <= open : open_print >= open);
        if (print_at_open_level)
            return directional_tick(open, tick, facts.is_buy);
        if (zero_offset_open_arms) {
            if (!favorable_first) return level(open);
            return level(long_side ? policy_script_bar_.high
                                   : policy_script_bar_.low);
        }
        bool armed = placement_armed;
        bool armed_from_open = false;
        double best = placement;
        if (!std::isfinite(best)) best = open;
        if (!armed && open_reaches && open_favorable) {
            armed = true;
            armed_from_open = true;
            best = open;
        }
        if (armed) {
            if (!armed_from_open && long_side && open <= best) return print(open);
            if (!armed_from_open && !long_side && open >= best) return print(open);
            if (armed_from_open || open_favorable) {
                best = open;
                if (print(open) == level(open)) return print(open);
            }
        }
        double path[4];
        path[0] = open;
        if (high_first) {
            path[1] = policy_script_bar_.high;
            path[2] = policy_script_bar_.low;
        } else {
            path[1] = policy_script_bar_.low;
            path[2] = policy_script_bar_.high;
        }
        path[3] = policy_script_bar_.close;
        for (int i = 1; i < 4; ++i) {
            const double from = path[i - 1];
            const double to = path[i];
            if (!armed) {
                const bool reached = long_side
                    ? (to >= activation && to > from)
                    : (to <= activation && to < from);
                if (reached) {
                    return one_shot_rest
                        ? source_one_shot_reach_tick(one_shot_rest->price, tick, facts.is_buy)
                        : level(activation);
                }
                continue;
            }
            const bool favorable = long_side ? to > best : to < best;
            if (favorable) {
                best = to;
                continue;
            }
            const double stop = level(best);
            const bool crossed = long_side
                ? (to <= stop && from > stop)
                : (to >= stop && from < stop);
            if (crossed) return stop;
        }
        if (trail_active && std::isfinite(trail_active->best_at_trigger))
            return level(trail_active->best_at_trigger);
        return std::nullopt;
    };
    const auto& trigger = facts.definition->request.trigger;
    const bool limit_fill = std::holds_alternative<native_order::Limit>(trigger)
        || std::holds_alternative<native_order::StopLimit>(trigger);
    const auto owner_tick_fill = [&](double price) {
        // ab9714be engine.hpp:1207-1210 + 1264-1266: a fill at a raw bar or
        // waypoint print books floor(p / mintick + 0.5) * mintick.  Keep that
        // binary64 form unless it lies past the immutable limit the generic
        // kernel checks (consume_matched_request's InvalidTerms refusal); there
        // the decimal grid form, since source_bar_fill_tick returns an on-grid
        // n * mintick unchanged.
        const double owner_form = nearest_tick(price, staged_.syminfo.mintick);
        std::optional<double> level;
        if (const auto* limit = std::get_if<native_order::Limit>(&trigger)) {
            level = limit->price;
        } else if (const auto* stop_limit = std::get_if<native_order::StopLimit>(&trigger)) {
            level = stop_limit->limit;
        }
        const bool within = !level
            || (facts.is_buy ? owner_form <= *level : owner_form >= *level);
        return within ? owner_form : source_decimal_tick(price, staged_.syminfo.mintick);
    };
    const auto source_forced_fill = [&](double forced) {
        return nearest_tick(forced, staged_.syminfo.mintick) == forced
            ? owner_tick_fill(forced)
            : source_bar_fill_tick(forced, staged_.syminfo.mintick);
    };
    const bool non_open = facts.cursor.point.path_phase != NativePathPhase::Open;
    const bool source_gap_point = !non_open
        || facts.cursor.point.provenance == NativePriceProvenance::ObservedPrint;
    const auto source_stop_fill = [&]() {
        const double source_level = source.family == PineOrderFamily::ExitTrail
            ? source.exit_levels.trail_price : source.exit_levels.stop;
        const double level = finite_positive(source_level) ? source_level
            : (facts.trigger_level ? *facts.trigger_level : facts.default_resolved_price);
        const double slipped = level + (facts.is_buy ? 1.0 : -1.0)
            * config_.slippage * staged_.syminfo.mintick;
        return directional_tick(slipped, staged_.syminfo.mintick, facts.is_buy);
    };
    const auto source_bar_fill = [&]() {
        // ab9714be engine.hpp:1160-1180 and pine_policy_members.cpp:45-53:
        // a raw bar print is rounded half-up first; slippage then rides on
        // that grid price and the directional projection is an identity.
        const double rounded = source_bar_fill_tick(
            facts.raw_price, staged_.syminfo.mintick);
        const double slipped = rounded + (facts.is_buy ? 1.0 : -1.0)
            * config_.slippage * staged_.syminfo.mintick;
        return directional_tick(slipped, staged_.syminfo.mintick, facts.is_buy);
    };
    // A named stop whose entry filled at this very point is matched from that
    // fill on (the kernel's cause floor), and the kernel reaches one already
    // through there at the fill's own print. TradingView fills it at once at
    // that print with the stop's slippage, never at a level the bar crossed
    // before the entry filled (TradingView tapes: tests/fixtures/global_exit_children
    // eth-member and eth-fresh, a short limit entry whose break-even stop the
    // bar rose through before the entry filled). Scoped to the pinned shape:
    // no calc_on_order_fills, no intrabar feed.
    const auto newborn_stop_through = [&]() -> std::optional<double> {
        if (source.family != PineOrderFamily::ExitStop || source.from_entry.empty()
            || config_.calc_on_order_fills
            || facts.price_kind != native_order::NativeCandidatePriceKind::PointPrice
            || facts.cursor.point.provenance != NativePriceProvenance::Confirmed
            || facts.cursor.point.path_phase == NativePathPhase::Open
            || facts.cursor.point.path_phase == NativePathPhase::None
            || !host_state.spec || !host_state.spec->intrabar.is_none()) {
            return std::nullopt;
        }
        const auto* pine = pine_view_of(&require_host());
        if (!pine) return std::nullopt;
        const PyramidEntry* newest = nullptr;
        for (const auto& lot : pine->pyramid_entries_) {
            if (lot.entry_id == source.from_entry
                && (!newest || lot.entry_incarnation > newest->entry_incarnation)) {
                newest = &lot;
            }
        }
        if (!newest || newest->entry_bar_index != facts.cursor.point.interval_index)
            return std::nullopt;
        // Already through at that point: a buy stop at or below it, a sell
        // stop at or above it.
        const double stop = source.exit_levels.stop;
        if (!finite_positive(stop) || (facts.is_buy ? stop > facts.raw_price : stop < facts.raw_price))
            return std::nullopt;
        // The entry is a limit order that filled here: the point is its
        // trigger threshold, half a tick from the level it booked, and that
        // booked fill is the print the stop fills at.
        const auto opening = placement_.find(newest->entry_incarnation);
        if (opening == placement_.end() || opening->second.family != PineOrderFamily::Entry
            || !finite_positive(opening->second.exit_levels.limit)
            || finite_positive(opening->second.exit_levels.stop)
            || std::abs(newest->price - facts.raw_price)
                > 0.5 * staged_.syminfo.mintick + 1e-9 * std::abs(facts.raw_price)) {
            return std::nullopt;
        }
        return newest->price;
    };
    const auto source_stop_resolved = [&]() {
        // ab9714be pine_fills.cpp:8002-8018: a realtime print gaps to the
        // observed price; an opening print already through the stop books
        // the open; otherwise the fill is the stop level (not the open, and
        // not a same-pass close's fill price).
        if (facts.cursor.point.provenance == NativePriceProvenance::ObservedPrint)
            return source_bar_fill();
        if (const auto print = newborn_stop_through()) {
            const double slipped = *print + (facts.is_buy ? 1.0 : -1.0)
                * config_.slippage * staged_.syminfo.mintick;
            return directional_tick(slipped, staged_.syminfo.mintick, facts.is_buy);
        }
        const double source_level = source.family == PineOrderFamily::ExitTrail
            ? source.exit_levels.trail_price : source.exit_levels.stop;
        const double level = finite_positive(source_level) ? source_level
            : (facts.trigger_level ? *facts.trigger_level : facts.default_resolved_price);
        // ab9714be pine_scheduler.cpp:911-916 keeps current_bar_.open as the
        // script-bar open while magnifier samples only update H/L/C, so
        // try_exit_open_gap_fill (engine_path_resolve.cpp:905-927) tests that
        // script open. Synthesized/distribution samples arrive as one-price
        // opens; a later sample through the stop is a path cross at the stop
        // level, not a fresh gap at the sample quote.
        double open_px = facts.raw_price;
        if (policy_script_bar_valid_
            && facts.cursor.point.path_phase == NativePathPhase::Open
            && facts.cursor.point.provenance == NativePriceProvenance::ModeledOHLCOpen
            && host_state.spec) {
            const auto* synthesized = host_state.spec->intrabar.synthesized_path();
            const auto* lower = host_state.spec->intrabar.lower();
            const bool one_price = synthesized != nullptr
                || (lower && lower->sample_eligibility
                    == IntrabarPath::SampleEligibility::DistributionSamples);
            if (one_price) open_px = policy_script_bar_.open;
        }
        // ab9714be pine_fills.cpp:4136-4240 + 7795-7800: a stop armed with its
        // pending MARKET parent and already breached at the parent's fill
        // open scratches at bar_fill_price(open).  The leg becomes live only
        // after that opening fill, so the driver first presents it on the
        // next path segment, crossed at the segment's start: the script-bar
        // open itself.  That is the same opening gap, not a path cross.
        const bool armed_after_open_fill = non_open
            && source.family == PineOrderFamily::ExitStop
            && policy_script_bar_valid_
            && !config_.process_orders_on_close && !config_.calc_on_order_fills
            && host_state.spec && host_state.spec->intrabar.is_none()
            && facts.cursor.point.provenance == NativePriceProvenance::Confirmed
            && facts.raw_price == policy_script_bar_.open;
        if (armed_after_open_fill) open_px = policy_script_bar_.open;
        const bool open_gapped = (!non_open || armed_after_open_fill)
            && std::isfinite(level)
            && (facts.is_buy ? open_px >= level : open_px <= level);
        // The pre-open margin slice rests at the raw adverse print
        // (schedule_preopen_margin_slice) but is TradingView's margin call, a
        // MARKET execution at that print: the print's nearest tick, then the
        // exit side's slippage (source_margin_fill_price), not a stop level's
        // adverse tick -- synthetic 25.005 books 25.01 (lab tv tapes pm-m10-f-k4-1007
        // and -gapup-0501, the intrabar margin correction). A stop crossed at its own
        // off-grid LEVEL keeps the directional rule (pm2-round-f, -es).
        if (!open_gapped) {
            return source.family == PineOrderFamily::Margin
                ? source_margin_fill_price(level, facts.is_buy)
                : source_stop_fill();
        }
        // ab9714be try_exit_open_gap_fill books bar.open (the script-bar
        // open), even when the matching sample is a later one-price tick.
        const double rounded = source_bar_fill_tick(
            open_px, staged_.syminfo.mintick);
        const double slipped = rounded + (facts.is_buy ? 1.0 : -1.0)
            * config_.slippage * staged_.syminfo.mintick;
        return directional_tick(slipped, staged_.syminfo.mintick, facts.is_buy);
    };
    const auto source_limit_fill = [&]() {
        // ab9714be pine_fills.cpp:7733-8072 + pine_policy_members.cpp:55-58:
        // an open gap receives the raw open with nearest-tick rounding;
        // otherwise a LIMIT receives its level, snapped limit-or-better and
        // never slipped.
        if (source.family == PineOrderFamily::ExitTrail && facts.trigger_level
            && non_open) {
            const double ticked = directional_tick(*facts.trigger_level, staged_.syminfo.mintick,
                                                   !facts.is_buy);
            // ab9714be pine_fills.cpp:7970-7988: limit fill is unslipped limit-or-better clamped to trigger to preserve limit invariant
            return facts.is_buy ? std::min(ticked, *facts.trigger_level)
                                : std::max(ticked, *facts.trigger_level);
        }
        const bool deferred_open_gap = source.defer_until_post_parent_calculation
            && facts.cursor.point.provenance == NativePriceProvenance::Confirmed;
        // ab9714be pine_fills.cpp:4136-4240 + 7795-7800: the limit leg of a
        // bracket armed with its pending MARKET parent and already marketable
        // at the parent's fill open scratches at bar_fill_price(open), exactly
        // like the stop leg (source_stop_resolved).  The driver first presents
        // it on the next path segment, crossed at that segment's start: the
        // script-bar open itself.
        const bool limit_armed_after_open_fill = non_open
            && source.family == PineOrderFamily::ExitLimit
            && policy_script_bar_valid_
            && !config_.process_orders_on_close && !config_.calc_on_order_fills
            && host_state.spec && host_state.spec->intrabar.is_none()
            && facts.cursor.point.provenance == NativePriceProvenance::Confirmed
            && facts.raw_price == policy_script_bar_.open;
        if (!non_open || deferred_open_gap || limit_armed_after_open_fill) {
            const bool raw_oca_reduce = source.family == PineOrderFamily::Order
                && source.oca_type == 2;
            if (raw_oca_reduce) {
                return nearest_tick(facts.raw_price, staged_.syminfo.mintick);
            }
            // ab9714be pine_fills.cpp:7943-7945: an exit gapped at the open
            // books bar_fill_price(open).
            if (source.family == PineOrderFamily::ExitLimit) {
                return owner_tick_fill(facts.raw_price);
            }
            return source_bar_fill_tick(facts.raw_price, staged_.syminfo.mintick);
        }
        // ab9714be engine_path_resolve.cpp:365-367: stop-limit fills at unslipped stop activation price when marketable against limit
        // A pure limit entry armed at its leg's extreme (entry(): a limit
        // resting from the extreme) is no stop-limit: it books its level.
        const bool armed_pure_limit_entry = source.family == PineOrderFamily::Entry
            && !finite_positive(source.exit_levels.stop);
        if (std::holds_alternative<native_order::StopLimit>(trigger) && !armed_pure_limit_entry) {
            const double projected = directional_tick(facts.raw_price, staged_.syminfo.mintick,
                                                      !facts.is_buy);
            // The repair the limit below makes: this projection can sit one
            // binary64 ULP past the immutable limit (a buy limit at 99.99 on
            // a 0.01 grid projects to 9999 * 0.01 = 99.990000000000009),
            // which the generic kernel refuses.  Only there, and only for a
            // print on the chart grid, the fill books that print's grid
            // spelling; an admitted projection is kept bit for bit.
            const double limit = std::get<native_order::StopLimit>(trigger).limit;
            if (facts.is_buy ? projected > limit : projected < limit) {
                const double print_on_grid = source_level_on_price_grid(
                    facts.raw_price, staged_.syminfo.mintick);
                if (source_bar_fill_tick(print_on_grid, staged_.syminfo.mintick)
                        == print_on_grid) {
                    return print_on_grid;
                }
            }
            return projected;
        }
        const double level = finite_positive(source.exit_levels.limit)
            ? source.exit_levels.limit
            : (facts.trigger_level ? *facts.trigger_level : facts.raw_price);
        // Preserve a source level that is on the chart grid (including a
        // computed level only ULPs away from it).  `directional_tick` can
        // return a value one binary64 ULP on the wrong side of that level
        // (2409.49 -> 2409.4900000000002 for a buy limit), which the generic
        // kernel then correctly rejects against its immutable limit.
        const double projected = directional_tick(
            level, staged_.syminfo.mintick, !facts.is_buy);
        const double level_on_grid = source_level_on_price_grid(
            level, staged_.syminfo.mintick);
        const bool grid_level = source_bar_fill_tick(
            level_on_grid, staged_.syminfo.mintick) == level_on_grid;
        const bool wrong_side = facts.is_buy
            ? projected > level
            : projected < level;
        // ab9714be pine_policy_members.cpp:53-58 books that projection as is
        // (a buy limit at 1.18054 fills 1.1805400000000001).  Substitute the
        // grid level only where the native limit itself refuses it; a
        // half-tick-shifted exit threshold admits the owner's spelling.
        const auto* native_limit = std::get_if<native_order::Limit>(&trigger);
        const bool native_admits = native_limit
            && (facts.is_buy ? projected <= native_limit->price
                             : projected >= native_limit->price);
        if (grid_level && wrong_side && !native_admits) {
            return level_on_grid;
        }
        return projected;
    };
    const auto source_trail_one_shot_fill = [&]() {
        // ab9714be pine_fills.cpp:7936-7958: an omitted-offset trail is a
        // stop-style activation print.  When the next bar opens through the
        // raw activation, Pine projects that print directionally; it is not a
        // nearest-tick LIMIT gap.  Explicit offsets and non-open crossings
        // keep the L6b limit-or-better projection.
        const double tick = staged_.syminfo.mintick;
        if (!std::isfinite(source.exit_levels.trail_offset)
            && finite_positive(tick) && finite_positive(source.trail_activation_level)) {
            // The native arm threshold sits half a tick inside the source
            // one-shot level (exit()).  ab9714be engine_path_resolve.cpp:
            // 667-705 gap-fills only a RAW open at or past the activation;
            // an open short of it is reached on the tick path and books the
            // activation itself (engine_path_resolve.cpp:980-987).
            const double slipped = source.trail_activation_level
                + (facts.is_buy ? 1.0 : -1.0) * config_.slippage * tick;
            double level = directional_tick(slipped, tick, facts.is_buy);
            if (!facts.is_buy) level = source_level_on_price_grid(level, tick);
            const bool open_through = facts.is_buy
                ? facts.raw_price <= level : facts.raw_price >= level;
            if (facts.cursor.point.path_phase == NativePathPhase::Open && open_through) {
                return directional_tick(
                    facts.default_resolved_price, tick, facts.is_buy);
            }
            const double ticked = directional_tick(level, tick, !facts.is_buy);
            return facts.is_buy ? std::min(ticked, level) : std::max(ticked, level);
        }
        if (!std::isfinite(source.exit_levels.trail_offset)
            && facts.cursor.point.path_phase == NativePathPhase::Open) {
            return directional_tick(
                facts.default_resolved_price, staged_.syminfo.mintick,
                facts.is_buy);
        }
        return source_limit_fill();
    };
    // Explicit native intents already carry their canonical trigger/fill
    // price. Limits retain their immutable generic value. The generic consumer
    // has already applied the one market slippage step; source projection only
    // rounds that resulting quote to the ordinary chart tick.
    // A core-sized opening is a host-resolved shape too: the core owns the
    // QUANTITY, the source still owns the fill price and every admission
    // policy below.  Only an intent that also carries its own price -- a
    // literal transaction, a reversal target -- takes the explicit path.
    const bool core_sized = std::holds_alternative<native_order::Sized>(
        facts.definition->request.intent);
    if (!core_sized
        && !std::holds_alternative<native_order::HostSized>(facts.definition->request.intent)) {
        if (std::holds_alternative<native_order::Market>(trigger)) {
            result.resolved_price = source_bar_fill();
        } else if (limit_fill) {
            result.resolved_price = source_limit_fill();
        // ab9714be pine_fills.cpp:8004-8020: Order-family stop triggers resolve fill price via source stop resolution
        } else if ((source.family == PineOrderFamily::Entry
                    || source.family == PineOrderFamily::Order)
                   && std::holds_alternative<native_order::Stop>(trigger)
                   && facts.trigger_level) {
            // pine_stream.cpp:278-303 at ab9714be presents each realtime trade
            // as a one-price broker point.  A stop crossed by that print gaps
            // to the observed price; it is not interpolated back to its level.
            result.resolved_price = source_stop_resolved();
        }
        if (finite_positive(source.forced_execution_price)) {
            // ab9714be pine_fills.cpp:1712-1726: margin slices use the exact fire
            // price (W34a); every other forced fill goes through the chained-fill
            // tick-grid helper (W35a).
            result.resolved_price = source.family == PineOrderFamily::Margin
                ? source.forced_execution_price
                : source_forced_fill(source.forced_execution_price);
        }
        if (source.family == PineOrderFamily::ExitLimit && facts.trigger_level
            && facts.cursor.point.path_phase != NativePathPhase::Open) {
            result.resolved_price = directional_tick(
                result.resolved_price, staged_.syminfo.mintick, !facts.is_buy);
            const double constraint = finite_positive(source.exit_levels.limit)
                ? source.exit_levels.limit : *facts.trigger_level;
            result.resolved_price = facts.is_buy
                ? std::min(result.resolved_price, constraint)
                : std::max(result.resolved_price, constraint);
        } else if ((source.family == PineOrderFamily::ExitStop
                    || source.family == PineOrderFamily::ExitTrail)
                   && facts.trigger_level
                   && facts.cursor.point.path_phase != NativePathPhase::Open) {
            result.resolved_price = directional_tick(
                result.resolved_price, staged_.syminfo.mintick, facts.is_buy);
        }
        return result;
    }
    const bool live_direction_gate = source.family == PineOrderFamily::Entry
        && ((risk_.direction > 0 && !source.is_long)
            || (risk_.direction < 0 && source.is_long));
    if (live_direction_gate) {
        const bool opposite = facts.position.signed_units != 0.0
            && ((facts.position.signed_units > 0.0) != source.is_long);
        if (opposite) {
            result.units = facts.opposite_book_units;
            result.shape = native_order::OpeningShape::CloseOpposite;
        } else {
            // `allow_entry_in` rejects a flat/same-side forbidden instruction;
            // unlike an opposite fill it never manufactures a close at the
            // command boundary.
            result.units = 0.0;
        }
        return result;
    }
    const bool market_like = std::holds_alternative<native_order::Market>(trigger);
    // NativeRunSpec carries the generic slippage ticks, so its candidate
    // default is already the one-slippage source fill. The adapter only owns
    // the frozen source sizing basis; applying it again here would double-slip
    // a market order after the on-tick calculation.
    if (market_like) {
        result.resolved_price = source_bar_fill();
    } else if (limit_fill) {
        result.resolved_price = source_limit_fill();
    }
    if (finite_positive(source.forced_execution_price)) {
        result.resolved_price = source_forced_fill(source.forced_execution_price);
    }
    // Source stop/trail exits crossed inside a modeled path settle at their
    // armed level, whereas an open gap retains the presented open quote.  The
    // generic driver deliberately exposes both facts; selecting this source
    // policy here preserves the non-gap relative-parent lifecycle.
    if ((source.family == PineOrderFamily::ExitLimit
         || source.family == PineOrderFamily::ExitStop || source.family == PineOrderFamily::ExitTrail
         || source.family == PineOrderFamily::Margin || source.family == PineOrderFamily::Order)
        && facts.trigger_level
        && facts.price_kind == native_order::NativeCandidatePriceKind::TriggerLevel) {
        if ((source.family == PineOrderFamily::ExitStop || source.family == PineOrderFamily::Order)
            && facts.cursor.point.path_phase == NativePathPhase::Open) {
            result.resolved_price = source_bar_fill();
        } else if (observed_tick_trail_price) {
            result.resolved_price = *observed_tick_trail_price;
        } else if (retained_trail_source_price) {
            result.resolved_price = *retained_trail_source_price;
        } else if (const auto source_price = zero_trail_policy_price()) {
            result.resolved_price = *source_price;
        } else if (const auto source_price = zero_trail_source_price()) {
            result.resolved_price = *source_price;
        } else if (trail_limit_one_shot) {
            result.resolved_price = source_trail_one_shot_fill();
        } else if (explicit_zero_trail) {
            if (zero_trail_first_activation) {
                result.resolved_price = directional_tick(
                    source.trail_activation_level, staged_.syminfo.mintick, facts.is_buy);
            } else {
                const double best = trail_active
                    ? trail_active->best_at_trigger : facts.default_resolved_price;
                result.resolved_price = directional_tick(
                    best, staged_.syminfo.mintick, facts.is_buy);
            }
        } else if ((source.family == PineOrderFamily::ExitStop || source.family == PineOrderFamily::Order)
                   && facts.cursor.point.path_phase == NativePathPhase::Open) {
            result.resolved_price = source_bar_fill();
        } else if (source.family == PineOrderFamily::ExitLimit
                   || (source.family == PineOrderFamily::Order && finite_positive(source.exit_levels.limit))) {
            result.resolved_price = source_limit_fill();
        } else if (source.family == PineOrderFamily::ExitTrail) {
            result.resolved_price = directional_tick(
                facts.default_resolved_price, staged_.syminfo.mintick, facts.is_buy);
        } else if ((source.family == PineOrderFamily::ExitStop || source.family == PineOrderFamily::Order)
                   && std::isfinite(source.exit_levels.stop)) {
            result.resolved_price = directional_tick(
                source.exit_levels.stop, staged_.syminfo.mintick, facts.is_buy);
        } else {
            result.resolved_price = directional_tick(
                *facts.trigger_level, staged_.syminfo.mintick, facts.is_buy);
        }
    } else if (observed_tick_trail_price) {
        result.resolved_price = *observed_tick_trail_price;
    } else if (retained_trail_source_price) {
        result.resolved_price = *retained_trail_source_price;
    } else if (const auto source_price = zero_trail_policy_price()) {
        result.resolved_price = *source_price;
    } else if (const auto source_price = zero_trail_source_price()) {
        result.resolved_price = *source_price;
    } else if (trail_limit_one_shot && facts.trigger_level && !sampled_one_price_gap) {
        result.resolved_price = source_trail_one_shot_fill();
    } else if (explicit_zero_trail && facts.trigger_level && !sampled_one_price_gap) {
        // Native's positive sentinel offset keeps the generic trail alive;
        // source settlement prints the carried raw best on the directional
        // chart grid.  A first activation is the source activation level.
        result.resolved_price = zero_trail_first_activation
            ? directional_tick(source.trail_activation_level, staged_.syminfo.mintick, facts.is_buy)
            : directional_tick(trail_active ? trail_active->best_at_trigger
                                            : facts.default_resolved_price,
                               staged_.syminfo.mintick, facts.is_buy);
    } else if (source.family == PineOrderFamily::ExitStop && facts.trigger_level
               && facts.price_kind == native_order::NativeCandidatePriceKind::PointPrice
               && (facts.cursor.point.path_phase == NativePathPhase::Open
                   || (source.defer_until_post_parent_calculation
                       && facts.cursor.point.provenance
                           == NativePriceProvenance::Confirmed))) {
        // A resting stop crossed by an adverse opening gap books the raw
        // opening print, then applies the ordinary nearest chart-tick print
        // projection (distinct from a non-gap trigger-level fill).
        result.resolved_price = nearest_tick(
            facts.default_resolved_price, staged_.syminfo.mintick);
    }
    if ((source.family == PineOrderFamily::ExitLimit
         || (source.family == PineOrderFamily::Order && finite_positive(source.exit_levels.limit)))
        && facts.trigger_level && facts.cursor.point.path_phase != NativePathPhase::Open) {
        // ab9714be:pine_policy_members.cpp:53-58.  A computed LIMIT close is
        // limit-or-better: buys floor and sells ceil to the price grid.  The
        // generic trigger level remains raw for reachability; only the booked
        // source fill receives this directional limit snap.
        if (finite_positive(source.exit_levels.limit)
            && !finite_positive(source.forced_execution_price)) {
            result.resolved_price = source_limit_fill();
        } else {
            result.resolved_price = directional_tick(
                result.resolved_price, staged_.syminfo.mintick, !facts.is_buy);
            const double constraint = finite_positive(source.exit_levels.limit)
                ? source.exit_levels.limit : *facts.trigger_level;
            result.resolved_price = facts.is_buy
                ? std::min(result.resolved_price, constraint)
                : std::max(result.resolved_price, constraint);
        }
    }
    if (source.family == PineOrderFamily::ExitTrail
        && std::isfinite(source.exit_levels.trail_offset)
        && std::floor(source.exit_levels.trail_offset) == 0.0
        && policy_script_bar_valid_
        && facts.cursor.point.path_phase != NativePathPhase::Open) {
        const bool closing_long = facts.position.signed_units > 0.0;
        double activation = source.exit_levels.trail_price;
        if (!finite_positive(activation)
            && std::isfinite(source.exit_levels.trail_points)
            && finite_positive(staged_.syminfo.mintick)) {
            const double ticks = source_trail_points_ticks(
                source.exit_levels.trail_points, staged_.syminfo.mintick);
            activation = require_host().position_avg_price()
                + (closing_long ? 1.0 : -1.0) * ticks * staged_.syminfo.mintick;
            activation = directional_tick(
                activation, staged_.syminfo.mintick, closing_long);
        }
        const bool armed_inside_this_bar = closing_long
            ? policy_script_bar_.open < activation
            : policy_script_bar_.open > activation;
        if (finite_positive(activation) && armed_inside_this_bar) {
            // ab9714be:test_fills_edge.cpp:827-858 and the zero-offset trail
            // owner: an activation first reached inside a path is a one-shot
            // fill at that activation.  A favourable opening gap keeps the
            // generic trail ride and is deliberately excluded here.  A resting
            // one-shot books the tick its limit stands for: a sub-tick
            // activation rounds away from the position, not toward it.
            result.resolved_price = one_shot_rest
                ? source_one_shot_reach_tick(
                    one_shot_rest->price, staged_.syminfo.mintick, facts.is_buy)
                : directional_tick(activation, staged_.syminfo.mintick, facts.is_buy);
        }
    }
    if ((std::holds_alternative<native_order::Stop>(trigger)
         || std::holds_alternative<native_order::Trail>(trigger)
        || source.family == PineOrderFamily::Margin)
        && facts.trigger_level && !explicit_zero_trail && !trail_limit_one_shot
        && !(source.defer_until_post_parent_calculation
              && facts.cursor.point.provenance == NativePriceProvenance::Confirmed)
        && !retained_trail_source_price && !observed_tick_trail_price) {
        result.resolved_price = std::holds_alternative<native_order::Stop>(trigger)
            ? source_stop_resolved()
            : (source_gap_point ? source_bar_fill() : source_stop_fill());
    }
    if (finite_positive(source.forced_execution_price)) {
        result.resolved_price = source_forced_fill(source.forced_execution_price);
    } else if (const auto* touch = std::get_if<native_order::Limit>(&trigger);
               touch && touch->fill_through && trail_limit_one_shot
               && std::isfinite(result.resolved_price)) {
        // ab9714be pine_policy_members.cpp:45-53 (apply_slippage): the
        // zero-offset one-shot trail's source print moves slippage ticks
        // against the exit and is re-snapped directionally
        // (round_to_mintick_directional), exactly as the owner's TRAIL fill.
        const double tick = staged_.syminfo.mintick;
        result.resolved_price = directional_tick(
            result.resolved_price + (facts.is_buy ? 1.0 : -1.0) * config_.slippage * tick,
            tick, facts.is_buy);
    }
    // A strategy.close(id) sized when it was placed (flush_pending_closes) is
    // the transaction it was given: it crosses zero on the smaller book.
    if (PF_RARE(source.crosses_zero) && source.family == PineOrderFamily::Close) return result;
    if (source.family == PineOrderFamily::Close || source.family == PineOrderFamily::ExitLimit
        || source.family == PineOrderFamily::ExitStop || source.family == PineOrderFamily::ExitTrail
        || source.family == PineOrderFamily::Margin) {
        const bool explicit_source_exit = finite_positive(source.requested_qty)
            && (source.family == PineOrderFamily::ExitLimit
                || source.family == PineOrderFamily::ExitStop
                || source.family == PineOrderFamily::ExitTrail);
        if (explicit_source_exit
            || (source.family == PineOrderFamily::Close
                && source.close_batch_calls != 0)) {
            result.grid_policy = native_order::ExecutionGridPolicy::ExplicitUnits;
        }
        if ((source.family == PineOrderFamily::ExitLimit
             || source.family == PineOrderFamily::ExitStop
             || source.family == PineOrderFamily::ExitTrail)
            && !(facts.scope_exposure_units > 0.0)) {
            result.units = 0.0;
            return result;
        }
        // One entry's bracket of a per-entry global exit closes that entry's
        // units, the oldest lots first (global_exit_per_entry_levels).
        if (PF_RARE(source.per_entry_origin != 0)) {
            result.grid_policy = native_order::ExecutionGridPolicy::ExplicitUnits;
            result.units = std::min(source.per_entry_units, facts.scope_exposure_units);
            return result;
        }
        // ab9714be pine_fills.cpp:1618: whole-position coverage is spelled
        // `qty - kQtyEpsilon`, and pine_fills.cpp:1717-1723 then routes that
        // covered residual through the WHOLE-position exit rather than a
        // sized reduction.  A reservation subtracted from the live basis in
        // binary64 can overshoot the exposure that actually remains at fill
        // time by a few ULPs; without this snap the leg is over-sized
        // against its scope, never fills, and strands a sub-lot remainder
        // that the 1x-margin path later fragments.
        const auto cover_full_scope = [&](double units) {
            if (source.family == PineOrderFamily::Close
                && !config_.close_entries_rule_any
                && std::holds_alternative<execution::Book>(facts.scope)) {
                const double close_units = std::min(units, facts.scope_exposure_units);
                const double boundary_units = source_fifo_close_units(
                    close_units, require_host().native_open_lots(kNaN));
                if (boundary_units != close_units) {
                    result.grid_policy = native_order::ExecutionGridPolicy::ExplicitUnits;
                    return boundary_units;
                }
                units = close_units;
            }
            if (facts.scope_exposure_units > 0.0
                && units >= facts.scope_exposure_units - internal::kQtyEpsilon) {
                // The covered residual IS the literal selected exposure, which
                // an earlier percentage close can have left a few binary64
                // steps off the run's quantity grid.  The owner books such an
                // exit through the whole-position path without re-quantizing
                // it, so authenticate the literal units for the pure reduction
                // instead of letting the grid reject the leg and strand the
                // dust (ab9714be pine_fills.cpp:1717-1723).
                if (const auto* host_close = std::get_if<native_order::HostSized>(
                        &facts.definition->request.intent);
                    host_close
                    && host_close->kind == native_order::HostSizedKind::Close) {
                    result.grid_policy =
                        native_order::ExecutionGridPolicy::ExplicitUnits;
                }
                return facts.scope_exposure_units;
            }
            return units;
        };
        if (fill_time_global_exit(source)) {
            const double percent = std::isfinite(source.qty_percent) ? source.qty_percent : 100.0;
            if (percent >= 100.0 - internal::kFullPercentEps) {
                result.units = cover_full_scope(facts.scope_exposure_units);
                return result;
            }
            // A partial exit sized when it fills still keeps the reservation
            // its placement split off: the fill takes in the lots an add
            // opened since (w4-f19a cell E), never less than a sibling exit
            // that filled first left it (lab tv w3bf05-g8, lane W3B-ENG-GRID).
            double units = quantize_close_units(facts.scope_exposure_units, percent);
            if (finite_positive(source.projection_remaining_qty))
                units = std::max(units, source.projection_remaining_qty);
            result.units = cover_full_scope(units);
            return result;
        }
        const bool has_projected_remaining =
            (source.from_entry.empty() || source.fixed_exit_reservation)
            && std::isfinite(source.projection_remaining_qty);
        if (has_projected_remaining) {
            // ab9714be pine_fills.cpp:1708-1723: an exit reduction executes its
            // exact reservation without re-quantizing against the quantity grid,
            // so binary64 rounding of available = live_basis - reserved cannot
            // cause the native matcher to reject the leg as off-grid.
            if (const auto* host_close = std::get_if<native_order::HostSized>(
                    &facts.definition->request.intent);
                host_close && host_close->kind == native_order::HostSizedKind::Close) {
                result.grid_policy =
                    native_order::ExecutionGridPolicy::ExplicitUnits;
            }
            result.units = cover_full_scope(
                std::max(0.0, source.projection_remaining_qty));
            if ((source.family == PineOrderFamily::ExitLimit
                 || source.family == PineOrderFamily::ExitStop
                 || source.family == PineOrderFamily::ExitTrail)
                && source.qty_percent >= 100.0 - 1e-9
                && facts.scope_exposure_units > 0.0
                && (!source.from_entry.empty()
                    || source.pooc_global_full_exit_dynamic_qty)) {
                // An adopted anchored leg is the same book close, armed.
                const auto& owner = facts.definition->request.owner;
                const auto* armed = std::get_if<native_order::WaitForApplied>(&owner);
                const bool book_owner = std::holds_alternative<native_order::Independent>(owner)
                    || (armed && armed->scope == native_order::NativeArmScope::Book);
                const bool whole_scope_owner = !book_owner || source.from_entry.empty();
                if (whole_scope_owner) result.units = std::isfinite(source.requested_qty)
                    ? std::min(*result.units, facts.scope_exposure_units)
                    : cover_full_scope(facts.scope_exposure_units);
            }
            return result;
        }
        // A source full close is an all-live-cohort operation, not a stale
        // placement-sized reduction.  The generic selected scope is the
        // authoritative physical sum at this candidate.  Reusing the source
        // snapshot can differ by one binary64 rounding step after a previous
        // percentage close; that leaves a positive dust lot which the next
        // percent entry cannot represent alongside its new units.  The fixed
        // quantity source transaction retains its captured own/transaction
        // facts, so it must not use this percent-sizing projection.
        // pine_strategy_commands.cpp:2775-2790 leaves a full-percentage exit
        // exact so it always flattens its live source scope.  Do not send a
        // 100% HostSized close through the multiply/divide and quantity-grid
        // path: after an earlier margin slice that can floor one extra step
        // and leave a dust lot behind.
        if (source.deferred_cohort && !source.fixed_exit_reservation
            && !source.frozen_market_instruction
            && !std::isfinite(source.requested_qty)
            && (std::isnan(source.qty_percent) || source.qty_percent >= 100.0)) {
            result.units = cover_full_scope(facts.scope_exposure_units);
            return result;
        }
        if (finite_positive(source.requested_qty)) {
            result.units = source.requested_qty;
            return result;
        }
        double percent = source.qty_percent;
        if (std::isnan(percent)) percent = 100.0;
        const bool selected_exit =
            (source.family == PineOrderFamily::ExitLimit
             || source.family == PineOrderFamily::ExitStop
             || source.family == PineOrderFamily::ExitTrail)
            && std::holds_alternative<native_order::SelectedExposure>(facts.scope);
        result.units = selected_exit && percent == 100.0
            ? cover_full_scope(facts.scope_exposure_units)
            : cover_full_scope(
                  quantize_close_units(facts.scope_exposure_units, percent));
        return result;
    }
    if (source.family == PineOrderFamily::Order && std::isfinite(source.requested_qty)) {
        result.units = std::max(0.0, source.requested_qty);
        const bool opposite = facts.position.signed_units != 0.0
            && ((facts.position.signed_units > 0.0) != source.is_long);
        if (opposite) {
            result.units = std::min(*result.units, facts.opposite_book_units);
            result.shape = native_order::OpeningShape::CloseOpposite;
        }
        return result;
    }
    // A typed quantity (qty_type cash / percent_of_equity) names its own money.
    // The source chooses that money and floors the units onto its grid; the
    // conversion cash / (fill price * point value * fx) and a percentage's fee
    // reserve are the kernel's (native_sized_units), as for a default
    // quantity. typed_entry_units is also what the placement admission prices
    // and what the fill-quantity probe answers.
    const bool typed_quantity = source.qty_type == static_cast<int>(QtyType::CASH)
        || source.qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY);
    if (source.family == PineOrderFamily::Entry && source.terms_priced_reverse) {
        const bool opposite_now = facts.position.signed_units != 0.0
            && ((facts.position.signed_units > 0.0) != source.is_long);
        if (source.affordability_close_only) {
            const bool stopped_flat_reversal = !opposite_now
                && facts.position.signed_units == 0.0
                && std::holds_alternative<native_order::Stop>(trigger)
                && finite_positive(source.projection_tv_carry_qty);
            result.units = opposite_now ? facts.opposite_book_units
                : (stopped_flat_reversal ? source.projection_tv_carry_qty : 0.0);
            result.shape = opposite_now ? native_order::OpeningShape::CloseOpposite
                                        : native_order::OpeningShape::Transact;
            return result;
        }
        double own_units = source.requested_qty;
        if (typed_quantity) {
            const auto typed = typed_entry_units(source, result.resolved_price,
                                                 facts.active_fx, facts.target);
            if (!typed) return result;
            own_units = *typed;
        }
        result.units = own_units;
        const auto created_side = static_cast<PositionSide>(
            source.projection_position_side);
        if (facts.position.signed_units == 0.0
            && finite_positive(source.projection_tv_carry_qty)
            && created_side != PositionSide::FLAT
            && ((created_side == PositionSide::LONG) != source.is_long)) {
            result.units = std::abs(own_units) + source.projection_tv_carry_qty;
            result.shape = native_order::OpeningShape::Transact;
            return result;
        }
        if (finite_positive(source.frozen_reversal_transaction)
            && source.placement_cycle == current_position_cycle_
            && std::abs(facts.position.signed_units - (source.is_long
                ? -source.frozen_reversal_transaction : source.frozen_reversal_transaction))
                < 1e-12) {
            result.units = source.frozen_reversal_transaction;
            result.shape = native_order::OpeningShape::CloseOpposite;
        } else {
            // A co-queued source close can have flattened the placement-time
            // opposite side before this priced entry reaches its trigger.
            // ab9714be pine_fills.cpp:4618-4664 then executes an ordinary
            // opening, not a reversal against an already-consumed book.
            result.shape = opposite_now ? native_order::OpeningShape::ReverseTo
                                        : native_order::OpeningShape::Transact;
        }
        return result;
    }
    if (source.family == PineOrderFamily::Entry && finite_positive(source.requested_qty)) {
        result.units = typed_quantity
            ? typed_entry_units(source, result.resolved_price, facts.active_fx, facts.target)
                  .value_or(0.0)
            : source.requested_qty;
    } else if (core_sized) {
        // The core resolved cash / (signal price * point value * fx) with the
        // fee reserve at acceptance and published the quotient as this
        // request's remaining units; only the source lot floor is left.
        // default_sizing_intent emits Sized only where that acceptance is
        // resolvable, so a missing quotient is a broken invariant (R5 N11).
        const auto* published = std::get_if<native_order::RemainingUnits>(&facts.remaining);
        if (!published) {
            throw coded<std::logic_error>(RunFailureCode::engine_invariant, {},
                                          "core-sized quantity without the core's quotient");
        }
        result.units = default_sizing_lot_floor(published->q);
        // A margin call that filled after the command, on its calculation's
        // bar, revised the source sizing to the equity after it
        // (refresh_pending_sizing_after_margin); the quotient the core froze
        // at acceptance is the equity before it. TradingView sizes the entry
        // on the equity after the call (lane W4-ENG-POOC-SAMEPASS).
        if (source.market_admission.sizing_revision()
            && finite_positive(source.sizing.frozen_units)) {
            result.units = source.sizing.frozen_units;
        }
    } else if (finite_positive(source.sizing.frozen_units) && !source.sizing.at_fill
               && (!(source.family == PineOrderFamily::Entry
                     && finite_positive(source.exit_levels.stop)
                     && !finite_positive(source.exit_levels.limit))
                   || config_.default_qty_type
                          == static_cast<int>(QtyType::PERCENT_OF_EQUITY))) {
        result.units = source.sizing.frozen_units;
    } else if (config_.default_qty_type == static_cast<int>(QtyType::FIXED)) {
        result.units = config_.default_qty_value;
    } else {
        const double price = source.sizing.at_fill ? result.resolved_price : source.sizing.price;
        const double fx = source.sizing.at_fill ? facts.active_fx : source.sizing.fx;
        PineSizingSnapshot sizing;
        sizing.price = price;
        sizing.fx = fx;
        sizing.mark = price;
        if (source.sizing.at_fill) {
            mark_sizing_equity(sizing, result.resolved_price, facts.active_fx);
        } else {
            sizing.equity = source.sizing.equity;
            sizing.strategy_equity = source.sizing.strategy_equity;
        }
        // ab9714be pine_policy_members.cpp:282: default sizing units divides equity by price, pointvalue, and currency fx
        result.units = default_sizing_units(sizing);
    }
    const auto created_side = static_cast<PositionSide>(source.projection_position_side);
    if (source.family == PineOrderFamily::Entry) {
        const bool opposite = facts.position.signed_units != 0.0
            && ((facts.position.signed_units > 0.0) != source.is_long);
        const bool keep_mc_close_surplus = [&]() {
            if (!source.affordability_keep_mc_close_surplus) return false;
            bool receipt_origin_live = false;
            for (const auto& cohort : cohorts_by_id_.held_rows()) {
                const auto units = cohort.second.live_units_by_origin.find(
                    source.signal_close_mc_entry_incarnation);
                if (units != cohort.second.live_units_by_origin.end()
                    && units->second > 0.0) {
                    receipt_origin_live = true;
                    break;
                }
            }
            const auto state = detail::run_state(require_host());
            const auto* pine_host = pine_view_of(&require_host());
            const bool magnifier = pine_host
                && pine_host->scheduler_.bar_magnifier_enabled();
            const double close_surplus = source.projection_tv_carry_qty
                - std::abs(facts.position.signed_units);
            return source.signal_close_mc_bar == source.projection_created_bar
                && source.projection_created_bar
                    == facts.cursor.point.interval_index - 1
                && source.signal_close_mc_entry_incarnation != 0
                && last_margin_call_event_ordinal_ == last_applied_ordinal_
                && pine_host
                && source.signal_close_mc_fill_seq
                    == pine_host->adapter_broker_fill_event_sequence()
                && !config_.process_orders_on_close && !config_.calc_on_order_fills
                && !coof_recalc_active_ && !magnifier
                && std::holds_alternative<native_order::Market>(trigger)
                && !source.is_long && !std::isfinite(source.requested_qty)
                && !source.projection_after_close && !source.birth.from_fill()
                && source.projection_position_side
                    == static_cast<std::int32_t>(PositionSide::LONG)
                && source.placement_cycle == current_position_cycle_
                && facts.position.signed_units > 0.0
                && facts.position.lot_count == 1U && receipt_origin_live
                && facts.position.signed_units
                    == source.signal_close_mc_remaining_qty
                && std::isfinite(close_surplus)
                && std::abs(close_surplus - 1.0) < 1e-6;
        }();
        // The unified admission (tests/fixtures/margin_call_rules,
        // margin_ledger_rules and admission_rules): at its signal, placement
        // rule 2 on the money scale -- E < sig10(Q c' m) drops an opening from
        // flat and keeps only a reversal's closing leg -- and rule 5 on the
        // price scale at full margin -- sig10(sig10(E) / Q) under (ticks(c') +
        // side x slip) x mintick drops it whole (switch unified_placement); at
        // its fill only the price scale, every order type at every margin:
        // sig10(sig10(E) / (Q m)) under the tick-built fill quote moved by the
        // slippage ticks drops the whole order, a reversal keeping its old
        // position (switch fill_price_recheck). E is the signal's, frozen. No
        // money check is taken at the fill quote, and no tie band bounds
        // either half. A close-first entry takes rule 2 alone: it fills flat
        // behind the close it follows (close_first_admission).
        const bool market_or_stop = std::holds_alternative<native_order::Market>(trigger)
            || std::holds_alternative<native_order::Stop>(trigger);
        bool unified_admit = false;
        const auto& admission_rules = detail::margin_rule_switches();
        if (PF_RARE(source.signal_price_refused && admission_rules.unified_placement)) {
            result.units = 0.0;
            result.shape = native_order::OpeningShape::Transact;
            return result;
        }
        // The scope answers false outside its configuration
        // (unified_configured_); the terms are formed out of line, inside it.
        if (PF_RARE(unified_configured_ && !keep_mc_close_surplus
                    && (admission_rules.unified_placement
                        || admission_rules.fill_price_recheck))
            && unified_admission_terms(source, facts, market_or_stop, opposite, result,
                                       unified_admit)) {
            return result;
        }
        // ab9714be pine_fills.cpp:6577-6598: a default MARKET request carries
        // frozen_default_qty into execute_market_entry as a prequantized
        // quantity. Only per-call typed percentage requests use the
        // hypothetical-Flatten sizing path above.
        const bool default_money_candidate = !unified_admit
            && std::holds_alternative<native_order::Market>(trigger)
            && !std::isfinite(source.requested_qty)
            && config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
            && std::abs(config_.default_qty_value - 100.0) < 1e-12
            && std::abs((source.is_long ? config_.margin_long : config_.margin_short) - 100.0)
                < 1e-12
            && staged_.quantity_grid && *staged_.quantity_grid > 0.0
            && result.units && finite_positive(*result.units)
            && finite_positive(source.sizing.price)
            && finite_positive(source.sizing.equity)
            && finite_positive(source.sizing.fx)
            && finite_positive(staged_.syminfo.pointvalue);
        if (default_money_candidate) {
            bool ordinary_book = true;
            for (const auto& handle : live_handles_) {
                if (handle == facts.target) continue;
                const auto peer = placement_.find(handle.incarnation);
                if (peer == placement_.end()) continue;
                const auto& row = peer->second;
                const bool unpriced_close = (row.family == PineOrderFamily::Close
                    || row.family == PineOrderFamily::CloseAll)
                    && !finite_positive(row.exit_levels.limit)
                    && !finite_positive(row.exit_levels.stop)
                    && !finite_positive(row.exit_levels.trail_points)
                    && !finite_positive(row.exit_levels.trail_price);
                if (!unpriced_close) {
                    ordinary_book = false;
                    break;
                }
            }
            const bool low_value_lot = *staged_.quantity_grid * source.sizing.price
                * staged_.syminfo.pointvalue * source.sizing.fx < 1.0;
            const bool ordinary_fractional = *staged_.quantity_grid < 1.0
                && staged_.syminfo.pointvalue == 1.0 && source.sizing.fx == 1.0
                && staged_.account_fx_effective_from_ms.empty()
                && config_.commission_value == 0.0 && config_.slippage == 0
                && !config_.process_orders_on_close && !config_.calc_on_order_fills
                && config_.pyramiding >= 0 && config_.pyramiding <= 1
                && !cap.active() && risk_.max_intraday_loss <= 0.0
                && risk_.max_drawdown <= 0.0 && risk_.max_cons_loss_days == 0
                && ordinary_book;
            const bool whole_lot_tie_scope = *staged_.quantity_grid == 1.0
                && staged_.syminfo.pointvalue == 1.0 && source.sizing.fx == 1.0
                && staged_.account_fx_effective_from_ms.empty()
                && config_.commission_value == 0.0 && config_.slippage == 0
                && !config_.process_orders_on_close && !config_.calc_on_order_fills
                && config_.pyramiding >= 0 && config_.pyramiding <= 1
                && !cap.active() && risk_.max_intraday_loss <= 0.0
                && risk_.max_drawdown <= 0.0 && risk_.max_cons_loss_days == 0
                && ordinary_book;
            // Flat money ties use rounded notional, with TAIL-D's settled
            // agreement or no-gap qualification preserved (source_buying_power
            // flat-*/pooc-* and whole_lot_tie). Pyramiding does not affect a
            // genuinely flat book with no competing opening.
            const bool whole_flat_money = *staged_.quantity_grid == 1.0
                && staged_.syminfo.pointvalue == 1.0 && source.sizing.fx == 1.0
                && staged_.account_fx_effective_from_ms.empty()
                && config_.commission_value == 0.0 && config_.slippage == 0
                && !config_.calc_on_order_fills
                && finite_positive(staged_.syminfo.mintick)
                && !source.birth.from_fill() && source.oca_name.empty()
                && !cap.active() && risk_.max_intraday_loss <= 0.0
                && risk_.max_drawdown <= 0.0 && risk_.max_cons_loss_days == 0
                && source.projection_position_side
                    == static_cast<std::int32_t>(PositionSide::FLAT)
                && !source.projection_after_close && source.projection_predecessor == 0
                && facts.position.signed_units == 0.0
                && std::none_of(live_handles_.begin(), live_handles_.end(),
                    [&](const auto& handle) {
                        if (handle == facts.target) return false;
                        const auto peer = placement_.find(handle.incarnation);
                        return peer != placement_.end() && peer->second.opening;
                    });
            if (whole_flat_money) {
                const double rounded_cost = source_money_round(
                    *result.units * source.sizing.price);
                double settled = source.sizing.equity;
                const auto* pine = pine_view_of(host_);
                if (pine && std::isfinite(pine->net_profit_sum_)
                    && same_double_bits(percent_commission_live_equity(source.sizing.mark),
                                        source.sizing.equity)) {
                    settled = pine->initial_capital_
                        + source_money_round(pine->net_profit_sum_);
                    const double direction = pine->position_side_ == PositionSide::SHORT
                        ? -1.0 : 1.0;
                    for (const auto& lot : pine->pyramid_entries_) {
                        settled += direction * (source.sizing.mark - lot.price) * lot.qty
                            * staged_.syminfo.pointvalue * source.sizing.fx
                            - pine->open_entry_commission(lot);
                    }
                }
                const bool no_gap_tie = nearest_tick(
                    result.resolved_price, staged_.syminfo.mintick) == source.sizing.price
                    && rounded_cost == source_money_round(source.sizing.equity);
                if (std::isfinite(rounded_cost) && source.sizing.equity < rounded_cost
                    && (settled < rounded_cost || no_gap_tie)) {
                    result.units = 0.0;
                    result.shape = native_order::OpeningShape::Transact;
                    return result;
                }
            }
            const auto native_state = detail::run_state(require_host());
            const bool pooc_flat_money = config_.process_orders_on_close
                && source.projection_position_side
                    == static_cast<std::int32_t>(PositionSide::FLAT)
                && !source.projection_after_close && source.projection_predecessor == 0
                && facts.position.signed_units == 0.0
                && source.projection_created_bar == projection_bar_index(facts.cursor.point)
                && !source.birth.from_fill() && source.oca_name.empty()
                && config_.pyramiding >= 0 && config_.pyramiding <= 1
                && config_.commission_value == 0.0 && config_.slippage >= 0
                && finite_positive(staged_.syminfo.mintick)
                && *staged_.quantity_grid < 1.0
                && staged_.syminfo.pointvalue == 1.0 && source.sizing.fx == 1.0
                && staged_.account_fx == 1.0
                && staged_.account_fx_effective_from_ms.empty()
                && (!native_state.spec || native_state.spec->intrabar.is_none())
                && !cap.active()
                && risk_.max_intraday_loss <= 0.0
                && risk_.max_drawdown <= 0.0 && risk_.max_cons_loss_days == 0
                && nearest_tick(facts.raw_price, staged_.syminfo.mintick)
                    == nearest_tick(source.sizing.mark, staged_.syminfo.mintick);
            // Whole lots: the signal's equity against the cost of the whole
            // lots it sized, the units times the signal close, compared
            // exactly and whatever the next open does. Short of it by a
            // rounding tie, TradingView drops a flat entry and keeps only the
            // closing leg of a reversal (lab tv tapes
            // tests/fixtures/whole_lot_tie jd-rev-tie-pair, -bare, -gapdown,
            // -nogap, jd-flat-tie-gapdown and the control jd-rev-notie-pair).
            // That equity is the capital plus the realized profit plus the
            // open profit in floating point, whose residue decides an exact
            // tie (jd-drift-under and jd-drift-over: the capital and a
            // realized loss sum one ulp under and over their cent value). A
            // running sum of many closed profits carries a residue of its own
            // the engine does not reproduce: where the engine's sum and that
            // sum on the money grid disagree on the tie, TradingView takes it
            // on some books and not on others (declined on third-party
            // NASDAQ:AAPL 15 and NYSE:F 15 strategies, taken on another
            // third-party NYSE:F 15 strategy). Those differing ledgers
            // do not establish a broader rule, so the adapter keeps the no-gap
            // rule it had there (ab9714be pine_fills.cpp:5190-5219). While the
            // book is still the signal's the settled sum is read (lane TAIL-D).
            if (whole_lot_tie_scope) {
                const double cost = *result.units * source.sizing.price;
                double settled = source.sizing.equity;
                const auto* pine = pine_view_of(host_);
                if (pine && std::isfinite(pine->net_profit_sum_)
                    && same_double_bits(percent_commission_live_equity(source.sizing.mark),
                                        source.sizing.equity)) {
                    settled = pine->initial_capital_
                        + source_money_round(pine->net_profit_sum_);
                    const double direction = pine->position_side_ == PositionSide::SHORT
                        ? -1.0 : 1.0;
                    for (const auto& lot : pine->pyramid_entries_) {
                        settled += direction * (source.sizing.mark - lot.price) * lot.qty
                            * staged_.syminfo.pointvalue * source.sizing.fx
                            - pine->open_entry_commission(lot);
                    }
                }
                const bool short_raw = source.sizing.equity < cost;
                const bool short_settled = settled < cost;
                if (std::isfinite(cost) && short_raw && short_settled) {
                    result.units = opposite ? facts.opposite_book_units : 0.0;
                    result.shape = opposite ? native_order::OpeningShape::CloseOpposite
                                            : native_order::OpeningShape::Transact;
                    return result;
                }
                if (std::isfinite(cost) && short_raw
                    && nearest_tick(result.resolved_price, staged_.syminfo.mintick)
                        == source.sizing.price
                    && cost == source_money_round(source.sizing.equity)) {
                    result.units = 0.0;
                    result.shape = native_order::OpeningShape::Transact;
                    return result;
                }
            }
            if (low_value_lot || ordinary_fractional || pooc_flat_money) {
                const double notional_per_price = *result.units
                    * staged_.syminfo.pointvalue * source.sizing.fx;
                const double rounded_cost = source_money_round(
                    notional_per_price
                        * (pooc_flat_money ? source.sizing.mark : source.sizing.price));
                // The no-epsilon tape proves ordinary low-value opposite
                // market entries with pyramiding zero or one, including its
                // default (source_buying_power forex and px-fx tapes).
                // Preserve the prior guard for fractional POOC, costs, fill
                // births, other pyramiding, and projected-close books.
                const bool exact_money_scope = low_value_lot && ordinary_fractional
                    && opposite && !source.projection_after_close
                    && !source.birth.from_fill() && source.oca_name.empty()
                    && config_.pyramiding <= 1;
                const double money_guard = exact_money_scope ? 0.0 : 1e-9;
                if (source.sizing.equity + money_guard < rounded_cost) {
                    result.units = keep_mc_close_surplus ? 1.0
                        : (opposite ? facts.opposite_book_units : 0.0);
                    result.shape = keep_mc_close_surplus
                        ? native_order::OpeningShape::ReverseTo
                        : (opposite ? native_order::OpeningShape::CloseOpposite
                                    : native_order::OpeningShape::Transact);
                    return result;
                }
                if (!source.projection_after_close) {
                    const double affordable_price = source_money_round(
                        source_money_round(source.sizing.equity) / notional_per_price);
                    if (std::isfinite(affordable_price)
                        && affordable_price < source.sizing.price) {
                        result.units = 0.0;
                        result.shape = native_order::OpeningShape::Transact;
                        return result;
                    }
                }
            }
        }
        bool affordability_close_only = !unified_admit && source.affordability_close_only;
        if (!unified_admit && !affordability_close_only && source.affordability_policy_active
            && opposite) {
            const double margin = source.is_long ? config_.margin_long : config_.margin_short;
            const double own = result.units ? *result.units : 0.0;
            const double fill = nearest_tick(result.resolved_price, staged_.syminfo.mintick);
            const double required = own * fill * staged_.syminfo.pointvalue * facts.active_fx
                * margin / 100.0;
            // The source affordability tuple freezes its MTM equity at the
            // signal. The entry's later gap changes the cost, not the
            // carried-position mark; this is the NQ/rampatel close-only rule.
            const auto* pine_host = pine_view_of(&require_host());
            const double equity = finite_positive(source.sizing.equity) ? source.sizing.equity
                : pine_host ? pine_host->marked_equity_at(fill, facts.active_fx)
                            : require_host().native_marked_equity(fill);
            const double epsilon = std::max(
                1e-9, std::abs(equity) * 1e-12);
            affordability_close_only = margin > 0.0 && std::isfinite(required)
                && (!std::isfinite(equity) || required > equity + epsilon);
        }
        if (affordability_close_only) {
            if (!opposite) {
                result.units = 0.0;
                return result;
            }
            result.units = keep_mc_close_surplus ? 1.0
                : facts.opposite_book_units;
            result.shape = keep_mc_close_surplus
                ? native_order::OpeningShape::ReverseTo
                : native_order::OpeningShape::CloseOpposite;
            return result;
        }
    }
    if (source.family == PineOrderFamily::Order) {
        const bool opposite = facts.position.signed_units != 0.0
            && ((facts.position.signed_units > 0.0) != source.is_long);
        if (opposite) {
            result.units = std::min(*result.units, facts.opposite_book_units);
            result.shape = native_order::OpeningShape::CloseOpposite;
        }
        return result;
    }
    if (source.family == PineOrderFamily::Entry && source.sequential_group != 0
        && source.sequential_rank != 0 && source.has_full_entry_bracket) {
        bool paired = false;
        // The group's entries are kept while a member is live or queued
        // (erase_retired_rows, K7).
        const auto pairs = [&](const PlacementSnapshot& peer) {
            return peer.family == PineOrderFamily::Entry
                && peer.sequential_group == source.sequential_group
                && peer.sequential_rank != 0 && peer.sequential_rank != source.sequential_rank
                && peer.has_full_entry_bracket
                && !(source.is_long && peer.replaced_opening
                     && peer.replacement_predecessor_market);
        };
        PINEFORGE_AUDIT_PLACEMENT_SCAN(placement_,
            [&](std::uint64_t, const PlacementSnapshot& peer) { return pairs(peer); });
        for (const auto& row : placement_) {
            if (pairs(row.second)) {
                paired = true;
                break;
            }
        }
        if (paired) {
            const bool opposite = facts.position.signed_units != 0.0
                && ((facts.position.signed_units > 0.0) != source.is_long);
            if (source.sequential_rank == 1 && opposite)
                result.units = std::max(std::abs(facts.position.signed_units), *result.units);
            result.shape = native_order::OpeningShape::Transact;
            return result;
        }
    }
    // A same-id replacement of a live MARKET entry over an opposite open book
    // is a source transaction (reduce the carried side by its own size, open
    // any remainder), not the ordinary auto-reversal shape. The replacement
    // fact is captured before submit_or_replace retires its predecessor.
    // TradingView sizes a MARKET reissue against the position its predecessor
    // would leave, so it carries no reversal addend on either side and for
    // every quantity kind: default percent, fixed and cash, and an explicit
    // qty (R1, tests/fixtures/same_bar_reissue). The sell default-percent
    // scope before it is kept for a priced reissue.
    const bool opposite_at_fill = facts.position.signed_units != 0.0
        && ((facts.position.signed_units > 0.0) != source.is_long);
    const auto live_side = facts.position.signed_units > 0.0
        ? PositionSide::LONG : (facts.position.signed_units < 0.0
            ? PositionSide::SHORT : PositionSide::FLAT);
    const bool prior_cycle_close_only = opposite_at_fill
        && created_side != live_side
        && !source.projection_opposite_market_predecessor
        && (finite_positive(source.exit_levels.stop)
            || finite_positive(source.exit_levels.limit));
    const bool deferred_flip_from_flat = facts.position.signed_units == 0.0
        && source.projection_position_side
            != static_cast<std::int32_t>(PositionSide::FLAT)
        && ((source.projection_position_side
                == static_cast<std::int32_t>(PositionSide::LONG)) != source.is_long)
        && (finite_positive(source.exit_levels.stop)
            || finite_positive(source.exit_levels.limit))
        && finite_positive(source.projection_tv_carry_qty)
        && result.units && finite_positive(*result.units);
    if (deferred_flip_from_flat) {
        // ab9714be pine_orders.cpp:676-696: an opposite priced entry
        // which outlives the position it was placed against opens its own
        // units plus the captured carried side.
        result.units = *result.units + source.projection_tv_carry_qty;
        result.shape = native_order::OpeningShape::Transact;
    }
    if (opposite_at_fill) {
        const bool source_close_precedes = source.projection_after_close;
        const bool replacement_transaction = source.reverse_to
            && source.replaced_opening
            && source.replacement_predecessor_market
            && (std::holds_alternative<native_order::Market>(trigger)
                || (!source.is_long && !std::isfinite(source.requested_qty)
                    && config_.default_qty_type
                        == static_cast<int>(QtyType::PERCENT_OF_EQUITY)));
        // A flat stop entry is kept while a live or queued entry shares its
        // placement bar (erase_retired_rows, K8).
        const auto dual_stop_peer = [&](std::uint64_t incarnation, const PlacementSnapshot& peer) {
            return incarnation != facts.target.incarnation && peer.opening
                && peer.family == PineOrderFamily::Entry
                && peer.projection_position_side
                    == static_cast<std::int32_t>(PositionSide::FLAT)
                && peer.projection_created_bar == source.projection_created_bar
                && peer.is_long != source.is_long
                && finite_positive(peer.exit_levels.stop)
                && !finite_positive(peer.exit_levels.limit);
        };
        const bool flat_dual_candidate = source.projection_position_side
                == static_cast<std::int32_t>(PositionSide::FLAT)
            && finite_positive(source.exit_levels.stop)
            && !finite_positive(source.exit_levels.limit);
        if (flat_dual_candidate)
            PINEFORGE_AUDIT_PLACEMENT_SCAN(placement_, dual_stop_peer);
        const bool flat_dual_stop = flat_dual_candidate
            && std::any_of(placement_.begin(), placement_.end(),
                [&](const auto& row) { return dual_stop_peer(row.first, row.second); });
        result.shape = source_close_precedes || replacement_transaction
            ? native_order::OpeningShape::Transact
            : prior_cycle_close_only
            ? native_order::OpeningShape::CloseOpposite
            : flat_dual_stop
            ? native_order::OpeningShape::Transact
            : native_order::OpeningShape::ReverseTo;
    }
    return result;
}
 
bool PineExecutionAdapter::partial_exit_sibling_live(
        const PlacementSnapshot& source, native_order::RequestHandle target) const {
    return std::any_of(live_handles_.begin(), live_handles_.end(), [&](const auto& handle) {
        if (handle == target) return false;
        const auto sibling = placement_.find(handle.incarnation);
        if (sibling == placement_.end()) return false;
        const auto family = sibling->second.family;
        // One bracket's stop/limit/trail legs are one owner order. Keep the
        // existing consumed-cycle predicate, shared with on_applied below.
        if (sibling->second.command_sequence == source.command_sequence
            && sibling->second.bracket_origin == source.bracket_origin) return false;
        return sibling->second.source_id == source.source_id
            && sibling->second.from_entry == source.from_entry
            && (family == PineOrderFamily::ExitLimit || family == PineOrderFamily::ExitStop
                || family == PineOrderFamily::ExitTrail);
    });
}
 
void PineExecutionAdapter::preflight_id_pair_precommit(const NativePrecommitView& view) const {
    if (view.settlement_readiness != execution::Status::Applied
        || !(view.inspected_closed_units > 0.0) || view.account.signed_units_after == 0.0)
        return;
    const auto found = placement_.find(view.target.incarnation);
    if (found == placement_.end()) return;
    const auto& source = found->second;
    if ((source.family != PineOrderFamily::ExitLimit && source.family != PineOrderFamily::ExitStop
         && source.family != PineOrderFamily::ExitTrail)
        || !((std::isfinite(source.requested_qty) && source.requested_qty > 0.0)
             || (std::isfinite(source.qty_percent) && source.qty_percent < 100.0 - 1e-9))
        || partial_exit_sibling_live(source, view.target)) return;
    // Still ONE single-string key with one separator. This borrowed view
    // performs no allocation, publication or financial/source mutation.
    consumed_partial_exit_cycles_.preflight_joined_single(source.source_id, '\x1f', source.from_entry);
}
 
NativePrecommitVerdict PineExecutionAdapter::validate_precommit(const NativePrecommitView& view) const {
    require_tree_precommit(view);
    const auto snapshot = placement_.find(view.target.incarnation);
    if (snapshot != placement_.end()) {
        const auto& source = snapshot->second;
        const auto physical = detail::run_position(require_host());
        // ab9714be pine_fills.cpp:7449-7459: a deferred strategy.close belongs
        // to the position cycle it was issued in.  When the live position
        // opened on a bar later than the close's creation bar — the next open's
        // opposite entry applied first and flipped the book — the legacy book
        // Removes the stale close instead of flattening the freshly opened lot
        // at its own entry price.  The two legacy exclusions are the short-seed
        // MATERIALIZE_LONG close and the same-bar market transaction's targeted
        // close artifact.
        const bool stale_close_for_new_position =
            (source.family == PineOrderFamily::Close
             || source.family == PineOrderFamily::CloseAll)
            && static_cast<PositionSide>(source.projection_position_side)
                   != PositionSide::FLAT
            && physical.signed_units != 0.0
            && position_open_bar_index_ > source.projection_created_bar
            && !source.frozen_market_targeted_close
            && !(short_seed_.active && view.target == short_seed_.materialize_long);
        if (stale_close_for_new_position) return NativePrecommitVerdict::Refuse;
        // ab9714be pine_fills.cpp:7483-7537: priced (stop/limit) entries are
        // throttled to one opening from flat per bar after an earlier entry
        // fill. A same-direction pyramid while still in position is the
        // exception and is admitted below by the not-flat check. Not gated on
        // process_orders_on_close (the owner applies it at the POOC fill
        // point too); COOF stays excluded.
        const bool leftover_flat_stop = view.definition
            && std::holds_alternative<native_order::Stop>(view.definition->request.trigger)
            && !finite_positive(source.exit_levels.limit);
        // ab9714be pine_fills.cpp:3687-3788: an older same-direction flip-prep
        // stop that this bar also touches fills first and consumes the
        // from-flat carry. Skip this later stop until that sibling opens,
        // then re-arm it (probe 72/93 S then S2).
        if (source.family == PineOrderFamily::Entry
            && view.account.would_open
            && physical.signed_units == 0.0
            && leftover_flat_stop
            && policy_script_bar_valid_
            && !config_.calc_on_order_fills
            && modeled_input()) {
            for (const auto& handle : live_handles_) {
                if (handle == view.target) continue;
                const auto found = placement_.find(handle.incarnation);
                if (found == placement_.end()) continue;
                const auto& prior = found->second;
                if (!prior.opening || prior.family != PineOrderFamily::Entry
                    || prior.is_long != source.is_long
                    || !finite_positive(prior.exit_levels.stop)
                    || finite_positive(prior.exit_levels.limit)
                    // ab9714be pine_fills.cpp:3895-3899: stable_sort orders touched entry stops by created_seq (source_sequence)
                    || prior.source_sequence >= source.source_sequence) {
                    continue;
                }
                const auto created = static_cast<PositionSide>(
                    prior.projection_position_side);
                // ab9714be pine_fills.cpp:3687-3788 / 7470-7516: the pending
                // scan is book order, not path order. An older same-direction
                // stop that this bar also touches fills first, including a
                // leftover flat-armed leg (probe 80 morning LE then afternoon
                // LE2). Same-side-created pyramid adds are not leftovers.
                if (created != PositionSide::FLAT
                    && (created == PositionSide::LONG) == prior.is_long) {
                    continue;
                }
                // Same-bar siblings keep fill_phase (open-tick vs path). A
                // leftover from an earlier bar that this bar also touches
                // is the book-order override (LE then LE2).
                if (prior.projection_created_bar == source.projection_created_bar) {
                    continue;
                }
                const bool source_open_mkt = source.is_long
                    ? policy_script_bar_.open >= source.exit_levels.stop
                    : policy_script_bar_.open <= source.exit_levels.stop;
                const bool prior_open_mkt = prior.is_long
                    ? policy_script_bar_.open >= prior.exit_levels.stop
                    : policy_script_bar_.open <= prior.exit_levels.stop;
                if (source_open_mkt != prior_open_mkt) continue;
                const bool prior_touched = prior.is_long
                    ? policy_script_bar_.high >= prior.exit_levels.stop
                    : policy_script_bar_.low <= prior.exit_levels.stop;
                if (!prior_touched) continue;
                if (!throttled_rearm_already_queued(throttled_reopen_rearm_, source))
                    throttled_reopen_rearm_.push_back(source);
                return NativePrecommitVerdict::Refuse;
            }
        }
        if (source.family == PineOrderFamily::Entry
            && view.account.would_open
            && physical.signed_units == 0.0
            && entry_openings_this_interval_ > 0
            && view.cursor.point.interval_index == entry_openings_interval_index_
            && leftover_flat_stop
            && !config_.calc_on_order_fills
            && modeled_input()) {
            // The legacy throttle is OrderEligibility::Skip for the bar; the
            // order keeps resting. A generic Refuse is terminal, so re-arm the
            // original stop at the bar close (L9g).
            if (!throttled_rearm_already_queued(throttled_reopen_rearm_, source))
                throttled_reopen_rearm_.push_back(source);
            return NativePrecommitVerdict::Refuse;
        }
        const bool opposite_entry = source.family == PineOrderFamily::Entry
            && physical.signed_units != 0.0
            && ((physical.signed_units > 0.0) != source.is_long);
        // ab9714be pine_risk.cpp:111-118, called only from
        // pine_orders.cpp:221 and pine_fills.cpp:4720-4727: these latches
        // gate a same-side/flat ENTRY at its fill. They never gate closes,
        // exits, RAW orders, or the closing half of an opposite entry.
        if (source.family == PineOrderFamily::Entry && !opposite_entry) {
            if (risk_.halted) return NativePrecommitVerdict::Refuse;
            if (risk_.max_cons_loss_days > 0
                && day_ledger_.consecutive_loss_days >= risk_.max_cons_loss_days) {
                return NativePrecommitVerdict::Refuse;
            }
            // pine_risk.cpp:115 compares the live source position, not the
            // candidate's resulting quantity. Equality blocks a further add.
            if (risk_.max_position_size > 0.0 && view.account.would_open
                && std::abs(physical.signed_units) >= risk_.max_position_size) {
                return NativePrecommitVerdict::Refuse;
            }
        }
        const bool exit = source.family == PineOrderFamily::ExitLimit
            || source.family == PineOrderFamily::ExitStop
            || source.family == PineOrderFamily::ExitTrail;
        if (exit && !source.immediately) {
            if (!config_.close_entries_rule_any && !source.from_entry.empty()) {
                const auto cohort = cohorts_by_id_.find(source.from_entry);
                if (cohort == cohorts_by_id_.end() || cohort->second.opened.empty()) {
                    return NativePrecommitVerdict::Refuse;
                }
            }
            const bool restored_after_margin = source.restored_after_margin
                || (source.legs.last_action()
                    && source.legs.last_action()->cause.phase
                        == exit_legs::Phase::AfterMargin
                    && !source.legs.dormant());
            const bool retained_trail = source.family == PineOrderFamily::ExitTrail
                && !source.legs.retired(exit_legs::Leg::Trail);
            if (!retained_trail
                && (source.legs.dormant()
                    || (!restored_after_margin
                        && follows_same_bar_declined_reversal(source, view)))) {
                return NativePrecommitVerdict::Refuse;
            }
        }
    }
    // All exit-specific refusal gates above have passed. A storage refusal
    // is a coded exception, never a trading-policy Refuse verdict.
    preflight_id_pair_precommit(view);
    if (!view.account.would_open) return NativePrecommitVerdict::Admit;
    if (snapshot == placement_.end()) return NativePrecommitVerdict::Refuse;
    const auto& source = snapshot->second;
    if (cap.active() && cap.budget().latched()
        && source.source_id != "__intraday_cap_close__") {
        const auto& transfer = cap.budget().transfer();
        const bool inherited = transfer
            && transfer->inheritor == view.target.incarnation
            && transfer->close_fill == cap_latest_fill_;
        if (!inherited) return NativePrecommitVerdict::Refuse;
    }
    const auto physical_now = detail::run_position(require_host());
    // A market entry the script placed at a process_orders_on_close close where
    // a follow-up was then booked after it (book_owed_close_follow_up), filling
    // at that close on the book the frozen close's over-fill lot left on its
    // side, buys its own leg: the pyramiding-0 refusal does not read it (lab tv
    // tapes tests/fixtures/margin_open_rules lots/close-id-*,
    // close-all-overfill-gap: the entry "L" opens beside the over-fill lot), and
    // a default-sized one is not re-checked for affordability at the fill
    // either (synthetic OANDA:EURUSD 15m: a default-sized "LONG" of
    // 40000 opens beside 0.20; the over-fill controls cover the ordering).
    // Other shapes beside the lot -- a priced entry, a fill on a later bar --
    // keep every gate: no tape decides them.
    const auto beside_frozen_close_lot = [&]() {
        if (last_margin_call_script_bar_ != source.placement_script_open_ms
            || !config_.process_orders_on_close || !source.opening
            || !detail::margin_schedule_switches().close_follow_up_after_script
            || !view.definition
            || !std::holds_alternative<native_order::Market>(view.definition->request.trigger)
            || finite_positive(source.exit_levels.limit) || finite_positive(source.exit_levels.stop)
            || projection_bar_index(view.cursor.point) != source.projection_created_bar) {
            return false;
        }
        const auto lots = require_host().native_open_lots(kNaN);
        if (lots.empty()) return false;
        const auto first = placement_.find(lots.front().entry_incarnation);
        return first != placement_.end() && first->second.crosses_zero
            && (first->second.family == PineOrderFamily::Close
                || first->second.family == PineOrderFamily::CloseAll)
            && first->second.placement_script_open_ms == source.placement_script_open_ms;
    };
    if (source.family == PineOrderFamily::Entry && view.account.would_open
        && physical_now.signed_units != 0.0
        && ((physical_now.signed_units > 0.0) == source.is_long)) {
        const bool beside = !source.affordability_close_only && PF_RARE(beside_frozen_close_lot());
        if (beside && source.deferred_cohort && !std::isfinite(source.requested_qty))
            return NativePrecommitVerdict::AdmitWithHostMargin;
        if (config_.pyramiding == 0 && !beside) return NativePrecommitVerdict::Refuse;
    }
    // ab9714be pine_fills.cpp:5551-5554,5564-5664: the high-level MARKET
    // affordability gate never owned RAW strategy.order.  A36 places host
    // admission before the generic gate so this explicit exclusion can remain
    // source policy while the native core still owns the resulting fill and
    // any post-fill margin checkpoint.
    if (source.family == PineOrderFamily::Order) {
        return NativePrecommitVerdict::AdmitWithHostMargin;
    }
    // Nor an order sized when it was placed (close_point_margin_call): a
    // margin call or close whose book shrank before it filled opens the rest
    // on the other side, or beside the lot the other side already holds, as
    // placed -- no entry gate, pyramiding included, reads it (w13-b1s-close-f; synthetic:
    // the close_all's 6 units and the follow-up's 2, once the short is flat,
    // both open long at the next 25.00 open).
    // The scope includes the current batch phase. Cross-phase frozen sizing
    // remains outside this route; persisting placement scope also needs the
    // snapshot's state-hash and placement-receipt representation.
    if (source.crosses_zero
        || (source.frozen_market_instruction && fixed_unmargined_market_batch_scope())) {
        return NativePrecommitVerdict::AdmitWithHostMargin;
    }
    // The unified admission's fill half (fill_price_recheck), at this fill's
    // own quote; no money check follows here (resolve_terms took the signal
    // half). A close-first entry is never checked on the price scale.
    const bool close_first_admitted = source.close_first_entry
        && detail::margin_rule_switches().close_first_admission;
    if (PF_RARE(unified_configured_ && view.definition
        && (detail::margin_rule_switches().fill_price_recheck || close_first_admitted)
        && unified_admission_scope(
            source,
            std::holds_alternative<native_order::Market>(view.definition->request.trigger)
                || std::holds_alternative<native_order::Stop>(view.definition->request.trigger),
            physical_now.signed_units, std::abs(view.inspected_opened_units)))) {
        if (close_first_admitted) return NativePrecommitVerdict::AdmitWithHostMargin;
        const double quote = finite_positive(view.raw_price) ? view.raw_price : view.resolved_price;
        return unified_fill_admits(source, std::abs(view.inspected_opened_units), quote)
            ? NativePrecommitVerdict::AdmitWithHostMargin : NativePrecommitVerdict::Refuse;
    }
    const double placed_reversal_units = finite_positive(source.projection_affordability_held_qty)
        ? source.projection_affordability_held_qty : source.projection_tv_carry_qty;
    if (source.family == PineOrderFamily::Entry && source.reverse_to
        && std::holds_alternative<native_order::Stop>(view.definition->request.trigger)
        && physical_now.signed_units == 0.0
        && source.projection_position_side != static_cast<std::int32_t>(PositionSide::FLAT)
        && (source.projection_position_side == static_cast<std::int32_t>(PositionSide::LONG))
            != source.is_long
        && finite_positive(placed_reversal_units)
        && finite_positive(source.sizing.equity)) {
        const double own_units = std::abs(view.inspected_opened_units)
            - placed_reversal_units;
        const double margin_pct = source.is_long ? config_.margin_long : config_.margin_short;
        const double required = own_units * view.resolved_price * staged_.syminfo.pointvalue
            * active_staged_fx(view.cursor.point.effective_time_ms) * margin_pct / 100.0;
        const double guard = std::max(1e-9, std::abs(source.sizing.equity) * 1e-12);
        if (std::abs(margin_pct - 100.0) < 1e-12
            && finite_positive(own_units) && std::isfinite(required)
            && required <= source.sizing.equity + guard) {
            return NativePrecommitVerdict::AdmitWithHostMargin;
        }
    }
    // Entries a bar placed while the book was flat all fill where they reach
    // their fill point, the later ones behind a book of their own side that
    // only the earlier ones opened: TradingView judges each on its own cost
    // against the equity it was sized from, as it judged the first, and
    // margin-calls the combined book once they have all filled (lab tv tapes
    // tests/fixtures/margin_residual w5b-sb-market-60x2, -pooc-60x2,
    // -default-x3 and -pooc-default-x3: every cell's entries fill, and the
    // book is called at the fill, or at the next open under
    // process_orders_on_close; lane W5B-ENG-MARGIN-RESIDUAL).
    if (flat_sibling_book(source, view.cursor.point.interval_index,
                          view.cursor.point.path_phase)) {
        if (config_.pyramiding > 0
            && physical_now.lot_count >= static_cast<std::size_t>(config_.pyramiding)) {
            return NativePrecommitVerdict::Refuse;
        }
        const double margin_pct = source.is_long ? config_.margin_long : config_.margin_short;
        if (!(margin_pct > 0.0) || !std::isfinite(margin_pct))
            return NativePrecommitVerdict::AdmitWithHostMargin;
        const double fx = active_staged_fx(view.cursor.point.effective_time_ms);
        const double own_units = finite_positive(source.sizing.frozen_units)
                && !std::isfinite(source.requested_qty)
            ? source.sizing.frozen_units : std::abs(view.inspected_opened_units);
        const double unit_margin = view.resolved_price * staged_.syminfo.pointvalue * fx
            * margin_pct / 100.0;
        const double equity = finite_positive(source.sizing.equity)
            ? source.sizing.equity : view.account.marked_equity;
        const double guard = std::max(
            {1e-9, std::abs(equity) * 1e-12,
             staged_.quantity_grid ? *staged_.quantity_grid * unit_margin : 0.0});
        if (!finite_positive(own_units) || !std::isfinite(unit_margin)
            || !std::isfinite(equity) || own_units * unit_margin > equity + guard) {
            return NativePrecommitVerdict::Refuse;
        }
        return NativePrecommitVerdict::AdmitWithHostMargin;
    }
 
    // Under process_orders_on_close a default percent_of_equity (at most 100)
    // stop entry placed from flat and not yet marketable is sized at its
    // level. When a later bar opens through that level, TradingView fills it
    // at the open only if the equity it was sized from pays for its units
    // there; otherwise it refuses the order, which is then gone (lane
    // W10-DIAG-UNKNOWN rule GAPSTOP, tests/fixtures/pooc_gap_stop). A fill at
    // the level itself costs no more than that equity by the sizing's floor.
    const double gap_stop_slip = (source.is_long ? 1.0 : -1.0) * config_.slippage
        * staged_.syminfo.mintick;
    if (source.family == PineOrderFamily::Entry && config_.process_orders_on_close
        && std::holds_alternative<native_order::Stop>(view.definition->request.trigger)
        && !std::isfinite(source.requested_qty)
        && config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        && config_.default_qty_value <= 100.0 && !source.sizing.at_fill
        && source.projection_position_side == static_cast<std::int32_t>(PositionSide::FLAT)
        && physical_now.signed_units == 0.0
        && finite_positive(source.sizing.frozen_units)
        && finite_positive(source.sizing.equity) && finite_positive(source.exit_levels.stop)
        && source.sizing.price == source.exit_levels.stop + gap_stop_slip
        && (source.is_long ? view.resolved_price > source.sizing.price
                           : view.resolved_price < source.sizing.price)) {
        const double margin_pct = source.is_long ? config_.margin_long : config_.margin_short;
        const double cost = source.sizing.frozen_units * view.resolved_price
            * staged_.syminfo.pointvalue * source.sizing.fx * margin_pct / 100.0;
        const double epsilon = std::max(1e-9, std::abs(source.sizing.equity) * 1e-12);
        if (!std::isfinite(cost) || cost > source.sizing.equity + epsilon)
            return NativePrecommitVerdict::Refuse;
    }
 
    // ab9714be pine_policy_members.cpp:153-210 and pine_fills.cpp:5627-5644:
    // a same-bar process-on-close long uses ten-significant-digit signal money
    // and the slipped signal threshold.  This is the source host's complete
    // margin decision for the candidate; a genuine post-fill shortfall is
    // admitted and becomes the observable opening-margin event.
    const auto native_state = detail::run_state(require_host());
    const bool pooc_default_all_in = !std::isfinite(source.requested_qty)
        && config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        && config_.default_qty_value == 100.0
        && finite_positive(source.sizing.frozen_units)
        && finite_positive(source.sizing.equity) && source.sizing.fx == 1.0;
    const bool pooc_explicit_fixed = finite_positive(source.requested_qty)
        && (source.qty_type < 0 || source.qty_type == static_cast<int>(QtyType::FIXED))
        && finite_positive(source.projection_affordability_equity)
        && source.projection_affordability_held_qty == 0.0;
    const bool pooc_money_scope = config_.process_orders_on_close
        && source.family == PineOrderFamily::Entry
        && std::holds_alternative<native_order::Market>(view.definition->request.trigger)
        && source.is_long && source.opening
        && source.projection_created_bar == projection_bar_index(view.cursor.point)
        && source.projection_position_side == static_cast<std::int32_t>(PositionSide::FLAT)
        && !source.projection_after_close && !source.birth.from_fill()
        && source.projection_predecessor == 0 && !source.replaced_opening
        && source.oca_name.empty() && source.oca_type == 0
        && physical_now.signed_units == 0.0
        && config_.pyramiding >= 0 && config_.pyramiding <= 1
        && config_.margin_long == 100.0 && config_.commission_value == 0.0
        && config_.slippage >= 0 && finite_positive(staged_.syminfo.mintick)
        && staged_.quantity_grid && *staged_.quantity_grid > 0.0
        && *staged_.quantity_grid < 1.0
        && staged_.syminfo.pointvalue == 1.0 && staged_.account_fx == 1.0
        && source.sizing.fx == 1.0 && staged_.account_fx_effective_from_ms.empty()
        && (!native_state.spec || native_state.spec->intrabar.is_none())
        && !cap.active()
        && risk_.max_intraday_loss <= 0.0 && risk_.max_drawdown <= 0.0
        && risk_.max_cons_loss_days == 0
        && (pooc_default_all_in || pooc_explicit_fixed);
    if (pooc_money_scope) {
        const double units = pooc_default_all_in
            ? source.sizing.frozen_units : source.requested_qty;
        const double equity = pooc_default_all_in
            ? source.sizing.equity : source.projection_affordability_equity;
        const double signal = pooc_default_all_in
            ? source.sizing.mark : source.projection_affordability_signal_price;
        const double admission_price = pooc_default_all_in
            ? source.sizing.price
            : nearest_tick(signal + config_.slippage * staged_.syminfo.mintick,
                           staged_.syminfo.mintick);
        const double rounded_cost = source_money_round(units * signal);
        const double affordable_price = source_money_round(
            source_money_round(equity) / units);
        if (!finite_positive(units) || !finite_positive(equity)
            || !finite_positive(signal) || !finite_positive(admission_price)
            || equity + 1e-9 < rounded_cost
            || (std::isfinite(affordable_price)
                && affordable_price < admission_price)) {
            return NativePrecommitVerdict::Refuse;
        }
        return NativePrecommitVerdict::AdmitWithHostMargin;
    }
    if (source.family == PineOrderFamily::Entry && source.affordability_policy_active) {
        const double margin_pct = source.is_long ? config_.margin_long : config_.margin_short;
        const double fx = active_staged_fx(view.cursor.point.effective_time_ms);
        const auto physical = detail::run_position(require_host());
        // ab9714be pine_fills.cpp:5560-5622: an ordinary explicit fixed
        // MARKET opening at fractional-lot resolution first passes the
        // rounded-money signal-cost and affordable-price checks.  This is a
        // source broker precommit policy; the configured default sizing mode
        // does not participate in its decision.
        const double explicit_units = std::abs(view.inspected_opened_units);
        const bool explicit_money_scope =
            std::holds_alternative<native_order::Market>(view.definition->request.trigger)
            && std::isfinite(source.requested_qty) && source.requested_qty > 0.0
            && (source.qty_type < 0
                || source.qty_type == static_cast<int>(QtyType::FIXED))
            && physical.signed_units == 0.0
            && source.projection_position_side
                == static_cast<std::int32_t>(PositionSide::FLAT)
            && !source.projection_after_close && source.projection_predecessor == 0
            && source.oca_type == 0 && source.oca_name.empty()
            && projection_bar_index(view.cursor.point) == source.projection_created_bar + 1
            && live_handles_.size() == 1
            && config_.margin_long == 100.0 && config_.margin_short == 100.0
            && staged_.quantity_grid && *staged_.quantity_grid > 0.0
            && *staged_.quantity_grid < 1.0
            && staged_.syminfo.pointvalue == 1.0 && source.sizing.fx == 1.0
            && staged_.account_fx == 1.0
            && staged_.account_fx_effective_from_ms.empty()
            && config_.slippage == 0
            && config_.commission_type == static_cast<int>(CommissionType::PERCENT)
            && !config_.process_orders_on_close && !config_.calc_on_order_fills
            && config_.pyramiding >= 0 && config_.pyramiding <= 1
            && !cap.active() && risk_.max_intraday_loss <= 0.0
            && risk_.max_drawdown <= 0.0 && risk_.max_cons_loss_days == 0
            && finite_positive(source.projection_affordability_equity)
            && finite_positive(source.projection_affordability_signal_price)
            && finite_positive(explicit_units)
            && *staged_.quantity_grid * source.projection_affordability_signal_price < 1.0;
        if (explicit_money_scope) {
            const double equity = source.projection_affordability_equity;
            const double signal = source.projection_affordability_signal_price;
            const double rounded_cost = source_money_round(explicit_units * signal);
            const double affordable_price = source_money_round(
                source_money_round(equity) / explicit_units);
            if (equity + 1e-9 < rounded_cost
                || (std::isfinite(affordable_price) && affordable_price < signal)) {
                return NativePrecommitVerdict::Refuse;
            }
        }
        const bool same_side = physical.signed_units != 0.0
            && ((physical.signed_units > 0.0) == source.is_long);
        const bool reversal = physical.signed_units != 0.0
            && ((physical.signed_units > 0.0) != source.is_long);
        double units = same_side
            ? std::abs(view.account.resulting_abs_notional)
                / (view.resolved_price * staged_.syminfo.pointvalue * fx)
            : std::abs(view.inspected_opened_units);
        // TradingView judges a MARKET entry filled at the open after the bar
        // that placed it against the position held at its placement, not
        // against a sibling entry that filled at the same open a moment
        // earlier: two entries that each fit the equity alone both fill, and
        // the excess is margin-called at the fill, first in first out (lane
        // W10-DIAG-UNKNOWN rule COQ, tests/fixtures/coqueued_open_margin).
        // Units held beyond the placement's own held quantity can only be
        // such same-open fills, so only they leave the requirement. An entry
        // the open trades already hold at the pyramiding cap is TradingView's
        // to refuse at this check (H-MEASURE's first-eligible-point count),
        // so it keeps the whole-book requirement. Under
        // process_orders_on_close the adds a bar placed fill at its close and
        // are judged alike, each beside the position held when it was placed
        // (lab tv tapes tests/fixtures/add_sibling_margin tailb-adds-pooc-*;
        // lane TAIL-B).
        const auto placed_side = static_cast<PositionSide>(source.projection_position_side);
        const double placed_held = source.projection_affordability_held_qty;
        const bool same_point_as_placed =
            projection_bar_index(view.cursor.point) == source.projection_created_bar + 1
            || (config_.process_orders_on_close && !config_.calc_on_order_fills
                && projection_bar_index(view.cursor.point) == source.projection_created_bar
                && view.cursor.point.path_phase == NativePathPhase::Close);
        if (same_side
            && std::holds_alternative<native_order::Market>(view.definition->request.trigger)
            && (placed_side == PositionSide::FLAT
                || (placed_side == PositionSide::LONG) == source.is_long)
            && std::isfinite(placed_held) && placed_held >= 0.0
            && same_point_as_placed
            && std::abs(physical.signed_units) > placed_held + 1e-10
            && config_.pyramiding > 0
            && physical.lot_count < static_cast<std::size_t>(config_.pyramiding)) {
            units = placed_held + std::abs(view.inspected_opened_units);
        }
        // Margin rule 2 at a next-bar fill: an explicit quantity market long
        // that opens from flat at full margin is dropped only when the equity
        // is below sig10(Q x the fill's UNSLIPPED quote); its slippage was
        // judged at placement, on the price scale (tests/fixtures/
        // margin_call_rules admit-eth-nonpooc-s2-m04u; synthetic 2.5 at the 200.11
        // open fits 500.32499996 though its slipped 200.13 does not;
        // admit-eth-nonpooc-s2-gapup: a gap-up open whose unslipped
        // cost exceeds the equity drops). Pinned with slippage only: without
        // it TradingView fills such an entry and calls it at the open
        // (test_high_value_fractional_money_margin_l4a's capital controls).
        // Inside the unified admission's scope the fill re-check replaces it
        // (margin_call_rules factorial/c1-a3-exp-long-s1-gapup1): with
        // fill_price_recheck on, that check has already decided such an order
        // above and this one is never reached. It stays for the orders outside
        // that scope (a commission, pyramiding above one, another order
        // resting, a risk rule), which no tape decides.
        if (PF_RARE(detail::margin_rule_switches().slipped_signal_admission
            && source.family == PineOrderFamily::Entry && margin_pct == 100.0
            && source.is_long && !config_.process_orders_on_close && config_.slippage > 0
            && std::holds_alternative<native_order::Market>(view.definition->request.trigger)
            && std::isfinite(source.requested_qty)
            && (source.qty_type < 0 || source.qty_type == static_cast<int>(QtyType::FIXED))
            && source.projection_position_side == static_cast<std::int32_t>(PositionSide::FLAT)
            && physical.signed_units == 0.0 && view.inspected_closed_units == 0.0
            && staged_.syminfo.pointvalue == 1.0 && fx == 1.0 && source.sizing.fx == 1.0
            && staged_.account_fx_effective_from_ms.empty()
            && finite_positive(staged_.syminfo.mintick) && finite_positive(view.resolved_price)
            && std::isfinite(source.sizing.equity) && finite_positive(units))) {
            const double tick = staged_.syminfo.mintick;
            // The fill's own price decides (switch open_fill_admission): the
            // order is dropped where sig10(sig10(E) / Q) is below the slipped
            // open tick it fills at. Synthetic BINANCE:ETHUSDT.P at slippage 2 and
            // commission 0.05 %: a long of 4 placed on 1000.04 fills
            // at no price above 250.01, and the 250.00 open fills at
            // 250.02: dropped; 0.05 more cash admits it (lab tv tapes
            // tests/fixtures/margin_open_rules admission/). A tie on the ten
            // significant digits admits: synthetic 2.5 at the 200.11 open, filled at
            // 200.13, on 500.32499996 (admit-eth-nonpooc-s2-m04u).
            if (PF_RARE(detail::margin_opening_switches().open_fill_admission)) {
                const double exec = std::floor(view.resolved_price / tick + 0.5) * tick;
                const double per_unit = source_money_round(
                    source_money_round(source.sizing.equity) / units);
                return per_unit < exec
                    ? NativePrecommitVerdict::Refuse : NativePrecommitVerdict::AdmitWithHostMargin;
            }
            const double quote = (std::floor(view.resolved_price / tick + 0.5)
                - (source.is_long ? 1.0 : -1.0) * config_.slippage) * tick;
            return source.sizing.equity < source_money_round(units * quote)
                ? NativePrecommitVerdict::Refuse : NativePrecommitVerdict::AdmitWithHostMargin;
        }
        // A same-side add at full margin is judged as the whole book at the
        // tick-built signal close, not at its slipped fill, against the
        // fee-charged equity there, with and without process_orders_on_close
        // (switch add_signal_close): on NYSE:F 1D at slippage 3 and commission 0.1 %
        // synthetic 200 shares plus an add of 10 cost 5250.00 at a 25.00 signal
        // close and fit fee-charged equity of 5253.00, where the 25.03 fill's
        // 5256.30 does not (lab tv tapes tests/fixtures/margin_schedule_rules
        // add/ establish the signal-close rule).
        const double add_price = PF_RARE(same_side && source.family == PineOrderFamily::Entry
                && detail::margin_schedule_switches().add_signal_close && margin_pct == 100.0
                && finite_positive(source.projection_affordability_signal_price))
            ? source.projection_affordability_signal_price : view.resolved_price;
        const double required = units * add_price * staged_.syminfo.pointvalue * fx
            * margin_pct / 100.0;
        // The placement tuple deliberately excludes the prospective opening
        // commission. Use its source-time MTM equity for fixed/cash/explicit
        // affordability instead of the native post-open projection.
        double equity = reversal
            ? view.account.marked_equity
            : (finite_positive(source.sizing.equity)
                ? source.sizing.equity : view.account.marked_equity);
        const bool pooc_slipped_signal = config_.process_orders_on_close
            && source.projection_created_bar == projection_bar_index(view.cursor.point)
            && source.projection_position_side
                == static_cast<std::int32_t>(PositionSide::FLAT)
            && physical.signed_units == 0.0
            && std::holds_alternative<native_order::Market>(
                view.definition->request.trigger)
            && finite_positive(source.projection_affordability_signal_price);
        if (pooc_slipped_signal) {
            const double signal_fill = nearest_tick(
                source.projection_affordability_signal_price
                    + (source.is_long ? 1.0 : -1.0) * config_.slippage
                        * staged_.syminfo.mintick,
                staged_.syminfo.mintick);
            const double signal_threshold = units * signal_fill
                * staged_.syminfo.pointvalue * fx * margin_pct / 100.0;
            if (std::isfinite(signal_threshold))
                equity = std::max(equity, signal_threshold);
        }
        const double epsilon = std::max(1e-9, std::abs(equity) * 1e-12);
        if (!(margin_pct > 0.0) || !std::isfinite(margin_pct)) {
            return NativePrecommitVerdict::AdmitWithHostMargin;
        }
        // ab9714be pine_fills.cpp:5564-5663: a MARKET reversal is costed as its
        // own new side at max(tick(close(S)), tick(fill)) against the PLACEMENT
        // equity snapshot, fees excluded.  The post-close marked book already
        // carries the reversal's closing fee and the carried side's gap, so it
        // declined fee-only shortfalls that the owner admits and then trims at
        // the fill (pine_fills.cpp:5999-6005, 1386-1482).
        const bool market_reversal = reversal
            && std::holds_alternative<native_order::Market>(view.definition->request.trigger)
            && finite_positive(source.projection_affordability_equity)
            && finite_positive(source.projection_affordability_signal_price);
        if (market_reversal) {
            const double raw_fill = finite_positive(view.raw_price)
                ? view.raw_price : view.resolved_price;
            const double admit_price = std::max(
                source.projection_affordability_signal_price,
                nearest_tick(raw_fill, staged_.syminfo.mintick));
            const double placement_equity = source.projection_affordability_equity;
            const double reversal_required = units * admit_price
                * staged_.syminfo.pointvalue * fx * margin_pct / 100.0;
            const double guard = std::max(1e-9, std::abs(placement_equity) * 1e-12);
            if (!std::isfinite(reversal_required)
                || reversal_required > placement_equity + guard) {
                return NativePrecommitVerdict::Refuse;
            }
            return NativePrecommitVerdict::AdmitWithHostMargin;
        }
        if (!std::isfinite(required) || !std::isfinite(equity) || required > equity + epsilon) {
            return NativePrecommitVerdict::Refuse;
        }
        return NativePrecommitVerdict::AdmitWithHostMargin;
    }
    const bool exit = source.family == PineOrderFamily::ExitLimit
        || source.family == PineOrderFamily::ExitStop || source.family == PineOrderFamily::ExitTrail;
    if (exit) {
        // A bound exit whose selected scope has no remaining physical units is
        // a stale source leg, not a zero-quantity trade.  The legacy pending
        // book removed that sibling before settlement; refusing the native
        // candidate preserves the same observable trade roster.
        if (!view.account.would_open && !(view.inspected_closed_units > 0.0))
            return NativePrecommitVerdict::Refuse;
        if (PF_RARE(((std::isfinite(source.requested_qty) && source.requested_qty > 0.0)
                     || (std::isfinite(source.qty_percent) && source.qty_percent < 100.0 - 1e-9))
                    && exit_tombstoned(source.source_id, source.from_entry))) {
            return NativePrecommitVerdict::Refuse;
        }
        const auto& bounds = source.leg_activation.bounds();
        const bool stop_leg = source.family == PineOrderFamily::ExitStop;
        const bool limit_leg = source.family == PineOrderFamily::ExitLimit;
        if (bounds && current_position_cycle_ > 0) {
            const bool ready = stop_leg
                ? source.leg_activation.stop_ready(current_position_cycle_, view.cursor.point.interval_index)
                : (limit_leg ? source.leg_activation.limit_ready(
                    current_position_cycle_, view.cursor.point.interval_index) : true);
            if (!ready) return NativePrecommitVerdict::Refuse;
        }
        if (source.legs.retired(exit_legs::Leg::Stop)
            && source.legs.retired(exit_legs::Leg::Limit)
            && source.legs.retired(exit_legs::Leg::Trail)) {
            return NativePrecommitVerdict::Refuse;
        }
    }
    if (source.family == PineOrderFamily::Entry && source.reverse_to
        && !source.projection_after_close
        && config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        && config_.default_qty_value >= 100.0
        && finite_positive(source.sizing.frozen_units)) {
        // pine_fills.cpp:5497-5519 prices an all-in reversal against the
        // source-time frozen equity even under COOF.  The native marked book
        // includes the carried side's gap PnL and would otherwise admit the
        // +1-gap reversal that the source broker declines.
        const double margin = source.is_long ? config_.margin_long : config_.margin_short;
        const double fx = active_staged_fx(view.cursor.point.effective_time_ms);
        const double required = source.sizing.frozen_units * view.resolved_price
            * staged_.syminfo.pointvalue * fx * margin / 100.0;
        const double equity = source.sizing.equity;
        const double guard = std::max(1e-9, std::abs(equity) * 1e-12);
        const bool nested_price_gap_scope = margin == 100.0
            && std::holds_alternative<native_order::Market>(view.definition->request.trigger)
            && finite_positive(staged_.syminfo.mintick)
            && staged_.quantity_grid && *staged_.quantity_grid > 0.0
            && *staged_.quantity_grid < 1.0
            && staged_.syminfo.pointvalue == 1.0 && source.sizing.fx == 1.0
            && staged_.account_fx_effective_from_ms.empty()
            && config_.commission_type == static_cast<int>(CommissionType::PERCENT)
            && config_.commission_value == 0.0 && config_.slippage == 0
            && !config_.process_orders_on_close && !config_.calc_on_order_fills
            && view.resolved_price > source.sizing.price;
        const bool nested_price_gap_affordable = nested_price_gap_scope
            && source_price_band_affordable(equity, source.sizing.frozen_units,
                view.resolved_price, staged_.syminfo.mintick);
        if (!std::isfinite(required) || !std::isfinite(equity)
            || (nested_price_gap_scope && !nested_price_gap_affordable)
            || (required > equity + guard && !nested_price_gap_affordable)) {
            return NativePrecommitVerdict::Refuse;
        }
    }
    const bool variable_default = config_.default_qty_type != static_cast<int>(QtyType::FIXED);
    // The pyramiding cap: a same-side add is refused at its fill once the open
    // close-ledger records reach pyramiding, whatever its quantity type; a
    // LIMIT entry the cap admitted at placement fills however many are open.
    const auto fill_records = open_ledger_records();
    if (PF_RARE(fill_records && source.family == PineOrderFamily::Entry && source.opening
        && config_.pyramiding > 0 && view.inspected_closed_units == 0.0
        && !pure_limit_entry(source))) {
        // The position at the fill, read only where the cap can decide.
        const double held_at_fill = detail::run_position(require_host()).signed_units;
        if (held_at_fill != 0.0 && ((held_at_fill > 0.0) == source.is_long)
            && *fill_records >= static_cast<std::size_t>(config_.pyramiding)) {
            return NativePrecommitVerdict::Refuse;
        }
    }
    // A LIMIT entry the cap admitted when it was placed fills however many
    // lots are open by then (lane W8A-SIGSTATE-1 R-B,
    // tests/fixtures/pyramiding_open_order).
    if (variable_default && !source.frozen_market_instruction && config_.pyramiding > 0
        && view.inspected_closed_units == 0.0
        && !(source.family == PineOrderFamily::Entry && pure_limit_entry(source))
        && (fill_records ? *fill_records : detail::run_position(require_host()).lot_count)
            >= static_cast<std::size_t>(config_.pyramiding)) {
        return NativePrecommitVerdict::Refuse;
    }
    const double margin_pct = view.account.incoming_short
        ? config_.margin_short : config_.margin_long;
    if (!(margin_pct > 0.0) || !std::isfinite(margin_pct))
        return NativePrecommitVerdict::AdmitWithHostMargin;
    const double fraction = margin_pct / 100.0;
    if (finite_positive(source.sizing.frozen_units) && !source.sizing.at_fill) {
        const double frozen_required = std::abs(source.sizing.frozen_units)
            * source.sizing.price * staged_.syminfo.pointvalue * source.sizing.fx * fraction;
        // ab9714be pine_fills.cpp:4814-4897: a reversal rechecks its frozen
        // quantity at the actual fill price. A lower fill can therefore admit
        // a signal tuple that is fractionally over budget; flat/same-side
        // openings still require their placement tuple to be valid.
        if (!std::isfinite(frozen_required) || !std::isfinite(source.sizing.equity)) {
            return NativePrecommitVerdict::Refuse;
        }
        const auto state = detail::run_state(require_host());
        const bool live_slippage_changed = state.spec
            && config_.slippage != static_cast<int>(state.spec->slippage_ticks);
        const bool placement_sized_stop = source.family == PineOrderFamily::Entry
            && finite_positive(source.exit_levels.stop)
            && !finite_positive(source.exit_levels.limit)
            && !std::isfinite(source.requested_qty);
        if (placement_sized_stop && live_slippage_changed) {
            // The adapter owns this admission (the placement tuple was frozen
            // at a different slippage); say so, or the run spec's own per-side
            // initial fraction would decline the opening TradingView takes.
            return NativePrecommitVerdict::AdmitWithHostMargin;
        }
        // The frozen tuple protects a rate rollover (the FX opening checkpoint
        // owns that later adjustment), but an ordinary price gap is still
        // rechecked at the fill just as the legacy admission path does.
        const double active_fx = active_staged_fx(view.cursor.point.effective_time_ms);
        if (active_fx == source.sizing.fx) {
            double fill_required = view.account.resulting_abs_notional * fraction;
            const auto physical = detail::run_position(require_host());
            const bool reversal = physical.signed_units != 0.0
                && ((physical.signed_units > 0.0) != source.is_long);
            // A MARKET entry placed while flat or on its own side that reverses
            // the position an earlier market entry of its bar opened at this
            // same open is judged by TradingView against its placement equity
            // with that position still margined: its own side plus the held
            // side must fit, or it is refused and the held position stays
            // (lane W10-DIAG-UNKNOWN rule SAMEOPEN-REV,
            // tests/fixtures/same_open_reversal). With slippage TradingView
            // runs such a reversal close-only instead (the -slip tape), which
            // this rule does not model. An entry placed on its own side is
            // held to the book its tapes pin, the bar's market entries and
            // unpriced closes: a priced or raw order, or one carried in from
            // an earlier bar, leaves it to the ordinary reversal, as the
            // live-position rule of test_live_position_market_gross_admission
            // does.
            const auto bare_same_bar_book = [&] {
                if (!delayed_market_orders_.empty()) return false;
                for (const auto& handle : live_handles_) {
                    if (handle == view.target) continue;
                    const auto found = placement_.find(handle.incarnation);
                    if (found == placement_.end()) continue;
                    const auto& row = found->second;
                    if (row.family == PineOrderFamily::Order) return false;
                    if (row.family != PineOrderFamily::Entry) continue;
                    if (finite_positive(row.exit_levels.limit)
                        || finite_positive(row.exit_levels.stop)
                        || row.projection_created_bar != source.projection_created_bar)
                        return false;
                }
                return true;
            };
            const bool same_open_reversal = reversal
                && source.family == PineOrderFamily::Entry
                && std::holds_alternative<native_order::Market>(
                    view.definition->request.trigger)
                && (source.projection_position_side
                        == static_cast<std::int32_t>(PositionSide::FLAT)
                    || (source.projection_position_side == static_cast<std::int32_t>(
                            source.is_long ? PositionSide::LONG : PositionSide::SHORT)
                        && bare_same_bar_book()))
                && !source.projection_after_close
                && projection_bar_index(view.cursor.point) == source.projection_created_bar + 1
                && position_open_bar_index_ == view.cursor.point.interval_index
                && !position_open_priced_ && config_.slippage == 0
                && !config_.process_orders_on_close && !config_.calc_on_order_fills
               ;
            if (same_open_reversal) {
                const double held_fraction = (physical.signed_units > 0.0
                    ? config_.margin_long : config_.margin_short) / 100.0;
                fill_required += std::abs(physical.signed_units) * view.resolved_price
                    * staged_.syminfo.pointvalue * active_fx * held_fraction;
            }
            const bool variable_batch = source.frozen_market_instruction
                && (config_.default_qty_type == static_cast<int>(QtyType::CASH)
                    || (config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
                        && config_.default_qty_value < 100.0));
            // An all-in source reversal remains admitted against the source
            // call snapshot.  Re-marking the carried side at a later gap
            // would manufacture buying power that the legacy precommit did
            // not grant (the ShortSeed all-in rejection controls).
            const bool all_in_reversal = reversal
                && config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
                && config_.default_qty_value >= 100.0;
            const bool close_then_open_margin_checkpoint = all_in_reversal
                && source.projection_after_close && margin_pct == 100.0
                && std::holds_alternative<native_order::Market>(
                    view.definition->request.trigger);
            // ab9714be pine_fills.cpp:5288-5390 (gap-reject), :5392-5526
            // (frozen sizing) and engine_fills.cpp:4618
            // (stop_entry_margin_admission_declines): a TRUE-FLAT all-in
            // default percent_of_equity==100 opening is costed against the
            // PRE-commission placement equity snapshot.  Commission is
            // EXCLUDED from fill-time affordability -- a fee-only (or one-tick
            // grid-rounding) overage admits here and the entry-bar
            // margin-call trim downstream books the observable residual lot
            // that closes again on the entry bar.  Judging the same opening
            // against the post-commission marked equity instead declines the
            // whole entry and loses both lots.
            const bool all_in_true_flat_opening = !reversal
                && source.family == PineOrderFamily::Entry
                && !std::isfinite(source.requested_qty)
                && physical.signed_units == 0.0
                && source.projection_position_side
                    == static_cast<std::int32_t>(PositionSide::FLAT)
                && !source.projection_after_close
                && config_.default_qty_type
                    == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
                && std::abs(config_.default_qty_value - 100.0) < 1e-12
                && std::abs(margin_pct - 100.0) < 1e-12
                && finite_positive(source.sizing.equity);
            const double fill_equity = (variable_batch || all_in_reversal
                || all_in_true_flat_opening || same_open_reversal)
                ? source.sizing.equity : view.account.marked_equity;
            const double float_guard = std::max(
                1e-9, std::abs(source.sizing.equity) * 1e-12);
            bool paired_market_opening = false;
            for (const auto& handle : live_handles_) {
                if (handle == view.target) continue;
                const auto peer = placement_.find(handle.incarnation);
                if (peer == placement_.end()) continue;
                const auto& row = peer->second;
                if (row.opening && row.family == PineOrderFamily::Entry
                    && row.placement_script_open_ms == source.placement_script_open_ms
                    && !finite_positive(row.exit_levels.limit)
                    && !finite_positive(row.exit_levels.stop)) {
                    paired_market_opening = true;
                    break;
                }
            }
            const auto native_state = detail::run_state(require_host());
            const bool magnified = native_state.spec
                && !native_state.spec->intrabar.is_none();
            const bool price_gap_scope = source.family == PineOrderFamily::Entry
                && std::holds_alternative<native_order::Market>(view.definition->request.trigger)
                && finite_positive(staged_.syminfo.mintick)
                && !std::isfinite(source.requested_qty)
                && config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
                && config_.default_qty_value == 100.0
                && std::abs((source.is_long ? config_.margin_long : config_.margin_short)
                            - 100.0) < 1e-12
                && staged_.quantity_grid && *staged_.quantity_grid > 0.0
                && *staged_.quantity_grid < 1.0
                && staged_.syminfo.pointvalue == 1.0 && source.sizing.fx == 1.0
                && staged_.account_fx_effective_from_ms.empty()
                && config_.commission_type == static_cast<int>(CommissionType::PERCENT)
                && config_.commission_value == 0.0 && config_.slippage == 0
                && !config_.process_orders_on_close && !config_.calc_on_order_fills
                && !magnified && !source.birth.from_fill()
                && !source.projection_after_close
                && view.resolved_price > source.sizing.price
                && ((physical.signed_units == 0.0
                     && source.projection_position_side
                        == static_cast<std::int32_t>(PositionSide::FLAT)
                     && !paired_market_opening)
                    || reversal);
            const bool price_gap_affordable = price_gap_scope
                && source_price_band_affordable(source.sizing.equity,
                    source.sizing.frozen_units, view.resolved_price, staged_.syminfo.mintick);
            if (price_gap_scope && !price_gap_affordable)
                return NativePrecommitVerdict::Refuse;
            const bool true_flat_gap_scope = source.family == PineOrderFamily::Entry
                && source.projection_position_side
                    == static_cast<std::int32_t>(PositionSide::FLAT)
                && !source.projection_after_close
                && physical.signed_units == 0.0
                && config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
                && config_.default_qty_value == 100.0
                && !config_.process_orders_on_close;
            if (true_flat_gap_scope
                && fill_required > source.sizing.equity + float_guard
                && !price_gap_affordable) {
                return NativePrecommitVerdict::Refuse;
            }
            if (source.family == PineOrderFamily::Entry
                && source.projection_after_close && physical.signed_units == 0.0) {
                // ab9714be pine_fills.cpp:4814-4897 / AG-C1: after an earlier
                // same-tick close, the new flat opening is admitted on its
                // frozen sizing notional. A worse fill is handled by the
                // post-opening margin slice, not by declining the entry.
                // AdmitWithHostMargin, not a bare admission: the adapter is
                // taking responsibility for this opening's margin check, and
                // the run spec now carries a per-side initial fraction that
                // would otherwise decline it.
                return NativePrecommitVerdict::AdmitWithHostMargin;
            }
            // A flat opening keeps one lot of slack for the floor its
            // quantity was sized on; an add to a held position of its side
            // keeps none, as it has none when it is placed
            // (add_margin_exceeds_equity; lab tv tape
            // tests/fixtures/margin_residual w5b-pa-f-pooc-p50, a
            // process_orders_on_close add judged at its close fill; lane
            // W5B-ENG-MARGIN-RESIDUAL).
            const bool same_side_add = physical.signed_units != 0.0
                && (physical.signed_units > 0.0) == source.is_long;
            // Such an add filled at the open after its bar is judged, as an
            // explicit one is (rule COQ above), against the position held
            // when it was placed: a sibling that filled at this open a moment
            // earlier does not count, so two default adds that each fit on
            // top of the held position both fill and the book is called at
            // the fill (lab tv tape tests/fixtures/int29_compositions
            // int29-c1-open-pairs, cells D and E; composing placement-time
            // equity checks with the same-side add's residual-margin check).
            const auto placed_side = static_cast<PositionSide>(source.projection_position_side);
            const double placed_held = source.projection_tv_carry_qty;
            if (same_side_add && source.family == PineOrderFamily::Entry
                && std::holds_alternative<native_order::Market>(view.definition->request.trigger)
                && (placed_side == PositionSide::FLAT
                    || (placed_side == PositionSide::LONG) == source.is_long)
                && std::isfinite(placed_held) && placed_held >= 0.0
                && projection_bar_index(view.cursor.point) == source.projection_created_bar + 1
                && std::abs(physical.signed_units) > placed_held + 1e-10
                && config_.pyramiding > 0
                && physical.lot_count < static_cast<std::size_t>(config_.pyramiding)) {
                fill_required = (placed_held + std::abs(view.inspected_opened_units))
                    * view.resolved_price * staged_.syminfo.pointvalue * active_fx * fraction;
            }
            double admission_guard = float_guard;
            if (!reversal && !same_side_add && staged_.quantity_grid) {
                admission_guard = std::max(admission_guard,
                    *staged_.quantity_grid * view.resolved_price
                        * staged_.syminfo.pointvalue * active_fx * fraction);
            }
            if (!std::isfinite(fill_required) || !std::isfinite(fill_equity)
                || (fill_required > fill_equity + admission_guard
                    && (same_open_reversal || !price_gap_affordable)
                    && !close_then_open_margin_checkpoint)) {
                return NativePrecommitVerdict::Refuse;
            }
        }
        return NativePrecommitVerdict::AdmitWithHostMargin;
    }
    const double required = view.account.resulting_abs_notional * fraction;
    // A 1x LONG opening may be admitted against its pre-entry realized
    // budget even when the entry commission makes the post-entry marked
    // equity fractionally short.  The adapter immediately runs the
    // opening-price margin checkpoint from on_native_applied, which produces
    // the source-required 4x/one-contract reduction before any same-bar
    // exit.  Rejecting here would erase that observable margin event.
    const bool opening_margin_checkpoint =
        source.family == PineOrderFamily::Entry && margin_pct == 100.0
        && finite_positive(source.requested_qty)
        && std::isfinite(view.account.realized_balance)
        && required <= view.account.realized_balance;
    if (opening_margin_checkpoint) return NativePrecommitVerdict::AdmitWithHostMargin;
    if (!std::isfinite(required) || !std::isfinite(view.account.marked_equity)
        || required > view.account.marked_equity) {
        return NativePrecommitVerdict::Refuse;
    }
    return NativePrecommitVerdict::AdmitWithHostMargin;
}
 
namespace {
 
constexpr std::int64_t kChartDayCivilSpan = std::int64_t{1} << 40;
 
// chart_day_key on a UTC chart for a second `secs` inside the arithmetic's
// span: gmtime_r's day and month, the kernel's civil date of the floor day
// (native_calendar::native_civil_date). Everything below reads the floor day
// alone, so the day's seconds all answer its key, and `index` (when there is
// one) keeps them with it.
[[gnu::noinline]] std::int64_t civil_chart_day_key(AdapterLookupIndex* index,
                                                   std::int64_t secs) noexcept {
    const std::int64_t days = secs / 86400 - (secs % 86400 < 0 ? 1 : 0);
    const native_calendar::NativeCivilDate date = native_calendar::native_civil_date(days);
    const std::int64_t key = std::int64_t{date.day} * 100 + date.month;
    if (index != nullptr) {
        index->day_lo = std::max(days * 86400, -kChartDayCivilSpan + 1);
        index->day_hi = std::min(days * 86400 + 86400, kChartDayCivilSpan);
        index->day_key = key;
    }
    return key;
}
 
// chart_day_key's libc half, for a second the civil arithmetic does not answer:
// localtime_r under a chart timezone, gmtime_r on a UTC chart, each falling
// back to gmtime_r as it always did.
[[gnu::noinline]] std::int64_t libc_chart_day_key(const std::string& timezone, bool utc_chart,
                                                  std::time_t seconds) noexcept {
    std::tm fields{};
    const auto utc = [&]() {
        return ::gmtime_r(&seconds, &fields) != nullptr;
    };
    if (utc_chart) {
        if (!utc()) return std::numeric_limits<std::int64_t>::min();
    } else {
        try {
            tz_util::ScopedTimezone guard(timezone);
            if (::localtime_r(&seconds, &fields) == nullptr) {
                if (!utc()) return std::numeric_limits<std::int64_t>::min();
            }
        } catch (...) {
            // A malformed staged timezone must not turn a source-policy
            // read into an unhashable partial state.  The run-spec validator
            // owns rejection; preserve the legacy UTC fallback meanwhile.
            if (!utc()) return std::numeric_limits<std::int64_t>::min();
        }
    }
    return static_cast<std::int64_t>(fields.tm_mday) * 100
        + static_cast<std::int64_t>(fields.tm_mon + 1);
}
 
}  // namespace
 
std::int64_t PineExecutionAdapter::chart_day_key(std::int64_t timestamp_ms) const noexcept {
    const std::time_t seconds = static_cast<std::time_t>(timestamp_ms / 1000);
    const std::string& timezone = staged_.chart_timezone;
    const bool utc_chart = timezone.empty() || timezone == "UTC" || timezone == "Etc/UTC";
    if (utc_chart) {
        // gmtime_r's day and month without the libc call every bar paid:
        // civil arithmetic on the floor day, exact for every second within
        // +/-2^40 of the epoch. gmtime_r keeps the rest.
        const std::int64_t secs = static_cast<std::int64_t>(seconds);
        if (secs > -kChartDayCivilSpan && secs < kChartDayCivilSpan) {
            // A second of the day last read here answers that day's key: the
            // day is kept with the consumer that keeps this adapter's lookup
            // state for the run (the UTC chart-day memo). An unbound adapter, or a
            // consumer that holds no cache, computes every read as it always did.
            AdapterLookupIndex* index = parked_lookup_index(host_, this, run_counter_);
            if (index != nullptr && index->day_lo <= secs && secs < index->day_hi)
                return index->day_key;
            return civil_chart_day_key(index, secs);
        }
    }
    return libc_chart_day_key(timezone, utc_chart, seconds);
}
 
compat::pine::CapClock PineExecutionAdapter::cap_clock(
        const NativeDecisionContext& context) const {
    const std::int64_t key = chart_day_key(context.sub_bar_open_ms);
    return {context.sub_bar_open_ms,
            staged_.syminfo.session.empty() ? "24x7" : staged_.syminfo.session,
            staged_.syminfo.timezone.empty() ? "UTC" : staged_.syminfo.timezone,
            static_cast<int>(key / 100), static_cast<int>(key % 100)};
}
 
compat::pine::Calculation PineExecutionAdapter::cap_calculation(
        const NativeDecisionContext& context) const {
    const auto state = detail::run_state(require_host());
    const auto* pine_host = pine_view_of(&require_host());
    const bool magnifier = pine_host
        ? pine_host->scheduler_.bar_magnifier_enabled()
        : context.sub_count > 1;
    return {config_.process_orders_on_close, config_.calc_on_order_fills,
            coof_recalc_active_, magnifier,
            !modeled_input() && state.phase == NativeRunPhase::Warmup,
            modeled_input(),
            !config_.close_entries_rule_any,
            context.coordinate.interval_index};
}
 
compat::pine::MatchedAttempt PineExecutionAdapter::cap_attempt(
        const PlacementSnapshot& snapshot, std::uint64_t incarnation,
        const native_order::ExecutionAppliedEvent* applied) const {
    compat::pine::OrderKind kind = compat::pine::OrderKind::Other;
    if (snapshot.family == PineOrderFamily::Entry) {
        kind = (finite_positive(snapshot.exit_levels.limit)
                || finite_positive(snapshot.exit_levels.stop))
            ? compat::pine::OrderKind::Entry : compat::pine::OrderKind::Market;
    }
    const auto position = detail::run_position(require_host());
    compat::pine::Side side = position.signed_units > 0.0
        ? compat::pine::Side::Long
        : (position.signed_units < 0.0 ? compat::pine::Side::Short
                                       : compat::pine::Side::Flat);
    std::size_t prefill_entries = position.lot_count;
    if (applied) {
        if (applied->closed_units > 0.0) {
            // The matched ENTRY saw the side opposite its requested side.
            // Factor A only needs that exact side to avoid misclassifying a
            // reversal as a same-side no-op.
            side = snapshot.is_long ? compat::pine::Side::Short
                                    : compat::pine::Side::Long;
        } else if (applied->opened_units != 0.0
                   && applied->cycle_before != applied->cycle_after) {
            side = compat::pine::Side::Flat;
            prefill_entries = 0;
        } else if (applied->opened_units != 0.0
                   && applied->opened_lot_incarnation != 0
                   && prefill_entries > 0) {
            // A same-side add created exactly one new physical opening.
            --prefill_entries;
        }
    } else {
        const auto projected = static_cast<PositionSide>(snapshot.projection_position_side);
        if (projected == PositionSide::FLAT) {
            side = compat::pine::Side::Flat;
            prefill_entries = 0;
        }
    }
    const int live_entries = prefill_entries
            > static_cast<std::size_t>(std::numeric_limits<int>::max())
        ? std::numeric_limits<int>::max() : static_cast<int>(prefill_entries);
    return {kind, incarnation, snapshot.projection_created_bar,
            snapshot.is_long, side, live_entries,
            config_.pyramiding};
}
 
bool PineExecutionAdapter::cap_placement_denied(const NativeDecisionContext& context) {
    return cap.active() && cap.placement(cap_clock(context)) == compat::pine::Placement::Deny;
}
 
bool PineExecutionAdapter::intraday_loss_orders_blocked() const noexcept {
    return risk_.intraday_block_day != std::numeric_limits<std::int64_t>::min()
        && risk_.intraday_block_day == day_ledger_.current_day;
}
 
void PineExecutionAdapter::update_risk_state(double mark_price) {
    if (std::isfinite(mark_price)) {
        const double equity = require_host().native_marked_equity(mark_price);
        if (std::isfinite(equity)) {
            if (!std::isfinite(risk_.observed_peak_equity)
                || equity > risk_.observed_peak_equity) {
                risk_.observed_peak_equity = equity;
            }
            const double drawdown = risk_.observed_peak_equity - equity;
            if (drawdown > risk_.observed_max_drawdown)
                risk_.observed_max_drawdown = drawdown;
        }
    }
    if (risk_.halted) return;
    if (risk_.max_drawdown > 0.0 && std::isfinite(risk_.observed_peak_equity)) {
        const double threshold = risk_.max_drawdown_percent
            ? risk_.observed_peak_equity * risk_.max_drawdown / 100.0
            : risk_.max_drawdown;
        if (std::isfinite(risk_.max_drawdown) && !std::isfinite(threshold)) {
            engine_command_value_invalid_or_count("risk.threshold",
                EngineValueStage::risk, EngineValueReason::numeric_overflow);
        }
        if (risk_.observed_max_drawdown >= threshold) {
            risk_.halted = true;
            return;
        }
    }
    if (risk_.max_cons_loss_days > 0
        && day_ledger_.consecutive_loss_days >= risk_.max_cons_loss_days) {
        risk_.halted = true;
    }
}
 
bool PineExecutionAdapter::intraday_loss_breached(double mark_price) const {
    if (!(risk_.max_intraday_loss > 0.0) || intraday_loss_orders_blocked()
        || !std::isfinite(day_ledger_.intraday_start_equity)
        || !std::isfinite(mark_price)) {
        return false;
    }
    const double equity = require_host().native_marked_equity(mark_price);
    const double loss = day_ledger_.intraday_start_equity - equity;
    const double threshold = risk_.max_intraday_loss_percent
        ? day_ledger_.intraday_start_equity * risk_.max_intraday_loss / 100.0
        : risk_.max_intraday_loss;
    if (std::isfinite(risk_.max_intraday_loss) && !std::isfinite(threshold)) {
        engine_command_value_invalid_or_count("risk.threshold",
            EngineValueStage::risk, EngineValueReason::numeric_overflow);
    }
    if (!(threshold > 0.0) || !(loss > 0.0) || !std::isfinite(loss)) return false;
    const double epsilon = 1e-9 * std::max(1.0, std::abs(threshold));
    return loss + epsilon >= threshold;
}
 
// =========================================================== R5 margin policy
// The kernel (src/native_execution_consumer.cpp, the kernel execution sampler) owns the
// margin MECHANISM: when the requirement is tested, the liquidation request it
// originates, its Superseded re-pricing, its receipt and its MarginCallEvent.
// The answers below are the only TradingView-specific things left in that
// loop -- when TradingView would check, what money it compares, and how many
// units it takes -- and each is answered on the kernel's own facts.
 
// TradingView's money at one mark, which is what `required > equity` is made
// of. This is the single implementation: `submit_margin_call_slice` (the
// checkpoints the kernel has no point for) and `resolve_margin_requirement`
// (the kernel's own path check) both read it, so the two routes cannot drift.
PineExecutionAdapter::SourceMarginMoney PineExecutionAdapter::source_margin_money(
        double mark_price, std::int64_t sub_bar_open_ms) const {
    SourceMarginMoney money;
    const auto position = detail::run_position(require_host());
    if (position.signed_units < 0.0) {
        // ab9714be pine_fills.cpp: a short's checkpoint marks on the chart
        // tick, while the slice still rests at the raw waypoint.
        mark_price = nearest_tick(mark_price, staged_.syminfo.mintick);
    }
    money.mark = mark_price;
    money.held = std::abs(position.signed_units);
    const double margin_pct = position.signed_units > 0.0
        ? config_.margin_long : config_.margin_short;
    if (!source_margin_call_enabled_ || !(money.held > 0.0)
        || !finite_positive(mark_price) || !finite_positive(margin_pct)
        || !finite_positive(staged_.syminfo.pointvalue)) {
        return money;
    }
    const double fx = active_staged_fx(sub_bar_open_ms);
    const double fraction = margin_pct / 100.0;
    money.scale = staged_.syminfo.pointvalue * fx * fraction;
    money.short_book = position.signed_units < 0.0;
    money.unit_margin = mark_price * staged_.syminfo.pointvalue * fx * fraction;
    money.exact_required = money.held * money.unit_margin;
    money.required = money.exact_required;
    if (staged_.quantity_grid && *staged_.quantity_grid > 0.0
        && staged_.account_fx_effective_from_ms.empty()) {
        const double lot_value = *staged_.quantity_grid * mark_price
            * staged_.syminfo.pointvalue * fx;
        if (std::isfinite(lot_value) && lot_value < 1.0) {
            // ab9714be pine_fills.cpp:11491-11499: a sub-unit lot puts the
            // requirement on TradingView's ten-significant-digit money ladder.
            money.required = source_money_round(money.exact_required);
        }
    }
    // ab9714be pine_fills.cpp:1411-1423: fee-adjusted live equity -- on
    // TradingView's own money (gain_loss_money) where the mirror holds.
    money.equity = percent_commission_live_equity(mark_price);
    if (const double mirrored = gain_loss_signal_equity(mark_price); std::isfinite(mirrored))
        money.equity = mirrored;
    // Cash-per-contract margin charges the open entry fees. Cash-per-order
    // retains the legacy restoring basis: cash_fee_sizing/pcf-order-p100-m100
    // shows TradingView charging fees too, but its distinct margin schedule
    // remains a recorded divergence, not covered by the contract-fee rule.
    if (config_.commission_type == static_cast<int>(CommissionType::CASH_PER_CONTRACT)
        && config_.commission_value > 0.0) {
        money.equity = strategy_equity_at(mark_price, std::nullopt);
    }
    money.valid = finite_positive(money.unit_margin) && std::isfinite(money.equity);
    return money;
}
 
// TradingView's slice quantity from that money: the lot-floored restore taken
// four times, floored to the lot again, and the family R whole-drop band for a
// restore that floors below one lot.
double PineExecutionAdapter::source_margin_units(
        const SourceMarginMoney& money, bool opening_checkpoint, bool gated, double print) const {
    if (!money.valid || !(money.required > money.equity)) return 0.0;
    const bool opening_basis = opening_checkpoint && money.required == money.exact_required;
    const double raw_minimum = opening_basis
        ? money.held - money.equity / money.unit_margin
        : (money.required - money.equity) / money.unit_margin;
    if (!(raw_minimum > 0.0) || !std::isfinite(raw_minimum)) return 0.0;
    // ab9714be pine_fills.cpp:1572-1575: a dust-sized restore requirement is
    // not a broker action.  It must be discarded before lot quantization, so
    // floating-point residue at a 1x full-margin opening cannot become a
    // 4x epsilon Reduce (and a phantom trade row).
    // On TradingView's own money a shortfall of any size is a call: a dust
    // restore falls to the one-unit call below (tests/fixtures/
    // margin_ledger_rules and margin_call_rules: one unit of an NYSE:F long
    // ledger and of a margin-50 ETH long admitted one ulp under its cost).
    const bool dust_unit = detail::margin_rule_switches().dust_unit_call
        && std::isfinite(gain_loss_signal_equity(money.mark));
    if (raw_minimum <= internal::kQtyEpsilon && !dust_unit) return 0.0;
    double minimum = raw_minimum;
    if (staged_.quantity_grid) {
        // The lots the restore floors to count the shortfall as TradingView's
        // money, on its ten-significant-digit ladder: a shortfall of exactly
        // two units' margin floors to two, not one below it for binary64
        // residue (synthetic NYSE:F book: 600 shares 50.00 short at the 25.00
        // mark take 8 at the close, where an unrounded difference of
        // 49.99999999999999 floors to one unit and calls 4 instead;
        // the margin_opposite fixtures establish the rounding rule).
        const double floor_basis = opening_basis
            ? raw_minimum
            : source_money_round(money.required - money.equity) / money.unit_margin;
        minimum = std::floor(floor_basis / *staged_.quantity_grid)
            * *staged_.quantity_grid;
    }
    double units = minimum > 0.0 ? 4.0 * minimum : 0.0;
    if (units > 0.0 && staged_.quantity_grid) {
        units = std::floor(units / *staged_.quantity_grid + 1e-6)
            * *staged_.quantity_grid;
    }
    if (!(units > 0.0) && staged_.quantity_grid
        && *staged_.quantity_grid <= 1.0
        && (raw_minimum > internal::kQtyEpsilon || dust_unit) && raw_minimum < 1.0) {
        const double candidate = std::min(1.0, money.held);
        const double rounded = floor_quantity_grid(candidate, staged_.quantity_grid);
        const double guard = std::max(1e-12, std::abs(candidate) * 1e-12);
        // The one unit is taken only where it restores the book at the call's
        // own fill: TradingView prices the whole position's requirement at the
        // liquidation's slipped print -- a short's buy is the slippage ticks
        // above the mark, a long's sell below it -- against the equity at the
        // mark, and closes nothing when that requirement exceeds the equity by
        // a unit's margin or more. A long's sell never does, nor does a call at
        // zero slippage. A synthetic NYSE:F short of 1000 shares filled
        // at 20.00, 15.00 short at 20.01, takes no one-unit call at slippage 1:
        // 1000 x 20.02 exceeds equity by 25.00, over one unit's margin.
        // At slippage 3, 400 shares filled at 20.00, 10.00 short at 20.03,
        // lack 22.00 at the 20.06 fill and also take no one-unit call.
        // These synthetic slipped_short books illustrate the slipped-short margin rule;
        // an otherwise similar book inside the band can take the call.
        const double slip = config_.slippage > 0
            ? config_.slippage * staged_.syminfo.mintick : 0.0;
        const bool short_book = detail::run_position(require_host()).signed_units < 0.0;
        const double fill_required = money.exact_required
            * (finite_positive(print) ? print : money.mark + (short_book ? slip : -slip))
            / money.mark;
        if ((candidate >= money.held - guard || std::abs(rounded - candidate) <= guard)
            && fill_required - money.equity < money.unit_margin)
            units = candidate;
    }
    units = std::min(money.held, units);
    // ab9714be pine_fills.cpp:1708: the final slice quantity carries the same
    // slack gate, so a floored-to-dust restore closes nothing at all.
    if (!(units > internal::kQtyEpsilon) || !std::isfinite(units)) return 0.0;
    if (PF_RARE(money.short_book) && gated
        && short_call_vetoed(money, units, opening_checkpoint, print))
        return 0.0;
    return units;
}
 
// TradingView takes a short's call only where it restores the book at the
// call's own slipped print p': the units called, priced there, must exceed
// the whole position's requirement at p' less the equity at the mark (switch
// short_call_gate). The one-unit band above is its one-unit case. A long's
// sell never binds, nor does a call at zero slippage, whose print is its mark;
// with slippage it suppresses the calls whose deficit is below about a third
// of the position's slippage cost: on OANDA:EURUSD at slippage 1 a short of
// synthetic 50000 units found 0.10 short at a 2.00000 high would call 0.20,
// worth 0.400002 at the 2.00001 fill, below the 0.60 the book lacks there,
// so nothing is called until a later high needs a larger call (lab tv tapes
// tests/fixtures/margin_call_rules short-cutoff-gate/, 67 tapes, and
// tests/fixtures/margin_schedule_rules gate/). An opening checkpoint at a
// fill keeps the earlier rules.
bool PineExecutionAdapter::short_call_vetoed(
        const SourceMarginMoney& money, double units, bool opening_checkpoint, double print) const {
    if (!detail::margin_schedule_switches().short_call_gate || opening_checkpoint
        || !money.short_book || !(config_.slippage > 0) || !finite_positive(money.scale)
        || !finite_positive(staged_.syminfo.mintick)) {
        return false;
    }
    const double fill = finite_positive(print) ? print : source_margin_fill_price(money.mark, true);
    if (!finite_positive(fill)) return false;
    return !(units * fill * money.scale > money.held * fill * money.scale - money.equity);
}
 
// The follow-up TradingView takes after a margin call of `called` units on a
// long of several lots, sized on `money`, the book before that call, and
// filled at `fill`. Its broker checks the book again after each lot the call
// closes, first in first out, on a state that has taken the lot out of the
// book but not yet booked its P&L -- the lot relieves the shortfall by its
// cost (its entry fee was booked when it opened) -- while each lot before it,
// booked, relieves it by what its sale fetched net of its exit fee. The last
// of those checks that is still short is called again: four times its
// lot-floored shortfall. So a call whose first lots cost less than the
// shortfall is followed; one that starts inside a lot costing more is not
// (lab tv tapes tests/fixtures/add_sibling_margin tailb-lots12-pooc-c0s0,
// tailb-lots30-pooc-c10s3 and tailb-lots30-mkt-c10s2; the grid bots'
// calls on BINANCE BTC and ETH daily bars; lane TAIL-B). Only on a
// fractional lot grid, at a percent commission or none: a whole-unit book's
// follow-up is whole_unit_follow_up_due's.
double PineExecutionAdapter::lagged_margin_follow_up_units(
        const std::vector<NativeOpenLot>& lots, const SourceMarginMoney& money, double called,
        double fill, std::int64_t sub_bar_open_ms) const {
    // A whole-share grid takes it too (switch whole_share_lagged_follow_up):
    // on NYSE:F at slippage 3 and commission 0.1 %, synthetic lots of
    // 5, 15 and 500 shares can require a follow-up after the open's call;
    // the last still-short FIFO check sizes it (margin_schedule_rules fixtures).
    const bool whole_share = detail::margin_schedule_switches().whole_share_lagged_follow_up
        && staged_.quantity_grid && *staged_.quantity_grid == 1.0;
    if (!money.valid || !(money.required > money.equity) || !(called > internal::kQtyEpsilon)
        || !staged_.quantity_grid || !(*staged_.quantity_grid > 0.0)
        || !(*staged_.quantity_grid < 1.0 || whole_share) || !finite_positive(fill)
        || (config_.commission_value != 0.0
            && config_.commission_type != static_cast<int>(CommissionType::PERCENT))) {
        return 0.0;
    }
    const double scale = staged_.syminfo.pointvalue * active_staged_fx(sub_bar_open_ms);
    const double fee = config_.commission_value / 100.0;
    const double shortfall = money.required - money.equity;
    double remaining = called;
    double booked = 0.0;
    double last_short = 0.0;
    for (const auto& lot : lots) {
        if (!(remaining > internal::kQtyEpsilon)) break;
        if (!(lot.signed_units > 0.0)) return 0.0;
        const double taken = std::min(remaining, lot.signed_units);
        remaining -= taken;
        const double lagged = shortfall - booked - taken * lot.entry_price * scale;
        if (lagged > 0.0) last_short = lagged;
        booked += taken * fill * scale * (1.0 - fee);
    }
    if (!(last_short > 0.0) || !std::isfinite(last_short)) return 0.0;
    const double grid = *staged_.quantity_grid;
    const double minimum = std::floor(source_money_round(last_short) / money.unit_margin / grid)
        * grid;
    double units = std::floor(4.0 * minimum / grid + 1e-6) * grid;
    units = std::min(units, money.held - called);
    if (!(units > internal::kQtyEpsilon) || !std::isfinite(units)) return 0.0;
    return units;
}
 
// The forced execution price of a liquidation that fired at `fire`: the fire
// price on the chart tick ladder, then the EXIT side's own market slippage
// (ab9714be pine_fills.cpp:1712-1726 and :2649-2658). Reducing a long is a
// sell (slippage subtracts); reducing a short is a buy (it adds). A margin
// call is a MARKET execution at the print it fired at, so an off-ladder print
// (a half-cent low) books its nearest tick, as every TradingView market fill
// at a print does -- synthetic 25.005 books 25.01; 1.005 books 1.00 (lab tv tapes
// tests/fixtures/margin_entry_bar/pm-m10-f-k4-1007, -gapup-0501, -gapup-0424
// and, beyond margin calls, pm2-round-f-print; the intrabar margin correction). A print
// on the ladder is its own tick (source_bar_fill_tick is idempotent there).
double PineExecutionAdapter::source_margin_fill_price(double fire, bool close_is_buy) const {
    if (config_.slippage == 0) return source_bar_fill_tick(fire, staged_.syminfo.mintick);
    const double rounded = source_bar_fill_tick(fire, staged_.syminfo.mintick);
    const double slipped = rounded + (close_is_buy ? 1.0 : -1.0)
        * config_.slippage * staged_.syminfo.mintick;
    return directional_tick(slipped, staged_.syminfo.mintick, close_is_buy);
}
 
// ab9714be pine_fills.cpp:5159-5221: a rounded whole-lot tie is rejected only
// for the SOLE opening. A coexisting resting entry excludes that rejection,
// and the lot that was admitted on the rounded tie must not then be
// immediately liquidated for the same sub-lot representation residue. This is
// a rule about when TradingView does not check at all, so it vetoes the
// adapter's own checkpoints and, through margin_check_allowed, the kernel's
// check point too.
bool PineExecutionAdapter::source_margin_rounded_tie_veto() const {
    if (!staged_.quantity_grid || *staged_.quantity_grid != 1.0
        || config_.default_qty_type != static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        || config_.default_qty_value != 100.0 || config_.commission_value != 0.0) {
        return false;
    }
    bool rounded_tie_opening = false;
    for (const auto& cohort : cohorts_by_id_.held_rows()) {
        for (const auto& origin : cohort.second.opened) {
            const auto opening = placement_.find(origin.incarnation);
            if (opening == placement_.end()) continue;
            const auto& row = opening->second;
            const double cost = row.sizing.frozen_units * row.sizing.price
                * staged_.syminfo.pointvalue * row.sizing.fx;
            if (row.opening && std::isfinite(cost)
                && cost == source_money_round(row.sizing.equity)
                && cost > row.sizing.equity) {
                rounded_tie_opening = true;
                break;
            }
        }
        if (rounded_tie_opening) break;
    }
    if (!rounded_tie_opening) return false;
    for (const auto& handle : live_handles_) {
        const auto pending = placement_.find(handle.incarnation);
        if (pending == placement_.end()) continue;
        const auto& row = pending->second;
        if (row.opening && (finite_positive(row.exit_levels.limit)
                            || finite_positive(row.exit_levels.stop))) {
            return true;
        }
    }
    return false;
}
 
// TradingView's scheduling (MG-I). The kernel offers its own check points;
// this admits exactly the ones the adapter's own scheduling decided to check
// at, and refuses the rest. A refused point is inert: the kernel measures
// nothing, re-arms nothing and withdraws nothing there, so the state stays as
// the last admitted point left it. The decision itself is taken where
// TradingView takes it -- inside on_bar_open, with the bar's competing
// orders in front of it -- and only carried here.
bool PineExecutionAdapter::margin_check_allowed(
        const NativeMarginCheckPoint& point) const {
    // The kernel's FX-roll point is not TradingView's rollover: that is the
    // broker-open checkpoint of apply_fx_open_margin_slice, measured AT the
    // open and executed there. The roll point measures at the remaining
    // path's adverse mark and rests the slice on it -- on a step bar O 100
    // L 97 a carried 1x long books 0.4116 @ 97 there against TradingView's
    // pinned 0.3996 @ 100 (test_native_margin_hooks_twin MG-FX, the margin and cancellation comparison).
    // Refused by kind, ahead of the ordinal test, because a roll can share
    // its driver point with an armed BarOpen check.
    if (point.kind == NativeMarginCheckKind::FxRoll) return false;
    // A magnified run's later samples. TradingView's magnified broker checks
    // the book at every lower-timeframe bar and books the call at the first
    // sub-bar low that crosses, sized there, then again at each later one
    // that crosses the reduced book's line (lab tv tapes
    // tests/fixtures/intrabar_margin/pm-i3-eth-mag-*, the margin-schedule correction);
    // the kernel's IntrabarSample point is that check.
    if (point.kind == NativeMarginCheckKind::IntrabarSample) {
        return intrabar_sample_checked(point) && !source_margin_rounded_tie_veto();
    }
    // The kernel's BarOpen point and its post-fill AfterApplied re-arm are
    // both points TradingView checks at -- schedule_margin_call_path is
    // called from on_bar_open and from on_applied -- so the admitted point is
    // named by the driver point the decision was taken at, not by its kind.
    const std::uint64_t ordinal = point.cursor.point.ordinal;
    if (kernel_margin_resize_point_ == ordinal) {
        // The post-exit re-size point (on_applied, a priced bracket leg of
        // this script bar). The legacy broker cancelled the live path slice
        // there and re-scheduled from the reduced book, and did NOTHING when
        // no slice was live -- so this point is TradingView's only while one
        // rests. With one resting the kernel withdraws it and re-rests
        // whatever schedule_margin_call_path armed on the reduced book; with
        // the book flat the same admission withdraws it and rests nothing.
        if (!point.liquidation_resting) return false;
    } else if (kernel_margin_path_point_ != ordinal) {
        return false;
    }
    // The rounded-tie veto is re-read here rather than at the arming site: the
    // book it inspects is the one standing at the check point.
    return !source_margin_rounded_tie_veto();
}
 
// Where the per-sample check is TradingView's as measured, on a magnified run
// with no slice of the adapter's own resting (the pre-open slice keeps its
// verdict for its bar, as on the chart path): a leveraged long, plain, under
// process_orders_on_close or under calc_on_order_fills, and a short at any
// margin, plain or under calc_on_order_fills (lab tv tapes
// tests/fixtures/intrabar_margin: pm-i3-eth-mag-* for the plain leveraged long,
// The margin-schedule correction; pm2-i3-pooc-mag-*, pm2-i3-coof-* and the full-margin
// short pm2-i3-s1x-mag-*, the intrabar margin correction). Not a full-margin long, whose
// one-contract money call owns the book (resolve_margin_call_units refuses
// it), nor a short under process_orders_on_close, whose carried slice is the
// post-script checkpoint's (schedule_margin_call_path), unmeasured here. A
// flat book is admitted: the kernel then withdraws what it had resting.
bool PineExecutionAdapter::intrabar_sample_checked(
        const NativeMarginCheckPoint& point) const {
    if (!bar_magnifier_) return false;
    const double held = point.position.signed_units;
    if (held == 0.0) return true;
    if (held > 0.0 ? !(config_.margin_long < 100.0) : config_.process_orders_on_close)
        return false;
    return !any_live_row(live_handles_, placement_, [](const PlacementSnapshot& row) {
        return row.family == PineOrderFamily::Margin;
    });
}
 
// TradingView's money (MG-A + MG-B), restated for the kernel's breach test at
// the mark it measured. nullopt would keep the kernel's own unrounded
// requirement against its own marked equity, which is a different broker.
std::optional<NativeMarginDecision> PineExecutionAdapter::resolve_margin_requirement(
        const NativeMarginRequirementView& view) const {
    const auto money = source_margin_money(view.mark, view.cursor.point.open_ms);
    if (!money.valid) return std::nullopt;
    NativeMarginDecision decision;
    decision.required = money.required;
    decision.equity = money.equity;
    return decision;
}
 
// TradingView's sizing (MG-F + MG-G), on the kernel's own facts. This hook is
// the whole sizing authority for every call the kernel makes on the adapter's
// behalf, which is why project() declares no kernel sizing knob for the model.
std::optional<double> PineExecutionAdapter::resolve_margin_call_units(
        const NativeMarginCallView& view) const {
    // Always an answer, never nullopt. A non-positive answer is the kernel's
    // documented refusal, which withdraws the reduction instead of booking one.
    //
    // TradingView never takes the adverse-path slice on a 1x long: the
    // one-contract money call owns that book instead
    // (submit_tv_money_long_margin_call). Every dispatch site guards on that
    // before it schedules, but the book can turn into a 1x long between the
    // scheduling decision and the check point -- a reversal at the same
    // driver point does exactly that -- and the book that decides is the one
    // the call would be made against. This is a refusal of the CALL, not of
    // the check point: the point still runs, so a reduction resting from an
    // earlier book is withdrawn here rather than left behind.
    if (view.position.signed_units > 0.0 && std::isfinite(config_.margin_long)
        && std::abs(config_.margin_long - 100.0) < 1e-12) {
        return 0.0;
    }
    // A point whose only adverse mark is the close: the call is taken there
    // after the script (close_point_margin_call), not rested at the close.
    if (view.cursor.point.ordinal == close_margin_point_) return 0.0;
    const auto money = source_margin_money(view.mark, view.cursor.point.open_ms);
    return source_margin_units(money, false);
}
 
// A TradingView margin checkpoint the kernel has no check point for (MG-I):
// the bar-open mark, the script-close pass, the stream tick, the opening
// print. The money, the mark's chart-tick rounding and the sizing are the
// shared source_margin_* rules -- the same ones the kernel's own path check
// reads through the requirement and units hooks -- and the slice is a market
// execution at the current point, never a resting order: the kernel owns
// every resting liquidation now.
bool PineExecutionAdapter::submit_margin_call_slice(
        double mark_price, const NativeDecisionContext& context,
        bool opening_checkpoint, std::optional<double> resolved_execution_price) {
    const auto position = detail::run_position(require_host());
    const auto money = source_margin_money(mark_price, context.sub_bar_open_ms);
    mark_price = money.mark;
    if (!money.valid) return false;
    if (source_margin_rounded_tie_veto()) return false;
    // A repeat at an already-resolved price -- the call TradingView repeats
    // at one fill until the book is covered (on_applied, recheck_at_fill) --
    // is a follow-up, not a fresh call, and the gate never reaches it.
    const double units = source_margin_units(money, opening_checkpoint,
                                             !resolved_execution_price.has_value());
    if (!(units > 0.0)) return false;
 
    // ab9714be pine_fills.cpp:1712-1726 books the checkpoint's residual
    // against bar_fill_price(fire) and only then applies the EXIT side's own
    // market slippage.  The opening checkpoint hands this helper the
    // already-SLIPPED opening print, so the entry-side slippage step is undone
    // here first and submit_margin_call_units re-applies the exit side on top
    // of the raw chart fill.  At zero slippage the reconstruction is the
    // identity.
    double close_base = mark_price;
    if (opening_checkpoint && std::isfinite(config_.slippage)
        && config_.slippage != 0.0) {
        close_base = source_bar_fill_tick(
            mark_price - (position.signed_units > 0.0 ? 1.0 : -1.0)
                * config_.slippage * staged_.syminfo.mintick,
            staged_.syminfo.mintick);
    }
    return submit_margin_call_units(close_base, context, units, true, resolved_execution_price);
}
 
bool PineExecutionAdapter::submit_margin_call_units(
        double mark_price, const NativeDecisionContext& context, double units,
        bool force_execution_price, std::optional<double> resolved_execution_price) {
    const auto position = detail::run_position(require_host());
    const double held = std::abs(position.signed_units);
    if (!(units > 0.0) || !std::isfinite(units) || !(held > 0.0)
        || !finite_positive(mark_price)) {
        return false;
    }
    units = std::min(units, held);
    native_order::Request request;
    request.intent = native_order::Reduce{native_order::ExplicitUnits{units}};
    request.label = kMarginCallLabel;
    request.comment = "Margin call";
    PlacementSnapshot snapshot;
    snapshot.family = PineOrderFamily::Margin;
    snapshot.source_id = request.label;
    snapshot.requested_qty = units;
    if (force_execution_price) {
        // ab9714be pine_fills.cpp:1712-1726 and :2649-2658: ordinary margin-call
        // closes book bar_fill_price(fire), then apply EXIT-side market slippage,
        // as does the adverse-extreme cascade. The default branch reproduces
        // that slippage before pinning: subtract for a long's sell, add for a
        // short's buy. An already-resolved recheck fill bypasses slippage and
        // is pinned unchanged; TradingView books repeated calls at one price
        // (tests/fixtures/margin_residual px-f2b-eth-short-0/1, -eth-slip-3).
        // The generic forced-execution fact rounds to the chart tick; at zero
        // slippage the default remains the identity.
        snapshot.forced_execution_price =
            resolved_execution_price ? *resolved_execution_price
                : source_margin_fill_price(mark_price, position.signed_units < 0.0);
    }
    snapshot.sizing = sizing_snapshot();
    const auto accepted = submit_or_replace(std::move(request), std::move(snapshot), false,
                                            kMarginCallLabel);
    if (!accepted) return false;
    if (PF_RARE(open_call_sequence_)) unrepeated_margin_calls_.push_back(accepted->incarnation);
    (void)require_host().execute_current({*accepted, NativeCurrentPriceRule::NearestTick});
    return true;
}
 
// TradingView's realized money (switch gain_loss_money): the profit of every
// closed trade, margin calls included, in booking order, summed into gains
// and into losses apart; strategy.netprofit is G + L, not one running sum.
// A synthetic NYSE:F ledger reaches 9999.999999999998 where the running
// sum reaches 10000 and is dropped close-only at that cost (tests/fixtures/
// margin_ledger_rules). Folded as trades book; the state hash carries both.
// Most asks find nothing booked since the last fold: they stop at the count,
// inline in the per-bar callers.
[[gnu::always_inline]] inline void PineExecutionAdapter::fold_source_money() {
    const auto* pine = pine_view_of(host_);
    if (!pine) return;
    const std::uint64_t count = pine->closed_trade_count();
    if (count == source_money_folded_) return;
    fold_source_money_through(*pine, count);
}
 
// The fold itself, over the trades booked since the last one (`count`
// trades in all).
[[gnu::noinline]]
void PineExecutionAdapter::fold_source_money_through(const PineStrategyHost& pine,
                                                     std::uint64_t count) {
    if (count < source_money_folded_) {
        const auto& prefix = detail::run_consumer(pine).closed_trade_prefix();
        if (count < prefix.base)
            throw coded<std::logic_error>(RunFailureCode::engine_invariant, {},
                                           "source-money rewind precedes the sealed prefix");
        source_gains_ = prefix.source_gains;
        source_losses_ = prefix.source_losses;
        source_money_folded_ = prefix.base;
    }
    for (; source_money_folded_ < count; ++source_money_folded_) {
        const double profit = pine.closed_trade(source_money_folded_).pnl;
        if (profit > 0.0) source_gains_ += profit;
        else source_losses_ += profit;
    }
}
 
// The G + L mirror's regime: the one predicate that scopes it. The regime
// the margin_ledger_rules and margin_call_rules tapes pin is the switch on;
// no fee at all (none configured, none in the run's fee model, none recorded
// at an opening); point value 1; no FX series; a power-of-ten lot step
// (every tape's); and at most one open lot (the ledger tapes hold one).
// The configuration (no commission, point value 1, no FX series, a
// power-of-ten lot step) is gain_loss_configured_, formed once per
// configuration; every condition here is a plain read, so their order only
// decides how soon a run outside the regime answers.
[[gnu::always_inline]] inline bool PineExecutionAdapter::gain_loss_regime() const {
    return gain_loss_configured_ && detail::margin_rule_switches().gain_loss_money
        && gain_loss_run_regime();
}
 
// The run's part of the regime: the fee model, the recorded fees, the book.
[[gnu::noinline]]
bool PineExecutionAdapter::gain_loss_run_regime() const {
    const auto* pine = pine_view_of(host_);
    if (pine == nullptr || host_ == nullptr) return false;
    const auto* spec = detail::run_spec(*host_);
    if (spec == nullptr || spec->fee_value != 0.0) return false;
    for (const auto& fact : open_entry_fees_) {
        if (fact.nonpercent_fee != 0.0) return false;
    }
    return pine->pyramid_entries_.size() <= 1;
}
 
// The signal's equity on TradingView's own money, inside gain_loss_regime().
// There sizing reads it through sig10(E) and the margin money floors sig10
// of its deficit to the lot step, so it parts from the engine's own equity
// only at the ten-digit ties the tapes pin. Elsewhere it is NaN and the
// engine's own equity stands: a commission written into a live configuration
// (the open entry's fee the mirror never charges), recorded cash fees, a
// pyramided book or a continuous or non-decimal lot moved the publication
// witness's fuzz runs off the engine's equity
// (tests/test_publication_witness.cpp).
double PineExecutionAdapter::gain_loss_signal_equity(double mark) const {
    return gain_loss_regime() ? gain_loss_mirror_equity(mark) : kNaN;
}
 
// The closed part of that money, initial + (G + L), for a commission-free
// long's one-unit call after a trade history (switch long_call_gain_loss):
// Synthetic G + L money of 49.99999999999999 is 7.1e-15 under a 2 x 25.00
// cost and calls, where the running sum need not (lab tv tapes
// tests/fixtures/margin_schedule_rules money/: histories whose sequential
// sum, initial + sequential net and G + L sums can straddle the cost of 400
// synthetic NYSE:F shares at 25.00). NaN outside gain_loss_regime() -- a fee-bearing
// book keeps the engine's closed-trade equity, which no tape decides yet.
double PineExecutionAdapter::gain_loss_closed_equity() const {
    if (!detail::margin_schedule_switches().long_call_gain_loss || !gain_loss_regime()) return kNaN;
    const auto* pine = pine_view_of(host_);
    if (!pine) return kNaN;
    double gains = source_gains_;
    double losses = source_losses_;
    const std::uint64_t count = pine->closed_trade_count();
    if (count < source_money_folded_) return kNaN;
    for (std::uint64_t index = source_money_folded_; index < count; ++index) {
        const double profit = pine->closed_trade(index).pnl;
        if (profit > 0.0) gains += profit;
        else losses += profit;
    }
    const double equity = pine->initial_capital_ + (gains + losses);
    return std::isfinite(equity) ? equity : kNaN;
}
 
// The mirror's equity itself: (initial + (G + L)) plus the open profit
// side x (c' - AP) x Q, AP the lots' (price x Q) / Q; NaN where it cannot be
// formed. Its callers scope it with gain_loss_regime().
// Out of line: inlined into its one caller, it widened that per-bar
// function's fetch footprint (CMakeLists.txt, -falign-functions).
[[gnu::noinline]]
double PineExecutionAdapter::gain_loss_mirror_equity(double mark) const {
    const auto* pine = pine_view_of(host_);
    if (!pine || !finite_positive(mark)) return kNaN;
    double gains = source_gains_;
    double losses = source_losses_;
    const std::uint64_t count = pine->closed_trade_count();
    if (count < source_money_folded_) return kNaN;
    for (std::uint64_t index = source_money_folded_; index < count; ++index) {
        const double profit = pine->closed_trade(index).pnl;
        if (profit > 0.0) gains += profit;
        else losses += profit;
    }
    double open = 0.0;
    if (pine->position_side_ != PositionSide::FLAT) {
        double weighted = 0.0;
        double units = 0.0;
        for (const auto& lot : pine->pyramid_entries_) {
            weighted += lot.price * lot.qty;
            units += lot.qty;
        }
        if (!finite_positive(units) || !std::isfinite(weighted)) return kNaN;
        const double side = pine->position_side_ == PositionSide::LONG ? 1.0 : -1.0;
        open = side * (mark - weighted / units) * units;
    }
    const double equity = (pine->initial_capital_ + (gains + losses)) + open;
    return std::isfinite(equity) ? equity : kNaN;
}
 
// The shapes the unified admission (placement rules 2 and 5, the fill
// re-check) is pinned on: one market or stop strategy.entry, from flat or
// reversing, at a percent-of-equity 100 default or an explicit quantity,
// commission-free, point value 1, no FX, pyramiding at most one, nothing else
// resting but unpriced closes, no risk rule. Each half has its own switch,
// read by the callers (unified_placement, fill_price_recheck), and a
// close-first entry (PlacementSnapshot::close_first_entry) takes rule 2 alone.
bool PineExecutionAdapter::unified_admission_scope(
        const PlacementSnapshot& source, bool market_or_stop, double signed_units,
        double units, bool beside_exits) const {
    // The tapes pin it on lot-stepped instruments, without
    // calc_on_order_fills and without the bar magnifier; a continuous
    // quantity (test_tv_money_precision_l4b, test_l10ac_full_equity_single_lot),
    // a fill recalculation or a magnified run keeps the earlier rules
    // (test_taro_price_gap_admission_l4d's scope controls).
    if (source.family != PineOrderFamily::Entry || !market_or_stop
        || !finite_positive(units) || finite_positive(source.exit_levels.limit)
        || !source.oca_name.empty() || source.birth.from_fill() || source.crosses_zero
        || !pinned_lot_grid()
        || config_.calc_on_order_fills || bar_magnifier_
        || config_.commission_value != 0.0 || config_.pyramiding < 0 || config_.pyramiding > 1
        || staged_.syminfo.pointvalue != 1.0 || source.sizing.fx != 1.0
        || staged_.account_fx != 1.0 || !staged_.account_fx_effective_from_ms.empty()
        || !finite_positive(staged_.syminfo.mintick) || !finite_positive(source.sizing.mark)
        || !std::isfinite(source.sizing.equity) || cap.active()
        || risk_.max_intraday_loss > 0.0 || risk_.max_drawdown > 0.0
        || risk_.max_cons_loss_days > 0 || risk_.max_position_size > 0.0) {
        return false;
    }
    if (signed_units != 0.0 && ((signed_units > 0.0) == source.is_long)) return false;
    // From flat or reversing as placed: an entry placed on a flat book is
    // judged only while the book is still flat when it fills -- a same-open
    // pair's later leg that finds the earlier one filled is the engine's
    // earlier rule (tests/fixtures/same_open_reversal) -- and one placed
    // against the other side only while that side, or flat behind its close,
    // is what it meets.
    const auto placed = static_cast<PositionSide>(source.projection_position_side);
    if (placed == PositionSide::FLAT ? signed_units != 0.0
                                     : ((placed == PositionSide::LONG) == source.is_long)) {
        return false;
    }
    // A stop is pinned from flat only (factorial/c1-s1-exp-stop-long-s1, the
    // stop and stopband tapes); a stop that reverses keeps the earlier
    // fill-time admission of the closing leg (test_m_admission_36_l4d).
    if (finite_positive(source.exit_levels.stop) && placed != PositionSide::FLAT) return false;
    // Nor is a default-sized stop: the stop the tapes pin through the fill
    // check is an explicit quantity (factorial/c1-s1-exp-stop-long-s1); a
    // percent stop is sized at its level and keeps the earlier admission, which
    // its tapes match (stop/stop-11-percent, -38-percent and -40-percent;
    // test_stop_entry_placement_open_qty_l4b), and no tape decides a percent
    // stop entry under the fill check (a population script's percent stops,
    // a third-party OANDA:EURUSD strategy, booked other trades there).
    if (finite_positive(source.exit_levels.stop) && !std::isfinite(source.requested_qty))
        return false;
    const bool default_all_in = !std::isfinite(source.requested_qty)
        && config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        && config_.default_qty_value == 100.0;
    const bool explicit_units = std::isfinite(source.requested_qty)
        && (source.qty_type < 0 || source.qty_type == static_cast<int>(QtyType::FIXED));
    if (!default_all_in && !explicit_units) return false;
    const double margin = source.is_long ? config_.margin_long : config_.margin_short;
    if (!finite_positive(margin) || margin > 100.0) return false;
    for (const auto& handle : live_handles_) {
        const auto peer = placement_.find(handle.incarnation);
        if (peer == placement_.end()) continue;
        const auto& row = peer->second;
        if (row.source_id == source.source_id && row.source_sequence == source.source_sequence)
            continue;
        const bool unpriced_close = (row.family == PineOrderFamily::Close
            || row.family == PineOrderFamily::CloseAll)
            && !finite_positive(row.exit_levels.limit) && !finite_positive(row.exit_levels.stop)
            && !finite_positive(row.exit_levels.trail_points)
            && !finite_positive(row.exit_levels.trail_price);
        // `beside_exits`: strategy.exit stop and trail legs may rest too (the
        // tie in unified_admission_terms); a limit leg is not pinned there.
        const bool stop_or_trail_leg = row.family == PineOrderFamily::ExitStop
            || row.family == PineOrderFamily::ExitTrail;
        if (!unpriced_close && row.family != PineOrderFamily::Margin
            && !(beside_exits && stop_or_trail_leg)) {
            return false;
        }
    }
    return true;
}
 
// The unified admission at resolve_terms, out of line: true when the terms
// are final (resolve_terms returns `result`), false when the order is outside
// the scope or, a reversal admitted (`admitted`), takes the ordinary reversal
// shape below with no money check on the way. Its rules: at its signal,
// placement rule 2 on the money scale -- E < sig10(Q c' m) drops an opening
// from flat and keeps only a reversal's closing leg -- and rule 5 on the price
// scale at full margin; at its fill only the price scale (resolve_terms).
[[gnu::noinline]]
bool PineExecutionAdapter::unified_admission_terms(
        const PlacementSnapshot& source, const NativeExecutionTermsFacts& facts,
        bool market_or_stop, bool opposite, native_order::ExecutionTerms& result,
        bool& admitted) const {
    const auto& admission_rules = detail::margin_rule_switches();
    const double unified_units = result.units && finite_positive(*result.units)
        ? *result.units
        : (std::isfinite(source.requested_qty)
            ? floor_quantity_grid(std::abs(source.requested_qty), staged_.quantity_grid)
            : kNaN);
    const bool book_clear = unified_admission_scope(source, market_or_stop,
                                                    facts.position.signed_units, unified_units);
    if (!book_clear
        && !(opposite && admission_rules.tie_reversal_beside_exits
             && admission_rules.unified_placement
             && unified_admission_scope(source, market_or_stop, facts.position.signed_units,
                                        unified_units, /*beside_exits=*/true))) {
        return false;
    }
    const double tick = staged_.syminfo.mintick;
    const double units = unified_units;
    const double side = source.is_long ? 1.0 : -1.0;
    const double margin = (source.is_long ? config_.margin_long : config_.margin_short) / 100.0;
    const double equity = source.sizing.equity;
    const double signal_ticks = std::floor(source.sizing.mark / tick + 0.5);
    const double signal_close = signal_ticks * tick;
    // Beside resting strategy.exit stop and trail legs (the reversed
    // position's, the new entry's own) only rule 2's exact tie is judged: a
    // default 100 % reversal at full margin on a whole-unit lot whose
    // binary64 E is under sig10(Q c') while sig10(E) reaches it keeps only
    // its close leg, as on a clear book (tests/fixtures/admission_rules
    // reversal_tie). Off that tie, beside a limit leg and on a fractional lot
    // the engine's earlier rules stand: no tape decides there.
    if (!book_clear) {
        const double cost = source_money_round(units * signal_close * margin);
        const bool default_all_in = !std::isfinite(source.requested_qty)
            && config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
            && config_.default_qty_value == 100.0;
        const bool whole_units = staged_.quantity_grid && *staged_.quantity_grid == 1.0;
        if (!(default_all_in && whole_units && margin == 1.0 && equity < cost
              && !(source_money_round(equity) < cost))) {
            return false;
        }
        result.units = facts.opposite_book_units;
        result.shape = native_order::OpeningShape::CloseOpposite;
        return true;
    }
    if (admission_rules.unified_placement
        && equity < source_money_round(units * signal_close * margin)) {
        result.units = opposite ? facts.opposite_book_units : 0.0;
        result.shape = opposite ? native_order::OpeningShape::CloseOpposite
                                : native_order::OpeningShape::Transact;
        return true;
    }
    // A close-first entry passed rule 2 and is never checked on the price
    // scale: it fills flat behind its close with the quantity it was sized at,
    // and the margin rules trim it there (tests/fixtures/admission_rules cf1,
    // cf2, cf5, cf9, cf10; c3b).
    if (!(source.close_first_entry && admission_rules.close_first_admission)) {
        const double per_unit = margin == 1.0
            ? source_money_round(source_money_round(equity) / units)
            : source_money_round(source_money_round(equity) / (units * margin));
        const bool placement_short = admission_rules.unified_placement
            && margin == 1.0
            && per_unit < (signal_ticks + side * config_.slippage) * tick;
        const double quote = finite_positive(facts.raw_price) ? facts.raw_price
                                                              : result.resolved_price;
        const bool fill_short = admission_rules.fill_price_recheck
            && !unified_fill_admits(source, units, quote);
        if (placement_short || fill_short) {
            result.units = 0.0;
            result.shape = native_order::OpeningShape::Transact;
            return true;
        }
    }
    result.units = units;
    if (!opposite) return true;
    admitted = true;
    return false;
}
 
// The instruments these rules are pinned on: a lot grid that is a power
// of ten (every tape's -- 1, 0.01, 0.0001, 1e-05 -- and every population
// member's). A continuous quantity or another grid keeps the engine's earlier
// rules: no tape decides there, and the synthetic fuzz batteries that run
// there (tests/test_publication_witness.cpp's 0.25 lot,
// test_adapter_live_state_equivalence's continuous one) book their trades as
// before.
// Formed once per staged configuration (set_staged_configuration).
[[gnu::always_inline]] inline bool PineExecutionAdapter::pinned_lot_grid() const {
    return lot_grid_pinned_;
}
 
// Whether nothing rests or waits beside an entry the script is placing now
// but unpriced closes and margin rows: the book the unified admission's
// placement half is pinned on (unified_admission_scope's, at placement).
// Out of line and cold: a narrow scope's body, kept off the per-bar
// path, which is front-end bound (CMakeLists.txt, -falign-functions).
[[gnu::noinline, gnu::cold]]
bool PineExecutionAdapter::unified_placement_book_clear() const {
    for (const auto& handle : live_handles_) {
        const auto peer = placement_.find(handle.incarnation);
        if (peer == placement_.end()) continue;
        const auto& row = peer->second;
        const bool unpriced_close = (row.family == PineOrderFamily::Close
            || row.family == PineOrderFamily::CloseAll)
            && !finite_positive(row.exit_levels.limit) && !finite_positive(row.exit_levels.stop)
            && !finite_positive(row.exit_levels.trail_points)
            && !finite_positive(row.exit_levels.trail_price);
        if (!unpriced_close && row.family != PineOrderFamily::Margin) return false;
    }
    for (const auto& pending : pending_same_bar_commands_)
        if (pending.opening) return false;
    for (const auto& pending : pending_entries_)
        if (pending.snapshot.opening) return false;
    for (const auto& pending : delayed_market_orders_)
        if (pending.snapshot.opening) return false;
    return true;
}
 
// The fill half: sig10(sig10(E) / (Q m)) against the tick-built fill quote
// moved by the slippage ticks (the next open; max/min(open, stop) for a stop;
// the signal close under process_orders_on_close), E frozen at the signal.
// Out of line and cold: a narrow scope's body, kept off the per-bar
// path, which is front-end bound (CMakeLists.txt, -falign-functions).
[[gnu::noinline, gnu::cold]]
bool PineExecutionAdapter::unified_fill_admits(const PlacementSnapshot& source, double units,
                                               double quote) const {
    const double tick = staged_.syminfo.mintick;
    if (!finite_positive(units) || !finite_positive(quote) || !finite_positive(tick)) return true;
    const double margin = (source.is_long ? config_.margin_long : config_.margin_short) / 100.0;
    const double equity = source.sizing.equity;
    const double per_unit = margin == 1.0
        ? source_money_round(source_money_round(equity) / units)
        : source_money_round(source_money_round(equity) / (units * margin));
    const double side = source.is_long ? 1.0 : -1.0;
    const double exec = (std::floor(quote / tick + 0.5) + side * config_.slippage) * tick;
    return !(per_unit < exec);
}
 
// Margin rule 3's scope, as pinned: one commission-free long lot that a
// strategy.entry opened, at full margin with slippage, point value 1 and no
// FX series, on a lot grid of at most one, pyramiding at most one, no risk
// rule, and no order of the script resting beside it but the close_all of
// the bar. Without slippage the residual checkpoint
// (submit_tv_money_long_margin_call) owns the long.
// The configuration before the book: plain reads, so their order only decides
// how soon an out-of-scope run answers (every bar open asks). Full margin, no
// commission, slippage, a lot step of at most one, pyramiding at most one,
// point value 1 and no FX series are slipped_long_configured_, formed once
// per configuration.
[[gnu::always_inline]] inline bool PineExecutionAdapter::slipped_long_margin_scope() const {
    return slipped_long_configured_ && detail::margin_rule_switches().long_open_close_checks
        && source_margin_call_enabled_ && slipped_long_book_scope();
}
 
// The book's part of the scope.
[[gnu::noinline]]
bool PineExecutionAdapter::slipped_long_book_scope() const {
    const auto position = detail::run_position(require_host());
    if (!(position.signed_units > 0.0) || position.lot_count != 1 || cap.active()
        || risk_.max_intraday_loss > 0.0 || risk_.max_drawdown > 0.0
        || risk_.max_cons_loss_days > 0 || pine_view_of(&require_host()) == nullptr
        || !pending_bracket_legs_.empty() || !pending_entries_.empty()
        || !pending_same_bar_commands_.empty() || !pending_relative_exits_.empty()
        || !source_shadow_pending_.empty()) {
        return false;
    }
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found != placement_.end() && found->second.family != PineOrderFamily::Margin
            && found->second.family != PineOrderFamily::CloseAll) {
            return false;
        }
    }
    const CohortFacts* sole_cohort = nullptr;
    for (const auto& row : cohorts_by_id_.held_rows()) {
        if (row.second.opened.empty()) continue;
        if (sole_cohort != nullptr) return false;
        sole_cohort = &row.second;
    }
    if (sole_cohort == nullptr || sole_cohort->opened.size() != 1) return false;
    const auto placement = placement_.find(sole_cohort->opened.front().incarnation);
    return placement != placement_.end()
        && placement->second.family == PineOrderFamily::Entry
        && placement->second.opening && placement->second.is_long
        && !finite_positive(placement->second.exit_levels.limit)
        && !finite_positive(placement->second.exit_levels.stop)
        && !finite_positive(placement->second.exit_levels.trail_offset);
}
 
// The units TradingView calls off such a long marked at `quote`, as it calls a
// short: the requirement is the position's value at the mark on the
// ten-significant-digit money ladder, the shortfall is that against the cash
// plus the open profit, four times its lot-floored quotient is called, and a
// shortfall under one unit's worth calls one unit (tests/fixtures/
// margin_call_rules: a synthetic F long of 2 at 25.00 with 49.999999999 cash
// is 1e-9 short at a 24.98 open and sells 1 at 24.96). The cash is the
// closed-trade equity -- the running net profit, not the G + L money -- so
// after a trade history a ten-digit tie can fall on either side of the cost:
// on a population NYSE:F 15-minute strategy TradingView's G + L money,
// illustrated by 49.99999999999999, is 7.1e-15 under 2 x 25.00 and calls, where a
// running sum need not (reconstructed from the trade set, not replayed). The
// money basis of the long call after a history is unpinned.
// Out of line and cold: a narrow scope's body, kept off the per-bar
// path, which is front-end bound (CMakeLists.txt, -falign-functions).
[[gnu::noinline, gnu::cold]]
double PineExecutionAdapter::slipped_long_margin_units(double quote) const {
    const auto* pine = pine_view_of(&require_host());
    const auto position = detail::run_position(require_host());
    const double held = position.signed_units;
    const double step = *staged_.quantity_grid;
    if (!pine || !finite_positive(quote) || !(held > 0.0)) return 0.0;
    const double required = source_money_round(held * quote);
    const double gain_loss = gain_loss_closed_equity();
    const double marked = (std::isfinite(gain_loss) ? gain_loss : pine->closed_trade_equity())
        + held * (quote - pine->position_entry_price_);
    const double deficit = required - marked;
    if (!(deficit > 0.0) || !std::isfinite(deficit)) return 0.0;
    // Only the one-unit call is pinned for a long: a shortfall whose
    // lot-floored quotient is a lot or more (four times it called) stays
    // with the engine's existing checkpoints.
    if (std::floor(source_money_round(deficit) / quote / step) > 0.0 || !(deficit / quote < 1.0))
        return 0.0;
    // Margin rule 3: the unit is called on negative free cash too; switched
    // off, a book whose cash is below its entry cost keeps it.
    const double free_cash = pine->closed_trade_equity() - held * pine->position_entry_price_;
    if (!detail::margin_rule_switches().negative_free_cash_call && free_cash < 0.0) return 0.0;
    return std::min(1.0, held);
}
 
// Whether such a long marked at `quote` is short by less than one lot's
// worth of its ten-digit money -- the one-unit call's shortfall, which
// TradingView takes at the next open rather than at the fill that opened it
// (tests/fixtures/margin_call_rules long-admit-m10n: 1e-8 short at the
// 20:30 close fill, called at the 20:45 open).
// Out of line and cold: a narrow scope's body, kept off the per-bar
// path, which is front-end bound (CMakeLists.txt, -falign-functions).
[[gnu::noinline, gnu::cold]]
bool PineExecutionAdapter::slipped_long_unit_shortfall(double quote) const {
    const auto* pine = pine_view_of(&require_host());
    const double held = detail::run_position(require_host()).signed_units;
    if (!pine || !finite_positive(quote) || !(held > 0.0)) return false;
    const double gain_loss = gain_loss_closed_equity();
    const double deficit = source_money_round(held * quote)
        - ((std::isfinite(gain_loss) ? gain_loss : pine->closed_trade_equity())
           + held * (quote - pine->position_entry_price_));
    return deficit > 0.0 && deficit / quote < 1.0
        && std::floor(source_money_round(deficit) / quote / *staged_.quantity_grid) == 0.0;
}
 
// Margin rule 4: a call at an extreme of the bar whose script closes the
// position, under calc_on_order_fills, recalculates the script there, and its
// close fills at the bar's next point -- the other extreme, or the close
// after the second one -- with the close's slippage (tests/fixtures/
// margin_call_rules coof-low-call-on: 2293.8 at the high after the
// low's call).
// Out of line and cold: a narrow scope's body, kept off the per-bar
// path, which is front-end bound (CMakeLists.txt, -falign-functions).
[[gnu::noinline, gnu::cold]]
bool PineExecutionAdapter::close_all_at_next_point(
        const Bar& bar, int fired,
        const std::vector<std::pair<native_order::RequestHandle, PlacementSnapshot>>& closes,
        const NativeDecisionContext& context) {
    if (!detail::margin_rule_switches().coof_next_point_close || !config_.calc_on_order_fills
        || !finite_positive(staged_.syminfo.mintick))
        return false;
    const auto position = detail::run_position(require_host());
    if (!(position.signed_units > 0.0)) return false;
    bool live = false;
    for (const auto& close : closes) {
        if (std::find(live_handles_.begin(), live_handles_.end(), close.first)
            != live_handles_.end()) {
            live = true;
        }
    }
    if (!live) return false;
    const bool high_first = source_path_uses_high_first(bar);
    const double next = fired == 1 ? (high_first ? bar.low : bar.high) : bar.close;
    const double tick = staged_.syminfo.mintick;
    const double quote = std::floor(next / tick + 0.5) * tick;
    native_order::Request request;
    request.intent = native_order::Flatten{};
    request.label = "__close__";
    PlacementSnapshot snapshot;
    snapshot.family = PineOrderFamily::CloseAll;
    snapshot.source_id = request.label;
    snapshot.forced_execution_price = source_margin_fill_price(quote, false);
    snapshot.sizing = sizing_snapshot();
    const auto accepted = submit_or_replace(std::move(request), std::move(snapshot), false,
                                            "__pine_close_all");
    if (!accepted) return false;
    (void)require_host().execute_current({*accepted, NativeCurrentPriceRule::NearestTick});
    return true;
}
 
bool PineExecutionAdapter::submit_tv_money_long_margin_call(
        const Bar& bar, const NativeDecisionContext& context, int* fired_waypoint) {
    // The one-contract 10-significant-digit money residual is an adapter
    // policy over the native position and its ordinary chart path.  It is not
    // a second matching loop: the resulting reduction is still a generic
    // current execution with an immutable source terms fact.
    const auto grid = staged_.quantity_grid;
    // Quiet: out of scope by the run's configuration alone, which the test
    // below would refuse before it reads the book.
    if (detail::skip_quiet(detail::QuietHook::TvMoneyLongMargin,
            host_ != nullptr
            && (!source_margin_call_enabled_
                || std::abs(config_.margin_long - 100.0) > 1e-12
                || config_.commission_value != 0.0 || config_.slippage != 0
                || !grid || !(*grid > 0.0) || *grid > 1.0
                || std::abs(staged_.syminfo.pointvalue - 1.0) > 1e-12
                || !staged_.account_fx_effective_from_ms.empty()
                || cap.active() || risk_.max_intraday_loss > 0.0
                || risk_.max_drawdown > 0.0 || risk_.max_cons_loss_days > 0
                || last_margin_call_script_bar_ == context.script_bar_open_ms))) {
        return false;
    }
    // A one-lot book under process_orders_on_close takes the call whatever
    // pyramiding the strategy declares: at pyramiding 2 TradingView books the
    // same fourteen one-unit calls, trade for trade, as at 1 (lab tv tapes
    // tests/fixtures/margin_residual w5b-ms-eur-p100-pyr2 and
    // w5b-sz-eur-p100-10m-0410; none at 99 %, w5b-ms-eur-p99-pyr2; lane
    // W5B-ENG-MARGIN-RESIDUAL). ab9714be scoped it to pyramiding 1.
    const auto position = detail::run_position(require_host());
    if (!source_margin_call_enabled_
        || position.signed_units <= 0.0 || position.lot_count != 1
        || std::abs(config_.margin_long - 100.0) > 1e-12
        || config_.commission_value != 0.0 || config_.slippage != 0
        || !grid || !(*grid > 0.0) || *grid > 1.0
        || std::abs(staged_.syminfo.pointvalue - 1.0) > 1e-12
        || active_staged_fx(context.sub_bar_open_ms) != 1.0
        || !staged_.account_fx_effective_from_ms.empty()
        || cap.active() || risk_.max_intraday_loss > 0.0
        || risk_.max_drawdown > 0.0 || risk_.max_cons_loss_days > 0
        || last_margin_call_script_bar_ == context.script_bar_open_ms) {
        return false;
    }
    const double lot_value = *grid * bar.close * staged_.syminfo.pointvalue
        * active_staged_fx(context.sub_bar_open_ms);
    if (!config_.process_orders_on_close
        && (config_.pyramiding < 0 || config_.pyramiding > 1)
        && std::isfinite(lot_value) && lot_value >= 1.0) {
        // The high-value fractional extension is pinned only for a single
        // opening slot; low-value rounded-money path checks remain valid with
        // larger source pyramiding limits (open-money-before-priced-exit).
        return false;
    }
    if (position_open_priced_
        && (!std::isfinite(lot_value) || lot_value >= 1.0)) {
        return false;
    }
    // Margin rule 5: under process_orders_on_close the close_all the script
    // placed at this close waits behind the close point's call, sized before
    // it (the caller freezes it; tests/fixtures/margin_call_rules
    // size-eth-06-22-t1).
    const bool close_point_reversal = detail::margin_rule_switches().close_point_reversal
        && fired_waypoint != nullptr;
    if (config_.process_orders_on_close) {
        for (const auto& handle : live_handles_) {
            const auto found = placement_.find(handle.incarnation);
            if (found != placement_.end()
                && found->second.family != PineOrderFamily::Margin
                && !(close_point_reversal && found->second.family == PineOrderFamily::CloseAll
                     && found->second.placement_script_open_ms == context.script_bar_open_ms)) {
                return false;
            }
        }
    }
 
    int begin = 0;
    if (position_open_script_bar_ == context.script_bar_open_ms) {
        // A new position can see only the suffix after its actual native
        // opening point.  The high-value residual witnesses deliberately
        // cover a true market opening at O; a close-time/priced entry cannot
        // retrospectively inspect this bar.
        if (position_open_phase_ != NativePathPhase::Open) return false;
        begin = 0;
    }
    const bool high_first = source_path_uses_high_first(bar);
    const double path[] = {bar.open, high_first ? bar.high : bar.low,
                           high_first ? bar.low : bar.high, bar.close};
    const double quantity = position.signed_units;
    const double point_value = staged_.syminfo.pointvalue;
    // ab9714be pine_fills.cpp:1929-1965: a single-entry, commission-free book
    // whose cached net profit carries tracked addition roundoff narrows the
    // 1e-7 guard to what the current evaluation and that history support, so
    // a genuine 1e-7 rounding deficit fires (synthetic Q 10000 at 2.00000,
    // mark 2.00010: equity 20000.9999999 against required money 20001.00).
    const auto* pine = pine_view_of(&require_host());
    const bool supported_guard_scope = pine
        && pine->position_entry_count_ == 1 && pine->pyramid_entries_.size() == 1
        && pine->net_profit_sum_ == pine->net_profit_roundoff_value_
        && std::isfinite(pine->net_profit_roundoff_bound_);
    // Margin rule 3 on a book whose net profit carries no tracked roundoff:
    // TradingView checks the open, the low and the close -- not the high --
    // at the tick-built price c' = ticks x mintick, and calls one unit when
    // the free cash is below the ten-digit residual of the position's value,
    // sig10(Q c') - Q c', compared exactly (tests/fixtures/margin_call_rules:
    // 7.3e-12 at an ETH low calls, as a 5e-6 residual over 3e-6 of free cash
    // at a close c' one ULP above its decimal does). Negative free cash calls
    // nothing in this scope -- the loop moves on, and the guarded check below
    // is not reached: the call on negative free cash is pinned for the slipped
    // long only.
    const auto& rules = detail::margin_rule_switches();
    const bool exact_residual = rules.long_open_close_checks
        && finite_positive(staged_.syminfo.mintick)
        && supported_guard_scope && pine->net_profit_roundoff_bound_ == 0.0;
    for (int index = begin; index != 4; ++index) {
        if (exact_residual) {
            if ((index == 1 || index == 2) && path[index] == bar.high
                && bar.high != bar.low) {
                continue;
            }
            const double tick = staged_.syminfo.mintick;
            const double price = std::floor(path[index] / tick + 0.5) * tick;
            if (!finite_positive(price)) continue;
            const double gain_loss = gain_loss_closed_equity();
            const double free_cash = (std::isfinite(gain_loss) ? gain_loss
                                                             : pine->closed_trade_equity())
                - quantity * pine->position_entry_price_;
            const double residual = source_money_round(quantity * price) - quantity * price;
            if (!(free_cash < residual) || free_cash < 0.0) continue;
            const double units = std::min(1.0, quantity);
            const double rounded_units = std::round(units / *grid) * *grid;
            const double guard = std::max({1e-12, std::abs(units) * 1e-12,
                                           std::abs(*grid) * 1e-9});
            if (units < quantity - guard && std::abs(rounded_units - units) > guard)
                return false;
            if (fired_waypoint) *fired_waypoint = index;
            return submit_margin_call_units(price, context, units, true);
        }
        const double price = path[index];
        if (!finite_positive(price)) continue;
        const double exact_value = quantity * price * point_value;
        const double equity = require_host().native_marked_equity(price);
        const double rounded_value = source_money_round(exact_value);
        // This trigger is exclusively for an exact-funded book whose
        // 10-significant-digit account valuation is fractionally larger.
        // Preserve the base 1e-7 guard for ordinary historical arithmetic.
        double arithmetic_guard = 1e-7;
        if (supported_guard_scope) {
            const double entry_value = quantity * pine->position_entry_price_ * point_value;
            const double money_scale = std::max({
                std::abs(pine->closed_trade_equity()),
                std::abs(pine->BacktestEngine::open_profit(price)),
                std::abs(entry_value), std::abs(exact_value), std::abs(equity),
                std::abs(rounded_value)});
            const double evaluation_guard = 8.0
                * std::numeric_limits<double>::epsilon() * money_scale;
            const double supported_guard = std::nextafter(
                evaluation_guard + pine->net_profit_roundoff_bound_,
                std::numeric_limits<double>::infinity());
            if (std::isfinite(supported_guard))
                arithmetic_guard = std::min(arithmetic_guard, supported_guard);
        }
        if (!std::isfinite(exact_value) || !std::isfinite(equity)
            || equity + arithmetic_guard < exact_value
            || !(equity + arithmetic_guard < rounded_value)) {
            continue;
        }
        const double units = std::min(1.0, quantity);
        const double rounded_units = std::round(units / *grid) * *grid;
        const double guard = std::max({1e-12, std::abs(units) * 1e-12,
                                       std::abs(*grid) * 1e-9});
        if (units < quantity - guard && std::abs(rounded_units - units) > guard)
            return false;
        // ab9714be pine_fills.cpp:1985-2020 books the one contract at
        // bar_fill_price(fire), the path point that fired, not wherever the
        // checkpoint callback happens to stand (the script-bar close).
        if (fired_waypoint) *fired_waypoint = index;
        return submit_margin_call_units(price, context, units, true);
    }
    return false;
}
 
bool PineExecutionAdapter::slipped_pooc_opening_money_scope(
        const Bar& bar, const NativeDecisionContext& context) const {
    // pine_fills.cpp:1753-1775 and :1823-1868 at ab9714be: a terminal
    // process_orders_on_close MARKET entry with positive slippage is the sole
    // owner of the deferred opening-money check. Recover the retired lot
    // provenance from durable cohort and placement receipts.
    const auto position = detail::run_position(require_host());
    const auto grid = staged_.quantity_grid;
    if (!source_margin_call_enabled_ || !modeled_input()
        || !config_.process_orders_on_close || config_.slippage <= 0
        || position.signed_units <= 1.0 || position.lot_count != 1
        || std::abs(config_.margin_long - 100.0) > 1e-12
        || config_.pyramiding < 0 || config_.pyramiding > 1
        || config_.commission_value != 0.0
        || !grid || !(*grid > 0.0) || *grid >= 1.0
        || std::abs(staged_.syminfo.pointvalue - 1.0) > 1e-12
        || active_staged_fx(context.sub_bar_open_ms) != 1.0
        || !staged_.account_fx_effective_from_ms.empty()
        || context.driver_statistics.intrabar_path_enabled
        || cap.active() || risk_.max_intraday_loss > 0.0
        || risk_.max_drawdown > 0.0 || risk_.max_cons_loss_days > 0
        || position_open_phase_ != NativePathPhase::Close
        || position_open_priced_
        || position_open_script_bar_ == std::numeric_limits<std::int64_t>::min()
        || !live_handles_.empty() || !pending_bracket_legs_.empty()
        || !pending_entries_.empty() || !pending_same_bar_commands_.empty()
        || !pending_relative_exits_.empty() || !pending_coof_requests_.empty()
        || !source_shadow_pending_.empty()) {
        return false;
    }
 
    const CohortFacts* sole_cohort = nullptr;
    for (const auto& row : cohorts_by_id_.held_rows()) {
        if (row.second.opened.empty()) continue;
        if (sole_cohort != nullptr) return false;
        sole_cohort = &row.second;
    }
    if (sole_cohort == nullptr || sole_cohort->opened.size() != 1
        || sole_cohort->live_units_by_origin.size() != 1) {
        return false;
    }
    const auto origin = sole_cohort->opened.front();
    const auto live_units = sole_cohort->live_units_by_origin.find(origin.incarnation);
    const auto placement = placement_.find(origin.incarnation);
    if (live_units == sole_cohort->live_units_by_origin.end()
        || !(live_units->second > 1.0)
        || placement == placement_.end()
        || placement->second.family != PineOrderFamily::Entry
        || !placement->second.opening || !placement->second.is_long
        || finite_positive(placement->second.exit_levels.limit)
        || finite_positive(placement->second.exit_levels.stop)
        || finite_positive(placement->second.exit_levels.trail_offset)
        || placement->second.placement_script_open_ms
            != position_open_script_bar_) {
        return false;
    }
 
    const double lot_value = *grid * bar.close * staged_.syminfo.pointvalue;
    return std::isfinite(lot_value) && lot_value < 1.0;
}
 
bool PineExecutionAdapter::submit_slipped_pooc_opening_money_call(
        const Bar& bar, const NativeDecisionContext& context) {
    // Quiet: out of scope by the run's configuration alone, which
    // slipped_pooc_opening_money_scope refuses before it reads the book.
    if (detail::skip_quiet(detail::QuietHook::SlippedPoocMoney,
            host_ != nullptr
            && (!source_margin_call_enabled_ || !modeled_input()
                || !config_.process_orders_on_close || config_.slippage <= 0
                || config_.commission_value != 0.0))) {
        return false;
    }
    if (!slipped_pooc_opening_money_scope(bar, context)
        || position_open_script_bar_ == context.script_bar_open_ms
        || last_margin_call_script_bar_ == context.script_bar_open_ms) {
        return false;
    }
    const auto position = detail::run_position(require_host());
    const double exact_value = position.signed_units * bar.open
        * staged_.syminfo.pointvalue;
    const double equity = require_host().native_marked_equity(bar.open);
    const double rounded_value = source_money_round(exact_value);
    if (!std::isfinite(exact_value) || !std::isfinite(equity)
        || equity < exact_value || !(equity < rounded_value)) {
        return false;
    }
 
    return submit_margin_call_units(
        bar.open, context, std::min(1.0, position.signed_units), false);
}
 
bool PineExecutionAdapter::schedule_tv_money_long_margin_before_trail(
        const Bar& bar, const NativeDecisionContext& context) {
    const auto grid = staged_.quantity_grid;
    // Quiet: out of scope by the run's configuration alone, which the test
    // below would refuse before it reads the book.
    if (detail::skip_quiet(detail::QuietHook::TvMoneyTrailMargin,
            host_ != nullptr
            && (!source_margin_call_enabled_ || config_.calc_on_order_fills || !modeled_input()
                || std::abs(config_.margin_long - 100.0) > 1e-12
                || config_.commission_value != 0.0 || config_.slippage != 0
                || config_.pyramiding < 0 || config_.pyramiding > 1
                || !grid || !(*grid > 0.0) || *grid >= 1.0
                || std::abs(staged_.syminfo.pointvalue - 1.0) > 1e-12
                || !staged_.account_fx_effective_from_ms.empty()
                || cap.active() || risk_.max_intraday_loss > 0.0
                || risk_.max_drawdown > 0.0 || risk_.max_cons_loss_days > 0
                || last_margin_call_script_bar_ == context.script_bar_open_ms))) {
        return false;
    }
    const auto position = detail::run_position(require_host());
    if (!source_margin_call_enabled_ || config_.calc_on_order_fills || !modeled_input()
        || position.signed_units <= 1.0 || position.lot_count != 1
        || std::abs(config_.margin_long - 100.0) > 1e-12
        || config_.commission_value != 0.0 || config_.slippage != 0
        || config_.pyramiding < 0 || config_.pyramiding > 1
        || !grid || !(*grid > 0.0) || *grid >= 1.0
        || std::abs(staged_.syminfo.pointvalue - 1.0) > 1e-12
        || active_staged_fx(context.sub_bar_open_ms) != 1.0
        || !staged_.account_fx_effective_from_ms.empty()
        || cap.active() || risk_.max_intraday_loss > 0.0
        || risk_.max_drawdown > 0.0 || risk_.max_cons_loss_days > 0
        || last_margin_call_script_bar_ == context.script_bar_open_ms) {
        return false;
    }
    const double lot_value = *grid * bar.close * staged_.syminfo.pointvalue
        * active_staged_fx(context.sub_bar_open_ms);
    if (position_open_priced_
        && (!std::isfinite(lot_value) || lot_value >= 1.0)) {
        return false;
    }
 
    const PlacementSnapshot* owned_trail = nullptr;
    std::uint64_t owned_trail_incarnation = 0;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& candidate = found->second;
        if (candidate.family == PineOrderFamily::Margin) continue;
        const bool exit = candidate.family == PineOrderFamily::ExitLimit
            || candidate.family == PineOrderFamily::ExitStop
            || candidate.family == PineOrderFamily::ExitTrail;
        if (exit && !candidate.from_entry.empty()
            && cohort_exposure_for(candidate.from_entry) == 0.0) {
            continue;
        }
        if (!exit || candidate.family != PineOrderFamily::ExitTrail
            || owned_trail != nullptr) {
            return false;
        }
        owned_trail = &candidate;
        owned_trail_incarnation = handle.incarnation;
    }
    if (owned_trail) {
        const bool full = !std::isfinite(owned_trail->requested_qty)
            && (!std::isfinite(owned_trail->qty_percent)
                || owned_trail->qty_percent >= 100.0);
        const bool relative = std::isfinite(owned_trail->exit_levels.trail_points)
            && !std::isfinite(owned_trail->exit_levels.trail_price)
            && std::isfinite(owned_trail->exit_levels.trail_offset)
            && owned_trail->exit_levels.trail_offset > 0.0;
        if (!full || !relative || !owned_trail->oca_name.empty()) return false;
    }
 
    const bool high_first = source_path_uses_high_first(bar);
    const double path[] = {bar.open, high_first ? bar.high : bar.low,
                           high_first ? bar.low : bar.high, bar.close};
    double fire_price = kNaN;
    int fire_point = -1;
    constexpr double kArithmeticGuard = 1e-7;
    for (int point = 0; point != 4; ++point) {
        const double price = path[point];
        if (!finite_positive(price)) continue;
        const double exact_value = position.signed_units * price
            * staged_.syminfo.pointvalue;
        const double equity = require_host().native_marked_equity(price);
        const double rounded_value = source_money_round(exact_value);
        if (std::isfinite(exact_value) && std::isfinite(equity)
            && equity + kArithmeticGuard >= exact_value
            && equity + kArithmeticGuard < rounded_value) {
            fire_price = price;
            fire_point = point;
            break;
        }
    }
    if (!finite_positive(fire_price)) return false;
    // A call the close fires is taken there after the script
    // (close_point_margin_call), not rested for the path to reach its price
    // first. Under process_orders_on_close it rests as before: it fills ahead
    // of the orders the script places at that close, which is where
    // TradingView executes it, and a close_all placed there keeps the size it
    // had before it (close).
    if (fire_point == 3 && !config_.process_orders_on_close) return false;
    if (config_.process_orders_on_close && owned_trail) {
        // ab9714be pine_fills.cpp:378-384, 1843-1846 and 1935-1937: under
        // POOC a resting order suppresses the carried rounded-money check
        // unless it is the owned trailing exit filling on THIS bar, and then
        // only a path point strictly before that fill may fire.  Walk the
        // trail over the same waypoints from its state at the open.
        const double tick = staged_.syminfo.mintick;
        double activation = owned_trail->trail_activation_level;
        if (!finite_positive(activation) && finite_positive(tick)) {
            activation = require_host().position_avg_price()
                + source_trail_points_ticks(
                    owned_trail->exit_levels.trail_points, tick) * tick;
        }
        const double offset = compat::pine::trail_offset_to_ticks(
            owned_trail->exit_levels.trail_offset) * tick;
        if (!finite_positive(activation) || !std::isfinite(offset)) return false;
        const auto state = trail_state_at_open_.find(owned_trail_incarnation);
        bool armed = state != trail_state_at_open_.end() && state->second.activated
            && finite_positive(state->second.best_price);
        double best = armed ? state->second.best_price : kNaN;
        int fill_point = -1;
        for (int point = 0; point != 4 && fill_point < 0; ++point) {
            const double price = path[point];
            if (!finite_positive(price)) continue;
            if (!armed) {
                if (price >= activation) {
                    armed = true;
                    best = price;
                }
                continue;
            }
            if (offset > 0.0 ? price <= best - offset : price < best) {
                fill_point = point;
            } else {
                best = std::max(best, price);
            }
        }
        if (fill_point < 0 || !(fire_point < fill_point)) return false;
    }
 
    native_order::Request request;
    request.intent = native_order::Reduce{native_order::ExplicitUnits{
        std::min(1.0, position.signed_units)}};
    request.label = kMarginCallLabel;
    request.comment = "Margin call";
    request.trigger = fire_price <= bar.open
        ? native_order::Trigger{native_order::Stop{fire_price}}
        : native_order::Trigger{native_order::Limit{fire_price}};
    PlacementSnapshot snapshot;
    snapshot.family = PineOrderFamily::Margin;
    snapshot.source_id = request.label;
    snapshot.requested_qty = std::min(1.0, position.signed_units);
    snapshot.sizing = sizing_snapshot();
    return static_cast<bool>(submit_or_replace(
        std::move(request), std::move(snapshot), false,
        "__tv_money_margin_path__"));
}
 
namespace {
 
// A MARKET entry: no limit, stop or trail level. A flat bar's priced entries
// keep their own route (a stop pair that fires on one bar pyramids past the
// cap, TradingView probe 80, test_integration's flat-armed stops).
bool market_entry_row(const PlacementSnapshot& row) noexcept {
    return !finite_positive(row.exit_levels.limit) && !finite_positive(row.exit_levels.stop)
        && !finite_positive(row.exit_levels.trail_points)
        && !finite_positive(row.exit_levels.trail_price)
        && !finite_positive(row.exit_levels.trail_offset);
}
 
// An add: an opening MARKET entry placed while the book held its own side.
bool add_entry_row(const PlacementSnapshot& row) noexcept {
    return row.family == PineOrderFamily::Entry && row.opening && market_entry_row(row)
        && row.projection_position_side
            == static_cast<std::int32_t>(row.is_long ? PositionSide::LONG : PositionSide::SHORT);
}
 
// Two adds one script bar placed on the same side.
bool add_siblings(const PlacementSnapshot& a, const PlacementSnapshot& b) noexcept {
    return add_entry_row(a) && add_entry_row(b) && a.is_long == b.is_long
        && a.placement_script_open_ms == b.placement_script_open_ms;
}
 
}  // namespace
 
// The script bar every live lot of the book was placed on, when each is an
// opening MARKET entry of the book's side placed while the book was flat on
// that one bar, and there are at least `min_lots` of them: a book only one
// bar's flat market entries opened (lane W5B-ENG-MARGIN-RESIDUAL;
// validate_precommit, on_applied and on_bar_open).
std::optional<std::int64_t> PineExecutionAdapter::flat_sibling_placement(
        std::size_t min_lots) const {
    const auto position = detail::run_position(require_host());
    if (position.signed_units == 0.0 || position.lot_count < min_lots) return std::nullopt;
    std::optional<std::int64_t> placed;
    for (const auto& cohort : cohorts_by_id_.held_rows()) {
        for (const auto& [incarnation, units] : cohort.second.live_units_by_origin) {
            if (!(units > 0.0)) continue;
            const auto found = placement_.find(incarnation);
            if (found == placement_.end()) return std::nullopt;
            const auto& lot = found->second;
            if (lot.family != PineOrderFamily::Entry || !lot.opening || !market_entry_row(lot)
                || lot.is_long != (position.signed_units > 0.0)
                || lot.projection_position_side
                    != static_cast<std::int32_t>(PositionSide::FLAT)
                || (placed && *placed != lot.placement_script_open_ms)) {
                return std::nullopt;
            }
            placed = lot.placement_script_open_ms;
        }
    }
    return placed;
}
 
// Whether `source`, a MARKET entry placed while the book was flat, meets at
// the point `interval_index`/`phase` a book of its own side that only its own
// bar's earlier flat market entries opened, there.
bool PineExecutionAdapter::flat_sibling_book(const PlacementSnapshot& source,
                                             std::int32_t interval_index,
                                             NativePathPhase phase) const {
    if (source.family != PineOrderFamily::Entry || !source.opening || !market_entry_row(source)
        || source.projection_position_side != static_cast<std::int32_t>(PositionSide::FLAT)) {
        return false;
    }
    const auto position = detail::run_position(require_host());
    if (position.signed_units == 0.0 || (position.signed_units > 0.0) != source.is_long
        || position_open_bar_index_ != interval_index || position_open_phase_ != phase) {
        return false;
    }
    const auto placed = flat_sibling_placement(1);
    return placed && *placed == source.placement_script_open_ms;
}
 
// Whether another entry of `filled`'s bar, placed while flat on its side,
// still waits to fill at the same point `filled` just filled at: TradingView
// checks the margin of such a book once they have all filled (lane
// W5B-ENG-MARGIN-RESIDUAL, the opening checkpoint in on_applied).
bool PineExecutionAdapter::flat_sibling_fill_follows(
        const PlacementSnapshot& filled, const native_order::RequestHandle& filled_handle) const {
    if (filled.family != PineOrderFamily::Entry || !filled.opening || !market_entry_row(filled)
        || filled.projection_position_side != static_cast<std::int32_t>(PositionSide::FLAT)) {
        return false;
    }
    const auto position = detail::run_position(require_host());
    if (config_.pyramiding > 0
        && position.lot_count >= static_cast<std::size_t>(config_.pyramiding)) {
        return false;
    }
    return std::any_of(live_handles_.begin(), live_handles_.end(),
        [&](const native_order::RequestHandle& handle) {
            if (handle == filled_handle) return false;
            const auto found = placement_.find(handle.incarnation);
            if (found == placement_.end()) return false;
            const auto& row = found->second;
            return row.family == PineOrderFamily::Entry && row.opening
                && row.is_long == filled.is_long
                && row.projection_position_side
                    == static_cast<std::int32_t>(PositionSide::FLAT)
                && row.placement_script_open_ms == filled.placement_script_open_ms
                && market_entry_row(row);
        });
}
 
// Whether another add of `filled`'s bar -- a MARKET entry placed, as `filled`
// was, while the book held their side -- still waits to fill at the point
// `filled` just filled at: TradingView margins the grown book once they have
// all filled (lab tv tapes tests/fixtures/add_sibling_margin; lane TAIL-B).
bool PineExecutionAdapter::add_sibling_fill_follows(
        const PlacementSnapshot& filled, const native_order::RequestHandle& filled_handle) const {
    if (!add_entry_row(filled)) return false;
    const auto position = detail::run_position(require_host());
    if (config_.pyramiding > 0
        && position.lot_count >= static_cast<std::size_t>(config_.pyramiding)) {
        return false;
    }
    return std::any_of(live_handles_.begin(), live_handles_.end(),
        [&](const native_order::RequestHandle& handle) {
            if (handle == filled_handle) return false;
            const auto found = placement_.find(handle.incarnation);
            return found != placement_.end() && add_siblings(filled, found->second);
        });
}
 
// The book's live lots that the adds the script bar `placed` placed on the
// book's side opened.
std::size_t PineExecutionAdapter::add_sibling_lots(std::int64_t placed) const {
    const auto position = detail::run_position(require_host());
    if (position.signed_units == 0.0) return 0;
    std::size_t count = 0;
    for (const auto& cohort : cohorts_by_id_.held_rows()) {
        for (const auto& [incarnation, units] : cohort.second.live_units_by_origin) {
            if (!(units > 0.0)) continue;
            const auto found = placement_.find(incarnation);
            if (found == placement_.end()) continue;
            const auto& lot = found->second;
            if (add_entry_row(lot) && lot.is_long == (position.signed_units > 0.0)
                && lot.placement_script_open_ms == placed) {
                ++count;
            }
        }
    }
    return count;
}
 
// Whether TradingView follows a margin call of `called_units` on the book as it
// stands before that call with a call of one more unit at its next check
// point: on a whole-unit lot grid, a call of four times a floored restore of
// at least one lot (not the one unit a sub-lot restore takes) that leaves part
// of the book, when the book's oldest lot is one unit. Long or short, the
// oldest lot called whole or in part, at a market opening's fill (the next
// path point books it) or under process_orders_on_close at the next open (that
// open books it): lab tv tapes tests/fixtures/margin_residual
// w5b-sb-es-fixed-n, -pooc-fixed-n, w5b-es-short-q111111, -q1122,
// -pooc-q1122, -q115 (CME_MINI:ES1!) and w5b-f-q1x12 (NYSE:F). A book whose
// oldest lot is larger takes no follow-up (w5b-es-q21111, -pooc-q21111,
// -q222), nor a one-unit oldest lot on a finer grid (w5b-eth-q111, 1 ETH on
// 0.0001 lots); lane W5B-ENG-MARGIN-RESIDUAL.
bool PineExecutionAdapter::whole_unit_follow_up_due(double called_units, double mark) const {
    if (!staged_.quantity_grid || *staged_.quantity_grid != 1.0) return false;
    const double held = std::abs(detail::run_position(require_host()).signed_units);
    if (!(called_units >= 4.0) || !(called_units < held)) return false;
    const auto lots = require_host().native_open_lots(mark);
    return !lots.empty() && std::abs(std::abs(lots.front().signed_units) - 1.0) < 1e-9;
}
 
// The runs whose margin calls TradingView follows (margin_follow_up_units):
// slipped, with no commission or a percent one, on a whole-unit lot grid --
// or on any lot grid under a percent commission: on OANDA:EURUSD's 0.01 lots
// at slippage 2 and commission 0.05 %, a synthetic short's call of 0.20
// can leave a deficit at its fill; if that deficit is 0.30 at a 2.00002
// fill, the next-point follow-up is 4 x 0.14 = 0.56 units on that lot grid
// (the margin_open_print fixtures establish the follow-up rule).
bool PineExecutionAdapter::margin_follow_up_scope() const noexcept {
    if (!(config_.slippage > 0) || !staged_.quantity_grid
        || !(*staged_.quantity_grid > 0.0)) {
        return false;
    }
    const bool percent = config_.commission_type == static_cast<int>(CommissionType::PERCENT);
    if (config_.commission_value != 0.0 && !percent) return false;
    return *staged_.quantity_grid == 1.0 || (config_.commission_value > 0.0 && percent);
}
 
// What TradingView's follow-up to a margin call of `called_units` filled at
// `fill` takes. The book the call left is re-marked at that fill: without a
// commission the follow-up is one unit, due while that book is short by more
// than two of the slippage steps -- the called book short by more than the
// unit's margin and those steps (the follow-up rule; a close's call,
// followed so at the next open). Under a percent commission a call of any
// size is followed while the book it left, re-marked there, is short by more
// than two slippage steps for each unit called and the exit fees of those
// units and of one more, and the follow-up takes four times the shortfall's
// lot floor over the fill, or one unit where that floors to none: on NYSE:F
// at slippage 2 and commission 0.05 %, use synthetic check snapshots.
// A re-marked deficit of 30.00 at a 25.02 fill, above the fee/slip band,
// calls 4 x floor(30.00 / 25.02) = 4 whole shares at the next point.
// A sub-unit restore takes the one-unit fallback if it restores the book.
// A deficit of 0.01 below the fee/slip band takes no follow-up instead.
// These illustrate the margin_open_print fixtures without trade records;
// each snapshot supplies its own deficit. Zero where none is due.
double PineExecutionAdapter::margin_follow_up_units(
        double called_units, double fill, std::int64_t sub_bar_open_ms) const {
    const auto money = source_margin_money(fill, sub_bar_open_ms);
    if (!money.valid || !staged_.quantity_grid || !(*staged_.quantity_grid > 0.0)
        || !(called_units > internal::kQtyEpsilon)) {
        return 0.0;
    }
    const double fx = active_staged_fx(sub_bar_open_ms);
    const double step = config_.slippage * staged_.syminfo.mintick
        * staged_.syminfo.pointvalue * fx;
    const double shortfall = money.required - money.equity;
    const bool commissioned = config_.commission_value > 0.0
        && config_.commission_type == static_cast<int>(CommissionType::PERCENT);
    if (!commissioned) return shortfall > 2.0 * step ? std::min(1.0, money.held) : 0.0;
    // The book after the call has paid the called units' exit fees; the book
    // it called, re-marked at the fill, had not -- and the follow-up's own
    // unit pays one more.
    const double exit_fees = (called_units + 1.0) * fill * staged_.syminfo.pointvalue * fx
        * config_.commission_value / 100.0;
    if (!(shortfall - exit_fees > 2.0 * step * called_units)) return 0.0;
    const double grid = *staged_.quantity_grid;
    const double minimum = std::floor(
        source_money_round(shortfall) / money.unit_margin / grid) * grid;
    double units = std::floor(4.0 * minimum / grid + 1e-6) * grid;
    if (!(units > internal::kQtyEpsilon)) units = 1.0;
    units = std::min(units, money.held);
    return units > internal::kQtyEpsilon && std::isfinite(units) ? units : 0.0;
}
 
// TradingView follows a margin call on a whole-unit lot grid at the bar's
// next path point while the call did not restore the book at its own fill
// (margin_follow_up_units) -- without a commission a one-unit call only: one
// of four called at a synthetic 25.00 high, 0.10 short at its 25.01 fill, is
// not followed at the 24.94 low (the margin_opposite fixtures establish
// the one-unit restriction). That point books the follow-up where its own
// check calls nothing and its print is inside the call's fill (below it for a
// short); a print at or beyond the fill is judged by its own check alone. A
// follow-up so taken is followed alike, and the close is the last point a bar
// offers. A long's call is never followed -- its sell lowers the requirement
// with the equity -- nor is a call at zero slippage, whose fill is its mark.
// Synthetic NYSE:F snapshots at slippage 1 illustrate the three cases:
// a one-share call at 25.00 leaving a 0.10 re-marked deficit can owe one
// more at a later low of 24.97; a call at 26.00 leaving a 0.01 surplus
// owes none. A call at 27.00 followed by a 27.005 high reaches a point
// beyond that fill: its own check, rather than the owed follow-up, decides.
// If that check calls, a later low of 26.95 may follow the new call.
// These are independent synthetic checks of the follow-up rule in slipped_short.
// `called_units` is the call's size, `fill` its own fill,
// `current` the print its check point fired at.
void PineExecutionAdapter::follow_margin_call(
        double called_units, double fill, double current,
        const NativeDecisionContext& context) {
    if (!(called_units > internal::kQtyEpsilon) || !margin_follow_up_scope()) return;
    if (config_.commission_value == 0.0 && std::abs(called_units - 1.0) > 1e-9) return;
    const Bar& bar = policy_script_bar_;
    const bool high_first = source_path_uses_high_first(bar);
    const double tick = staged_.syminfo.mintick;
    const double guard = tick * 1e-6;
    auto phase = context.coordinate.path_phase;
    double at = current;
    double called = called_units;
    while (finite_positive(fill)) {
        const auto position = detail::run_position(require_host());
        if (position.signed_units == 0.0) return;
        const bool short_book = position.signed_units < 0.0;
        const double units = margin_follow_up_units(called, fill, context.sub_bar_open_ms);
        if (!(units > 0.0)) return;
        double next = next_source_path_waypoint(bar, phase, at, high_first);
        auto next_phase = NativePathPhase::None;
        if (phase == NativePathPhase::Open) {
            next_phase = high_first ? NativePathPhase::High : NativePathPhase::Low;
        } else if (std::isfinite(next)) {
            next_phase = next == bar.high ? NativePathPhase::High : NativePathPhase::Low;
        } else if (phase == NativePathPhase::High || phase == NativePathPhase::Low) {
            next = bar.close;
            next_phase = NativePathPhase::Close;
        }
        if (!finite_positive(next) || next_phase == NativePathPhase::None) return;
        const double next_mark = nearest_tick(next, tick);
        if (short_book ? next_mark >= fill - guard : next_mark <= fill + guard) return;
        if (source_margin_units(source_margin_money(next, context.sub_bar_open_ms), false) > 0.0)
            return;
        // A follow-up that falls on the close is booked there after the
        // script (close_point_margin_call).
        if (next_phase == NativePathPhase::Close && close_point_margin_scope()) {
            close_margin_follow_up_bar_ = context.script_bar_open_ms;
            close_margin_follow_up_units_ = units;
            return;
        }
        if (!submit_margin_call_units(next, context, units, true)) return;
        fill = source_margin_fill_price(next, short_book);
        called = units;
        at = next;
        phase = next_phase;
    }
}
 
// The runs whose short calls take the lagged follow-up (switch
// lagged_short_follow_up): a fractional lot grid, at a percent commission or
// none, point money on one FX rate. A whole-share book keeps its pinned
// follow-ups (whole_unit_follow_up_due, margin_follow_up_units).
bool PineExecutionAdapter::lagged_short_scope() const noexcept {
    return detail::margin_schedule_switches().lagged_short_follow_up
        && source_margin_call_enabled_ && staged_.quantity_grid
        && *staged_.quantity_grid > 0.0 && *staged_.quantity_grid < 1.0
        && staged_.account_fx_effective_from_ms.empty()
        && (config_.commission_value == 0.0
            || config_.commission_type == static_cast<int>(CommissionType::PERCENT));
}
 
// The follow-up TradingView takes after a short's call (switch
// lagged_short_follow_up). Its broker checks the book again at the call's fill
// `fill`, lot by lot, first in first out, on the state that has taken the
// called units of a lot out of the book but not yet booked their P&L or exit
// fee -- each earlier lot booked, at the fill, net of its exit fee -- and the
// last of those checks still short is called again: four times its
// lot-floored restore at the fill, at the bar's next path point and ungated.
// `taken` lists the units the call took from each lot with the lot's entry
// price, `equity_before` is the equity at the fill before the call and
// `held_before` the units held then. On OANDA:EURUSD at slippage 1 a short of
// synthetic 50000 units can remain short after a 0.40 call at 2.00001:
// the last still-short unbooked-lot check, not the final booked state,
// decides the next call. At slippage 0, synthetic lots of 0.25 and 40000
// can likewise leave the first lot's check short after that lot is removed;
// its lot-floored restore is followed at the close (lab tv tapes tests/fixtures/margin_call_rules
// short-cutoff-gate/cutoff-*, tests/fixtures/margin_schedule_rules lag/).
double PineExecutionAdapter::lagged_short_follow_up_units(
        const std::vector<std::pair<double, double>>& taken, double equity_before,
        double held_before, double fill, std::int64_t sub_bar_open_ms) const {
    if (!lagged_short_scope() || taken.empty() || !finite_positive(fill)
        || !std::isfinite(equity_before) || !finite_positive(held_before)
        || !finite_positive(config_.margin_short)) {
        return 0.0;
    }
    const double grid = *staged_.quantity_grid;
    const double fx = active_staged_fx(sub_bar_open_ms);
    const double point = staged_.syminfo.pointvalue * fx;
    const double unit_margin = fill * point * (config_.margin_short / 100.0);
    const double fee = config_.commission_value / 100.0;
    if (!finite_positive(unit_margin)) return 0.0;
    const double lot_value = grid * fill * point;
    double out = 0.0;
    double booked_fees = 0.0;
    double last_short = 0.0;
    for (const auto& [units, entry] : taken) {
        if (!(units > 0.0)) continue;
        out += units;
        const double remaining = held_before - out;
        if (!(remaining > internal::kQtyEpsilon)) break;
        const double exact = remaining * unit_margin;
        const double required = std::isfinite(lot_value) && lot_value < 1.0
            ? source_money_round(exact) : exact;
        // The called units are out of the book: their open P&L at the fill,
        // (entry - fill) a unit for a short, leaves the equity unbooked.
        const double equity = equity_before - booked_fees + (fill - entry) * units * point;
        const double deficit = required - equity;
        if (deficit > 0.0) last_short = deficit;
        booked_fees += units * fill * point * fee;
    }
    if (!(last_short > 0.0) || !std::isfinite(last_short)) return 0.0;
    const double minimum = std::floor(source_money_round(last_short) / unit_margin / grid) * grid;
    double units = std::floor(4.0 * minimum / grid + 1e-6) * grid;
    units = std::min(units, held_before - out);
    if (!(units > internal::kQtyEpsilon) || !std::isfinite(units)) return 0.0;
    return units;
}
 
// The opening-call schedule's scope (MarginOpeningSwitches): a full-margin
// position of one lot that a process_orders_on_close close fill opened, at a
// percent commission with slippage, on a lot grid of at most one, point value
// 1 on one FX rate -- the shape the tapes under
// tests/fixtures/margin_open_rules pin. The caller checks that the fill was
// the previous bar's close; a book two or more entries or adds of that bar
// opened keeps its own rules, except for the call sized at that close on a
// fractional lot grid (`several_lots`, switch lot_by_lot_open_follow_up):
// every lot the close's fills opened is in its book -- an over-fill lot a
// frozen close opened (close_follow_up_after_script) and the entry beside it,
// or several entries -- and its follow-up is checked lot by lot
// (open_print_lot_follow_up_units; lab tv tapes
// tests/fixtures/margin_open_rules lots/).
bool PineExecutionAdapter::close_sized_open_call_scope(bool short_book, bool several_lots) const {
    const double margin = short_book ? config_.margin_short : config_.margin_long;
    if (!config_.process_orders_on_close || config_.calc_on_order_fills
        || !(config_.slippage > 0) || !source_margin_call_enabled_
        || config_.commission_type != static_cast<int>(CommissionType::PERCENT)
        || !(config_.commission_value > 0.0) || std::abs(margin - 100.0) > 1e-12
        || !staged_.quantity_grid || !(*staged_.quantity_grid > 0.0)
        || *staged_.quantity_grid > 1.0 || staged_.syminfo.pointvalue != 1.0
        || staged_.account_fx != 1.0 || !staged_.account_fx_effective_from_ms.empty()
        || !finite_positive(staged_.syminfo.mintick)) {
        return false;
    }
    const auto position = detail::run_position(require_host());
    if (position.signed_units == 0.0 || (position.signed_units < 0.0) != short_book) return false;
    // Several lots on a fractional lot grid only: a whole-share book keeps its
    // one-unit follow-ups (whole_unit_follow_up_due), which no tape has decided
    // beside this schedule.
    return position.lot_count == 1
        || (several_lots && position.lot_count > 1 && *staged_.quantity_grid < 1.0
            && PF_RARE(detail::margin_opening_switches().lot_by_lot_open_follow_up));
}
 
// The call TradingView sizes at the source close c' (the tick-built close the
// position filled at, slippage aside) and executes at the next open's print
// `print`: money and unit margin at c', long or short (switch
// close_sized_long_call for a long), its one-unit band and the short gate
// priced at that print (switch close_call_gate_at_print). On OANDA:EURUSD at
// slippage 1, a synthetic deficit of 50.0005 at a 2.00000 close takes 4 x
// floor(25.00025 / 0.01) x 0.01 = 100.00; a 2.00004 open gives 99.96. A
// synthetic NYSE:F short at slippage 2 can pass the band at a 25.00 open
// print and fail it at the close's own 25.02 print (lab tv tapes
// tests/fixtures/margin_open_rules po/ and replica/).
double PineExecutionAdapter::close_sized_open_units(
        double close_mark, double print, std::int64_t sub_bar_open_ms) const {
    const auto money = source_margin_money(close_mark, sub_bar_open_ms);
    if (!money.valid) return 0.0;
    const bool at_print = detail::margin_opening_switches().close_call_gate_at_print;
    return source_margin_units(money, false, true, at_print ? print : kNaN);
}
 
// The follow-up TradingView takes after a call of `called` units filled at
// `fill` on a one-lot book: the book checked again at the fill with the
// called units out of it but their P&L and exit fee unbooked
// (`equity_before` is the equity at the fill before the call, `entry` the
// lot's entry price), four times its lot-floored restore at the fill, or one
// unit where that floors to none and the unit restores the book there -- the
// one-unit fallback, on any lot grid (lab tv tapes
// tests/fixtures/margin_open_rules po/short-follow-up-one-unit: 0.0004 and
// then 1 ETH at one print; lag/whole-share-follow-up: 1 + 1 NYSE:F shares).
double PineExecutionAdapter::open_print_follow_up_units(
        double held_before, double equity_before, double entry, double called, double fill,
        bool short_book, std::int64_t sub_bar_open_ms) const {
    if (!staged_.quantity_grid || !(*staged_.quantity_grid > 0.0) || !finite_positive(fill)
        || !finite_positive(entry) || !std::isfinite(equity_before)
        || !(called > internal::kQtyEpsilon)) {
        return 0.0;
    }
    const double remaining = held_before - called;
    if (!(remaining > internal::kQtyEpsilon)) return 0.0;
    const double grid = *staged_.quantity_grid;
    const double point = staged_.syminfo.pointvalue * active_staged_fx(sub_bar_open_ms);
    const double margin = (short_book ? config_.margin_short : config_.margin_long) / 100.0;
    const double unit_margin = fill * point * margin;
    if (!finite_positive(unit_margin)) return 0.0;
    const double exact = remaining * unit_margin;
    const double lot_value = grid * fill * point;
    const double required = std::isfinite(lot_value) && lot_value < 1.0
        ? source_money_round(exact) : exact;
    // The called units' open P&L at the fill leaves the equity unbooked.
    const double side = short_book ? -1.0 : 1.0;
    const double equity = equity_before - side * (fill - entry) * called * point;
    const double deficit = required - equity;
    if (!(deficit > 0.0) || !std::isfinite(deficit)) return 0.0;
    const double minimum = std::floor(source_money_round(deficit) / unit_margin / grid) * grid;
    double units = std::floor(4.0 * minimum / grid + 1e-6) * grid;
    if (!(units > internal::kQtyEpsilon) && exact - equity < unit_margin)
        units = std::min(1.0, remaining);
    units = std::min(units, remaining);
    return units > internal::kQtyEpsilon && std::isfinite(units) ? units : 0.0;
}
 
// open_print_follow_up_units on a book of several lots (switch
// lot_by_lot_open_follow_up): the call's units are taken first in first out,
// `taken` listing the units it took from each lot with the lot's entry price,
// and the book is checked after each lot as the lagged follow-up checks it
// (lagged_short_follow_up_units), long or short -- that lot's called units out
// of the book with their P&L and exit fee unbooked, the earlier lots' booked
// at the fill net of their exit fees, the rest re-marked there -- and the
// last check still short is called four times its lot-floored restore at the
// fill, with the one-unit fallback. Synthetic OANDA:EURUSD longs of 10
// and 40000 units can have their initial call cross a lot boundary;
// with lots of 5, 10 and 40000, it can cross two boundaries instead.
// In either case the last still-short check sizes the follow-up (lab tv tapes
// tests/fixtures/margin_open_rules lots/two-longs-one-close,
// lots/three-longs-last-short).
double PineExecutionAdapter::open_print_lot_follow_up_units(
        const std::vector<std::pair<double, double>>& taken, double equity_before,
        double held_before, double fill, bool short_book, std::int64_t sub_bar_open_ms) const {
    if (!staged_.quantity_grid || !(*staged_.quantity_grid > 0.0) || taken.empty()
        || !finite_positive(fill) || !std::isfinite(equity_before)
        || !finite_positive(held_before)) {
        return 0.0;
    }
    const double grid = *staged_.quantity_grid;
    const double point = staged_.syminfo.pointvalue * active_staged_fx(sub_bar_open_ms);
    const double margin = (short_book ? config_.margin_short : config_.margin_long) / 100.0;
    const double unit_margin = fill * point * margin;
    if (!finite_positive(unit_margin)) return 0.0;
    const double fee = config_.commission_value / 100.0;
    const double side = short_book ? -1.0 : 1.0;
    const double lot_value = grid * fill * point;
    double out = 0.0;
    double booked_fees = 0.0;
    double last_short = 0.0;
    double last_exact = 0.0;
    double last_equity = 0.0;
    double last_remaining = 0.0;
    for (const auto& [units, entry] : taken) {
        if (!(units > 0.0)) continue;
        out += units;
        const double remaining = held_before - out;
        if (!(remaining > internal::kQtyEpsilon)) break;
        const double exact = remaining * unit_margin;
        const double required = std::isfinite(lot_value) && lot_value < 1.0
            ? source_money_round(exact) : exact;
        const double equity = equity_before - booked_fees - side * (fill - entry) * units * point;
        const double deficit = required - equity;
        if (deficit > 0.0) {
            last_short = deficit;
            last_exact = exact;
            last_equity = equity;
            last_remaining = remaining;
        }
        booked_fees += units * fill * point * fee;
    }
    if (!(last_short > 0.0) || !std::isfinite(last_short)) return 0.0;
    const double minimum = std::floor(source_money_round(last_short) / unit_margin / grid) * grid;
    double units = std::floor(4.0 * minimum / grid + 1e-6) * grid;
    if (!(units > internal::kQtyEpsilon) && last_exact - last_equity < unit_margin)
        units = std::min(1.0, last_remaining);
    units = std::min(units, held_before - out);
    return units > internal::kQtyEpsilon && std::isfinite(units) ? units : 0.0;
}
 
// The calls the open takes after a call sized at the source close
// (close_sized_open_units): that call at the open's print, then the book it
// booked checked at the open's own mark -- unit margin at the open, its
// one-unit band and the short gate priced at the same print (switch
// booked_open_recheck; short there with nothing booked, the sequence ends)
// -- and then the follow-up of the last call at that print
// (open_print_follow_up_units, switch open_print_follow_up), except that a
// short's re-check that booked owes it to the bar's first extreme (switch
// short_point_drops_owed). On
// a synthetic OANDA:EURUSD short at slippage 1 can give up 0.20 at an open
// three ticks above the close, then 0.12 on a still-short booked book;
// a larger weekend gap can enlarge both calls (lab tv tapes
// tests/fixtures/margin_open_rules po/short-booked-recheck,
// po/short-weekend-gap). TradingView does not repeat these calls at one
// price: on_applied's recheck_at_fill stands down while they book.
bool PineExecutionAdapter::run_close_sized_open_calls(
        double units, double opening_mark, const NativeDecisionContext& context) {
    const auto position = detail::run_position(require_host());
    if (position.signed_units == 0.0 || !(units > 0.0)) return false;
    const bool short_book = position.signed_units < 0.0;
    const double print = source_margin_fill_price(opening_mark, short_book);
    const auto& rules = detail::margin_opening_switches();
    // A book of several lots keeps each lot's units and entry price, first in
    // first out, for the follow-up's lot-by-lot check (switch
    // lot_by_lot_open_follow_up).
    struct Before {
        double held = 0.0, equity = kNaN, entry = kNaN;
        std::vector<std::pair<double, double>> lots;
    };
    const auto before_call = [&]() {
        Before b;
        b.held = std::abs(detail::run_position(require_host()).signed_units);
        b.equity = source_margin_money(print, context.sub_bar_open_ms).equity;
        const auto lots = require_host().native_open_lots(print);
        if (lots.size() == 1) {
            b.entry = lots.front().entry_price;
        } else if (PF_RARE(rules.lot_by_lot_open_follow_up)) {
            for (const auto& lot : lots)
                b.lots.emplace_back(std::abs(lot.signed_units), lot.entry_price);
        }
        return b;
    };
    const auto called_since = [&](const Before& b) {
        return b.held - std::abs(detail::run_position(require_host()).signed_units);
    };
    open_call_sequence_ = true;
    Before last = before_call();
    if (!submit_margin_call_units(opening_mark, context, units)) {
        open_call_sequence_ = false;
        return false;
    }
    double last_called = called_since(last);
    bool rechecked = false;  // the booked re-check booked units
    if (rules.booked_open_recheck && detail::run_position(require_host()).signed_units != 0.0) {
        // The open's check of the booked book is a check like any other: its
        // call passes the short gate at the print (short_call_vetoed), and
        // where it finds the book short but books nothing the open is a point
        // short itself, so the follow-up the call before it owes is dropped
        // as at a path point (execute_owed_short_follow_up). On OANDA:EURUSD
        // at slippage 1, consider an independent synthetic re-check snapshot:
        // 50000 units 0.12 short at a 2.00003 mark would call 0.20.
        // At the 2.00004 fill those units cover about 0.40, below the
        // book's 0.62 deficit, so the short gate vetoes the re-check.
        // Neither that call nor the preceding call's owed follow-up books;
        // the next high is decided by its own check.
        const auto booked = source_margin_money(opening_mark, context.sub_bar_open_ms);
        const double again = source_margin_units(booked, false, true, print);
        if (again > 0.0) {
            const Before before = before_call();
            if (submit_margin_call_units(opening_mark, context, again)) {
                last = before;
                last_called = called_since(before);
                rechecked = true;
            }
        } else if (booked.valid && booked.required > booked.equity) {
            open_call_sequence_ = false;
            return true;
        }
    }
    // A booked re-check on a book of several lots is followed by nothing: the
    // lot-by-lot follow-up is pinned only where the re-check books nothing (lab
    // tv tape lots/two-shorts-one-close), and no tape has decided the one a
    // short's booked re-check owes to the first extreme there.
    if (PF_RARE(rechecked && !last.lots.empty())) {
        open_call_sequence_ = false;
        return true;
    }
    if (rules.open_print_follow_up && detail::run_position(require_host()).signed_units != 0.0) {
        double more = 0.0;
        if (last.lots.empty()) {
            more = open_print_follow_up_units(
                last.held, last.equity, last.entry, last_called, print, short_book,
                context.sub_bar_open_ms);
        } else {
            std::vector<std::pair<double, double>> taken;
            double left = last_called;
            for (const auto& [size, entry] : last.lots) {
                if (!(left > internal::kQtyEpsilon)) break;
                const double take = std::min(left, size);
                taken.emplace_back(take, entry);
                left -= take;
            }
            more = open_print_lot_follow_up_units(taken, last.equity, last.held, print,
                                                  short_book, context.sub_bar_open_ms);
        }
        if (more > 0.0) {
            // A re-check that booked owes its follow-up to the bar's first
            // extreme, where a point short itself drops it (rule 7), as the
            // open's own call does (open_call_owing_follow_up). On
            // synthetic OANDA:EURUSD at slippage 1: a re-check of 0.20 at a 2.00001
            // print can owe 0.12 to the low, booked at 1.99981; where
            // the first extreme is a high short itself, TradingView drops the
            // owed 0.24 and books the high's own 40.00 instead (lab tv tapes
            // tests/fixtures/margin_open_rules po/short-recheck-owes-low,
            // po/short-recheck-owed-dropped-high).
            if (rechecked && short_book && PF_RARE(rules.short_point_drops_owed)
                && short_path_points_scope(context)) {
                owed_follow_up_bar_ = context.script_bar_open_ms;
                owed_follow_up_point_ = 1;
                owed_follow_up_units_ = more;
            } else {
                (void)submit_margin_call_units(opening_mark, context, more);
            }
        }
    }
    open_call_sequence_ = false;
    return true;
}
 
// A short's call of `units` at `mark` taken by the adapter itself, executed at
// the mark's print with the exit side's slippage; with the lagged follow-up in
// scope, the follow-up it owes the bar's next path point (zero for none). The
// book and the money at the fill are read before the call books. On a
// whole-share book the follow-up is whole_share_lag_units' (switch
// whole_share_lagged_short for a point's own call, chained_follow_up for an
// owed follow-up booked there, `owed`).
double PineExecutionAdapter::call_short_with_lagged_follow_up(
        double mark, double units, const NativeDecisionContext& context, bool owed) {
    const auto before = detail::run_position(require_host());
    if (!(before.signed_units < 0.0)) {
        (void)submit_margin_call_units(mark, context, units, true);
        return 0.0;
    }
    const double fill = source_margin_fill_price(mark, true);
    const auto& opening = detail::margin_opening_switches();
    const bool whole = PF_RARE(whole_share_lag_scope())
        && (owed ? opening.chained_follow_up : opening.whole_share_lagged_short);
    const bool lagged = (whole || lagged_short_scope()) && finite_positive(fill);
    const auto money = lagged ? source_margin_money(fill, context.sub_bar_open_ms)
                              : SourceMarginMoney{};
    const auto lots = lagged ? require_host().native_open_lots(fill) : std::vector<NativeOpenLot>{};
    if (!submit_margin_call_units(mark, context, units, true)) return 0.0;
    if (!lagged || !money.valid) return 0.0;
    const double held_before = std::abs(before.signed_units);
    const double called = held_before - std::abs(detail::run_position(require_host()).signed_units);
    std::vector<std::pair<double, double>> taken;
    double left = called;
    for (const auto& lot : lots) {
        if (!(left > internal::kQtyEpsilon)) break;
        const double size = std::abs(lot.signed_units);
        const double take = std::min(left, size);
        taken.emplace_back(take, lot.entry_price);
        left -= take;
    }
    return whole ? whole_share_lag_units(taken, money.equity, held_before, fill,
                                         context.sub_bar_open_ms)
                 : lagged_short_follow_up_units(taken, money.equity, held_before, fill,
                                                context.sub_bar_open_ms);
}
 
// The whole-share books whose short calls take the lagged follow-up
// (switch whole_share_lagged_short, with lagged_short_follow_up): a lot grid
// of one share, at a percent commission or none, point money on one FX rate.
bool PineExecutionAdapter::whole_share_lag_scope() const noexcept {
    return detail::margin_schedule_switches().lagged_short_follow_up
        && source_margin_call_enabled_ && staged_.quantity_grid
        && *staged_.quantity_grid == 1.0 && staged_.account_fx_effective_from_ms.empty()
        && (config_.commission_value == 0.0
            || config_.commission_type == static_cast<int>(CommissionType::PERCENT));
}
 
// lagged_short_follow_up_units on a whole-share book, with the one-unit
// fallback: where the last still-short check's restore floors to no lot, one
// share is called if it restores that book at the fill. Synthetic NYSE:F:
// at full margin, 200 shares at 25.00 require 5000.00; an unbooked prior unit
// leaves 199 at 4975.00. With adjusted equity 4965.00, the 10.00 shortfall
// floors to zero whole units and calls one more; an eagerly booked
// close would use another money basis (lab tv tapes
// tests/fixtures/margin_open_rules lag/whole-share-chain,
// replica/f-path-follow-up-0209).
double PineExecutionAdapter::whole_share_lag_units(
        const std::vector<std::pair<double, double>>& taken, double equity_before,
        double held_before, double fill, std::int64_t sub_bar_open_ms) const {
    if (taken.empty() || !finite_positive(fill) || !std::isfinite(equity_before)
        || !finite_positive(held_before) || !finite_positive(config_.margin_short)) {
        return 0.0;
    }
    const double point = staged_.syminfo.pointvalue * active_staged_fx(sub_bar_open_ms);
    const double unit_margin = fill * point * (config_.margin_short / 100.0);
    const double fee = config_.commission_value / 100.0;
    if (!finite_positive(unit_margin)) return 0.0;
    const double lot_value = fill * point;
    double out = 0.0;
    double booked_fees = 0.0;
    double last_short = 0.0;
    double last_remaining = 0.0;
    double last_equity = 0.0;
    for (const auto& [units, entry] : taken) {
        if (!(units > 0.0)) continue;
        out += units;
        const double remaining = held_before - out;
        if (!(remaining > internal::kQtyEpsilon)) break;
        const double exact = remaining * unit_margin;
        const double required = std::isfinite(lot_value) && lot_value < 1.0
            ? source_money_round(exact) : exact;
        const double equity = equity_before - booked_fees + (fill - entry) * units * point;
        const double deficit = required - equity;
        if (deficit > 0.0) {
            last_short = deficit;
            last_remaining = remaining;
            last_equity = equity;
        }
        booked_fees += units * fill * point * fee;
    }
    if (!(last_short > 0.0) || !std::isfinite(last_short)) return 0.0;
    const double minimum = std::floor(source_money_round(last_short) / unit_margin);
    double units = std::floor(4.0 * minimum + 1e-6);
    if (!(units > internal::kQtyEpsilon) && last_remaining * unit_margin - last_equity < unit_margin)
        units = 1.0;
    units = std::min(units, held_before - out);
    if (!(units > internal::kQtyEpsilon) || !std::isfinite(units)) return 0.0;
    return units;
}
 
// The open's own check of a carried process_orders_on_close short in the
// path walk's scope (short_path_points_scope) and the opening-call scope
// (close_sized_open_call_scope): its call at the open's print,
// whose lagged follow-up is owed to the bar's first extreme rather than
// repeated at that print (switch short_point_drops_owed, with the follow-up's
// own scope); there it is dropped if that point's own check finds the book
// short (execute_owed_short_follow_up). Synthetic OANDA:EURUSD at slippage 1:
// a short called 0.20 at a 2.00001 open print can owe 0.12 to the high.
// If that high is short itself, its own check sizes its call,
// instead of booking 0.12 at the open and then checking the high (lab tv tapes
// tests/fixtures/margin_open_rules lag/owed-dropped-fractional,
// lag/whole-share-follow-up: on a bar opening at its low one share owed
// there books at the open's print).
bool PineExecutionAdapter::open_call_owing_follow_up(
        double opening_mark, const NativeDecisionContext& context) {
    const auto before = detail::run_position(require_host());
    const auto& opening = detail::margin_opening_switches();
    const bool whole = whole_share_lag_scope() && opening.whole_share_lagged_short;
    if (!PF_RARE(opening.short_point_drops_owed) || !(before.signed_units < 0.0)
        || !(whole || lagged_short_scope()) || !short_path_points_scope(context)
        || !close_sized_open_call_scope(true)) {
        return submit_margin_call_slice(opening_mark, context);
    }
    const double fill = source_margin_fill_price(opening_mark, true);
    const auto money = source_margin_money(fill, context.sub_bar_open_ms);
    const auto lots = require_host().native_open_lots(fill);
    open_call_sequence_ = true;
    const bool called = submit_margin_call_slice(opening_mark, context);
    open_call_sequence_ = false;
    if (!called || !money.valid || !finite_positive(fill)) return called;
    const double held_before = std::abs(before.signed_units);
    const double taken_units = held_before - std::abs(detail::run_position(require_host()).signed_units);
    if (!(std::abs(detail::run_position(require_host()).signed_units) > internal::kQtyEpsilon))
        return called;
    std::vector<std::pair<double, double>> taken;
    double left = taken_units;
    for (const auto& lot : lots) {
        if (!(left > internal::kQtyEpsilon)) break;
        const double take = std::min(left, std::abs(lot.signed_units));
        taken.emplace_back(take, lot.entry_price);
        left -= take;
    }
    const double more = whole
        ? whole_share_lag_units(taken, money.equity, held_before, fill, context.sub_bar_open_ms)
        : lagged_short_follow_up_units(taken, money.equity, held_before, fill,
                                       context.sub_bar_open_ms);
    if (more > 0.0) {
        owed_follow_up_bar_ = context.script_bar_open_ms;
        owed_follow_up_point_ = 1;
        owed_follow_up_units_ = more;
    }
    return called;
}
 
// A carried process_orders_on_close short checked over its bar's path before
// the script (on_bar_close_before_script): a commissioned or slipped one with
// nothing resting beside it, which schedule_margin_call_path leaves to the
// adapter (switch short_path_points).
bool PineExecutionAdapter::short_path_points_scope(const NativeDecisionContext& context) const {
    if (!detail::margin_schedule_switches().short_path_points || !config_.process_orders_on_close
        || config_.calc_on_order_fills || !source_margin_call_enabled_
        || (config_.commission_value == 0.0 && config_.slippage == 0)
        || !staged_.account_fx_effective_from_ms.empty()) {
        return false;
    }
    if (!(detail::run_position(require_host()).signed_units < 0.0)
        || position_open_script_bar_ == std::numeric_limits<std::int64_t>::min()
        || position_open_script_bar_ == context.script_bar_open_ms
        || !pending_bracket_legs_.empty() || !pending_coof_requests_.empty()
        || !delayed_market_orders_.empty() || !pending_entries_.empty()) {
        return false;
    }
    // A void call's request rests for no one (void_issue).
    return !std::any_of(live_handles_.begin(), live_handles_.end(), [&](const auto& handle) {
        const auto found = placement_.find(handle.incarnation);
        return found == placement_.end()
            || (found->second.family != PineOrderFamily::Margin && !found->second.void_issue);
    });
}
 
// The follow-up owed at `point` of this script bar (a close owes 4: the next
// bar's open), booked at `price`'s print with the exit side's slippage ahead
// of the point's own check.
void PineExecutionAdapter::execute_owed_short_follow_up(
        int point, double price, const NativeDecisionContext& context) {
    if (owed_follow_up_bar_ == std::numeric_limits<std::int64_t>::min()) return;
    const bool due = owed_follow_up_bar_ == context.script_bar_open_ms
        && owed_follow_up_point_ == point;
    if (!due) {
        // A follow-up whose point has passed is dead.
        if (owed_follow_up_bar_ != context.script_bar_open_ms || owed_follow_up_point_ < point) {
            owed_follow_up_bar_ = std::numeric_limits<std::int64_t>::min();
            owed_follow_up_point_ = -1;
            owed_follow_up_units_ = 0.0;
        }
        return;
    }
    const double units = owed_follow_up_units_;
    owed_follow_up_bar_ = std::numeric_limits<std::int64_t>::min();
    owed_follow_up_point_ = -1;
    owed_follow_up_units_ = 0.0;
    const auto position = detail::run_position(require_host());
    if (!(position.signed_units < 0.0) || !(units > 0.0) || !finite_positive(price)) return;
    const double mark = nearest_tick(price, staged_.syminfo.mintick);
    // The point's own check comes first: where it finds the book short --
    // whether its call books or is vetoed -- the owed follow-up is dropped
    // (switch short_point_drops_owed; lab tv tapes
    // tests/fixtures/margin_open_rules lag/: a synthetic NYSE:F high 12.00 short
    // with its unit vetoed books nothing owed; an OANDA:EURUSD high can call 40.00).
    if (PF_RARE(detail::margin_opening_switches().short_point_drops_owed)) {
        const auto here = source_margin_money(price, context.sub_bar_open_ms);
        if (here.valid && here.required > here.equity) return;
    }
    const double more = call_short_with_lagged_follow_up(
        mark, std::min(units, std::abs(position.signed_units)), context, true);
    if (more > 0.0 && point < 3) {
        owed_follow_up_bar_ = context.script_bar_open_ms;
        owed_follow_up_point_ = point + 1;
        owed_follow_up_units_ = more;
    }
}
 
// The follow-up owed to the close of a carried process_orders_on_close short
// (switch close_follow_up_after_script): the close's own check still comes
// first, and where it finds the book short the follow-up is dropped (switch
// short_point_drops_owed); otherwise it waits for the script and is booked
// after it (book_owed_close_follow_up).
void PineExecutionAdapter::hold_owed_close_follow_up(
        double close, const NativeDecisionContext& context) {
    if (owed_follow_up_bar_ == std::numeric_limits<std::int64_t>::min()) return;
    const auto drop = [&]() {
        owed_follow_up_bar_ = std::numeric_limits<std::int64_t>::min();
        owed_follow_up_point_ = -1;
        owed_follow_up_units_ = 0.0;
    };
    if (owed_follow_up_bar_ != context.script_bar_open_ms || owed_follow_up_point_ != 3) {
        // A follow-up whose point has passed is dead.
        if (owed_follow_up_bar_ != context.script_bar_open_ms || owed_follow_up_point_ < 3) drop();
        return;
    }
    if (!(detail::run_position(require_host()).signed_units < 0.0)
        || !(owed_follow_up_units_ > 0.0) || !finite_positive(close)) {
        drop();
        return;
    }
    if (PF_RARE(detail::margin_opening_switches().short_point_drops_owed)) {
        const auto here = source_margin_money(close, context.sub_bar_open_ms);
        if (here.valid && here.required > here.equity) drop();
    }
}
 
// A carried process_orders_on_close short's follow-up owed to this close
// (hold_owed_close_follow_up), booked after the script at the close's print,
// ahead of the fills of the orders the script placed there (switch
// close_follow_up_after_script). The script read the book before it, and its
// orders keep the sizes they were placed with: a strategy.close(id) or
// close_all() buys the units the script saw and opens the excess long as its
// own lot (flush_pending_closes, size_close_alls_at_placement), a
// reversal entry's excess joins the entry's own lot
// (apply_frozen_reversal_close). A synthetic OANDA:EURUSD short of
// 40000 owing 0.20 at a 2.00000 close books them at 2.00001 after
// the script's strategy.close("S"), which then buys 40000: it closes
// 39999.80 and opens 0.20 long, its entry the close order, ahead of the entry
// "L" (lab tv tapes tests/fixtures/margin_open_rules lots/).
void PineExecutionAdapter::book_owed_close_follow_up(
        const Bar& bar, const NativeDecisionContext& context) {
    if (owed_follow_up_bar_ != context.script_bar_open_ms || owed_follow_up_point_ != 3) return;
    const double owed_units = owed_follow_up_units_;
    owed_follow_up_bar_ = std::numeric_limits<std::int64_t>::min();
    owed_follow_up_point_ = -1;
    owed_follow_up_units_ = 0.0;
    const auto held = detail::run_position(require_host());
    if (!(held.signed_units < 0.0) || !(owed_units > 0.0) || !source_margin_call_enabled_
        || !finite_positive(bar.close)) {
        return;
    }
    // A close_all placed after the follow-up came due holds its size already.
    auto closes = same_bar_close_alls(context);
    closes.erase(std::remove_if(closes.begin(), closes.end(), [](const auto& close) {
        return close.second.crosses_zero;
    }), closes.end());
    const double units = std::min(owed_units, std::abs(held.signed_units));
    if (!submit_margin_call_units(nearest_tick(bar.close, staged_.syminfo.mintick), context,
                                  units, true)) {
        return;
    }
    const double left = std::abs(detail::run_position(require_host()).signed_units);
    record_close_call_after_script(std::abs(held.signed_units),
                                   std::abs(held.signed_units) - left, context);
    size_close_alls_at_placement(closes, held.signed_units);
}
 
// TradingView checks a carried process_orders_on_close short at every point
// of its bar's path before the script runs at the close -- the open
// (on_bar_open), the nearer extreme, the farther one, the close -- each on the
// book the earlier points left, a follow-up owed at a point booked there
// first (switches short_path_points, lagged_short_follow_up; lab tv tapes
// tests/fixtures/margin_call_rules short-cutoff-gate and
// tests/fixtures/margin_schedule_rules: on a high-first bar a call at the high
// is followed at the low's print), except one owed to the close, which is
// booked after the script there (hold_owed_close_follow_up). A follow-up the
// close owes is booked at the next bar's open.
void PineExecutionAdapter::walk_short_path_points(
        const Bar& bar, const NativeDecisionContext& context) {
    const bool high_first = source_path_uses_high_first(bar);
    const double path[] = {high_first ? bar.high : bar.low, high_first ? bar.low : bar.high,
                           bar.close};
    for (int index = 0; index < 3; ++index) {
        const int point = index + 1;
        const double price = path[index];
        if (!finite_positive(price)) continue;
        if (point == 3 && PF_RARE(detail::margin_schedule_switches().close_follow_up_after_script))
            hold_owed_close_follow_up(price, context);
        else
            execute_owed_short_follow_up(point, price, context);
        const auto position = detail::run_position(require_host());
        if (!(position.signed_units < 0.0)) return;
        const auto money = source_margin_money(price, context.sub_bar_open_ms);
        if (!money.valid || source_margin_rounded_tie_veto()) continue;
        const double units = std::min(source_margin_units(money, false),
                                      std::abs(position.signed_units));
        if (!(units > 0.0)) continue;
        const double more = call_short_with_lagged_follow_up(money.mark, units, context);
        if (more > 0.0) {
            owed_follow_up_bar_ = context.script_bar_open_ms;
            owed_follow_up_point_ = point + 1;
            owed_follow_up_units_ = more;
        }
    }
}
 
// A short's call the kernel or a rested path point booked at a path extreme
// outside process_orders_on_close (switch lagged_short_follow_up): the
// follow-up it owes the bar's next path point -- the other extreme, rested
// there, or the close, booked there after the script ahead of the close's own
// check (close_point_margin_call). The book before the call is the one after
// it with the called units back: the event's closed trades, first in first
// out, and their exit fees (synthetic OANDA:EURUSD 15m, margin 1 %: a short of
// several lots can owe a follow-up at the close after a high-point call;
// its size comes from the last still-short unbooked-lot check).
void PineExecutionAdapter::schedule_lagged_short_follow_up(
        const native_order::ExecutionAppliedEvent& event, const NativeDecisionContext& context) {
    const auto phase = context.coordinate.path_phase;
    if (phase != NativePathPhase::High && phase != NativePathPhase::Low) return;
    // A slipped run under a percent commission keeps the follow-up its
    // pinned rule takes (follow_margin_call, margin_follow_up_units: lab tv
    // tape tests/fixtures/margin_open_print taili-mop-eur).
    if (config_.process_orders_on_close || !close_point_margin_scope() || !lagged_short_scope()
        || margin_follow_up_scope()
        || !policy_script_bar_valid_ || policy_script_bar_.timestamp != context.script_bar_open_ms
        || event.closed_trade_count == 0 || !finite_positive(event.resolved_price)) {
        return;
    }
    const auto position = detail::run_position(require_host());
    if (!(position.signed_units < 0.0)) return;
    const auto& host = require_host();
    const double fill = event.resolved_price;
    const double fx = active_staged_fx(context.sub_bar_open_ms);
    const double point = staged_.syminfo.pointvalue * fx;
    const double fee = config_.commission_value / 100.0;
    std::vector<std::pair<double, double>> taken;
    double called = 0.0;
    double fees = 0.0;
    for (std::size_t i = 0; i < event.closed_trade_count; ++i) {
        const auto index = event.first_trade_index + i;
        if (index >= static_cast<std::size_t>(host.trade_count())) return;
        const Trade& trade = host.get_trade(static_cast<int>(index));
        if (trade.is_long) return;
        taken.emplace_back(trade.qty, trade.entry_price);
        called += trade.qty;
        fees += trade.qty * fill * point * fee;
    }
    const auto after = source_margin_money(fill, context.sub_bar_open_ms);
    if (!after.valid) return;
    const double more = lagged_short_follow_up_units(
        taken, after.equity + fees, std::abs(position.signed_units) + called, fill,
        context.sub_bar_open_ms);
    if (!(more > 0.0)) return;
    const Bar& bar = policy_script_bar_;
    const bool high_first = source_path_uses_high_first(bar);
    const bool first_extreme = high_first ? phase == NativePathPhase::High
                                          : phase == NativePathPhase::Low;
    if (!first_extreme) {
        owed_follow_up_bar_ = context.script_bar_open_ms;
        owed_follow_up_point_ = 3;
        owed_follow_up_units_ = more;
        return;
    }
    // The other extreme: rested at its print, reached from this one.
    const double next = high_first ? bar.low : bar.high;
    const double from = high_first ? bar.high : bar.low;
    if (!finite_positive(next) || !finite_positive(from)) return;
    native_order::Request request;
    request.intent = native_order::Reduce{native_order::ExplicitUnits{
        std::min(more, std::abs(position.signed_units))}};
    request.label = kMarginCallLabel;
    request.comment = "Margin call";
    request.trigger = next < from ? native_order::Trigger{native_order::Limit{next, true}}
                                  : native_order::Trigger{native_order::Stop{next}};
    PlacementSnapshot snapshot;
    snapshot.family = PineOrderFamily::Margin;
    snapshot.source_id = request.label;
    snapshot.requested_qty = more;
    snapshot.is_long = true;
    snapshot.forced_execution_price = source_margin_fill_price(next, true);
    snapshot.waypoint_margin_call = true;
    snapshot.sizing = sizing_snapshot();
    (void)submit_or_replace(std::move(request), std::move(snapshot), false,
                            "__margin_follow_up__");
}
 
// A deficit the open's check found and vetoed -- the one-unit band's veto or
// the gate (short_call_vetoed) -- stays pending, and while it is pending
// TradingView checks margin at the first path point whose segment touches a
// resting exit, before that exit (switch pending_veto_first). A call there
// re-issues the exit for the reduced book, which, marketable there, fills at
// that point's print with the exit's slippage. Synthetic NYSE:F at slippage 1:
// 400 shares 24.00 short at a 25.00 open, its unit vetoed there, with a
// buy stop at 25.06015 resting, fall to 24.95, then call 16 at the
// 25.10 high's 25.11 print and fill the stop's 384 there, where the stop
// alone fills 400 at 25.08 (the margin_schedule_rules fixtures
// establish the pending-veto ordering). With nothing pending
// a touched level fills at its level first. Called only where the open's own
// check ran on this book and called nothing.
bool PineExecutionAdapter::pending_veto_point_first(
        const Bar& bar, const NativeDecisionContext& context, double opening_mark) {
    if (!detail::margin_schedule_switches().pending_veto_first || config_.process_orders_on_close
        || !close_point_margin_scope() || !(config_.slippage > 0) || !source_margin_call_enabled_
        || !finite_positive(staged_.syminfo.mintick) || !finite_positive(bar.open)) {
        return false;
    }
    const auto position = detail::run_position(require_host());
    if (!(position.signed_units < 0.0)) return false;
    const double held = std::abs(position.signed_units);
    const auto at_open = source_margin_money(opening_mark, context.sub_bar_open_ms);
    if (!at_open.valid || !(at_open.required > at_open.equity)
        || source_margin_units(at_open, false) > 0.0) {
        return false;
    }
    const double tick = staged_.syminfo.mintick;
    const bool high_first = source_path_uses_high_first(bar);
    // The open and the two extremes in path order, on the tick ladder.
    const double points[] = {nearest_tick(bar.open, tick),
                             nearest_tick(high_first ? bar.high : bar.low, tick),
                             nearest_tick(high_first ? bar.low : bar.high, tick)};
    if (!finite_positive(points[1]) || !finite_positive(points[2])) return false;
    // The whole protective exit of the short a segment of the path touches
    // first: a buy stop on the way up, a buy limit on the way down.
    std::optional<std::pair<native_order::RequestHandle, PlacementSnapshot>> touched;
    int touched_point = 3;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& row = found->second;
        if ((row.family != PineOrderFamily::ExitStop && row.family != PineOrderFamily::ExitLimit)
            || row.legs.dormant() || row.void_issue
            || row.projection_created_bar >= projection_bar_index(context)
            || finite_positive(row.exit_levels.trail_offset)
            || finite_positive(row.exit_levels.trail_points)
            || finite_positive(row.exit_levels.trail_price)
            || (std::isfinite(row.requested_qty) && std::abs(row.requested_qty) < held - 1e-9)
            || (std::isfinite(row.qty_percent) && row.qty_percent < 100.0 - 1e-9)) {
            continue;
        }
        const double owned = row.from_entry.empty() ? held
                                                    : from_entry_units(row.from_entry).value_or(0.0);
        if (!(owned >= held - 1e-9)) continue;
        const bool stop = row.family == PineOrderFamily::ExitStop;
        const double level = stop ? row.exit_levels.stop : row.exit_levels.limit;
        if (!finite_positive(level)) continue;
        // Not already through at the open (the open fills it first).
        if (stop ? points[0] >= level : points[0] <= level) continue;
        int point = 3;
        for (int segment = 1; segment < 3 && point == 3; ++segment) {
            if (stop ? points[segment - 1] < level && points[segment] >= level
                     : points[segment - 1] > level && points[segment] <= level) {
                point = segment;
            }
        }
        if (point == 3) continue;
        if (point < touched_point) {
            touched.emplace(handle, row);
            touched_point = point;
        } else if (point == touched_point) {
            return false;
        }
    }
    if (!touched) return false;
    // The shape the tapes pin: the touched exit (and the other leg of its
    // strategy.exit) is the only order the book holds, so nothing the path
    // reaches earlier can change the book that point's check sees.
    if (!pending_bracket_legs_.empty() || !pending_coof_requests_.empty()
        || !delayed_market_orders_.empty() || !pending_entries_.empty()
        || !pending_same_bar_commands_.empty()) {
        return false;
    }
    const auto& exit_row = touched->second;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) return false;
        const auto& row = found->second;
        const bool same_exit = (row.family == PineOrderFamily::ExitStop
                                || row.family == PineOrderFamily::ExitLimit)
            && row.source_id == exit_row.source_id && row.from_entry == exit_row.from_entry;
        if (!same_exit && row.family != PineOrderFamily::Margin) return false;
    }
    // A point before it that calls ends the veto there: the earlier rules.
    if (touched_point == 2) {
        const auto before = source_margin_money(points[1], context.sub_bar_open_ms);
        if (before.valid && source_margin_units(before, false) > 0.0) return false;
    }
    const double first = points[touched_point];
    const auto money = source_margin_money(first, context.sub_bar_open_ms);
    if (!money.valid || source_margin_rounded_tie_veto()) return false;
    const double units = std::min(source_margin_units(money, false), held);
    if (!(units > 0.0)) return false;
    if (!submit_margin_call_units(money.mark, context, units, true)) return false;
    const auto left = detail::run_position(require_host());
    if (!(left.signed_units < 0.0)) return true;
    const auto& [handle, row] = *touched;
    if (std::find(live_handles_.begin(), live_handles_.end(), handle) == live_handles_.end())
        return true;
    cancel_bracket_siblings(handle);
    native_order::Request request;
    request.intent = native_order::Flatten{};
    request.label = row.source_id;
    request.comment = row.comment;
    request.trigger = native_order::Market{};
    PlacementSnapshot immediate = row;
    const bool stop_close = row.family == PineOrderFamily::ExitStop;
    immediate.forced_execution_price = nearest_tick(
        nearest_tick(first, tick) + (stop_close ? config_.slippage * tick : 0.0), tick);
    immediate.projection_predecessor = handle.incarnation;
    immediate.projection_predecessor_exit = true;
    const auto accepted = submit_or_replace(
        std::move(request), std::move(immediate), false,
        row.source_id + "\x1f" + row.from_entry + std::to_string(static_cast<int>(row.family)));
    if (accepted) execute_or_withdraw_close(*accepted, row.void_issue);
    return true;
}
 
// A margin call booked at a close after the script: the book the script saw
// there and the units called (switch frozen_reversal_close).
void PineExecutionAdapter::record_close_call_after_script(
        double book_before, double called, const NativeDecisionContext& context) {
    if (!detail::margin_schedule_switches().frozen_reversal_close || !(called > 0.0)) return;
    // Kept only while a reversal the script placed at this close waits: the
    // one order that reads it.
    const auto position = detail::run_position(require_host());
    const bool reversal_waits = position.signed_units != 0.0
        && any_live_row(live_handles_, placement_, [&](const PlacementSnapshot& row) {
               return row.family == PineOrderFamily::Entry && row.opening
                   && row.placement_script_open_ms == context.script_bar_open_ms
                   && row.is_long != (position.signed_units > 0.0);
           });
    if (!reversal_waits) return;
    if (close_call_after_script_bar_ != context.script_bar_open_ms) {
        close_call_after_script_bar_ = context.script_bar_open_ms;
        close_call_after_script_book_ = book_before;
        close_call_after_script_units_ = 0.0;
    }
    close_call_after_script_units_ += called;
}
 
bool PineExecutionAdapter::schedule_priced_opening_margin(
        const Bar& bar, const NativeDecisionContext& context, double fill) {
    const auto position = detail::run_position(require_host());
    if (position.signed_units == 0.0 || !source_margin_call_enabled_) return false;
    const bool buy = position.signed_units < 0.0;
    const double mark = next_source_path_waypoint(
        bar, context.coordinate.path_phase, fill, source_path_uses_high_first(bar));
    if (!finite_positive(mark)) return false;
    const double units = source_margin_units(
        source_margin_money(mark, context.sub_bar_open_ms), false);
    if (!(units > 0.0)) return false;
    native_order::Request request;
    request.intent = native_order::Reduce{native_order::ExplicitUnits{units}};
    request.label = kMarginCallLabel;
    request.comment = "Margin call";
    request.trigger = (buy ? mark > fill : mark < fill)
        ? native_order::Trigger{native_order::Stop{mark}}
        : native_order::Trigger{native_order::Limit{mark, true}};
    PlacementSnapshot snapshot;
    snapshot.family = PineOrderFamily::Margin;
    snapshot.source_id = request.label;
    snapshot.requested_qty = units;
    snapshot.forced_execution_price = source_margin_fill_price(mark, buy);
    snapshot.waypoint_margin_call = true;
    snapshot.sizing = sizing_snapshot();
    return submit_or_replace(std::move(request), std::move(snapshot), false,
                             "__margin_priced_opening__").has_value();
}
 
bool PineExecutionAdapter::schedule_margin_call_path(
        const Bar& bar, const NativeDecisionContext& context) {
    const auto position = detail::run_position(require_host());
    if (position.signed_units == 0.0) return false;
    if (config_.process_orders_on_close) {
        // A carried process_orders_on_close short is checked over its bar's
        // path before the script runs at the close, as a long is, whatever
        // else the book holds: a pending entry beside it, a bracket that
        // fills later on the path, a close, add or reversal at the close, and
        // at any money class (lab tv tapes tests/fixtures/margin_residual
        // w5b-pc-seen-size and -seen-size-parked: the script reads the called
        // size, a parked entry beside the short or not; w5b-pc-carried-close,
        // -reverse and -bracket-tp; lane W5B-ENG-MARGIN-RESIDUAL). ab9714be
        // took no path slice beside a competing entry, and none on a
        // rounded-money short, slicing after the script instead. The one
        // exception left is a commissioned or slipped short with nothing
        // resting: its slice is on_bar_close_before_script's, at the high
        // before the script (lane W5-ENG-MARGIN-V6, C1), and a path slice
        // here would take it twice.
        // A void call's request rests for no one (void_issue).
        const bool resting_order = std::any_of(
            live_handles_.begin(), live_handles_.end(), [&](const auto& handle) {
                const auto found = placement_.find(handle.incarnation);
                return found == placement_.end()
                    || (found->second.family != PineOrderFamily::Margin
                        && !found->second.void_issue);
            });
        if (!config_.calc_on_order_fills && modeled_input()
            && position.signed_units < 0.0
            && (config_.commission_value != 0.0 || config_.slippage != 0)
            && position_open_script_bar_ != std::numeric_limits<std::int64_t>::min()
            && position_open_script_bar_ != context.script_bar_open_ms
            && !resting_order && pending_bracket_legs_.empty()
            && pending_coof_requests_.empty() && delayed_market_orders_.empty()
            && pending_entries_.empty()) {
            return false;
        }
    }
    // ab9714be pine_fills.cpp:1025-1063, :1314-1339: an entry-bar margin
    // pass sees only the OHLC suffix after the actual opening point. Later
    // bars enter here from Open and retain the ordinary remaining path. A
    // fill matched at a waypoint was reached on the segment into it, so that
    // waypoint is still ahead of it (the kernel's post-fill point measures
    // from it too, NativeExecutionConsumer::margin_segment_origin): a limit
    // filled on the way down to the low still faces the low (the
    // intrabar margin correction).
    const bool high_first = source_path_uses_high_first(bar);
    struct Waypoint { NativePathPhase phase; double price; };
    const Waypoint path[] = {
        {NativePathPhase::Open, bar.open},
        {high_first ? NativePathPhase::High : NativePathPhase::Low,
         high_first ? bar.high : bar.low},
        {high_first ? NativePathPhase::Low : NativePathPhase::High,
         high_first ? bar.low : bar.high},
        {NativePathPhase::Close, bar.close},
    };
    int current = -1;
    for (int index = 0; index < 4; ++index) {
        if (path[index].phase == context.coordinate.path_phase) {
            current = index;
            break;
        }
    }
    double adverse = kNaN;
    for (int index = std::max(current, 0); index < 4; ++index) {
        if (!finite_positive(path[index].price)) continue;
        if (!std::isfinite(adverse)
            || (position.signed_units > 0.0
                    ? path[index].price < adverse : path[index].price > adverse)) {
            adverse = path[index].price;
        }
    }
    if (!finite_positive(adverse)) return false;
    // A fill between the open and the close whose remaining path is adverse
    // only at the close: TradingView checks that close after the script has
    // run there (close_point_margin_call), so the kernel's own check at this
    // point rests nothing (resolve_margin_call_units).
    bool close_alone = current == 1 || current == 2;
    close_alone = close_alone && close_point_margin_scope() && finite_positive(bar.close);
    for (int index = std::max(current, 0); close_alone && index < 3; ++index) {
        if (!finite_positive(path[index].price)) continue;
        close_alone = position.signed_units > 0.0 ? path[index].price > bar.close
                                                  : path[index].price < bar.close;
    }
    if (close_alone) close_margin_point_ = context.coordinate.ordinal;
    // TradingView checks every point of the path, not only its adverse
    // extreme: a point the path reaches before that extreme can already be
    // short of margin -- a short filled the slippage ticks under its print is
    // still short at a low above its fill -- and so can one after it, where
    // the one-unit band's call restores the book that the extreme's own print
    // would not: a synthetic full-margin short of 200 shares, 22.00 short at
    // the 25.00 high, takes no unit (a 25.02 fill leaves 26.00 short), then
    // gives one up at the 24.99 low, 18.00 short; the same 0.02 slippage
    // makes one unit restorative there where it was not at the high (taili-mop-f3).
    // The first point that calls is rested there, and the rest
    // of the path is checked again on the book it leaves.
    withdraw_waypoint_margin_calls();
    if (close_point_margin_scope()) {
        if (rest_waypoint_margin_call(bar, current <= 0 ? 1 : current, 3, context)) {
            kernel_margin_path_point_ = context.coordinate.ordinal;
            close_margin_point_ = context.coordinate.ordinal;
            waypoint_chain_bar_ = context.script_bar_open_ms;
            return true;
        }
    }
    // R5: the placement is the kernel's. TradingView's scheduling decision has
    // just been taken above -- with this bar's competing orders in front of
    // it, exactly where the legacy broker takes it -- so all that is left is
    // to admit the kernel's own check point for this driver point. The kernel
    // then measures the same adverse mark (margin_sizing_price), asks this
    // adapter for TradingView's money and units, and rests the reduction at
    // that mark itself (NativeLiquidationCheck::PathAdverseExtremeMark).
    kernel_margin_path_point_ = context.coordinate.ordinal;
    // The answer the caller needs is whether a call will be made, which is the
    // same money the kernel is about to ask for.
    return source_margin_units(
        source_margin_money(adverse, context.sub_bar_open_ms), false) > 0.0;
}
 
// The one unit a restore that floors below one lot takes (source_margin_units'
// band), before its fill is tested; zero for any other restore.
double PineExecutionAdapter::source_margin_one_unit(const SourceMarginMoney& money) const {
    if (!money.valid || !(money.required > money.equity) || !staged_.quantity_grid
        || !(*staged_.quantity_grid <= 1.0)) {
        return 0.0;
    }
    const double raw = (money.required - money.equity) / money.unit_margin;
    if (!(raw > internal::kQtyEpsilon) || !(raw < 1.0)) return 0.0;
    const double floor_basis = source_money_round(money.required - money.equity)
        / money.unit_margin;
    if (std::floor(floor_basis / *staged_.quantity_grid) * *staged_.quantity_grid > 0.0)
        return 0.0;
    const double candidate = std::min(1.0, money.held);
    const double rounded = floor_quantity_grid(candidate, staged_.quantity_grid);
    const double guard = std::max(1e-12, std::abs(candidate) * 1e-12);
    return candidate >= money.held - guard || std::abs(rounded - candidate) <= guard
        ? candidate : 0.0;
}
 
// Whether that one unit restores the book at `fill`, the call's own fill: the
// whole position's requirement at the fill against the equity at the mark
// (source_margin_units, the slipped-short margin rule).
bool PineExecutionAdapter::source_margin_unit_restores(
        const SourceMarginMoney& money, double fill) const {
    return money.valid && finite_positive(fill)
        && money.exact_required * fill / money.mark - money.equity < money.unit_margin;
}
 
// Where the close's own check is the one after the script: a run whose
// orders fill at the next open, with no fill recalculation or magnifier.
bool PineExecutionAdapter::close_point_margin_scope() const noexcept {
    return !config_.process_orders_on_close && !config_.calc_on_order_fills
        && !coof_recalc_active_ && !bar_magnifier_ && modeled_input();
}
 
// TradingView checks a book whose path after a fill is adverse only at the
// bar's close at that close, after the script has run there: the script
// reads the book before the call, and the call is an order sized at the
// close's mark. Left standing it executes at the close, ahead of the orders
// the script placed there, and those keep the size they were placed with: a
// strategy.close_all() placed on that bar closes the called units again and
// opens them on the other side at the next open (lab tv tape w13-b1-close-f).
// The script's strategy.cancel_all() withdraws it too; it is then placed again
// behind the script's orders and executes after them at the next open as a
// plain market order -- on the book the script's close_all flattened it opens
// the called units on the other side (w13-b2-cancel-close-f; the population
// probes pf-probe-ki62-margin-deferral on NYSE:F and OANDA:XAUUSD), on a book
// still held it reduces it (w13-b4-cancel-f). A one-unit call (a restore
// that floors below one lot) is taken only at a fill where the unit restores
// the book, so one its fill at this close would not restore is tried again
// at the next open, and a re-placed one is tried at that open's fill alone
// (close_point_margin_call_at_open).
bool PineExecutionAdapter::close_point_margin_call(
        const Bar& bar, const NativeDecisionContext& context, bool cancelled) {
    const bool follow_up = close_margin_follow_up_bar_ == context.script_bar_open_ms;
    const double follow_up_units = close_margin_follow_up_units_;
    close_margin_follow_up_bar_ = std::numeric_limits<std::int64_t>::min();
    close_margin_follow_up_units_ = 0.0;
    // A short's lagged follow-up owed at this close (schedule_lagged_short_follow_up)
    // is booked first, after the script, ahead of the close's own check; the
    // close_all orders the script placed here keep the size they were placed
    // with, as behind any call at the close.
    if (PF_RARE(owed_follow_up_bar_ != std::numeric_limits<std::int64_t>::min())) {
        const bool owed = owed_follow_up_bar_ == context.script_bar_open_ms
            && owed_follow_up_point_ == 3;
        const double owed_units = owed_follow_up_units_;
        owed_follow_up_bar_ = std::numeric_limits<std::int64_t>::min();
        owed_follow_up_point_ = -1;
        owed_follow_up_units_ = 0.0;
        const auto held = detail::run_position(require_host());
        if (owed && held.signed_units < 0.0 && owed_units > 0.0 && source_margin_call_enabled_) {
            auto closes = same_bar_close_alls(context);
            const double units = std::min(owed_units, std::abs(held.signed_units));
            if (submit_margin_call_units(nearest_tick(bar.close, staged_.syminfo.mintick),
                                         context, units, true)) {
                const double left = std::abs(detail::run_position(require_host()).signed_units);
                record_close_call_after_script(std::abs(held.signed_units),
                                               std::abs(held.signed_units) - left, context);
                size_close_alls_at_placement(closes, held.signed_units);
            }
        }
    }
    const auto position = detail::run_position(require_host());
    if (position.signed_units == 0.0 || !source_margin_call_enabled_) return false;
    // A full-margin long's call is the one-contract money call's
    // (resolve_margin_call_units).
    if (position.signed_units > 0.0 && std::abs(config_.margin_long - 100.0) < 1e-12)
        return false;
    const auto money = source_margin_money(bar.close, context.sub_bar_open_ms);
    if (!money.valid || source_margin_rounded_tie_veto()) return false;
    const double one_unit = source_margin_one_unit(money);
    double units = std::min(source_margin_units(money, false),
                            std::abs(position.signed_units));
    if (units > 0.0 && !cancelled) return book_close_point_call(money.mark, units, context, false);
    if (one_unit > 0.0) return book_close_point_call(money.mark, one_unit, context, true);
    if (units > 0.0) return book_close_point_call(money.mark, units, context, true);
    // The close's own check calls nothing: a follow-up owed there is booked
    // after the script (follow_margin_call).
    if (follow_up && follow_up_units > 0.0)
        return book_close_point_call(money.mark, follow_up_units, context, cancelled);
    return false;
}
 
// A call booked at the close after the script: at the close, after which
// every strategy.close_all() the script placed on the bar keeps the size it
// was placed with; or, `queued`, as a plain market order behind the script's
// orders for the next open.
bool PineExecutionAdapter::book_close_point_call(
        double mark, double units, const NativeDecisionContext& context, bool queued,
        double reference_mark) {
    const auto position = detail::run_position(require_host());
    units = std::min(units, std::abs(position.signed_units));
    if (!(units > 0.0)) return false;
    if (!queued) {
        auto closes = same_bar_close_alls(context);
        if (!submit_margin_call_units(mark, context, units, true)) return false;
        if (PF_RARE(detail::margin_schedule_switches().frozen_reversal_close)) {
            const double left = std::abs(detail::run_position(require_host()).signed_units);
            record_close_call_after_script(std::abs(position.signed_units),
                                           std::abs(position.signed_units) - left, context);
        }
        size_close_alls_at_placement(closes, position.signed_units);
        close_point_follow_up(mark, units, context);
        return true;
    }
    const bool buy = position.signed_units < 0.0;
    close_margin_open_bar_ = context.script_bar_open_ms;
    native_order::Request request;
    request.intent = native_order::Transact{buy ? units : -units};
    request.label = kMarginCallLabel;
    request.comment = "Margin call";
    PlacementSnapshot snapshot;
    snapshot.family = PineOrderFamily::Margin;
    snapshot.source_id = request.label;
    snapshot.requested_qty = units;
    snapshot.is_long = buy;
    snapshot.crosses_zero = true;
    snapshot.sizing = sizing_snapshot();
    snapshot.follow_up_fill = reference_mark;
    return submit_or_replace(std::move(request), std::move(snapshot), false,
                             kMarginCallLabel).has_value();
}
 
// The first of the bar's path points in [from, to) where TradingView's check
// calls the book as it stands, rested at that point: a touch of its print
// from the side the path reaches it from, executed at the print's tick with
// the exit side's slippage. The close is not one of them: its check is taken
// after the script (close_point_margin_call).
bool PineExecutionAdapter::rest_waypoint_margin_call(
        const Bar& bar, int from, int to, const NativeDecisionContext& context) {
    const auto position = detail::run_position(require_host());
    if (position.signed_units == 0.0) return false;
    // Measured on shorts slipped on whole lots (TradingView exports
    // int28fix-ou-s1 and -ou-s2, NYSE:F shares at slippage 1 and 2). A
    // full-margin long's call is the one-contract money call
    // (submit_tv_money_long_margin_call), and neither a long nor a fractional
    // lot is checked here: resting their calls at an earlier point takes calls
    // TradingView does not (lane W13-ENG-MARGIN-OPP's population replay).
    if (position.signed_units > 0.0 || !(config_.slippage > 0) || !staged_.quantity_grid
        || *staged_.quantity_grid != 1.0) {
        return false;
    }
    const bool high_first = source_path_uses_high_first(bar);
    const double path[] = {bar.open, high_first ? bar.high : bar.low,
                           high_first ? bar.low : bar.high, bar.close};
    const bool buy = position.signed_units < 0.0;
    for (int index = std::max(from, 1); index < std::min(to, 3); ++index) {
        const double price = path[index];
        if (!finite_positive(price) || !finite_positive(path[index - 1])) continue;
        const double units = std::min(
            source_margin_units(source_margin_money(price, context.sub_bar_open_ms), false),
            std::abs(position.signed_units));
        if (!(units > 0.0)) continue;
        const bool falling = price < path[index - 1];
        native_order::Request request;
        request.intent = native_order::Reduce{native_order::ExplicitUnits{units}};
        request.label = kMarginCallLabel;
        request.comment = "Margin call";
        request.trigger = falling == buy
            ? native_order::Trigger{native_order::Limit{price, true}}
            : native_order::Trigger{native_order::Stop{price}};
        PlacementSnapshot snapshot;
        snapshot.family = PineOrderFamily::Margin;
        snapshot.source_id = request.label;
        snapshot.requested_qty = units;
        snapshot.is_long = buy;
        snapshot.forced_execution_price = source_margin_fill_price(price, buy);
        snapshot.waypoint_margin_call = true;
        snapshot.sizing = sizing_snapshot();
        return submit_or_replace(std::move(request), std::move(snapshot), false,
                                 "__margin_waypoint__").has_value();
    }
    return false;
}
 
// A new schedule, or the bar's end, supersedes a path-point margin call.
void PineExecutionAdapter::withdraw_waypoint_margin_calls() {
    if (!has_live_family(PineOrderFamily::Margin)) return;
    std::vector<native_order::RequestHandle> stale;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found != placement_.end() && found->second.waypoint_margin_call)
            stale.push_back(handle);
    }
    for (const auto& handle : stale) {
        if (require_host().cancel(handle).status == native_order::CancelStatus::Cancelled)
            retire(handle);
    }
}
 
// This bar's strategy.close_all() orders still waiting for the next open.
std::vector<std::pair<native_order::RequestHandle, PlacementSnapshot>>
PineExecutionAdapter::same_bar_close_alls(const NativeDecisionContext& context) const {
    std::vector<std::pair<native_order::RequestHandle, PlacementSnapshot>> closes;
    if (!has_live_family(PineOrderFamily::CloseAll)) return closes;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found != placement_.end() && found->second.family == PineOrderFamily::CloseAll
            && found->second.placement_script_open_ms == context.script_bar_open_ms) {
            closes.emplace_back(handle, found->second);
        }
    }
    return closes;
}
 
// Those orders keep the size they were placed with, the book `placed` before
// a call at the close shrank it: each becomes the plain market transaction of
// that size, which crosses zero on the smaller book (close_point_margin_call).
void PineExecutionAdapter::size_close_alls_at_placement(
        std::vector<std::pair<native_order::RequestHandle, PlacementSnapshot>>& closes,
        double placed) {
    for (auto& close : closes) {
        if (std::find(live_handles_.begin(), live_handles_.end(), close.first)
            == live_handles_.end()) {
            continue;
        }
        native_order::Request request;
        request.intent = native_order::Transact{-placed};
        request.label = close.second.source_id;
        request.comment = close.second.comment;
        close.second.crosses_zero = true;
        (void)submit_or_replace(std::move(request), std::move(close.second), false,
                                "__pine_close_all");
    }
}
 
// A call taken at the close whose book, re-marked at the call's own fill, is
// still short of margin by more than two slippage steps (its exit fee added
// back) is followed at the next path point, as a call inside a bar is
// (follow_margin_call, margin_follow_up_units): after the close that point is
// the next open, where the follow-up waits behind the orders the script placed
// at the close and is taken only where that open's print is not beyond the
// call's fill (close_point_margin_call_at_open). A call of any size is followed
// so: a synthetic NYSE:F call at slippage 1 can leave 200 shares 0.10 short
// at its 25.01 fill off a 25.00 close; a 24.995 next open can take one more,
// behind the script's close_all. The follow-up is owed at the next point,
// rather than being booked ahead of the script's queued orders.
void PineExecutionAdapter::close_point_follow_up(
        double mark, double called_units, const NativeDecisionContext& context) {
    if (!margin_follow_up_scope()) return;
    const auto position = detail::run_position(require_host());
    if (position.signed_units == 0.0) return;
    const bool buy = position.signed_units < 0.0;
    const double fill = source_margin_fill_price(mark, buy);
    const double units = margin_follow_up_units(called_units, fill, context.sub_bar_open_ms);
    if (!(units > 0.0)) return;
    (void)book_close_point_call(mark, units, context, true, fill);
}
 
// The next open of a close that owed a one-unit call (close_point_margin_call):
// the book is the one that close checked, so its money is re-read at that
// close's mark and the unit is tested at this open's fill. One the close left
// standing executes here, ahead of the orders of that bar (a measured TradingView run, shown with synthetic numbers; a short:
// 100 shares, a 2.00 margin shortfall at a 25.01 close mark; buying one
// at 25.01 off the next 25.00 open leaves 99 shares and restores margin);
// one the script cancelled and placed again is withdrawn here
// when its fill would not restore the book (w13-b2-cancel-close-f), rather than being forced
// through on the strength of the close's earlier one-unit verdict.
bool PineExecutionAdapter::close_point_margin_call_at_open(
        const Bar& bar, const Bar& prior, const NativeDecisionContext& context) {
    if (close_margin_open_bar_ == std::numeric_limits<std::int64_t>::min()) return false;
    const bool owed = close_margin_open_bar_ == prior.timestamp;
    close_margin_open_bar_ = std::numeric_limits<std::int64_t>::min();
    std::vector<native_order::RequestHandle> queued;
    bool behind_orders = false;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end() || found->second.placement_script_open_ms != prior.timestamp)
            continue;
        if (found->second.family == PineOrderFamily::Margin && found->second.crosses_zero) {
            queued.push_back(handle);
        } else if (!finite_positive(found->second.exit_levels.limit)
                   && !finite_positive(found->second.exit_levels.stop)
                   && !finite_positive(found->second.exit_levels.trail_offset)
                   && !finite_positive(found->second.exit_levels.trail_points)) {
            behind_orders = true;
        }
    }
    const auto withdraw = [&](native_order::RequestHandle handle) {
        if (require_host().cancel(handle).status == native_order::CancelStatus::Cancelled)
            retire(handle);
    };
    const auto position = detail::run_position(require_host());
    if (!owed || position.signed_units == 0.0) {
        for (const auto& handle : queued) withdraw(handle);
        return false;
    }
    // A one-unit call is tested at this open's fill against the money of the
    // book at that close; a follow-up is taken where this open's print is not
    // beyond the fill of the call it follows (w13-b1s-close-f; synthetic short:
    // opens at or inside a 25.00 fill take their unit; an open at 25.04
    // takes none).
    const bool buy = position.signed_units < 0.0;
    const double fill = source_margin_fill_price(bar.open, buy);
    const double open_mark = nearest_tick(bar.open, staged_.syminfo.mintick);
    const double guard = staged_.syminfo.mintick * 1e-6;
    const auto money = source_margin_money(prior.close, context.sub_bar_open_ms);
    std::vector<native_order::RequestHandle> kept;
    double units = 0.0;
    for (const auto& handle : queued) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const double followed = found->second.follow_up_fill;
        const bool taken = finite_positive(followed)
            ? (buy ? open_mark <= followed + guard : open_mark >= followed - guard)
            : (!(source_margin_one_unit(money) > 0.0)
               || source_margin_unit_restores(money, fill));
        if (!taken) {
            withdraw(handle);
            continue;
        }
        kept.push_back(handle);
        if (finite_positive(found->second.requested_qty)) units += found->second.requested_qty;
    }
    if (kept.empty()) return false;
    // Behind the orders the script placed at that close, the calls keep their
    // place and fill after them in this open's matching pass; with none, they
    // are this open's first execution, ahead of the open's own check.
    if (behind_orders) return true;
    for (const auto& handle : kept) withdraw(handle);
    if (!submit_margin_call_units(bar.open, context, units, true)) return false;
    // A follow-up so taken is followed alike, at this same open while the
    // book re-marked at its fill is still short by more than two slippage
    // steps (margin_follow_up_units; w13-b5s-none-f; synthetic next open at 25.00 with
    // one-tick buy slippage: successive unit buys each fill at 25.01).
    for (int more = 0; more < 8 && margin_follow_up_scope(); ++more) {
        if (detail::run_position(require_host()).signed_units == 0.0) break;
        const double follow_up = margin_follow_up_units(units, fill, context.sub_bar_open_ms);
        if (!(follow_up > 0.0)) break;
        if (!submit_margin_call_units(bar.open, context, follow_up, true)) break;
        units = follow_up;
    }
    return false;
}
 
bool PineExecutionAdapter::declined_reversal_at_open(const Bar& bar) const {
    const auto position = detail::run_position(require_host());
    if (position.signed_units == 0.0) return false;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& candidate = found->second;
        // Only a default quantity can be declined here: ab9714be scopes the
        // fill-time decline to a frozen default quantity
        // (pine_fills.cpp:5227-5235, set by pine_strategy_commands.cpp:596-601
        // only when qty is omitted). An explicit qty is never priced as the
        // default value (lane TVDEF-DROPS, tests/fixtures/tvdef_drops R2).
        if (!candidate.opening || candidate.family != PineOrderFamily::Entry
            || candidate.is_long == (position.signed_units > 0.0)
            || !candidate.reverse_to || candidate.projection_after_close
            || std::isfinite(candidate.requested_qty)) {
            continue;
        }
        double units = candidate.sizing.frozen_units;
        if (!finite_positive(units)) units = config_.default_qty_value;
        const double fill = nearest_tick(bar.open, staged_.syminfo.mintick);
        const double margin = candidate.is_long ? config_.margin_long : config_.margin_short;
        const double required = units * fill * staged_.syminfo.pointvalue
            * active_staged_fx(bar.timestamp) * margin / 100.0;
        const double equity = candidate.sizing.equity;
        const double epsilon = std::max(1e-9, std::abs(equity) * 1e-12);
        if (finite_positive(units) && std::isfinite(required)
            && std::isfinite(equity) && required > equity + epsilon) {
            return true;
        }
    }
    return false;
}
 
void PineExecutionAdapter::defer_declined_reversal_exits_at_adverse(
        const Bar& bar, const NativeDecisionContext&, bool margin_scheduled) {
    const auto position = detail::run_position(require_host());
    if (position.signed_units == 0.0) return;
    const double adverse = position.signed_units > 0.0 ? bar.low : bar.high;
    if (!finite_positive(adverse)) return;
 
    const PlacementSnapshot* declined_reversal = nullptr;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& candidate = found->second;
        // As in declined_reversal_at_open: an explicit qty is never declined.
        if (!candidate.opening || candidate.family != PineOrderFamily::Entry
            || candidate.is_long == (position.signed_units > 0.0)
            || !candidate.reverse_to || candidate.projection_after_close
            || std::isfinite(candidate.requested_qty)) {
            continue;
        }
        double units = candidate.sizing.frozen_units;
        if (!finite_positive(units)) units = config_.default_qty_value;
        const double fill = nearest_tick(bar.open, staged_.syminfo.mintick);
        const double margin = candidate.is_long ? config_.margin_long : config_.margin_short;
        const double required = units * fill * staged_.syminfo.pointvalue
            * active_staged_fx(bar.timestamp) * margin / 100.0;
        const double equity = candidate.sizing.equity;
        const double epsilon = std::max(1e-9, std::abs(equity) * 1e-12);
        if (finite_positive(units) && std::isfinite(required)
            && std::isfinite(equity) && required > equity + epsilon) {
            declined_reversal = &candidate;
            break;
        }
    }
    if (!declined_reversal) return;
 
    // ab9714be:pine_fills.cpp:5509-5519,7232-7277.  A whole-position
    // strategy.close created after this same-bar reversal is the reversal's
    // dependent closing leg.  If the opening half is unaffordable, remove
    // that close before the generic open candidate is visited; otherwise its
    // ordinary MARKET trigger would flatten the held position independently
    // and erase the margin/revival chronology the source command specified.
    std::vector<native_order::RequestHandle> dependent_closes;
    const double held = std::abs(position.signed_units);
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& snapshot = found->second;
        const bool full = std::isfinite(snapshot.projection_remaining_qty)
            ? snapshot.projection_remaining_qty >= held - 1e-10
            : (std::isfinite(snapshot.requested_qty)
                ? std::abs(snapshot.requested_qty) >= held - 1e-10
                : std::isfinite(snapshot.qty_percent)
                    && snapshot.qty_percent >= 100.0 - 1e-9);
        if (snapshot.family == PineOrderFamily::Close && full
            && snapshot.command_ordinal > declined_reversal->command_ordinal
            && snapshot.projection_created_bar
                == declined_reversal->projection_created_bar) {
            dependent_closes.push_back(handle);
        }
    }
    for (const auto& handle : dependent_closes) {
        const auto result = require_host().cancel(handle);
        if (result.status == native_order::CancelStatus::Cancelled) retire(handle);
    }
 
    struct DeferredStop {
        native_order::RequestHandle handle;
        PlacementSnapshot snapshot;
    };
    std::vector<DeferredStop> stops;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& snapshot = found->second;
        if (snapshot.family != PineOrderFamily::ExitStop
            || snapshot.from_entry.empty() || snapshot.void_issue
            || !finite_positive(snapshot.exit_levels.stop)
            || std::isfinite(snapshot.requested_qty)
            || !(snapshot.qty_percent >= 100.0 - 1e-9)) {
            continue;
        }
        const bool adverse_reaches = position.signed_units > 0.0
            ? adverse <= snapshot.exit_levels.stop
            : adverse >= snapshot.exit_levels.stop;
        // A stop the open is already through fills at that open, ahead of
        // the declined reversal: TradingView exits there (lab tv
        // w6-f12b-stop-priority-default B2, lane W6-ENG-FILL-ORDER).
        const bool through_at_open = position.signed_units > 0.0
            ? bar.open <= snapshot.exit_levels.stop
            : bar.open >= snapshot.exit_levels.stop;
        if (adverse_reaches && !through_at_open) stops.push_back({handle, snapshot});
    }
    for (auto& deferred : stops) {
        if (!margin_scheduled) {
            const auto result = require_host().cancel(deferred.handle);
            if (result.status == native_order::CancelStatus::Cancelled)
                retire(deferred.handle);
            continue;
        }
        native_order::Request request;
        request.intent = native_order::HostSized{
            native_order::HostSizedKind::Close, std::nullopt};
        request.label = deferred.snapshot.source_id;
        request.comment = deferred.snapshot.comment;
        request.trigger = native_order::Stop{adverse};
        request.owner = owner_for_close(deferred.snapshot.from_entry, true);
        const std::string group_name = deferred.snapshot.oca_name.empty()
            ? deferred.snapshot.source_id + "\x1f" + deferred.snapshot.from_entry
            : deferred.snapshot.oca_name;
        request.group = group_for(group_name, 1);
        deferred.snapshot.forced_execution_price = adverse;
        const SourceId replacement_key = deferred.snapshot.source_id + "\x1f"
            + deferred.snapshot.from_entry
            + std::to_string(static_cast<int>(PineOrderFamily::ExitStop));
        const auto accepted = submit_or_replace(
            std::move(request), std::move(deferred.snapshot), false,
            replacement_key);
        if (accepted) {
            bracket_family(key_for(
                placement_.at(accepted->incarnation).source_id,
                placement_.at(accepted->incarnation).from_entry)).push_back(*accepted);
        }
    }
}
 
bool PineExecutionAdapter::submit_intraday_loss_close(
        double mark_price, const NativeDecisionContext& context, bool execute_current) {
    if (!intraday_loss_breached(mark_price)
        || detail::run_position(require_host()).signed_units == 0.0) {
        return false;
    }
    native_order::Request request;
    request.intent = native_order::Flatten{};
    // The legacy forced-close report has an empty exit id and this exact
    // comment.  An empty generic label is supported by the request algebra.
    request.comment = kIntradayLossComment;
    if (!execute_current) request.trigger = native_order::Stop{mark_price};
    PlacementSnapshot snapshot;
    snapshot.family = PineOrderFamily::Risk;
    snapshot.source_id = "__intraday_loss__";
    snapshot.comment = request.comment;
    snapshot.sizing = sizing_snapshot();
    const auto accepted = submit_or_replace(std::move(request), std::move(snapshot), false,
                                            "__intraday_loss_close__");
    if (!accepted) return false;
    if (execute_current) {
        const auto result = require_host().execute_current(
            {*accepted, NativeCurrentPriceRule::NearestTick});
        if (const auto* applied = std::get_if<native_order::ExecutionAppliedEvent>(&result);
            applied && applied->closed_units > 0.0) {
            risk_.intraday_block_day = chart_day_key(context.sub_bar_open_ms);
            risk_.intraday_cancel_pending = true;
        }
    }
    return true;
}
 
void PineExecutionAdapter::schedule_intraday_loss_path(
        const Bar& bar, const NativeDecisionContext& context) {
    const auto position = detail::run_position(require_host());
    if (position.signed_units == 0.0) return;
    const double adverse = position.signed_units > 0.0 ? bar.low : bar.high;
    if (!finite_positive(adverse) || adverse == bar.open) return;
    if (position.signed_units > 0.0 ? !(adverse < bar.open) : !(adverse > bar.open))
        return;
    (void)submit_intraday_loss_close(adverse, context, false);
}
 
void PineExecutionAdapter::execute_due_cap_close(const NativeDecisionContext& context) {
    const auto due = cap.due_cause();
    if (!due || context.coordinate.interval_index <= due->trigger_bar
        || detail::run_position(require_host()).signed_units == 0.0) {
        return;
    }
    native_order::Request request;
    request.intent = native_order::Flatten{};
    request.comment = "Close Position (Max number of filled orders in one day)";
    PlacementSnapshot snapshot;
    snapshot.family = PineOrderFamily::CloseAll;
    snapshot.source_id = "__intraday_cap_close__";
    snapshot.comment = request.comment;
    const auto accepted = submit_or_replace(std::move(request), std::move(snapshot), false,
                                            "__intraday_cap_close__");
    if (accepted) {
        (void)require_host().execute_current({*accepted, NativeCurrentPriceRule::NearestTick});
        cap.after_immediate_close_attempt();
    }
}
 
void PineExecutionAdapter::execute_cap_close_now(const compat::pine::CloseNow& close) {
    if (detail::run_position(require_host()).signed_units == 0.0) {
        cap.after_immediate_close_attempt();
        return;
    }
    native_order::Request request;
    request.intent = native_order::Flatten{};
    request.comment = close.request.comment;
    PlacementSnapshot snapshot;
    snapshot.family = PineOrderFamily::CloseAll;
    snapshot.source_id = "__intraday_cap_close__";
    snapshot.comment = close.request.comment;
    const bool closing_long = detail::run_position(require_host()).signed_units > 0.0;
    snapshot.forced_execution_price = nearest_tick(
        close.price + (closing_long ? -1.0 : 1.0) * config_.slippage * staged_.syminfo.mintick,
        staged_.syminfo.mintick);
    const auto accepted = submit_or_replace(std::move(request), std::move(snapshot), false,
                                            "__intraday_cap_close__");
    if (accepted) {
        (void)require_host().execute_current({*accepted, NativeCurrentPriceRule::NearestTick});
    }
    cap.after_immediate_close_attempt();
}
 
void PineExecutionAdapter::observe_intraday_cap(
        const native_order::ExecutionAppliedEvent& event,
        const PlacementSnapshot& snapshot, const NativeDecisionContext& context) {
    if (!cap.active()) return;
    if (snapshot.family == PineOrderFamily::Margin || snapshot.family == PineOrderFamily::Risk
        || snapshot.source_id == "__intraday_cap_close__")
        return;
    const auto clock = cap_clock(context);
    const auto calculation = cap_calculation(context);
    if (snapshot.family == PineOrderFamily::Close
        || snapshot.family == PineOrderFamily::CloseAll) {
        const bool full = event.closed_units > 0.0
            && detail::run_position(require_host()).signed_units == 0.0;
        const bool observe_close = cap.direct_close_routing(calculation, full)
            == compat::pine::DirectCloseRouting::Observe;
        const bool ordinary_full_close = full && calculation.process_on_close
            && !calculation.calc_on_fills && !calculation.coof_scheduler
            && !calculation.magnifier && !calculation.stream_warmup
            && calculation.stream_idle && calculation.fifo;
        if (observe_close || ordinary_full_close) {
            compat::pine::Side before = compat::pine::Side::Flat;
            if (event.closed_trade_count > 0
                && event.first_trade_index
                    < static_cast<std::size_t>(require_host().trade_count())) {
                before = require_host().get_trade(
                    static_cast<int>(event.first_trade_index)).is_long
                    ? compat::pine::Side::Long : compat::pine::Side::Short;
            }
            std::vector<compat::pine::ContinuationCandidate> candidates;
            std::optional<native_order::RequestHandle> continuation;
            std::optional<PlacementSnapshot> continuation_snapshot;
            std::size_t continuation_index = 0;
            std::uint64_t continuation_sequence =
                std::numeric_limits<std::uint64_t>::max();
            for (const auto& handle : live_handles_) {
                if (handle == event.handle()) continue;
                const auto found = placement_.find(handle.incarnation);
                if (found == placement_.end()) continue;
                const auto& candidate = found->second;
                const bool market = candidate.family == PineOrderFamily::Entry
                    && !finite_positive(candidate.exit_levels.limit)
                    && !finite_positive(candidate.exit_levels.stop)
                    && !finite_positive(candidate.exit_levels.trail_offset);
                candidates.push_back({
                    market ? compat::pine::OrderKind::Market
                           : (candidate.family == PineOrderFamily::Entry
                                ? compat::pine::OrderKind::Entry
                                : compat::pine::OrderKind::Other),
                    candidate.projection_created_bar, candidate.is_long,
                    static_cast<std::int64_t>(candidate.command_sequence),
                    handle.incarnation});
                if (market && candidate.is_long != (before == compat::pine::Side::Long)
                    && candidate.projection_created_bar == calculation.bar
                    && candidate.command_sequence < continuation_sequence) {
                    continuation = handle;
                    continuation_snapshot = candidate;
                    continuation_index = candidates.size() - 1U;
                    continuation_sequence = candidate.command_sequence;
                }
            }
            double continuation_units = continuation_snapshot
                ? continuation_snapshot->frozen_market_own_units : kNaN;
            if (continuation_snapshot && !finite_positive(continuation_units)) {
                if (finite_positive(continuation_snapshot->requested_qty)) {
                    continuation_units = std::abs(continuation_snapshot->requested_qty);
                } else if (config_.default_qty_type == static_cast<int>(QtyType::FIXED)) {
                    continuation_units = config_.default_qty_value;
                } else {
                    continuation_units = continuation_snapshot->sizing.frozen_units;
                }
            }
            if (candidates.size() != 1U) continuation.reset();
            if (candidates.size() == 1U && continuation && continuation_snapshot
                && finite_positive(continuation_units)) {
                const auto old = *continuation;
                const auto cancelled = require_host().cancel(old);
                if (cancelled.status == native_order::CancelStatus::Cancelled) retire(old);
                native_order::Request request;
                request.intent = native_order::Transact{
                    continuation_snapshot->is_long
                        ? continuation_units : -continuation_units};
                request.label = continuation_snapshot->source_id;
                request.comment = continuation_snapshot->comment;
                request.trigger = native_order::Market{};
                continuation_snapshot->projection_predecessor = old.incarnation;
                continuation_snapshot->projection_predecessor_market = true;
                // This is an adapter-created continuation request, not a
                // second binding of the original immutable admission draft.
                // Give the successor its own journal event while retaining
                // predecessor provenance on the placement snapshot.
                continuation_snapshot->market_admission = {};
                const auto accepted = submit_or_replace(
                    std::move(request), *continuation_snapshot, true,
                    continuation_snapshot->source_id);
                if (accepted) {
                    continuation = *accepted;
                    candidates[continuation_index].incarnation = accepted->incarnation;
                } else {
                    continuation.reset();
                    candidates.erase(candidates.begin()
                        + static_cast<std::ptrdiff_t>(continuation_index));
                }
            }
            if (observe_close) {
                // Only an opposite entry the script placed BEFORE this close
                // inherits its slot: that entry's reversal is what closed the
                // position, so TradingView books the bar as one fill. One
                // placed after the close opens from flat and is a fill of its
                // own (lane W10-DIAG-UNKNOWN rule CAP-ORDER,
                // tests/fixtures/intraday_cap_tv).
                std::vector<compat::pine::ContinuationCandidate> inheritors;
                for (const auto& candidate : candidates) {
                    if (static_cast<std::uint64_t>(candidate.created_seq)
                        < snapshot.command_sequence) {
                        inheritors.push_back(candidate);
                    }
                }
                cap.committed_close(clock, calculation, before, event.ordinal, inheritors);
            }
            cap_latest_fill_ = event.ordinal;
            if (continuation) {
                (void)require_host().execute_current(
                    {*continuation, NativeCurrentPriceRule::NearestTick});
            }
        }
        // Direct closes are candidate C, not ordinary matched-attempt factor
        // A.  Unsupported calculation modes and metadata-off runs deliberately
        // remain uncounted.
        return;
    }
    const auto attempt = cap_attempt(snapshot, event.handle().incarnation, &event);
    const auto origin = cap.origin(clock, calculation, event.handle().incarnation, cap_latest_fill_);
    const auto admission = cap.pre_dispatch(clock, calculation, attempt, cap_latest_fill_);
    if (admission.dispatch == compat::pine::Dispatch::Decline) {
        cap.decline(event.handle().incarnation);
        return;
    }
    const bool primary_fill_applied = event.closed_units > 0.0
        || event.opened_units != 0.0 || event.closed_trade_count > 0
        || event.opened_lot_incarnation != 0
        || event.cycle_before != event.cycle_after;
    cap.outcome(primary_fill_applied ? compat::pine::FillOutcome::Committed
                                     : compat::pine::FillOutcome::NoEffect,
                origin);
    const auto position = detail::run_position(require_host());
    Bar prices = policy_script_bar_valid_ ? policy_script_bar_ : coof_script_bar_;
    if (const auto* pine_host = pine_view_of(&require_host())) {
        if (const auto broker = pine_host->scheduler_.broker_bar(*pine_host, context))
            prices = *broker;
    }
    const auto decision = cap.post_dispatch(admission, calculation, attempt,
        position.signed_units > 0.0 ? compat::pine::Side::Long
        : (position.signed_units < 0.0 ? compat::pine::Side::Short
                                       : compat::pine::Side::Flat),
        current_position_cycle_,
        {((context.coordinate.path_phase == NativePathPhase::None || context.coordinate.path_phase == NativePathPhase::Close)
          && config_.process_orders_on_close)
             ? prices.close : event.resolved_price,
         prices.open, prices.high, prices.low});
    if (const auto* now = std::get_if<compat::pine::CloseNow>(&decision)) {
        execute_cap_close_now(*now);
    }
    cap_latest_fill_ = event.ordinal;
}
 
void PineExecutionAdapter::observe_intraday_cap_noop(
        bool is_long, const NativeDecisionContext& context) {
    if (!cap.active()) return;
    PlacementSnapshot snapshot;
    snapshot.family = PineOrderFamily::Entry;
    snapshot.is_long = is_long;
    snapshot.projection_position_side = is_long
        ? static_cast<std::int32_t>(PositionSide::LONG)
        : static_cast<std::int32_t>(PositionSide::SHORT);
    snapshot.projection_created_bar = projection_bar_index(context);
    snapshot.source_sequence = source_sequence_;
    const auto clock = cap_clock(context);
    const auto calculation = cap_calculation(context);
    const auto attempt = cap_attempt(snapshot, 0);
    const auto origin = cap.origin(clock, calculation, 0, cap_latest_fill_);
    const auto admission = cap.pre_dispatch(clock, calculation, attempt, cap_latest_fill_);
    if (admission.dispatch == compat::pine::Dispatch::Decline) {
        cap.decline(0);
        return;
    }
    cap.outcome(compat::pine::FillOutcome::NoEffect, origin);
    const auto position = detail::run_position(require_host());
    Bar prices = policy_script_bar_valid_ ? policy_script_bar_ : coof_script_bar_;
    if (const auto* pine_host = pine_view_of(&require_host())) {
        if (const auto broker = pine_host->scheduler_.broker_bar(*pine_host, context))
            prices = *broker;
    }
    const auto decision = cap.post_dispatch(admission, calculation, attempt,
        position.signed_units > 0.0 ? compat::pine::Side::Long
        : (position.signed_units < 0.0 ? compat::pine::Side::Short
                                       : compat::pine::Side::Flat),
        current_position_cycle_,
        {context.coordinate.path_phase == NativePathPhase::None ? prices.close
                                                                 : detail::callback_point(require_host())->price,
         prices.open, prices.high, prices.low});
    if (const auto* now = std::get_if<compat::pine::CloseNow>(&decision)) {
        execute_cap_close_now(*now);
    }
}
 
void PineExecutionAdapter::source_batch_end() {
    cap.source_batch_end();
}
 
// `bar` is the projection bar (projection_bar_index), the bar space of the
// command observations the review receipts name.
void PineExecutionAdapter::record_market_review(
        admission::Checkpoint checkpoint, int bar,
        const std::vector<native_order::RequestHandle>& handles) {
    std::vector<native_order::RequestHandle> selected;
    selected.reserve(handles.size());
    for (const auto& handle : handles) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& draft = found->second.market_admission;
        if (!draft.observation() || draft.review()) continue;
        const bool belongs = checkpoint == admission::Checkpoint::TerminalGross
            || (checkpoint == admission::Checkpoint::DefaultGross
                && compat::pine::awaits_default_review(draft))
            || (checkpoint == admission::Checkpoint::ExplicitPair
                && compat::pine::awaits_pair_review(draft));
        if (belongs) selected.push_back(handle);
    }
    if (selected.empty()) return;
 
    auto allocation = admission_journal.reserve();
    admission::ReviewEvent review;
    review.receipt = {allocation.sequence(), checkpoint, bar, 0};
    review.open_price = policy_script_bar_valid_ ? policy_script_bar_.open : kNaN;
    const auto physical = detail::run_position(require_host());
    review.position_side = physical.signed_units > 0.0
        ? static_cast<int>(PositionSide::LONG)
        : (physical.signed_units < 0.0 ? static_cast<int>(PositionSide::SHORT)
                                       : static_cast<int>(PositionSide::FLAT));
    review.position_cycle = current_position_cycle_;
    for (const auto& handle : selected) {
        auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        auto& snapshot = found->second;
        const auto& origin = snapshot.market_admission.observation();
        if (!origin) continue;
        admission::BookObservation book;
        book.incarnation = handle.incarnation;
        book.priority = static_cast<std::int64_t>(snapshot.source_sequence);
        book.bar = snapshot.projection_created_bar;
        book.type = snapshot.family == PineOrderFamily::Order ? 3 : 0;
        book.placement_side = snapshot.projection_position_side;
        book.buy = snapshot.is_long;
        book.id = snapshot.source_id;
        book.oca_name = snapshot.oca_name;
        book.oca_type = snapshot.oca_type;
        book.birth = snapshot.birth;
        book.prices = {snapshot.exit_levels.limit, snapshot.exit_levels.stop,
                       snapshot.exit_levels.trail_points,
                       snapshot.exit_levels.trail_price,
                       snapshot.exit_levels.trail_offset};
        book.draft = snapshot.market_admission;
        review.book.push_back(book);
        review.reviewed.push_back(book);
        snapshot.market_admission.reviewed(
            {allocation.sequence(), checkpoint, bar, origin->command});
        if (review.reviewed.size() == 1U) review.configuration = origin->configuration;
    }
    admission_journal.append(std::move(review));
}
 
void PineExecutionAdapter::refresh_pending_sizing_after_margin(
        const native_order::ExecutionAppliedEvent& event,
        const NativeDecisionContext& context) {
    const double mark = policy_script_bar_valid_
        ? policy_script_bar_.close : event.resolved_price;
    PineSizingSnapshot marked;
    mark_sizing_equity(marked, nearest_tick(mark, staged_.syminfo.mintick));
    const double active_fx = active_staged_fx(context.sub_bar_open_ms);
    const std::uint64_t cause_fill =
        static_cast<PineStrategyHost&>(require_host()).broker_fill_event_seq_;
    for (const auto& handle : live_handles_) {
        auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        auto& snapshot = found->second;
        if (snapshot.projection_created_bar != projection_bar_index(context)
            || !snapshot.market_admission.observation()) {
            continue;
        }
        const admission::SizingObservation before{
            snapshot.sizing.frozen_units, snapshot.sizing.equity,
            snapshot.sizing.price, snapshot.sizing.mark, snapshot.sizing.fx};
        const double affordability_before = snapshot.projection_affordability_equity;
        bool revised = false;
        const bool market_entry = snapshot.opening
            && (snapshot.family == PineOrderFamily::Entry
                || snapshot.family == PineOrderFamily::Order)
            && !finite_positive(snapshot.exit_levels.limit)
            && !finite_positive(snapshot.exit_levels.stop);
        if (market_entry && std::isfinite(snapshot.sizing.frozen_units)) {
            snapshot.sizing.equity = marked.equity;
            snapshot.sizing.strategy_equity = marked.strategy_equity;
            snapshot.sizing.fx = active_fx;
            snapshot.sizing.frozen_units = default_sizing_units(snapshot.sizing);
            revised = true;
        }
        if (market_entry
            && std::isfinite(snapshot.projection_affordability_equity)) {
            snapshot.projection_affordability_equity =
                require_host().native_marked_equity(mark);
            revised = true;
        }
        if (!revised || cause_fill == 0) continue;
 
        const auto& origin = snapshot.market_admission.observation();
        auto allocation = admission_journal.reserve();
        admission::SizingEvent sizing;
        // A receipt's bar is in its command's bar space: the observation
        // bound the row's projection bar, the input slot, which an
        // aggregated run keeps apart from the script-bar interval_index
        // (lane FIX-E1E2: a receipt at interval_index preceded its command).
        sizing.receipt = {allocation.sequence(), cause_fill,
                          projection_bar_index(context), origin->command};
        sizing.incarnation = handle.incarnation;
        sizing.before = before;
        sizing.after = {snapshot.sizing.frozen_units, snapshot.sizing.equity,
                        snapshot.sizing.price, snapshot.sizing.mark,
                        snapshot.sizing.fx};
        sizing.affordability_equity_before = affordability_before;
        sizing.affordability_equity_after =
            snapshot.projection_affordability_equity;
        snapshot.market_admission.sizing_revised(sizing.receipt);
        admission_journal.append(std::move(sizing));
    }
}
 
void PineExecutionAdapter::apply_open_market_admission(
        const NativeDecisionContext& context) {
    const bool began_flat = detail::run_position(require_host()).signed_units == 0.0;
    const int source_bar = context.coordinate.interval_index - 1;
    struct Candidate {
        native_order::RequestHandle handle;
        const PlacementSnapshot* snapshot = nullptr;
    };
    std::vector<Candidate> market;
    bool foreign_live_order = false;
    // The historical placement scan is consumed only by the two-candidate
    // pair rule below; evaluate it there rather than on every broker open.
    const auto commands_on_bar = [&]() {
        std::size_t count = 0;
        // An entry or raw order is kept while its placement bar is the
        // previous one or later (erase_retired_rows, K5).
        PINEFORGE_AUDIT_PLACEMENT_SCAN(placement_,
            [&](std::uint64_t, const PlacementSnapshot& snapshot) {
                return snapshot.projection_created_bar == source_bar
                    && (snapshot.family == PineOrderFamily::Entry
                        || snapshot.family == PineOrderFamily::Order);
            });
        for (const auto& row : placement_) {
            const auto& snapshot = row.second;
            if (snapshot.projection_created_bar != source_bar
                || (snapshot.family != PineOrderFamily::Entry
                    && snapshot.family != PineOrderFamily::Order)) {
                continue;
            }
            ++count;
        }
        for (const auto& delayed : delayed_market_orders_) {
            if (delayed.snapshot.projection_created_bar == source_bar)
                ++count;
        }
        return count;
    };
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& snapshot = found->second;
        const bool unpriced_entry = snapshot.projection_created_bar == source_bar
            && snapshot.family == PineOrderFamily::Entry
            && !finite_positive(snapshot.exit_levels.limit)
            && !finite_positive(snapshot.exit_levels.stop)
            && !finite_positive(snapshot.exit_levels.trail_points)
            && !finite_positive(snapshot.exit_levels.trail_price)
            && !finite_positive(snapshot.exit_levels.trail_offset)
            && !snapshot.birth.from_fill() && !snapshot.birth.at_terminal_fill()
            && !compat::pine::historical_cascade_reach(snapshot.birth_reach);
        if (unpriced_entry) {
            market.push_back({handle, &snapshot});
            continue;
        }
        const bool same_bar_unpriced_close = snapshot.projection_created_bar == source_bar
            && snapshot.family == PineOrderFamily::Close
            && snapshot.oca_name.empty()
            && !finite_positive(snapshot.exit_levels.limit)
            && !finite_positive(snapshot.exit_levels.stop)
            && !finite_positive(snapshot.exit_levels.trail_points)
            && !finite_positive(snapshot.exit_levels.trail_price)
            && !finite_positive(snapshot.exit_levels.trail_offset)
            && !snapshot.birth.from_fill() && !snapshot.birth.at_terminal_fill()
            && !compat::pine::historical_cascade_reach(snapshot.birth_reach);
        if (!same_bar_unpriced_close) foreign_live_order = true;
    }
    const bool family_s_command_order =
        config_.default_qty_type == static_cast<int>(QtyType::FIXED)
        && config_.pyramiding == 1 && config_.slippage == 0
        && config_.commission_value == 0.0;
    std::stable_sort(market.begin(), market.end(), [&](const Candidate& left,
                                                       const Candidate& right) {
        const std::uint64_t left_key = family_s_command_order
            ? left.snapshot->command_sequence : left.snapshot->source_sequence;
        const std::uint64_t right_key = family_s_command_order
            ? right.snapshot->command_sequence : right.snapshot->source_sequence;
        if (left_key != right_key) return left_key < right_key;
        if (left.snapshot->source_sequence != right.snapshot->source_sequence)
            return left.snapshot->source_sequence < right.snapshot->source_sequence;
        return left.handle.incarnation < right.handle.incarnation;
    });
 
    std::vector<native_order::RequestHandle> cancellations;
    const auto cancel_later = [&](const native_order::RequestHandle& handle) {
        if (std::find(cancellations.begin(), cancellations.end(), handle)
            == cancellations.end()) {
            cancellations.push_back(handle);
        }
    };
 
    if (market.size() == 2 && !foreign_live_order && commands_on_bar() == 2) {
        const auto& first = *market[0].snapshot;
        const auto& second = *market[1].snapshot;
        if (first.projection_predecessor == 0 && second.projection_predecessor == 0) {
            const bool default_pair =
                compat::pine::awaits_default_review(first.market_admission)
                && compat::pine::awaits_default_review(second.market_admission)
                && first.source_id != second.source_id
                && first.is_long != second.is_long;
            if (default_pair) {
                // ab9714be pine_fills.cpp:3005-3009: an earlier command that
                // was already at the entry cap contributes no broker movement
                // to the later call's all-in gross cost.
                const double first_units = first.projection_over_pyramiding
                    ? 0.0 : first.sizing.frozen_units;
                const double first_margin = first.is_long
                    ? config_.margin_long : config_.margin_short;
                const double second_margin = second.is_long
                    ? config_.margin_long : config_.margin_short;
                const double required = first_units * first.sizing.price
                        * staged_.syminfo.pointvalue * first.sizing.fx
                        * first_margin / 100.0
                    + second.sizing.frozen_units * second.sizing.price
                        * staged_.syminfo.pointvalue * second.sizing.fx
                        * second_margin / 100.0;
                const double equity = std::min(first.sizing.equity, second.sizing.equity);
                const double guard = std::max(1e-9, std::abs(equity) * 1e-12);
                if (std::isfinite(required) && std::isfinite(equity)
                    && required > equity + guard) {
                    cancel_later(market[1].handle);
                }
            } else if (began_flat && first.source_id != second.source_id
                       && first.is_long != second.is_long && config_.pyramiding == 2
                       && finite_positive(first.requested_qty)
                       && finite_positive(second.requested_qty)
                       && first.qty_type < 0 && second.qty_type < 0
                       && first.oca_name.empty() && second.oca_name.empty()) {
                const double required = (first.requested_qty + second.requested_qty)
                    * first.sizing.price * staged_.syminfo.pointvalue * first.sizing.fx;
                if (std::isfinite(required) && std::isfinite(first.sizing.equity)
                    && required > first.sizing.equity) {
                    cancel_later(market[1].handle);
                }
            }
        }
    }
 
    // A same-side-at-placement request is executable only if an earlier
    // opposite command in this broker batch can move the account before its
    // turn.  This retires the live-LONG pair's first no-op while preserving
    // the ordinary priced/raw/carried-book controls where the later request
    // becomes a reversal after its earlier sibling fills. In a batch of this
    // bar's market entries and closes alone -- no priced, raw or carried order
    // beside them, the controls that keep their ordinary fills -- a default
    // percent_of_equity (<= 100) add whose margin on top of the held side's
    // exceeded the equity when it was placed is not one of them: TradingView
    // dropped it there (entry(): the same rule inside the cap), so it never
    // reverses the book back once its sibling has reversed it (the
    // reversal-candle probe's tapes).
    const double held = detail::run_position(require_host()).signed_units;
    const auto dropped_at_placement = [&](const PlacementSnapshot& row) {
        return !foreign_live_order
            && !config_.process_orders_on_close && !config_.calc_on_order_fills
            && config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
            && config_.default_qty_value <= 100.0
            && row.deferred_cohort && !std::isfinite(row.requested_qty)
            && !row.projection_after_close
            && close_all_pending_script_bar_ != row.placement_script_open_ms
            && held != 0.0 && (held > 0.0) == row.is_long
            && finite_positive(row.sizing.frozen_units) && finite_positive(row.sizing.mark)
            && add_margin_exceeds_equity(std::abs(held), row.sizing,
                                         row.is_long ? config_.margin_long : config_.margin_short,
                                         staged_.syminfo.mintick, staged_.syminfo.pointvalue)
            && std::none_of(delayed_market_orders_.begin(), delayed_market_orders_.end(),
                            [&](const DelayedMarketOrder& delayed) {
                                return delayed.snapshot.projection_created_bar == source_bar;
                            });
    };
    for (std::size_t index = 0; index < market.size(); ++index) {
        if (!market[index].snapshot->projection_over_pyramiding) continue;
        bool earlier_opposite = false;
        for (std::size_t prior = 0; prior < index; ++prior) {
            if (market[prior].snapshot->is_long != market[index].snapshot->is_long) {
                earlier_opposite = true;
                break;
            }
        }
        if (!earlier_opposite || dropped_at_placement(*market[index].snapshot))
            cancel_later(market[index].handle);
    }
    std::vector<native_order::RequestHandle> review_handles;
    review_handles.reserve(market.size());
    for (const auto& candidate : market) review_handles.push_back(candidate.handle);
    record_market_review(admission::Checkpoint::DefaultGross,
                         projection_bar_index(context), review_handles);
    record_market_review(admission::Checkpoint::ExplicitPair,
                         projection_bar_index(context), review_handles);
    for (const auto& handle : cancellations) {
        const auto result = require_host().cancel(handle);
        if (result.status == native_order::CancelStatus::Cancelled) retire(handle);
    }
}
 
void PineExecutionAdapter::defer_open_marketable_sells(const Bar& bar) {
    if (config_.calc_on_order_fills || !modeled_input())
        return;
    if (detail::run_position(require_host()).signed_units != 0.0) return;
    const bool high_first = source_path_uses_high_first(bar);
    // ab9714be pine_fills.cpp:3687-3860 is not gated on process_orders_on_close.
    // Under POOC the fill point of a marketable order is the bar close
    // (pine_fills.cpp:7964-7965), not the open.
    const double fill_point_price = config_.process_orders_on_close ? bar.close : bar.open;
    struct Candidate {
        native_order::RequestHandle handle;
        const PlacementSnapshot* snapshot = nullptr;
        double path_position = 0.0;
        bool open_marketable = false;
        bool touched = false;
    };
    std::vector<Candidate> buys;
    std::vector<Candidate> sells;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& snapshot = found->second;
        if (snapshot.family != PineOrderFamily::Entry
            || !finite_positive(snapshot.exit_levels.stop)
            || finite_positive(snapshot.exit_levels.limit)
            || finite_positive(snapshot.exit_levels.trail_points)
            || finite_positive(snapshot.exit_levels.trail_price)
            || finite_positive(snapshot.exit_levels.trail_offset)) {
            continue;
        }
        Candidate row;
        row.handle = handle;
        row.snapshot = &snapshot;
        row.open_marketable = pure_stop_entry_marketable_at(snapshot, fill_point_price);
        row.touched = internal::entry_stop_first_touch(
            bar, high_first, snapshot.exit_levels.stop, snapshot.is_long,
            &row.path_position);
        if (snapshot.is_long) buys.push_back(row);
        else sells.push_back(row);
    }
    if (buys.empty() || sells.empty()) return;
    std::uint64_t min_open_buy_incarnation = std::numeric_limits<std::uint64_t>::max();
    bool open_buy = false;
    for (const auto& buy : buys) {
        if (!buy.open_marketable) continue;
        open_buy = true;
        min_open_buy_incarnation = std::min(min_open_buy_incarnation, buy.handle.incarnation);
    }
    if (!open_buy) return;
    std::vector<Candidate> deferred;
    bool deferred_open_sell = false;
    for (const auto& sell : sells) {
        if (sell.open_marketable && sell.handle.incarnation < min_open_buy_incarnation) {
            deferred.push_back(sell);
            deferred_open_sell = true;
        }
    }
    if (!deferred_open_sell) return;
    for (const auto& sell : sells) {
        if (sell.open_marketable) continue;
        // ab9714be: a resting stop the bar path never reaches is not an
        // order of this bar; it stays in the book for a later bar (L9d).
        if (!sell.touched) continue;
        deferred.push_back(sell);
    }
    std::stable_sort(deferred.begin(), deferred.end(),
                     [](const Candidate& left, const Candidate& right) {
                         return left.handle.incarnation < right.handle.incarnation;
                     });
    deferred.erase(std::unique(deferred.begin(), deferred.end(),
                               [](const Candidate& left, const Candidate& right) {
                                   return left.handle.incarnation == right.handle.incarnation;
                               }),
                   deferred.end());
    for (const auto& sell : deferred) {
        DeferredOpenMarketableSell row;
        row.snapshot = *sell.snapshot;
        row.replacement_key = sell.snapshot->source_id;
        row.fill_price = sell.open_marketable ? fill_point_price : sell.snapshot->exit_levels.stop;
        row.path_position = sell.path_position;
        row.open_marketable = sell.open_marketable;
        const auto result = require_host().cancel(sell.handle);
        if (result.status != native_order::CancelStatus::Cancelled) continue;
        retire(sell.handle);
        deferred_open_marketable_sells_.push_back(std::move(row));
    }
}
 
void PineExecutionAdapter::admit_deferred_open_marketable_sells() {
    require_cohort_ticket();
    auto queued = std::move(deferred_open_marketable_sells_);
    deferred_open_marketable_sells_.clear();
    std::stable_sort(queued.begin(), queued.end(),
                     [](const DeferredOpenMarketableSell& left,
                        const DeferredOpenMarketableSell& right) {
                         if (left.open_marketable != right.open_marketable)
                             return !left.open_marketable && right.open_marketable;
                         if (left.path_position != right.path_position)
                             return left.path_position < right.path_position;
                         return left.snapshot.command_sequence < right.snapshot.command_sequence;
                     });
    for (auto& row : queued) {
        native_order::Request request;
        if (row.snapshot.deferred_cohort || !std::isfinite(row.snapshot.requested_qty)) {
            request.intent = native_order::HostSized{
                native_order::HostSizedKind::Open, native_order::Side::Short};
        } else {
            request.intent = native_order::Transact{-std::abs(row.snapshot.requested_qty)};
        }
        request.label = row.snapshot.source_id;
        request.comment = row.snapshot.comment;
        request.trigger = native_order::Market{};
        request.group = group_for(row.snapshot.oca_name, row.snapshot.oca_type);
        row.snapshot.forced_execution_price = row.fill_price;
        // ab9714be pine_fills.cpp:8517-8538: the second of a flat dual-stop
        // pair is a Transact against the already-opened side, not ReverseTo.
        row.snapshot.projection_after_close = true;
        row.snapshot.cancellation = {};
        row.snapshot.market_admission = {};
        const SourceId key = row.replacement_key;
        // ab9714be pine_fills.cpp:7483-7537: once a priced entry filled on
        // this bar, an entry that would open from flat is skipped for the
        // bar and keeps resting. Re-arm the original stop for the next bar
        // instead of filling it at the deferred price (L9d).
        const bool throttled_reopen =
            detail::run_position(require_host()).signed_units == 0.0
            && entry_openings_this_interval_ > 0;
        if (throttled_reopen) {
            request.trigger = native_order::Stop{row.snapshot.exit_levels.stop};
            row.snapshot.forced_execution_price = kNaN;
            row.snapshot.projection_after_close = false;
            (void)submit_or_replace(std::move(request), std::move(row.snapshot), true, key);
            continue;
        }
        const auto accepted = submit_or_replace(
            std::move(request), std::move(row.snapshot), true, key);
        if (accepted) {
            (void)require_host().execute_current(
                {*accepted, NativeCurrentPriceRule::NearestTick});
        }
    }
}
 
void PineExecutionAdapter::apply_reversal_gap_bracket_policy(
        const Bar& bar, const NativeDecisionContext& context, bool defer_trails) {
    const auto physical = detail::run_position(require_host());
    if (physical.signed_units == 0.0) return;
    const int source_bar = context.coordinate.interval_index - 1;
    bool opposite_market = false;
    bool gap_decline = false;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& entry = found->second;
        const bool opposite = (physical.signed_units > 0.0) != entry.is_long;
        if (!opposite || entry.family != PineOrderFamily::Entry || !entry.opening
            || entry.projection_created_bar != source_bar
            || std::isfinite(entry.requested_qty)
            || finite_positive(entry.exit_levels.limit)
            || finite_positive(entry.exit_levels.stop)
            || config_.default_qty_type
                != static_cast<int>(QtyType::PERCENT_OF_EQUITY)
            || config_.default_qty_value > 100.0
            || !finite_positive(entry.sizing.frozen_units)
            || !finite_positive(entry.sizing.equity)
            || !finite_positive(entry.sizing.price)
            || !finite_positive(entry.sizing.fx)) {
            continue;
        }
        const double margin = entry.is_long ? config_.margin_long : config_.margin_short;
        if (!finite_positive(margin) || !finite_positive(staged_.syminfo.pointvalue))
            continue;
        const double notional_per_price = entry.sizing.frozen_units
            * staged_.syminfo.pointvalue * entry.sizing.fx;
        if (!finite_positive(notional_per_price)) continue;
 
        // ab9714be pine_fills.cpp:5010-5164: a rule-5 signal-price whole
        // rejection leaves the held position's bracket alone. Only a call
        // which passed that placement boundary and was then refused by the
        // adverse opening gap owns the declined-reversal bracket suspension.
        const bool money_scope = staged_.quantity_grid
            && *staged_.quantity_grid > 0.0 && *staged_.quantity_grid < 1.0
            && staged_.syminfo.pointvalue == 1.0 && entry.sizing.fx == 1.0
            && staged_.account_fx_effective_from_ms.empty()
            && config_.commission_value == 0.0 && config_.slippage == 0
            && !config_.process_orders_on_close && !config_.calc_on_order_fills
           ;
        double affordable_price = kNaN;
        if (money_scope) {
            const double rounded_cost = source_money_round(
                notional_per_price * entry.sizing.price);
            affordable_price = source_money_round(
                source_money_round(entry.sizing.equity) / notional_per_price);
            if (entry.sizing.equity + 1e-9 < rounded_cost
                || (std::isfinite(affordable_price)
                    && affordable_price < entry.sizing.price)) {
                continue;
            }
        }
        opposite_market = true;
        const double fill = source_bar_fill_tick(bar.open, staged_.syminfo.mintick)
            + (entry.is_long ? 1.0 : -1.0)
                * config_.slippage * staged_.syminfo.mintick;
        const double required = notional_per_price * fill * margin / 100.0;
        const double guard = std::max(1e-9, std::abs(entry.sizing.equity) * 1e-12);
        const bool price_band_admitted = money_scope
            && std::isfinite(affordable_price) && affordable_price >= fill;
        if (std::isfinite(required)
            && required > entry.sizing.equity + guard
            && !price_band_admitted) {
            gap_decline = true;
            break;
        }
    }
    if (!opposite_market) return;
 
    const double held_margin = physical.signed_units > 0.0
        ? config_.margin_long : config_.margin_short;
    const double open_fill = source_bar_fill_tick(bar.open, staged_.syminfo.mintick);
    const double open_fx = active_staged_fx(bar.timestamp);
    const double held_required = std::abs(physical.signed_units) * open_fill
        * staged_.syminfo.pointvalue * open_fx * held_margin / 100.0;
    const double held_equity = require_host().native_marked_equity(open_fill);
    const bool opening_margin_slice = source_margin_call_enabled_
        && finite_positive(held_margin) && std::isfinite(held_required)
        && std::isfinite(held_equity) && held_required > held_equity;
 
    struct RetiredLeg {
        native_order::RequestHandle handle;
        std::optional<PendingBracketLeg> delayed_leg;
        std::optional<PlacementSnapshot> margin_revival;
        bool release_at_open = false;
    };
    std::vector<RetiredLeg> retired_legs;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& leg = found->second;
        const bool stop_or_limit = leg.family == PineOrderFamily::ExitStop
            || leg.family == PineOrderFamily::ExitLimit;
        double trail_activation = leg.exit_levels.trail_price;
        if (!finite_positive(trail_activation)
            && finite_positive(leg.exit_levels.trail_points)
            && finite_positive(staged_.syminfo.mintick)) {
            trail_activation = require_host().position_avg_price()
                + (physical.signed_units > 0.0 ? 1.0 : -1.0)
                    * leg.exit_levels.trail_points * staged_.syminfo.mintick;
            trail_activation = directional_tick(
                trail_activation, staged_.syminfo.mintick,
                physical.signed_units > 0.0);
        }
        const bool omitted_offset_trail = leg.family == PineOrderFamily::ExitTrail
            && !std::isfinite(leg.exit_levels.trail_offset)
            && finite_positive(trail_activation);
        const bool exit_is_buy = physical.signed_units < 0.0;
        const double priced_level = leg.family == PineOrderFamily::ExitStop
            ? leg.exit_levels.stop : leg.exit_levels.limit;
        const bool gapped_priced_leg = stop_or_limit && finite_positive(priced_level)
            && (physical.signed_units > 0.0
                ? (leg.family == PineOrderFamily::ExitStop
                    ? bar.open <= priced_level : bar.open >= priced_level)
                : (leg.family == PineOrderFamily::ExitStop
                    ? bar.open >= priced_level : bar.open <= priced_level));
        const bool reorder_priced_leg = gapped_priced_leg
            && (!gap_decline || opening_margin_slice);
        // A declined reversal makes a standing non-gapped bracket dormant; it
        // does not delete it.  Only a leg already marketable at this opening
        // needs the L5b reorder/retirement path.  The broader condition erased
        // REVIVE-B's later margin restoration before the margin event existed.
        const bool retire_priced_leg = gapped_priced_leg
            && (gap_decline || reorder_priced_leg);
        const bool retire_trail = gap_decline && omitted_offset_trail;
        if ((!retire_priced_leg && !retire_trail)
            || (!leg.from_entry.empty()
                && !(cohort_exposure_for(leg.from_entry) > 0.0))) {
            continue;
        }
        std::optional<PendingBracketLeg> delayed;
        std::optional<PlacementSnapshot> margin_revival;
        bool release_at_open = false;
        if (reorder_priced_leg) {
            native_order::Request request;
            request.intent = native_order::HostSized{
                native_order::HostSizedKind::Close, std::nullopt};
            request.label = leg.source_id;
            request.comment = leg.comment;
            // Defer the gapped bracket until the first later waypoint so the
            // already-accepted opposite MARKET is adjudicated at O first.
            // The source report still settles at the saved gap-open price.
            const double deferred_level = physical.signed_units > 0.0
                ? bar.low : bar.high;
            request.trigger = native_order::Stop{source_trigger_threshold(
                deferred_level, staged_.syminfo.mintick, exit_is_buy, false)};
            request.owner = owner_for_close(leg.from_entry, true);
            const std::string group_name = leg.oca_name.empty()
                ? leg.source_id + "\x1f" + leg.from_entry : leg.oca_name;
            request.group = group_for(group_name, 1);
            const std::string replacement_key = leg.source_id + "\x1f"
                + leg.from_entry + std::to_string(static_cast<int>(leg.family));
            PlacementSnapshot reordered = leg;
            reordered.forced_execution_price = open_fill;
            delayed.emplace(PendingBracketLeg{
                std::move(request), std::move(reordered), replacement_key,
                key_for(leg.source_id, leg.from_entry)});
            release_at_open = true;
        } else if (retire_trail) {
            const bool long_position = physical.signed_units > 0.0;
            const bool activated_at_open = long_position
                ? bar.open >= trail_activation
                : bar.open <= trail_activation;
            if (!activated_at_open) {
                native_order::Request request;
                request.intent = native_order::HostSized{
                    native_order::HostSizedKind::Close, std::nullopt};
                request.label = leg.source_id;
                request.comment = leg.comment;
                request.trigger = native_order::Limit{
                    directional_tick(trail_activation,
                                     staged_.syminfo.mintick,
                                     exit_is_buy)};
                request.owner = owner_for_close(leg.from_entry, true);
                const std::string group_name = leg.oca_name.empty()
                    ? leg.source_id + "\x1f" + leg.from_entry : leg.oca_name;
                request.group = group_for(group_name, 1);
                const std::string replacement_key = leg.source_id + "\x1f"
                    + leg.from_entry
                    + std::to_string(static_cast<int>(PineOrderFamily::ExitTrail));
                delayed.emplace(PendingBracketLeg{
                    std::move(request), leg, replacement_key,
                    key_for(leg.source_id, leg.from_entry)});
            }
        }
        if (gap_decline && leg.family == PineOrderFamily::ExitStop
            && !reorder_priced_leg) {
            margin_revival = leg;
        }
        retired_legs.push_back({handle, std::move(delayed),
                                std::move(margin_revival), release_at_open});
    }
    for (auto& retired : retired_legs) {
        const auto result = require_host().cancel(retired.handle);
        if (result.status != native_order::CancelStatus::Cancelled) continue;
        if (const auto found = placement_.find(retired.handle.incarnation);
            found != placement_.end()) {
            found->second.cancellation = {
                PineCancellationCause::Dependency, 1, 0,
                retired.handle.incarnation,
                static_cast<std::int64_t>(found->second.source_sequence),
                retired.handle.incarnation, found->second.placement_cycle,
                found->second.legs.revision(), found->second.requested_qty, kNaN};
        }
        retire(retired.handle);
        if (retired.margin_revival) {
            pending_margin_revivals_.push_back({
                std::move(*retired.margin_revival),
                context.coordinate.interval_index});
        }
        if (retired.delayed_leg) {
            if (retired.release_at_open) {
                auto reordered = std::move(*retired.delayed_leg);
                const auto accepted = submit_or_replace(
                    std::move(reordered.request), std::move(reordered.snapshot),
                    false, reordered.replacement_key);
                if (accepted)
                    bracket_family(reordered.family_key).push_back(*accepted);
            } else if (defer_trails) {
                auto delayed = std::move(*retired.delayed_leg);
                delayed_market_orders_.push_back({
                    std::move(delayed.request), std::move(delayed.snapshot),
                    std::move(delayed.replacement_key), broker_open_epoch_ + 1U});
            } else {
                pending_write(pending_bracket_legs_).push_back(std::move(*retired.delayed_leg));
            }
        }
    }
}
 
void PineExecutionAdapter::reaccept_gapped_bracket_behind_same_id_add(
        const Bar& bar, const NativeDecisionContext& context) {
    // ab9714be pine_fills.cpp:3799-3845 (samebar_add_exit_first): a
    // from_entry PRICED bracket leg gapped through at the open and its own
    // same-id pure MARKET pyramid add both fill at the opening tick, where
    // the owner's priority is buy-market(1) > sell-market(2) > gapped
    // limit(3); a long's gapped stop is a sell (2), a short's a buy (1).
    // Unless the leg strictly precedes, the add is judged first against the
    // still-open position (pyramiding cap, pine_orders.cpp:738, and margin)
    // and the leg then closes the id, covering the add
    // (pine_fills.cpp:7026-7033).  The native matcher breaks a same-point tie
    // by incarnation, so the older leg would flatten the book and the add
    // would open from flat.  Re-accept the unchanged leg at this opening: its
    // fresh incarnation orders it behind the add at the same open point.
    if (config_.process_orders_on_close || !modeled_input() || coof_recalc_active_
        || context.sub_index != 0) {
        return;
    }
    const auto physical = detail::run_position(require_host());
    if (physical.signed_units == 0.0) return;
    const bool long_position = physical.signed_units > 0.0;
    // A from_entry "" exit that sizes on the position it fills against
    // (fill_time_global_exit) covers an add of ANY id the same way: TradingView
    // judges the market add first at the shared open and then closes both lots
    // with the exit, whether the script placed the exit before or after the add
    // (lab tv w4-f19a-plain cells A, B and G; lane W4-ENG-POOC-SAMEPASS).
    const auto pure_market_add = [&](const PlacementSnapshot& add,
                                     const SourceId& from_entry) {
        return add.opening
            && (add.family == PineOrderFamily::Entry
                || add.family == PineOrderFamily::Order)
            && (from_entry.empty() || add.source_id == from_entry)
            && add.is_long == long_position
            && !finite_positive(add.exit_levels.limit)
            && !finite_positive(add.exit_levels.stop)
            && !finite_positive(add.exit_levels.trail_points)
            && !finite_positive(add.exit_levels.trail_price)
            && !finite_positive(add.exit_levels.trail_offset)
            && !add.birth.from_fill() && !add.birth.at_terminal_fill();
    };
    std::vector<native_order::RequestHandle> gapped;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& leg = found->second;
        const bool global_leg = leg.from_entry.empty() && fill_time_global_exit(leg);
        // The same-id order is the owner's without calc_on_order_fills
        // only; TradingView's from_entry "" order holds with it too
        // (w4-f19a-plain-coof cell B).
        if (config_.calc_on_order_fills && !global_leg) continue;
        if ((leg.family != PineOrderFamily::ExitStop
                && leg.family != PineOrderFamily::ExitLimit)
            || (leg.from_entry.empty() && !global_leg) || !leg.deferred_cohort
            || std::isfinite(leg.requested_qty)
            || (!global_leg && std::isfinite(leg.qty_percent)
                && leg.qty_percent < 100.0 - 1e-9)
            || finite_positive(leg.exit_levels.trail_points)
            || finite_positive(leg.exit_levels.trail_price)
            || finite_positive(leg.exit_levels.trail_offset)
            || (!global_leg && !(cohort_exposure_for(leg.from_entry) > 0.0))) {
            continue;
        }
        int exit_priority = 0;
        if (leg.family == PineOrderFamily::ExitStop && finite_positive(leg.exit_levels.stop)
            && (long_position ? bar.open <= leg.exit_levels.stop
                              : bar.open >= leg.exit_levels.stop)) {
            exit_priority = long_position ? 2 : 1;
        } else if (leg.family == PineOrderFamily::ExitLimit
                   && finite_positive(leg.exit_levels.limit)
                   && (long_position ? bar.open >= leg.exit_levels.limit
                                     : bar.open <= leg.exit_levels.limit)) {
            exit_priority = 3;
        }
        const int add_priority = long_position ? 1 : 2;
        if (exit_priority == 0 || exit_priority < add_priority) continue;
        const bool add_waits = std::any_of(live_handles_.begin(), live_handles_.end(),
            [&](const native_order::RequestHandle& live) {
                if (live.incarnation < handle.incarnation) return false;
                const auto add = placement_.find(live.incarnation);
                return add != placement_.end()
                    && pure_market_add(add->second, leg.from_entry);
            });
        if (add_waits) gapped.push_back(handle);
    }
    const bool exit_is_buy = !long_position;
    const double tick = staged_.syminfo.mintick;
    for (const auto& handle : gapped) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        PlacementSnapshot leg = found->second;
        const auto result = require_host().cancel(handle);
        if (result.status != native_order::CancelStatus::Cancelled) continue;
        found->second.cancellation = {
            PineCancellationCause::Dependency, 1, 0, handle.incarnation,
            static_cast<std::int64_t>(leg.source_sequence), handle.incarnation,
            leg.placement_cycle, leg.legs.revision(), leg.requested_qty, kNaN};
        retire(handle);
        native_order::Request request;
        request.intent = native_order::HostSized{
            native_order::HostSizedKind::Close, std::nullopt};
        request.label = leg.source_id;
        request.comment = leg.comment;
        if (leg.family == PineOrderFamily::ExitStop) {
            request.trigger = native_order::Stop{source_trigger_threshold(
                leg.exit_levels.stop, tick, exit_is_buy, false)};
        } else {
            const double snapped = nearest_tick(leg.exit_levels.limit, tick);
            request.trigger = native_order::Limit{
                !finite_positive(tick) || snapped == leg.exit_levels.limit
                    ? leg.exit_levels.limit
                    : source_trigger_threshold(leg.exit_levels.limit, tick,
                                               exit_is_buy, true)};
            // A limit accepted at this opening would book its own level; the
            // owner's gapped limit fills limit-or-better at the open print.
            leg.forced_execution_price = source_bar_fill_tick(bar.open, tick);
        }
        request.owner = owner_for_close(leg.from_entry, true);
        const std::string group_name = leg.oca_name.empty()
            ? leg.source_id + "\x1f" + leg.from_entry : leg.oca_name;
        request.group = group_for(group_name, 1, static_cast<std::int64_t>(leg.family));
        leg.cancellation = {};
        const std::uint64_t family_key = key_for(leg.source_id, leg.from_entry);
        const SourceId replacement_key = leg.source_id + "\x1f" + leg.from_entry
            + std::to_string(static_cast<int>(leg.family));
        const auto accepted = submit_or_replace(
            std::move(request), std::move(leg), false, replacement_key);
        if (accepted) bracket_family(family_key).push_back(*accepted);
    }
}
 
void PineExecutionAdapter::order_open_marketable_limit_entries(
        const Bar& bar, const NativeDecisionContext& context) {
    // TradingView fills the orders executable at a bar's opening price in
    // this order: every MARKET order first, entries and exits alike, then the
    // buy LIMIT entries the open has already reached, lowest limit first,
    // whether a limit was placed at the previous close or has rested since an
    // earlier bar; neither the order they were placed in nor their ids decide
    // (R-A, tests/fixtures/open_fill_order). The native matcher breaks a
    // same-point tie by queue order, so re-pricing each such entry in place
    // (ReplaceOptions::keep_handle), lowest limit first, takes them behind
    // every other request in that order. Each still books the opening print,
    // as it would have at its own place in the queue.
    if (config_.process_orders_on_close || config_.calc_on_order_fills
        || !modeled_input() || coof_recalc_active_ || context.sub_index != 0) {
        return;
    }
    const double open_fill = source_bar_fill_tick(bar.open, staged_.syminfo.mintick);
    const auto marketable = [&](const PlacementSnapshot& row) {
        return row.family == PineOrderFamily::Entry && row.opening && row.is_long
            && finite_positive(row.exit_levels.limit) && !finite_positive(row.exit_levels.stop)
            && !finite_positive(row.exit_levels.trail_points)
            && !finite_positive(row.exit_levels.trail_price)
            && !finite_positive(row.exit_levels.trail_offset)
            && open_fill <= row.exit_levels.limit;
    };
    if (!has_live_family(PineOrderFamily::Entry) || !any_live_row(live_handles_, placement_, marketable)) return;
    // A flat book holding MARKET entries of both sides is the opposite-pair
    // family, whose own route decides its open: TradingView fills that pair
    // before the limit too, and also books the pair's later call as one
    // transaction admitted at its gross (tape r1c-ra-prior-limit cells M and
    // N), which this route does not model.
    const auto market_entry = [](const PlacementSnapshot& row, bool is_long) {
        return row.family == PineOrderFamily::Entry && row.opening && row.is_long == is_long
            && !finite_positive(row.exit_levels.limit) && !finite_positive(row.exit_levels.stop);
    };
    if (detail::run_position(require_host()).signed_units == 0.0
        && any_live_row(live_handles_, placement_,
                        [&](const PlacementSnapshot& row) { return market_entry(row, true); })
        && any_live_row(live_handles_, placement_,
                        [&](const PlacementSnapshot& row) { return market_entry(row, false); })) {
        return;
    }
    auto& host = require_host();
    struct Marketable {
        native_order::RequestHandle handle;
        native_order::Request request;
        double level = 0.0;
        std::uint64_t priority = 0;
    };
    std::vector<Marketable> limits;
    std::uint64_t last_market = 0;
    for (const auto& working : host.native_working_requests()) {
        const auto& definition = *working.definition;
        const std::uint64_t priority = definition.priority != 0
            ? definition.priority : definition.handle.incarnation;
        if (std::holds_alternative<native_order::Market>(definition.request.trigger)) {
            last_market = std::max(last_market, priority);
            continue;
        }
        const auto* limit = std::get_if<native_order::Limit>(&definition.request.trigger);
        if (!limit || open_fill > limit->price) continue;
        const auto found = placement_.find(definition.handle.incarnation);
        if (found == placement_.end() || !marketable(found->second)) continue;
        limits.push_back({definition.handle, definition.request, limit->price, priority});
    }
    std::sort(limits.begin(), limits.end(), [](const auto& left, const auto& right) {
        return left.priority < right.priority;
    });
    bool in_order = true;
    for (std::size_t i = 0; i < limits.size(); ++i) {
        if (limits[i].priority < last_market
            || (i > 0 && limits[i].level < limits[i - 1].level)) {
            in_order = false;
        }
    }
    if (in_order) return;
    std::stable_sort(limits.begin(), limits.end(), [](const auto& left, const auto& right) {
        return left.level < right.level;
    });
    // A priced entry keeps a host-resolved quantity (entry(): only an
    // unpriced default quantity is lowered onto the core's Sized intent), so
    // the same request re-prices with nothing frozen to re-measure.
    native_order::ReplaceOptions reprice;
    reprice.keep_handle = true;
    for (const auto& row : limits) {
        const auto result = host.replace(row.handle, row.request, reprice);
        if (result.status != native_order::ReplaceStatus::Replaced) continue;
        if (const auto found = placement_.find(row.handle.incarnation);
            found != placement_.end()) {
            found->second.forced_execution_price = open_fill;
        }
    }
}
 
void PineExecutionAdapter::apply_terminal_explicit_market_policy(
        const NativeDecisionContext& context) {
    apply_terminal_explicit_market_policy(context, true);
}
 
// With `execute_now` false the pass only submits: the reconciled entries stay
// working for the matcher, which fills them where a source replay of the last
// pre-T bar opens. The cancellations and re-submissions are the same either way.
void PineExecutionAdapter::apply_terminal_explicit_market_policy(
        const NativeDecisionContext& context, bool execute_now) {
    if (!config_.process_orders_on_close
        || config_.pyramiding != 0 || !modeled_input()) {
        return;
    }
    struct Candidate {
        native_order::RequestHandle handle;
        PlacementSnapshot snapshot;
        std::uint64_t priority = 0;
    };
    std::vector<Candidate> candidates;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& row = found->second;
        if (!row.opening || row.family != PineOrderFamily::Entry
            || row.projection_created_bar != projection_bar_index(context)
            || !finite_positive(row.requested_qty)
            || finite_positive(row.exit_levels.limit)
            || finite_positive(row.exit_levels.stop)
            || !row.oca_name.empty() || row.oca_type != 0
            || row.birth.from_fill() || row.birth.at_terminal_fill()
            || compat::pine::historical_cascade_reach(row.birth_reach)) {
            continue;
        }
        // The source sequence of the oldest row the predecessor chain
        // reaches, fixed when the row was remembered (its older rows may
        // have been erased since).
#if PINEFORGE_PLACEMENT_AUDIT
        {
            // The walk the field replaces, over the retained and the erased
            // rows alike: a difference is an audit hit on this line.
            const PlacementSnapshot* origin = &row;
            std::unordered_set<std::uint64_t> seen;
            const auto* stones = detail::placement_audit_tombstones(&placement_);
            while (origin->projection_predecessor != 0
                && seen.insert(origin->projection_predecessor).second) {
                const auto prior = placement_.find(origin->projection_predecessor);
                if (prior != placement_.end()) {
                    origin = &prior->second;
                    continue;
                }
                const PlacementSnapshot* stone = nullptr;
                if (stones) {
                    for (const auto& entry : *stones)
                        if (entry.first == origin->projection_predecessor) stone = entry.second;
                }
                if (!stone) break;
                origin = stone;
            }
            if (origin->source_sequence != row.chain_origin_sequence)
                detail::placement_audit_scan_hit(&placement_, handle.incarnation, __LINE__);
        }
#endif
        candidates.push_back({handle, row, row.chain_origin_sequence});
    }
    if (candidates.size() < 2) return;
    std::stable_sort(candidates.begin(), candidates.end(),
        [](const Candidate& left, const Candidate& right) {
            if (left.priority != right.priority) return left.priority < right.priority;
            return left.snapshot.source_sequence < right.snapshot.source_sequence;
        });
    std::vector<native_order::RequestHandle> terminal_review_handles;
    terminal_review_handles.reserve(candidates.size());
    for (const auto& candidate : candidates)
        terminal_review_handles.push_back(candidate.handle);
 
    const auto& first = candidates[0].snapshot;
    const auto& second = candidates[1].snapshot;
    // The gross decline holds under process_orders_on_close alone and with
    // costs as well: a flat pair of opposite fixed-quantity calls whose gross
    // is over the equity keeps only its earlier call (lab tv tapes
    // tests/fixtures/pooc_pair_gross hel-h1-pooc-pair-gross-slip, with
    // slippage 1 and a 0.01 % commission, and hel-h2-pooc-pair-gross-zero;
    // lane TAIL-D).
    const bool clean_pair = candidates.size() == 2
        && config_.margin_long == 100.0 && config_.margin_short == 100.0
        && entry_attempt_bar_ == context.coordinate.interval_index
        && entry_attempts_on_bar_ == 2
        && first.projection_predecessor == 0 && second.projection_predecessor == 0
        && first.recreated_after_named_cancelled_entry_incarnation == 0
        && second.recreated_after_named_cancelled_entry_incarnation == 0
        && first.source_id != second.source_id && first.is_long != second.is_long
        && compat::pine::explicit_qualification(first.market_admission)
        && compat::pine::explicit_qualification(second.market_admission);
    if (clean_pair) {
        const double required = (first.requested_qty + second.requested_qty)
            * second.sizing.price * staged_.syminfo.pointvalue * second.sizing.fx;
        const double equity = std::min(first.sizing.equity, second.sizing.equity);
        const double guard = std::max(1e-9, std::abs(equity) * 1e-12);
        if (std::isfinite(required) && std::isfinite(equity)
            && required > equity + guard) {
            const auto result = require_host().cancel(candidates[1].handle);
            if (result.status == native_order::CancelStatus::Cancelled)
                retire(candidates[1].handle);
            candidates.resize(1);
        }
    }
    record_market_review(admission::Checkpoint::TerminalGross,
                         projection_bar_index(context),
                         terminal_review_handles);
 
    // ab9714be pine_fills.cpp:3023-3270 and pine_orders.cpp:193-276:
    // outside the exact gross-decline book, explicit opposite entry calls
    // retain source order and each later opposite call is a full ReverseTo,
    // not a pair of net Transact deltas from the shared flat placement state.
    for (const auto& candidate : candidates) {
        const auto result = require_host().cancel(candidate.handle);
        if (result.status == native_order::CancelStatus::Cancelled)
            retire(candidate.handle);
    }
    // TradingView fills the buy of a flat sell-then-buy pair first at the
    // close (order_same_point_entries' order): the later buy is one
    // transaction of its own quantity plus the pending sell's, and the sell
    // then trades only its own (lab tv w6-f10d-pooc-pair, w6-f10e-pooc-coof-
    // pair MM-SF). A buy-first pair keeps the source order below.
    const bool buy_first = candidates.size() == 2 && !candidates[0].snapshot.is_long
        && candidates[1].snapshot.is_long
        && detail::run_position(require_host()).signed_units == 0.0;
    if (buy_first) std::swap(candidates[0], candidates[1]);
    int simulated_sign = 0;
    for (auto& candidate : candidates) {
        native_order::Request request;
        const int requested_sign = candidate.snapshot.is_long ? 1 : -1;
        const double signed_units = requested_sign * candidate.snapshot.requested_qty;
        if (buy_first) {
            const double pending_sell = candidate.snapshot.is_long
                ? candidates[1].snapshot.requested_qty : 0.0;
            request.intent = native_order::Transact{signed_units + pending_sell};
            candidate.snapshot.reverse_to = false;
        } else if (simulated_sign != 0 && simulated_sign != requested_sign) {
            request.intent = native_order::ReverseTo{signed_units};
            candidate.snapshot.reverse_to = true;
        } else {
            request.intent = native_order::Transact{signed_units};
            candidate.snapshot.reverse_to = false;
        }
        request.label = candidate.snapshot.source_id;
        request.comment = candidate.snapshot.comment;
        const SourceId replacement_key = candidate.snapshot.source_id;
        candidate.snapshot.market_admission = {};
        const auto accepted = submit_or_replace(
            std::move(request), std::move(candidate.snapshot), true,
            replacement_key);
        if (accepted) {
            simulated_sign = requested_sign;
            if (execute_now) {
                (void)require_host().execute_current(
                    {*accepted, NativeCurrentPriceRule::NearestTick});
            }
        }
    }
}
 
namespace {
// A priced request the Pine layer only ever places as a plain stop, which a
// COOF recalculation may rest from its leg's extreme as a trail pinned there
// (entry(), exit()): an entry stop, or an exit stop that names no trail.
bool rested_stop_family(const PlacementSnapshot& row) noexcept {
    if (!finite_positive(row.exit_levels.stop)) return false;
    if (row.family == PineOrderFamily::Entry) return true;
    return row.family == PineOrderFamily::ExitStop
        && std::isnan(row.exit_levels.trail_points)
        && std::isnan(row.exit_levels.trail_price)
        && std::isnan(row.exit_levels.trail_offset);
}
} // namespace
 
void PineExecutionAdapter::on_bar_open(const Bar& bar, const NativeDecisionContext& context) {
    // The script bar this opening follows, before it is replaced below: a
    // short process_orders_on_close filled at its close is margined at that
    // close (the opening slice below).
    const Bar prior_policy_bar = policy_script_bar_;
    const bool prior_policy_bar_valid = policy_script_bar_valid_;
    // Terminal entry refusals have no Applied notification.  Consume their
    // generic receipt before the next matching point so their deferred
    // per-origin bracket legs cannot close a different cohort member.
    observe_terminal_receipts();
    erase_retired_rows(context);
    release_closed_cohort_origins();
    retire_origin_prefixes();
    restore_carried_trail_retunes();
    trail_state_at_open_.clear();
    unrepeated_margin_calls_.clear();
    // An opening checkpoint after an open's exits is due only there (on_applied).
    if (PF_RARE(open_exit_first_bar_ != std::numeric_limits<std::int64_t>::min())) {
        open_exit_first_bar_ = std::numeric_limits<std::int64_t>::min();
        open_exit_first_origin_ = 0;
        open_exit_first_id_.clear();
        open_exit_first_fill_ = 0.0;
    }
    bool rested_entry_stop = false;
    if (has_live_trail_policy()) for (const auto& handle : live_handles_) {
        const auto placement = placement_.find(handle.incarnation);
        if (placement == placement_.end()) continue;
        if (rested_stop_family(placement->second)) {
            rested_entry_stop = rested_entry_stop
                || (finite_positive(placement->second.forced_execution_price)
                    && require_host().trail_state(handle).has_value());
            continue;
        }
        if (placement->second.family != PineOrderFamily::ExitTrail) continue;
        if (const auto state = require_host().trail_state(handle))
            trail_state_at_open_.emplace(handle.incarnation, *state);
    }
    // A stop entry() or exit() rested from its leg's extreme rode a trail
    // pinned at that extreme for the rest of its bar; from this opening on it
    // is the plain stop at its own level again, gap-filled at an open beyond
    // it.
    if (rested_entry_stop) {
        auto& host = require_host();
        native_order::ReplaceOptions keep;
        keep.keep_handle = true;
        for (const auto& working : host.native_working_requests()) {
            const auto& definition = *working.definition;
            if (!std::holds_alternative<native_order::Trail>(definition.request.trigger))
                continue;
            const auto found = placement_.find(definition.handle.incarnation);
            if (found == placement_.end() || !rested_stop_family(found->second)) continue;
            native_order::Request plain = definition.request;
            plain.trigger = native_order::Stop{found->second.exit_levels.stop};
            const auto result = host.replace(definition.handle, plain, keep);
            if (result.status == native_order::ReplaceStatus::Replaced)
                found->second.forced_execution_price = kNaN;
        }
    }
    // The preceding source broker batch is complete at this next opening.
    // This is deliberately after any POOC after-calculation matching of the
    // prior script bar, so a same-batch cap transfer remains available to its
    // designated sibling.
    source_batch_end();
    if (config_.process_orders_on_close && !config_.calc_on_order_fills
        && config_.pyramiding > 0 && margins_disabled()
        && detail::exit_binding_rule_switches().priced_add_at_cap_not_placed) {
        withdraw_unplaced_cap_adds(context);
    }
    if (context.coordinate.interval_index != entry_openings_interval_index_) {
        entry_openings_interval_index_ = context.coordinate.interval_index;
        entry_openings_this_interval_ = 0;
    }
    if (context.script_bar_open_ms != last_broker_open_ms_) {
        last_broker_open_ms_ = context.script_bar_open_ms;
        ++broker_open_epoch_;
    }
    // Quiet-bar gates (pine_quiet_bar.hpp): a policy hook below whose body
    // has nothing to act on at this opening is not called at all. Each
    // condition is that hook's own no-op precondition.
    using detail::QuietHook;
    using detail::skip_quiet;
    // ab9714be prearmed pending-entry legs become executable at the next
    // broker opening, before that bar's path is matched. Releasing them only
    // from the later source close callback misses the intended bar.
    // Quiet: no order is delayed.
    if (!skip_quiet(QuietHook::DelayedRelease, delayed_market_orders_.empty()))
        release_delayed_orders(/*explicit_brackets_only=*/true, bar.open);
    activate_short_seed_plan_at_open(context);
    // Quiet: OrderPriority::select ranks only a pair of live candidates, and
    // only for an attached retained-parent rule on a close-order run outside
    // fill recalculation; otherwise it answers nothing and the book keeps
    // its order.
    if (!skip_quiet(QuietHook::L4cPriority,
            !priority.attached() || !priority.retained_parent_first()
            || !config_.process_orders_on_close || config_.calc_on_order_fills
            || coof_recalc_active_ || live_handles_.size() < 2)) {
        update_l4c_priority();
    }
    // Quiet: every admission candidate is a live entry the previous source
    // bar placed; without one no pair or pyramiding rule applies, nothing is
    // cancelled and both reviews see no handle.
    const int source_bar = context.coordinate.interval_index - 1;
    if (!skip_quiet(QuietHook::OpenMarketAdmission, !has_live_family(PineOrderFamily::Entry) ||
            !any_live_row(live_handles_, placement_, [&](const PlacementSnapshot& row) {
                return row.family == PineOrderFamily::Entry
                    && row.projection_created_bar == source_bar;
            }))) {
        apply_open_market_admission(context);
    }
    // Quiet: a sell is deferred only when both a live pure-stop buy entry and
    // a live pure-stop sell entry are marketable at the fill point (the close
    // under process_orders_on_close, else the open).
    const double sell_fill_point = config_.process_orders_on_close ? bar.close : bar.open;
    const auto marketable_stop_entry = [&](bool is_long) {
        return has_live_family(PineOrderFamily::Entry) && any_live_row(live_handles_, placement_, [&](const PlacementSnapshot& row) {
            return row.is_long == is_long
                && pure_stop_entry_marketable_at(row, sell_fill_point);
        });
    };
    if (!skip_quiet(QuietHook::OpenMarketableSells,
            config_.calc_on_order_fills || !modeled_input()
            || !marketable_stop_entry(true) || !marketable_stop_entry(false))) {
        defer_open_marketable_sells(bar);
    }
    // Quiet: a gapped leg is re-accepted only behind a live pure market add
    // of its own id (of any id for a from_entry "" exit), which is an
    // opening entry or order.
    if (!skip_quiet(QuietHook::GappedBracketReaccept,
            !any_live_row(live_handles_, placement_, [](const PlacementSnapshot& row) {
                return row.opening && (row.family == PineOrderFamily::Entry
                                       || row.family == PineOrderFamily::Order);
            }))) {
        reaccept_gapped_bracket_behind_same_id_add(bar, context);
    }
    order_open_marketable_limit_entries(bar, context);
    pending_write(source_shadow_pending_).clear();
    coof_script_bar_ = bar;
    coof_script_bar_valid_ = true;
    policy_script_bar_ = bar;
    policy_script_bar_valid_ = true;
    if (modeled_input() && !context.driver_statistics.intrabar_path_enabled
        && !trail_state_at_open_.empty()) {
        const double open_tick = source_bar_fill_tick(bar.open, staged_.syminfo.mintick);
        native_order::ReplaceOptions keep;
        keep.keep_handle = true;
        for (const auto& working : require_host().native_working_requests()) {
            const auto& definition = *working.definition;
            const auto carried = trail_state_at_open_.find(definition.handle.incarnation);
            const auto found = placement_.find(definition.handle.incarnation);
            if (carried == trail_state_at_open_.end() || !carried->second.activated
                || found == placement_.end()
                || !std::holds_alternative<native_order::Trail>(definition.request.trigger)
                || !(found->second.exit_levels.trail_offset >= 1.0)) {
                continue;
            }
            const double held_units = detail::run_position(require_host()).signed_units;
            if (held_units == 0.0) continue;
            const bool is_buy = held_units < 0.0;
            const double level = carried->second.current_level;
            const bool raw_reached = is_buy ? bar.open >= level : bar.open <= level;
            const bool print_reached = is_buy ? open_tick >= level : open_tick <= level;
            if (raw_reached || !print_reached) continue;
            native_order::Request request = definition.request;
            request.trigger = native_order::Market{};
            const auto replaced = require_host().replace(definition.handle, request, keep);
            if (replaced.status != native_order::ReplaceStatus::Replaced) continue;
            found->second.forced_execution_price = open_tick
                + (is_buy ? 1.0 : -1.0) * config_.slippage * staged_.syminfo.mintick;
            (void)require_host().execute_current(
                {definition.handle, NativeCurrentPriceRule::NearestTick});
        }
    }
    retune_carried_trails_for_tick_reach(bar, context);
    // The C observer snapshots the ordinary flat two-stop arbitration at the
    // bar boundary, before either native request can fill or be declined.
    // COOF has its own callback scheduling and deliberately leaves this
    // ordinary-path projection untouched, matching the legacy contract.
    last_bar_dual_entry_path_ = 0;
    last_bar_dual_entry_script_open_ms_ = context.script_bar_open_ms;
    // Quiet: a path is recorded only when this bar touches two live flat
    // stop entries, each by its own side's test.
    const auto touched_stop_entry = [&](const PlacementSnapshot& row) {
        return row.family == PineOrderFamily::Entry
            && finite_positive(row.exit_levels.stop)
            && !std::isfinite(row.exit_levels.limit)
            && !finite_positive(row.exit_levels.trail_offset)
            && (row.is_long ? bar.high >= row.exit_levels.stop
                            : bar.low <= row.exit_levels.stop);
    };
    std::size_t touched_stop_entries = 0;
    if (has_live_family(PineOrderFamily::Entry)) for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found != placement_.end() && touched_stop_entry(found->second))
            ++touched_stop_entries;
    }
    if (!skip_quiet(QuietHook::DualEntryPath, touched_stop_entries < 2)
        && !config_.calc_on_order_fills && detail::run_position(require_host()).signed_units == 0.0) {
        std::vector<const PlacementSnapshot*> stops;
        for (const auto& handle : live_handles_) {
            const auto found = placement_.find(handle.incarnation);
            if (found == placement_.end()) continue;
            const auto& snapshot = found->second;
            if (snapshot.family != PineOrderFamily::Entry
                || !finite_positive(snapshot.exit_levels.stop)
                || std::isfinite(snapshot.exit_levels.limit)
                || finite_positive(snapshot.exit_levels.trail_offset)) {
                continue;
            }
            stops.push_back(&snapshot);
        }
        if (stops.size() == 2 && stops[0]->is_long != stops[1]->is_long) {
            const auto* long_stop = stops[0]->is_long ? stops[0] : stops[1];
            const auto* short_stop = stops[0]->is_long ? stops[1] : stops[0];
            const bool long_touched = bar.high >= long_stop->exit_levels.stop;
            const bool short_touched = bar.low <= short_stop->exit_levels.stop;
            if (long_touched && short_touched) {
                // The leg the run walks first, asked of the kernel: under Auto
                // a tie bar walks the low leg first and fills the short entry.
                last_bar_dual_entry_path_ = source_path_uses_high_first(bar) ? 1 : 2;
            }
        }
    }
    // Quiet: no fill recalculation left a request staged.
    if (!skip_quiet(QuietHook::CoofTail, pending_coof_requests_.empty()))
        flush_coof_tail(/*openings_only=*/false, /*include_next_open=*/true);
    // Quiet: brackets are suspended only for a live opening reversal entry.
    const auto opening_reversal_entry = [](const PlacementSnapshot& row) {
        return row.opening && row.family == PineOrderFamily::Entry && row.reverse_to;
    };
    if (!skip_quiet(QuietHook::CoofDeclinedReversal, !has_live_family(PineOrderFamily::Entry) ||
            !any_live_row(live_handles_, placement_, opening_reversal_entry))) {
        suspend_coof_declined_reversal_at_open(bar, context);
    }
    if (close_all_pending_script_bar_ != context.script_bar_open_ms)
        close_all_pending_script_bar_ = std::numeric_limits<std::int64_t>::min();
    pooc_open_script_bar_ = context.script_bar_open_ms;
    pooc_open_basis_ = std::abs(detail::run_position(require_host()).signed_units);
    day_ledger_.current_day = chart_day_key(context.sub_bar_open_ms);
    if (day_ledger_.intraday_loss_day != day_ledger_.current_day) {
        day_ledger_.intraday_loss_day = day_ledger_.current_day;
        day_ledger_.intraday_start_equity = require_host().native_marked_equity(bar.open);
        day_ledger_.intraday_start_script_bar = context.script_bar_open_ms;
        day_ledger_.intraday_realized = 0.0;
    }
    // Quiet: no filled-orders cap close is due.
    if (!skip_quiet(QuietHook::DueCapClose, !cap.due_cause().has_value()))
        execute_due_cap_close(context);
    apply_fx_open_margin_slice(bar, context);
    (void)submit_slipped_pooc_opening_money_call(bar, context);
    const bool close_call_queued = prior_policy_bar_valid
        && close_point_margin_call_at_open(bar, prior_policy_bar, context);
    // The previous close's after-script call is read only by the orders that
    // close placed, which fill at this open (apply_frozen_reversal_close).
    if (PF_RARE(close_call_after_script_bar_ != std::numeric_limits<std::int64_t>::min())
        && (!prior_policy_bar_valid || close_call_after_script_bar_ != prior_policy_bar.timestamp)) {
        close_call_after_script_bar_ = std::numeric_limits<std::int64_t>::min();
        close_call_after_script_book_ = 0.0;
        close_call_after_script_units_ = 0.0;
    }
    // A follow-up the previous close owes this open (walk_short_path_points),
    // booked ahead of the open's own check.
    if (PF_RARE(owed_follow_up_bar_ != std::numeric_limits<std::int64_t>::min())) {
        if (prior_policy_bar_valid && owed_follow_up_bar_ == prior_policy_bar.timestamp
            && owed_follow_up_point_ == 4 && short_path_points_scope(context)) {
            owed_follow_up_bar_ = context.script_bar_open_ms;
            owed_follow_up_point_ = 0;
            execute_owed_short_follow_up(0, bar.open, context);
        } else if (owed_follow_up_bar_ != context.script_bar_open_ms) {
            owed_follow_up_bar_ = std::numeric_limits<std::int64_t>::min();
            owed_follow_up_point_ = -1;
            owed_follow_up_units_ = 0.0;
        }
    }
    const auto opening_position = detail::run_position(require_host());
    const bool long_full_margin = opening_position.signed_units > 0.0
        && std::abs(config_.margin_long - 100.0) < 1e-12;
    // A full-margin long that a commissioned process_orders_on_close fill
    // opened at the previous bar's close is called at this open, not at that
    // fill (on_applied, called_at_next_open): the units the fill's checkpoint
    // would have taken, executed here (lab tv tapes tests/fixtures/margin_v6
    // w5-c2-pooc-rev-long and -rev-long-noslip; lane W5-ENG-MARGIN-V6). So is
    // a long two or more of that bar's flat entries opened there, sized at
    // that close as a short's is below (lab tv tapes
    // tests/fixtures/margin_residual w5b-sb-pooc-60x2 and -pooc-default-x3;
    // lane W5B-ENG-MARGIN-RESIDUAL).
    const bool pooc_opened_at_prior_close = config_.process_orders_on_close
        && !config_.calc_on_order_fills
        && !context.driver_statistics.intrabar_path_enabled && context.sub_index == 0
        && prior_policy_bar_valid && position_open_phase_ == NativePathPhase::Close
        && position_open_script_bar_ == prior_policy_bar.timestamp;
    // A book two or more adds of the previous bar grew at its close is called
    // at this open too, sized at that close, fees or none, long or short (lab
    // tv tapes tests/fixtures/add_sibling_margin tailb-adds-pooc-*; lane
    // TAIL-B): on_applied took no call at their fills.
    const bool pooc_adds_at_prior_close = config_.process_orders_on_close
        && !config_.calc_on_order_fills
        && !context.driver_statistics.intrabar_path_enabled && context.sub_index == 0
        && prior_policy_bar_valid && !pooc_opened_at_prior_close
        && finite_positive(prior_policy_bar.close)
        && add_sibling_lots(prior_policy_bar.timestamp) >= 2;
    if (long_full_margin && (pooc_opened_at_prior_close || pooc_adds_at_prior_close)) {
        const double opening_mark = nearest_tick(bar.open, staged_.syminfo.mintick);
        // In the opening-call schedule's shape a long's call is sized at the
        // source close too, and the open's own calls follow it at its print
        // (close_sized_open_units, run_close_sized_open_calls; switch
        // close_sized_long_call). With none sized there, the open's own check.
        const double close_sized = config_.commission_value != 0.0 && pooc_opened_at_prior_close
                && PF_RARE(detail::margin_opening_switches().close_sized_long_call)
                && !pooc_adds_at_prior_close && finite_positive(prior_policy_bar.close)
                && !source_margin_rounded_tie_veto() && close_sized_open_call_scope(false, true)
            ? close_sized_open_units(nearest_tick(prior_policy_bar.close, staged_.syminfo.mintick),
                                     source_margin_fill_price(opening_mark, false),
                                     context.sub_bar_open_ms)
            : 0.0;
        if (close_sized > 0.0) {
            (void)run_close_sized_open_calls(close_sized, opening_mark, context);
        } else if (config_.commission_value != 0.0 && pooc_opened_at_prior_close) {
            (void)submit_margin_call_slice(opening_mark, context);
        } else if ((pooc_adds_at_prior_close || flat_sibling_placement(2))
                   && finite_positive(prior_policy_bar.close)) {
            const double at_close_units = source_margin_units(
                source_margin_money(prior_policy_bar.close, context.sub_bar_open_ms), false);
            const auto at_open = source_margin_money(opening_mark, context.sub_bar_open_ms);
            const double open_shortfall = at_open.valid && at_open.required > at_open.equity
                ? (at_open.required - at_open.equity) / at_open.unit_margin : 0.0;
            const bool at_close = at_close_units > 0.0 && at_close_units >= open_shortfall;
            const bool follow_up = whole_unit_follow_up_due(
                at_close ? at_close_units : source_margin_units(at_open, false), opening_mark);
            const double held_before = opening_position.signed_units;
            const auto lots_before = pooc_adds_at_prior_close
                ? require_host().native_open_lots(opening_mark) : std::vector<NativeOpenLot>{};
            const bool called = at_close
                ? submit_margin_call_units(opening_mark, context, at_close_units)
                : submit_margin_call_slice(opening_mark, context);
            if (called && follow_up) (void)submit_margin_call_units(opening_mark, context, 1.0);
            // The adds' book takes the broker's follow-up at this same open
            // (lagged_margin_follow_up_units).
            if (called && pooc_adds_at_prior_close) {
                const double taken = held_before
                    - detail::run_position(require_host()).signed_units;
                const double more = lagged_margin_follow_up_units(
                    lots_before, at_open, taken, source_margin_fill_price(opening_mark, false),
                    context.sub_bar_open_ms);
                if (more > 0.0) (void)submit_margin_call_units(opening_mark, context, more);
            }
        }
    }
    // Margin rule 3: a commission-free full-margin long with slippage is
    // checked at every bar's opening mark, as a short is
    // (slipped_long_margin_units).
    if (PF_RARE(long_full_margin && slipped_long_margin_scope())) {
        const double opening_mark = nearest_tick(bar.open, staged_.syminfo.mintick);
        const double called = slipped_long_margin_units(opening_mark);
        if (called > 0.0) (void)submit_margin_call_units(opening_mark, context, called);
    }
    bool marketable_limit_at_open = false;
    if (long_full_margin) {
        for (const auto& handle : live_handles_) {
            const auto found = placement_.find(handle.incarnation);
            if (found == placement_.end()) continue;
            const auto& candidate = found->second;
            const bool exit = candidate.family == PineOrderFamily::ExitLimit
                || candidate.family == PineOrderFamily::ExitStop
                || candidate.family == PineOrderFamily::ExitTrail;
            if (exit && std::isfinite(candidate.exit_levels.limit)
                && bar.open >= candidate.exit_levels.limit) {
                marketable_limit_at_open = true;
                break;
            }
        }
    }
    if (long_full_margin && !marketable_limit_at_open
        && position_open_script_bar_ != context.script_bar_open_ms) {
        const Bar open_only{bar.open, bar.open, bar.open, bar.open, 0.0,
                            bar.timestamp};
        (void)submit_tv_money_long_margin_call(open_only, context);
        if (last_margin_call_script_bar_ != context.script_bar_open_ms)
            (void)schedule_tv_money_long_margin_before_trail(bar, context);
    }
    // Quiet: a flat book takes no open or path slice -- its margin money is
    // invalid, it declines no reversal and schedules no path check -- so the
    // block below changes nothing.
    if (!long_full_margin && staged_.account_fx_effective_from_ms.empty()
        && !skip_quiet(QuietHook::OpenMarginCheckpoints, opening_position.signed_units == 0.0)) {
        const double held_at_open = std::abs(opening_position.signed_units);
        const bool held_long_at_open = opening_position.signed_units > 0.0;
        // The point order (switch point_fills_before_margin): at the open the
        // queued orders execute first, then the exits the open reaches, and
        // the margin check runs on what is left. A close the script placed
        // ahead of its opposite entry (close-first) is unconditional, and a
        // protective strategy.exit stop or limit the opening print reaches
        // fills there (tests/fixtures/admission_rules c1, c2, c4 and the
        // stop-priority tapes; c3b and the coupled close + reversal tapes),
        // a leg of an exit that also trails included (switch
        // point_order_trailing_exits; gapstop-percent-trail-points and
        // -trail-offset: c2 with trail_points, and with a trail_offset too,
        // book c2's rows).
        const bool point_order = detail::margin_rule_switches().point_fills_before_margin
            && pinned_lot_grid();
        // The opening print, which only protective_exit reads, under the
        // point order.
        const double open_print = point_order ? nearest_tick(bar.open, staged_.syminfo.mintick)
                                              : 0.0;
        bool opposite_entry_waits = false;
        bool whole_market_close_waits = false;
        // Read only by protective_exit, which the point order gates.
        const bool opposite_entry_pending = point_order && any_live_row(live_handles_, placement_,
            [&](const PlacementSnapshot& row) {
                return row.opening && (row.family == PineOrderFamily::Entry
                                       || row.family == PineOrderFamily::Order)
                    && row.projection_created_bar < projection_bar_index(context)
                    && row.is_long != held_long_at_open && !row.close_first_entry;
            });
        // The protective exits the opening print reaches: a whole one, and the
        // units the partial ones close.
        bool protective_whole_waits = false;
        double protective_partial_closing = 0.0;
        for (const auto& handle : live_handles_) {
            const auto found = placement_.find(handle.incarnation);
            if (found == placement_.end()) continue;
            const auto& pending = found->second;
            if (pending.opening
                && (pending.family == PineOrderFamily::Entry
                    || pending.family == PineOrderFamily::Order)
                && pending.projection_created_bar < projection_bar_index(context)
                && pending.is_long != held_long_at_open
                && !(point_order && pending.close_first_entry)) {
                opposite_entry_waits = true;
            }
            const bool market_close = pending.family == PineOrderFamily::Close
                || pending.family == PineOrderFamily::CloseAll;
            // An opposite opening waiting at this open may be declined there,
            // which kills the position's brackets (dormant until a margin
            // call revives them: test_bracket_lifecycle_declined_reversal_l4c
            // CASCADE); with one waiting no exit is taken to fill first.
            const bool protective_exit = point_order && !opposite_entry_pending
                && (pending.family == PineOrderFamily::ExitStop
                    || pending.family == PineOrderFamily::ExitLimit)
                && !pending.legs.dormant() && !pending.void_issue
                && pending.projection_created_bar < projection_bar_index(context)
                && (detail::margin_rule_switches().point_order_trailing_exits
                    || (!finite_positive(pending.exit_levels.trail_offset)
                        && !finite_positive(pending.exit_levels.trail_points)
                        && !finite_positive(pending.exit_levels.trail_price)))
                && finite_positive(open_print)
                && ((pending.family == PineOrderFamily::ExitStop
                     && finite_positive(pending.exit_levels.stop)
                     && (held_long_at_open ? open_print <= pending.exit_levels.stop
                                           : open_print >= pending.exit_levels.stop))
                    || (pending.family == PineOrderFamily::ExitLimit
                        && finite_positive(pending.exit_levels.limit)
                        && (held_long_at_open ? open_print >= pending.exit_levels.limit
                                              : open_print <= pending.exit_levels.limit)));
            // An exit whose entry holds none of the position at the open fills
            // nothing there, so the margin check keeps its place: a bracket
            // still armed for an entry of the other side that never filled.
            const double exit_owned = !protective_exit ? 0.0
                : from_entry_units(pending.from_entry).value_or(held_at_open);
            if (PF_RARE(protective_exit && exit_owned > internal::kQtyEpsilon)) {
                const double closing = std::isfinite(pending.projection_remaining_qty)
                    ? pending.projection_remaining_qty
                    : (std::isfinite(pending.requested_qty)
                        ? std::abs(pending.requested_qty)
                        : (!std::isfinite(pending.qty_percent)
                            || pending.qty_percent >= 100.0 - 1e-9
                            ? held_at_open : 0.0));
                if (exit_owned >= held_at_open - 1e-10 && closing >= held_at_open - 1e-10)
                    protective_whole_waits = true;
                else
                    protective_partial_closing += std::min(closing, exit_owned);
                continue;
            }
            if (!market_close
                || pending.projection_created_bar >= projection_bar_index(context)
                || finite_positive(pending.exit_levels.limit)
                || finite_positive(pending.exit_levels.stop)
                || finite_positive(pending.exit_levels.trail_offset)) {
                continue;
            }
            const double closing = std::isfinite(pending.projection_remaining_qty)
                ? pending.projection_remaining_qty
                : (std::isfinite(pending.requested_qty)
                    ? std::abs(pending.requested_qty)
                    : (std::isfinite(pending.qty_percent)
                        && pending.qty_percent >= 100.0 - 1e-9
                        ? held_at_open : 0.0));
            const double owned = pending.from_entry.empty()
                ? held_at_open : cohort_exposure_for(pending.from_entry);
            if (pending.family == PineOrderFamily::CloseAll
                || (owned >= held_at_open - 1e-10
                    && closing >= held_at_open - 1e-10)) {
                whole_market_close_waits = true;
            }
        }
        // ab9714be pine_fills.cpp:2462-2523: an unconditional whole close
        // resting for this opening fills before the open margin checkpoint.
        // A close paired with an opposite entry is conditional on that entry's
        // admission and therefore does not suppress the slice.
        whole_market_close_waits = (whole_market_close_waits
            && !opposite_entry_waits) || close_call_queued;
        const double opening_mark = nearest_tick(bar.open, staged_.syminfo.mintick);
        // A short process_orders_on_close filled at the previous bar's close
        // is margined at that close: TradingView sizes the call there (the
        // slipped fill and the entry's commission leave it short of margin)
        // and executes it at this open, re-sized at the open only when it no
        // longer covers the open's own shortfall. Every first opening call of
        // the 258 such shorts in lab tv tape
        // the opening-margin probe (ETHUSDT.P 15,
        // commission 0.05 %, slippage 1) follows this; marking at the open
        // alone books 118 (lab tv tapes tests/fixtures/margin_v6
        // w5-m2-pooc-short-comm; lane W5-ENG-MARGIN-V6).
        double close_margined_units = 0.0;
        // The full-margin one-lot shape the opening-call schedule pins
        // (close_sized_open_call_scope): the call sized at the close stands
        // unless its gate or one-unit band, priced at this open's print,
        // vetoes it, and the open's own calls follow it at that print
        // (run_close_sized_open_calls). A vetoed one leaves the open's own
        // check.
        bool close_sized_calls = false;
        if (config_.process_orders_on_close && !config_.calc_on_order_fills
            && opening_position.signed_units < 0.0 && prior_policy_bar_valid
            && context.sub_index == 0 && !context.driver_statistics.intrabar_path_enabled
            && ((position_open_phase_ == NativePathPhase::Close
                 && position_open_script_bar_ == prior_policy_bar.timestamp)
                || pooc_adds_at_prior_close)
            && finite_positive(prior_policy_bar.close)
            && !source_margin_rounded_tie_veto()) {
            const auto& opening_rules = detail::margin_opening_switches();
            const bool schedule = !pooc_adds_at_prior_close
                && PF_RARE(close_sized_open_call_scope(true, true));
            const double at_close_units = schedule
                ? close_sized_open_units(nearest_tick(prior_policy_bar.close, staged_.syminfo.mintick),
                                         source_margin_fill_price(opening_mark, true),
                                         context.sub_bar_open_ms)
                : source_margin_units(
                      source_margin_money(prior_policy_bar.close, context.sub_bar_open_ms), false);
            const auto at_open = source_margin_money(opening_mark, context.sub_bar_open_ms);
            const double open_shortfall = at_open.valid && at_open.required > at_open.equity
                ? (at_open.required - at_open.equity) / at_open.unit_margin : 0.0;
            if (at_close_units > 0.0
                && ((schedule && opening_rules.close_call_gate_at_print)
                    || at_close_units >= open_shortfall)) {
                close_margined_units = at_close_units;
                close_sized_calls = schedule
                    && (opening_rules.booked_open_recheck || opening_rules.open_print_follow_up);
            }
        }
        // The exits the open reaches fill before the open's own margin check,
        // with two exceptions that keep the earlier order. A call sized at the
        // previous close that the open does not re-size (close_margined_units:
        // it still covers the open's own shortfall) is a queued order: it
        // executes first and the exits after it (TradingView's tape of
        // a third-party strategy on OANDA:XAUUSD 15m; synthetic illustration:
        // a call of 1 unit, then the gapped stop's remaining 2 units;
        // tests/test_point_order_open_call.cpp). A call the open re-sizes is
        // the open's own check, after the exits; no tape decides that shape
        // yet. And a partial exit fills first only when what it leaves is
        // margined (stop_priority stop-09 and -10: no call at the gapped
        // open); when the remainder is still short the call at the open comes
        // first, as before, which no tape decides yet.
        bool open_exit_fills_first = false;
        if (!(close_margined_units > 0.0)) {
            if (protective_whole_waits && !opposite_entry_waits) whole_market_close_waits = true;
            if (PF_RARE(protective_partial_closing > internal::kQtyEpsilon
                        && !whole_market_close_waits)) {
                const auto at_open = source_margin_money(opening_mark, context.sub_bar_open_ms);
                const double remainder = held_at_open - protective_partial_closing;
                open_exit_fills_first = !(at_open.valid && remainder > internal::kQtyEpsilon
                    && remainder * at_open.unit_margin > at_open.equity);
            }
        }
        // So is a short two or more of that bar's flat entries opened at the
        // close: a call there can take a one-unit follow-up at this open
        // (whole_unit_follow_up_due).
        const bool opening_follow_up = !whole_market_close_waits && close_margined_units > 0.0
            && flat_sibling_placement(2)
            && whole_unit_follow_up_due(close_margined_units, opening_mark);
        const bool opening_margin_applied =
            !whole_market_close_waits && !open_exit_fills_first
            && (close_margined_units > 0.0
                ? (close_sized_calls
                    ? run_close_sized_open_calls(close_margined_units, opening_mark, context)
                    : submit_margin_call_units(opening_mark, context, close_margined_units))
                : open_call_owing_follow_up(opening_mark, context));
        if (opening_margin_applied && opening_follow_up) {
            (void)submit_margin_call_units(opening_mark, context, 1.0);
        } else if (opening_margin_applied && close_margined_units > 0.0 && !close_sized_calls
                   && PF_RARE(detail::margin_schedule_switches().close_call_follow_up_at_open)) {
            // The call sized at the previous close and executed here is
            // followed at this same open, at its own fill, while the book it
            // left, re-marked at that fill, is still short
            // (margin_follow_up_units): TradingView books the follow-up at
            // the first slice's price (switch close_call_follow_up_at_open).
            // Synthetic check snapshots illustrate the margin_call_rules fixtures
            // (NYSE:F 15m, commission 0.05 %, slippage 2): an initial call
            // at a 25.02 open fills at 25.04; if still short at that fill,
            // its follow-up also fills at 25.04, before any high-point check.
            // Waiting for the high instead changes that check's book. One
            // follow-up restores the book at that fill -- four times its
            // lot-floored shortfall, or one unit under one lot of it -- so
            // none follows it.
            const double fill = source_margin_fill_price(opening_mark, true);
            if (margin_follow_up_scope()
                && detail::run_position(require_host()).signed_units != 0.0) {
                const double follow_up = margin_follow_up_units(
                    close_margined_units, fill, context.sub_bar_open_ms);
                if (follow_up > 0.0)
                    (void)submit_margin_call_units(opening_mark, context, follow_up, true, fill);
            }
        }
        // pine_fills.cpp:2525-2678 gives an opening slice priority over the
        // remaining path.  The surviving book is then evaluated over the
        // suffix: a restored bracket at an earlier level wins naturally, while
        // an unprotected position can take a second slice at the adverse
        // extreme on the same bar.
        // Quiet: only a live opening reversal entry can be declined.
        const bool declined_reversal = !skip_quiet(QuietHook::DeclinedReversalAtOpen,
                !any_live_row(live_handles_, placement_, opening_reversal_entry))
            && declined_reversal_at_open(bar);
        // A vetoed deficit pending at the open is checked at the bar's first
        // path point before an exit touched on the way (pending_veto_point_first).
        if (!opening_margin_applied && !whole_market_close_waits && !open_exit_fills_first
            && !declined_reversal && PF_RARE(!held_long_at_open
                && detail::margin_schedule_switches().pending_veto_first)) {
            (void)pending_veto_point_first(bar, context, opening_mark);
        }
        bool margin_scheduled = false;
        if (!opening_margin_applied
            && (!whole_market_close_waits || declined_reversal)) {
            margin_scheduled = schedule_margin_call_path(bar, context);
        }
        if (declined_reversal && !opening_margin_applied) {
            defer_declined_reversal_exits_at_adverse(
                bar, context, margin_scheduled);
        }
    }
    // Quiet: without an intraday loss rule no loss is ever breached, so no
    // close is executed now or scheduled on the path.
    const bool no_intraday_loss_rule = !(risk_.max_intraday_loss > 0.0);
    if (!skip_quiet(QuietHook::IntradayLossClose, no_intraday_loss_rule))
        (void)submit_intraday_loss_close(bar.open, context, true);
    if (!skip_quiet(QuietHook::IntradayLossPath, no_intraday_loss_rule))
        schedule_intraday_loss_path(bar, context);
    // Quiet: margin calls off, a non-percent default quantity or no live
    // opening entry, which the slice refuses before it reads the book.
    if (!skip_quiet(QuietHook::PreopenMarginSlice,
            !source_margin_call_enabled_
            || config_.default_qty_type != static_cast<int>(QtyType::PERCENT_OF_EQUITY)
            || !any_live_row(live_handles_, placement_, [](const PlacementSnapshot& row) {
                   return row.opening && row.family == PineOrderFamily::Entry;
               }))) {
        schedule_preopen_margin_slice(bar, context);
    }
    if (context.sub_index == 0)
        cap.ordinary_open(context.coordinate.interval_index);
}
 
void PineExecutionAdapter::on_tick(
        const Bar& tick, const NativeTickContext& context) {
    // A realtime print is a current generic decision point. The source
    // policy owns the financial threshold; the native request core still
    // owns request acceptance, settlement, receipts and any later matching.
    (void)submit_margin_call_slice(tick.close, context.decision);
}
 
void PineExecutionAdapter::rearm_throttled_reopens() {
    auto queued = std::move(throttled_reopen_rearm_);
    throttled_reopen_rearm_.clear();
    const auto physical = detail::run_position(require_host());
    for (auto& snapshot : queued) {
        native_order::Request request;
        if (snapshot.deferred_cohort || !std::isfinite(snapshot.requested_qty)) {
            request.intent = native_order::HostSized{
                native_order::HostSizedKind::Open,
                snapshot.is_long ? native_order::Side::Long : native_order::Side::Short};
        } else {
            const double units = std::abs(snapshot.requested_qty);
            request.intent = native_order::Transact{snapshot.is_long ? units : -units};
        }
        request.label = snapshot.source_id;
        request.comment = snapshot.comment;
        request.trigger = native_order::Stop{snapshot.exit_levels.stop};
        request.group = group_for(snapshot.oca_name, snapshot.oca_type);
        const bool same_dir = physical.signed_units != 0.0
            && ((physical.signed_units > 0.0) == snapshot.is_long);
        const bool already_touched = policy_script_bar_valid_
            && finite_positive(snapshot.exit_levels.stop)
            && (snapshot.is_long
                ? policy_script_bar_.high >= snapshot.exit_levels.stop
                : policy_script_bar_.low <= snapshot.exit_levels.stop);
        // The kernel already walked past the nearer stop. Keep the owner's
        // fill price (the stop level) instead of the current path quote.
        // ab9714be pine_fills.cpp:8008-8018: round_to_mintick_directional rounds touched stop execution price to tick
        snapshot.forced_execution_price = (same_dir && already_touched)
            ? (finite_positive(staged_.syminfo.mintick)
                ? directional_tick(snapshot.exit_levels.stop, staged_.syminfo.mintick, snapshot.is_long)
                : snapshot.exit_levels.stop)
            : kNaN;
        snapshot.projection_after_close = false;
        snapshot.cancellation = {};
        snapshot.market_admission = {};
        const SourceId key = snapshot.source_id;
        const auto accepted = submit_or_replace(
            std::move(request), std::move(snapshot), true, key);
        if (accepted && same_dir && already_touched) {
            (void)require_host().execute_current(
                {*accepted, NativeCurrentPriceRule::NearestTick});
        }
    }
}
 
void PineExecutionAdapter::flush_pooc_marketable_limit_entry_fills(
        const Bar& bar, const NativeDecisionContext& context) {
    // ab9714be pine_fills.cpp:7604-7646 (classify_order_eligibility) +
    // pine_fills.cpp:8022-8043 (evaluate_fill_price): under
    // process_orders_on_close, a pure LIMIT entry (no stop, no trail) placed by
    // this bar's source calc is evaluated in the post-calculation fill pass
    // (pine_scheduler.cpp:259 step 4) against THIS bar's close. When the
    // close's tick is on the marketable side of the limit, or on it, it fills
    // there, limit-or-better, at bar_fill_price(bar.close) with no slippage;
    // otherwise it rests and gets the ordinary touch evaluation from the next
    // bar on, however far the bar's range reached. TradingView reads the
    // close's tick, not the raw close (a sell limit at 11.76 over a raw 11.755
    // close fills at that close; a buy limit at 11.65 over 11.655, whose tick
    // is 11.66, rests), with or without calc_on_order_fills (lab tv
    // pa3-f3-pooc-limit-{long,short}{,-coof}; the extreme-point fill correction). Scoped
    // to the non-stream route and a flat book.
    // A pure STOP entry the close already reached fills there too, with or
    // without calc_on_order_fills (the order-schedule correction): TradingView books it
    // at that bar's close, the close's tick slipped like any stop fill, on
    // every path -- the five such entries of each of H-MEASURE's
    // hm-{chart,mag}-diff-v1 / -v3 / -v5 / -v7 tapes, which the resting stop
    // filled a bar late at the next open. The stop is reached when the close's
    // tick is at or through it (a raw close half a tick short prints it). Only
    // a lone marketable entry: when a second entry of this bar is marketable at
    // the same close, which fills first is unmeasured, and the stops keep the
    // next open's both-marketable arbitration (lane L9b's P0-B shapes).
    // A pure stop entry placed while the book held the other side fills at
    // that close as well, sized as its row is: a plain reversal here, and one
    // a same-bar strategy.close or close_all of the held side precedes right
    // after that close fills (fill_pooc_close_entries from on_applied), as
    // TradingView books both (the recalculation fill-order correction: lab tv
    // pa2-i3-rev-s-{chart,mag} and pa2-i3-flip-{s,l}-{chart,mag}, corpus probe
    // 96, which filled it at the next open; pa2-i3-flip-unreached-* keep an
    // unreached one resting). Only without calc_on_order_fills, the route the
    // tapes cover.
    if (!config_.process_orders_on_close || !modeled_input() || coof_recalc_active_) return;
    if (fill_pooc_close_pair(bar.close, context)) return;
    fill_pooc_close_entries(bar.close, context, /*after_close=*/false);
}
 
void PineExecutionAdapter::fill_pooc_close_entries(
        double raw_close, const NativeDecisionContext& context, bool after_close) {
    const double book_before = detail::run_position(require_host()).signed_units;
    if (!finite_positive(raw_close)) return;
    // A same-bar close of the held side fills at this close after this pass:
    // the reversing stops it precedes wait for its fill.
    const bool close_follows = !after_close && std::any_of(
        live_handles_.begin(), live_handles_.end(),
        [&](const native_order::RequestHandle& handle) {
            const auto found = placement_.find(handle.incarnation);
            return found != placement_.end()
                && (found->second.family == PineOrderFamily::Close
                    || found->second.family == PineOrderFamily::CloseAll)
                && found->second.projection_created_bar == projection_bar_index(context);
        });
    const double tick = staged_.syminfo.mintick;
    const double close_tick = source_bar_fill_tick(raw_close, tick);
    std::vector<std::pair<native_order::RequestHandle, PlacementSnapshot>> marketable;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& row = found->second;
        if (row.family != PineOrderFamily::Entry || !row.opening) continue;
        if (row.birth.from_fill()) continue;
        if (row.projection_created_bar != projection_bar_index(context)) continue;
        const bool pure_limit = finite_positive(row.exit_levels.limit)
            && !std::isfinite(row.exit_levels.stop);
        const bool pure_stop = finite_positive(row.exit_levels.stop)
            && !std::isfinite(row.exit_levels.limit);
        const bool stop_limit = finite_positive(row.exit_levels.stop)
            && finite_positive(row.exit_levels.limit);
        if (!pure_limit && !pure_stop && !stop_limit) continue;
        const bool placed_flat = row.projection_position_side
            == static_cast<std::int32_t>(PositionSide::FLAT);
        const bool placed_against = row.projection_position_side
            == static_cast<std::int32_t>(row.is_long ? PositionSide::SHORT
                                                     : PositionSide::LONG);
        const bool reversing_stop = placed_against && pure_stop
            && !config_.calc_on_order_fills && (after_close || !close_follows)
            && (book_before == 0.0 || (book_before > 0.0) != row.is_long);
        // So does a limit placed against the held side, reversing it at this
        // close (lab tv w5r-pooc-add-close cell J), and a limit or stop ADD
        // placed while its own side is held (cells A, B, C, E, H; the
        // unreached add D rests; the recalculation scheduling diag-w5r, the placement and recalculation correction).
        const bool reversing_limit = placed_against && pure_limit
            && !config_.calc_on_order_fills && (after_close || !close_follows)
            && (book_before == 0.0 || (book_before > 0.0) != row.is_long);
        const bool placed_with = row.projection_position_side
            == static_cast<std::int32_t>(row.is_long ? PositionSide::LONG
                                                     : PositionSide::SHORT);
        const bool pyramid_add = placed_with && !after_close && book_before != 0.0
            && (book_before > 0.0) == row.is_long;
        if (placed_flat ? (after_close || book_before != 0.0)
                        : !(reversing_stop || reversing_limit || pyramid_add)) {
            continue;
        }
        if (row.direction_gate || row.paired_flat_market_candidate) continue;
        if (row.terms_priced_reverse && !(reversing_stop || reversing_limit)) continue;
        const bool at_close = finite_positive(close_tick) && (pure_limit
            ? (row.is_long ? close_tick <= row.exit_levels.limit
                           : close_tick >= row.exit_levels.limit)
            : (row.is_long ? close_tick >= row.exit_levels.stop
                           : close_tick <= row.exit_levels.stop));
        if (stop_limit && !(row.is_long ? close_tick <= row.exit_levels.limit
                                       : close_tick >= row.exit_levels.limit)) {
            if (at_close) (void)require_host().activate_current_stop_limit(handle);
            continue;
        }
        if (at_close) marketable.emplace_back(handle, row);
    }
    if (marketable.size() > 1) {
        marketable.erase(std::remove_if(marketable.begin(), marketable.end(),
            [](const std::pair<native_order::RequestHandle, PlacementSnapshot>& candidate) {
                return finite_positive(candidate.second.exit_levels.stop);
            }), marketable.end());
    }
    for (auto& candidate : marketable) {
        // An earlier fill of this pass moves the book; the owner's later rows
        // are then ordinary pending orders again.
        if (detail::run_position(require_host()).signed_units != book_before) break;
        const auto& row = candidate.second;
        // A reversal's frozen transaction is resolved by the host, as at the
        // next open (resolve_execution_terms reads the copied row).
        const bool host_sized = row.deferred_cohort || row.terms_priced_reverse
            || row.qty_type == static_cast<int>(QtyType::CASH)
            || row.qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY);
        if (!host_sized && !finite_positive(row.requested_qty)) continue;
        native_order::Request request;
        request.intent = host_sized
            ? native_order::OrderIntent{native_order::HostSized{
                native_order::HostSizedKind::Open,
                row.is_long ? native_order::Side::Long : native_order::Side::Short}}
            : native_order::OrderIntent{native_order::Transact{
                row.is_long ? row.requested_qty : -row.requested_qty}};
        request.label = row.source_id;
        request.comment = row.comment;
        request.trigger = native_order::Market{};
        request.group = group_for(row.oca_name, row.oca_type);
        PlacementSnapshot immediate = row;
        immediate.cancellation = {};
        immediate.market_admission = {};
        // bar_fill_price(bar.close): the raw close, nearest-tick rounded
        // (pine_fills.cpp:8038-8041); a limit fill is never slipped, a stop
        // fill is, after the rounding.
        const bool stop_entry = finite_positive(row.exit_levels.stop)
            && !std::isfinite(row.exit_levels.limit);
        immediate.forced_execution_price = stop_entry && config_.slippage != 0
            ? nearest_tick(close_tick + (row.is_long ? 1.0 : -1.0)
                               * config_.slippage * tick, tick)
            : close_tick;
        const auto accepted = submit_or_replace(
            std::move(request), std::move(immediate), true, row.source_id);
        if (accepted) {
            // The replacement is the row's own order executed at this close:
            // it keeps the side and carried units it was placed against,
            // which its reversal sizing reads, when a same-bar close has
            // flattened the book since.
            auto& placed = placement_.at(accepted->incarnation);
            placed.projection_position_side = row.projection_position_side; invalidate_retirement();
            placed.projection_tv_carry_qty = row.projection_tv_carry_qty;
            (void)require_host().execute_current(
                {*accepted, NativeCurrentPriceRule::NearestTick});
        }
    }
}
 
void PineExecutionAdapter::flush_pooc_marketable_exit_fills(
        const Bar& bar, const NativeDecisionContext& context) {
    // Under process_orders_on_close the close pass decides the exits this
    // calculation placed, after the calculation's orders that fill at the
    // close whatever its price (fill_pooc_close_exits), with or without
    // calc_on_order_fills. With one of those still to fill, the exits wait for
    // it: on_applied runs the pass after that fill.
    if (!config_.process_orders_on_close || !modeled_input() || coof_recalc_active_) return;
    if (pooc_close_market_pending(context)) return;
    if (pooc_close_entry_immediate_pending(context, nullptr)) return;
    fill_pooc_close_exits(bar.close, context);
}
 
// A priced entry this calculation placed that fill_pooc_close_entries
// executes at this close (its immediate: an opening Entry row born this bar,
// not from a fill, with the close forced as its price) and that has not
// filled yet. The close pass decides the calculation's exits after it, as
// TradingView does (lab tv w5r-pooc-add-close cells A, B, E, H: the add's
// exit at that same close; the recalculation scheduling diag-w5r, the placement and recalculation correction).
bool PineExecutionAdapter::pooc_close_entry_immediate_pending(
        const NativeDecisionContext& context,
        const native_order::RequestHandle* except) const {
    const int bar_index = projection_bar_index(context);
    for (const auto& handle : live_handles_) {
        if (except && handle == *except) continue;
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& row = found->second;
        if (row.family == PineOrderFamily::Entry && row.opening && !row.birth.from_fill()
            && row.projection_created_bar == bar_index
            && std::isfinite(row.forced_execution_price)
            && (std::isfinite(row.exit_levels.limit) || std::isfinite(row.exit_levels.stop))) {
            return true;
        }
    }
    return false;
}
 
bool PineExecutionAdapter::pooc_close_market_pending(
        const NativeDecisionContext& context) const {
    // A strategy.close / close_all, or a market entry or order, that this
    // calculation placed and the close point has not filled yet.
    const int bar_index = projection_bar_index(context);
    return any_live_row(live_handles_, placement_, [&](const PlacementSnapshot& row) {
        if (row.projection_created_bar != bar_index || row.birth.from_fill()) return false;
        if (row.family == PineOrderFamily::Close || row.family == PineOrderFamily::CloseAll)
            return true;
        return (row.family == PineOrderFamily::Entry || row.family == PineOrderFamily::Order)
            && !std::isfinite(row.exit_levels.limit) && !std::isfinite(row.exit_levels.stop);
    });
}
 
bool PineExecutionAdapter::fill_time_global_exit(const PlacementSnapshot& source) const {
    // TradingView sizes a from_entry "" exit that names no quantity when it
    // fills: its percentage of the whole position then, the lots a market add
    // opened after it was placed included -- at the same open it fills at, on
    // a later bar, or at a process_orders_on_close close -- and whether it was
    // placed before or after that add (lab tv w4-f19a-*, lane
    // W4-ENG-POOC-SAMEPASS; job-2388's DCA take-profit). An exit that names its
    // entry closes that entry's lots only, which the kernel scope already
    // selects. Scoped to the book's only exit: beside another exit order the
    // placement-time reservation still splits the book.
    if (!source.from_entry.empty() || std::isfinite(source.requested_qty)) return false;
    if (source.family != PineOrderFamily::ExitLimit && source.family != PineOrderFamily::ExitStop
        && source.family != PineOrderFamily::ExitTrail) {
        return false;
    }
    if (!(std::isfinite(source.projection_remaining_qty) && source.projection_remaining_qty > 0.0))
        return false;
    const auto other_exit = [&](const PlacementSnapshot& row) {
        return (row.family == PineOrderFamily::ExitLimit || row.family == PineOrderFamily::ExitStop
                || row.family == PineOrderFamily::ExitTrail)
            && (row.source_id != source.source_id || !row.from_entry.empty());
    };
    if (any_live_row(live_handles_, placement_, other_exit)) return false;
    for (const auto& leg : pending_bracket_legs_)
        if (other_exit(leg.snapshot)) return false;
    return true;
}
 
// TradingView's from_entry "" exit with relative legs over a pyramided
// position (ExitBindingRuleSwitches::global_exit_per_entry_levels). It gives
// each entry its own bracket, at levels from that entry's own fill price
// (profit: fill + / - the profit ticks, loss: fill - / + the loss ticks); the
// two legs of one entry are one bracket. An entry that fills after the call
// gets its bracket at its fill, live for the rest of that bar. Each bracket
// fills at most once, and a re-issued exit does not give a consumed entry
// another. Every fill closes the oldest open trade, whichever entry's bracket
// filled. A book that goes flat ends the brackets left, so an entry filling
// later in that bar waits for the next call. 60 lab tv tapes of synthetic
// scripts (NYSE:F 15m: a held lot, a same-side add reached later by a limit,
// a stop or a market order, and the exit called on every held bar;
// tests/fixtures/per_entry_exit), each reproduced row for row by a forward
// predictor of these rules. A position of one entry keeps its one exit at
// the average price, which is that entry's own bracket; the second entry's
// fill turns it into the first entry's bracket (per_entry_exits_at_entry_fill).
// The tapes have neither calc_on_order_fills nor process_orders_on_close, run
// on the chart's own bars and close FIFO; every other configuration keeps the
// one exit over the whole position.
bool PineExecutionAdapter::per_entry_exit_scope() const {
    if (!detail::exit_binding_rule_switches().global_exit_per_entry_levels
        || config_.calc_on_order_fills || config_.process_orders_on_close
        || config_.close_entries_rule_any || !finite_positive(staged_.syminfo.mintick)
        || !modeled_input()) {
        return false;
    }
    const auto native = detail::run_state(require_host());
    return !native.spec || native.spec->intrabar.is_none();
}
 
// The held position's entries in fill order: one per open lot on the held
// side, each with its own fill price and the units it still holds. Empty
// when a lot was not opened by a strategy.entry order (the tapes reach
// nothing else).
detail::ExitScratchRows<PineExecutionAdapter::PerEntryExitChild>
PineExecutionAdapter::per_entry_open_entries(bool long_side) const {
    detail::ExitScratchRows<PerEntryExitChild> entries(*this);
    detail::exit_scratch_lots(entries.context(), require_host(), kNaN,
        [&](const NativeOpenLot& lot) {
        const auto row = placement_.find(lot.entry_incarnation);
        if (row == placement_.end() || !row->second.opening
            || row->second.family != PineOrderFamily::Entry
            || (lot.signed_units > 0.0) != long_side || !finite_positive(lot.entry_price)
            || !(std::abs(lot.signed_units) > 0.0)) {
            entries.clear();
            return false;
        }
        entries.push_back({lot.entry_incarnation, lot.entry_price, std::abs(lot.signed_units),
                           false});
        return true;
    });
    return entries;
}
 
detail::ExitScratchRows<native_order::RequestHandle> PineExecutionAdapter::per_entry_child_legs(
        const SourceId& exit_id, std::uint64_t origin) const {
    detail::ExitScratchRows<native_order::RequestHandle> legs(*this);
    for (const auto& handle : live_handles_) {
        const auto row = placement_.find(handle.incarnation);
        if (row != placement_.end() && row->second.per_entry_origin != 0
            && row->second.source_id == exit_id
            && (origin == 0 || row->second.per_entry_origin == origin)) {
            legs.push_back(handle);
        }
    }
    return legs;
}
 
// Cancels and retires those of `legs` still working. One the kernel already
// ended (an OCA sibling of a fill) waits for its terminal receipt, and a
// cancel of it would record a NotWorking event.
void PineExecutionAdapter::cancel_working_legs(
        const detail::ExitScratchRows<native_order::RequestHandle>& legs) {
    if (legs.empty()) return;
    detail::ExitScratchIndex working(legs.context());
    detail::exit_scratch_working(legs.context(), require_host(),
        [&](const NativeWorkingRequest& request) {
        working.put(request.definition->handle.incarnation, 0);
        return true;
    });
    for (const auto& handle : legs) {
        const bool still_working =
            working.find(handle.incarnation) != detail::ExitScratchIndex::absent;
        if (!still_working) continue;
        const auto result = require_host().cancel(handle);
        if (result.status == native_order::CancelStatus::Cancelled) retire(handle);
    }
}
 
// Serves a strategy.exit call per entry when the rule covers it; false leaves
// the call to exit()'s own course.
bool PineExecutionAdapter::per_entry_exit_call(
        const SourceId& exit_id, const SourceId& from_entry, double limit, double stop,
        double trail_points, double trail_offset, double trail_price, double qty_percent,
        const std::string& comment, double qty, const std::string& oca_name,
        double profit_ticks, double loss_ticks, std::uint64_t command_sequence) {
    const auto tracked = [&] {
        return std::find_if(per_entry_exits_.begin(), per_entry_exits_.end(),
            [&](const PerEntryExit& row) { return row.exit_id == exit_id; });
    };
    const auto absent_or_positive = [](double value) {
        return std::isnan(value) || finite_positive(value);
    };
    const bool relative_only = from_entry.empty() && std::isnan(limit) && std::isnan(stop)
        && std::isnan(trail_points) && std::isnan(trail_offset) && std::isnan(trail_price)
        && std::isnan(qty)
        && (std::isnan(qty_percent) || qty_percent >= 100.0 - internal::kFullPercentEps)
        && oca_name.empty() && absent_or_positive(profit_ticks)
        && absent_or_positive(loss_ticks)
        && (finite_positive(profit_ticks) || finite_positive(loss_ticks));
    auto record = tracked();
    if (record == per_entry_exits_.end() && !relative_only) return false;
    const auto physical = detail::run_position(require_host());
    const bool long_side = physical.signed_units > 0.0;
    const bool in_scope = relative_only && physical.signed_units != 0.0
        && per_entry_exit_scope();
    if (record != per_entry_exits_.end()
        && (!in_scope || record->cycle != current_position_cycle_
            || record->long_side != long_side)) {
        // Another definition, or a position this record no longer stands on:
        // the call takes exit()'s own course over what the position holds.
        end_per_entry_exit(static_cast<std::size_t>(record - per_entry_exits_.begin()));
        record = per_entry_exits_.end();
    }
    if (!in_scope) return false;
    const auto same = [](double left, double right) {
        return same_double_bits(left, right) || (std::isnan(left) && std::isnan(right));
    };
    if (record == per_entry_exits_.end()) {
        auto entries = per_entry_open_entries(long_side);
        if (entries.size() < 2) return false;
        // Called over two entries already: each takes its own bracket, and a
        // leg this exit holds over the whole position gives way to them.
        detail::ExitScratchRows<native_order::RequestHandle> whole(*this);
        for (const auto& handle : live_handles_) {
            const auto row = placement_.find(handle.incarnation);
            if (row == placement_.end()) continue;
            const auto& leg = row->second;
            if ((leg.family == PineOrderFamily::ExitLimit
                 || leg.family == PineOrderFamily::ExitStop
                 || leg.family == PineOrderFamily::ExitTrail)
                && leg.source_id == exit_id && leg.from_entry.empty()) {
                whole.push_back(handle);
            }
        }
        cancel_working_legs(whole);
        if (const auto family = bracket_families_.find(key_for(exit_id, from_entry));
            family != bracket_families_.end()) {
            family->second.remove_selected(whole);
            if (family->second.empty()) bracket_families_.erase(family);
        }
        PerEntryExit added;
        added.exit_id = exit_id;
        added.cycle = current_position_cycle_;
        added.long_side = long_side;
        added.profit_ticks = profit_ticks;
        added.loss_ticks = loss_ticks;
        added.comment = comment;
        for (const auto& entry : entries) added.children.push_back(entry);
        per_entry_exits_.push_back(std::move(added));
        const PerEntryExit& exit = per_entry_exits_.back();
        for (const auto& child : exit.children)
            submit_per_entry_child(exit, child, command_sequence);
        return true;
    }
    // Re-issued: every bracket stands as it was placed, and an entry whose
    // bracket filled gets none again. A changed definition re-prices the
    // brackets still live.
    const bool same_definition = same(record->profit_ticks, profit_ticks)
        && same(record->loss_ticks, loss_ticks) && record->comment == comment;
    record->profit_ticks = profit_ticks;
    record->loss_ticks = loss_ticks;
    record->comment = comment;
    for (const auto& entry : per_entry_open_entries(long_side)) {
        const bool known = std::any_of(record->children.begin(), record->children.end(),
            [&](const PerEntryExitChild& child) { return child.origin == entry.origin; });
        if (!known) record->children.push_back(entry);
    }
    const std::size_t index = static_cast<std::size_t>(record - per_entry_exits_.begin());
    for (std::size_t position = 0; position < per_entry_exits_[index].children.size();
         ++position) {
        const PerEntryExitChild child = per_entry_exits_[index].children[position];
        if (child.consumed) continue;
        const auto legs = per_entry_child_legs(exit_id, child.origin);
        if (!legs.empty() && same_definition) continue;
        cancel_working_legs(legs);
        submit_per_entry_child(per_entry_exits_[index], child, command_sequence);
    }
    return true;
}
 
// One entry's bracket: a limit at its fill price + / - the profit ticks and a
// stop at - / + the loss ticks, each the trigger exit() gives such a level,
// in one cancel group of the entry's own, each closing the entry's units.
void PineExecutionAdapter::submit_per_entry_child(const PerEntryExit& exit,
                                                  const PerEntryExitChild& child,
                                                  std::uint64_t command_sequence) {
    const double tick = staged_.syminfo.mintick;
    const double side = exit.long_side ? 1.0 : -1.0;
    const bool exit_is_buy = !exit.long_side;
    const double limit = finite_positive(exit.profit_ticks)
        ? source_level_on_price_grid(child.fill_price + side * exit.profit_ticks * tick, tick)
        : kNaN;
    const double stop = finite_positive(exit.loss_ticks)
        ? source_level_on_price_grid(child.fill_price - side * exit.loss_ticks * tick, tick)
        : kNaN;
    const std::string origin_key = std::to_string(child.origin);
    const SourceId group_name = exit.exit_id + "\x1f\x1f" + origin_key;
    const OrderBirth birth = capture_order_birth();
    const PineSizingSnapshot sizing = sizing_snapshot();
    const auto family_key = key_for(exit.exit_id, SourceId{});
    const auto submit = [&](PineOrderFamily family, native_order::Trigger trigger) {
        native_order::Request request;
        request.intent = native_order::HostSized{native_order::HostSizedKind::Close, std::nullopt};
        request.label = exit.exit_id;
        request.comment = exit.comment;
        request.trigger = trigger;
        request.owner = native_order::Independent{};
        request.group = group_for(group_name, 1, static_cast<std::int64_t>(family));
        PlacementSnapshot snapshot;
        snapshot.family = family;
        snapshot.source_id = exit.exit_id;
        snapshot.comment = exit.comment;
        snapshot.qty_percent = 100.0;
        snapshot.deferred_cohort = true;
        snapshot.is_long = false;
        snapshot.command_sequence = command_sequence;
        snapshot.exit_levels = {limit, stop, kNaN, kNaN, kNaN, exit.profit_ticks, exit.loss_ticks};
        snapshot.birth = birth;
        snapshot.birth_reach = compat::pine::select_historical_birth_reach(birth, false);
        snapshot.sizing = sizing;
        snapshot.placement_cycle = current_position_cycle_;
        snapshot.projection_remaining_qty = child.units;
        snapshot.per_entry_origin = child.origin;
        snapshot.per_entry_units = child.units;
        initialize_l4c_policy(snapshot, {});
        const SourceId replacement_key = exit.exit_id + "\x1f\x1f"
            + std::to_string(static_cast<int>(family)) + "\x1f" + origin_key;
        const auto accepted = submit_or_replace(std::move(request), std::move(snapshot), false,
                                                replacement_key);
        if (accepted) {
            auto& roster = bracket_family(family_key);
            if (!roster.holds(*accepted)) roster.push_back(*accepted);
        }
    };
    if (std::isfinite(limit)) {
        submit(PineOrderFamily::ExitLimit,
               native_order::Limit{exit_limit_trigger(limit, tick, exit_is_buy)});
    }
    if (std::isfinite(stop)) {
        submit(PineOrderFamily::ExitStop,
               native_order::Stop{source_trigger_threshold(stop, tick, exit_is_buy, false)});
    }
}
 
// An entry that fills while a global exit with relative legs stands on the
// position gets its own bracket there, born at the fill (live for the rest of
// the bar). The exit's legs over the one entry held before stay that entry's
// bracket, closing its units from now on.
void PineExecutionAdapter::per_entry_exits_at_entry_fill(
        const PlacementSnapshot& opening, const native_order::ExecutionAppliedEvent& event) {
    if (!opening.opening || opening.family != PineOrderFamily::Entry
        || !(std::abs(event.opened_units) > 0.0) || event.closed_units > 0.0) {
        return;
    }
    const auto physical = detail::run_position(require_host());
    const bool long_side = physical.signed_units > 0.0;
    if (physical.signed_units == 0.0 || opening.is_long != long_side) return;
    const auto tracked = [&](const SourceId& exit_id) {
        return std::any_of(per_entry_exits_.begin(), per_entry_exits_.end(),
            [&](const PerEntryExit& row) { return row.exit_id == exit_id; });
    };
    // The exits standing over the whole position: a from_entry "" stop or
    // limit leg with a relative operand, on the side held.
    detail::ExitScratchRows<SourceId> standing(*this);
    for (const auto& handle : live_handles_) {
        const auto row = placement_.find(handle.incarnation);
        if (row == placement_.end()) continue;
        const auto& leg = row->second;
        if ((leg.family != PineOrderFamily::ExitLimit && leg.family != PineOrderFamily::ExitStop)
            || !leg.from_entry.empty() || leg.per_entry_origin != 0
            || !(finite_positive(leg.exit_levels.profit_ticks)
                 || finite_positive(leg.exit_levels.loss_ticks))
            || tracked(leg.source_id)
            || standing.contains(leg.source_id)) {
            continue;
        }
        standing.push_back(leg.source_id);
    }
    if (per_entry_exits_.empty() && standing.empty()) return;
    if (!per_entry_exit_scope()) return;
    const PerEntryExitChild added{event.handle().incarnation, event.resolved_price,
                                  std::abs(event.opened_units), false};
    for (std::size_t index = 0; index < per_entry_exits_.size(); ++index) {
        auto& exit = per_entry_exits_[index];
        if (exit.cycle != current_position_cycle_ || exit.long_side != long_side
            || std::any_of(exit.children.begin(), exit.children.end(),
                   [&](const PerEntryExitChild& child) { return child.origin == added.origin; })) {
            continue;
        }
        exit.children.push_back(added);
        submit_per_entry_child(per_entry_exits_[index], added, 0);
    }
    if (standing.empty()) return;
    const auto held_side = static_cast<std::int32_t>(
        long_side ? PositionSide::LONG : PositionSide::SHORT);
    const double tick = staged_.syminfo.mintick;
    const double side = long_side ? 1.0 : -1.0;
    for (const auto& exit_id : standing) {
        const auto staged = [&](const PlacementSnapshot& row) {
            return row.source_id == exit_id && row.from_entry.empty();
        };
        bool uniform = std::none_of(pending_bracket_legs_.begin(), pending_bracket_legs_.end(),
                [&](const PendingBracketLeg& row) { return staged(row.snapshot); })
            && std::none_of(delayed_market_orders_.begin(), delayed_market_orders_.end(),
                [&](const DelayedMarketOrder& row) { return staged(row.snapshot); })
            && std::none_of(pending_coof_requests_.begin(), pending_coof_requests_.end(),
                [&](const PendingCoofRequest& row) { return staged(row.snapshot); });
        detail::ExitScratchRows<native_order::RequestHandle> legs(*this);
        const PlacementSnapshot* first = nullptr;
        for (const auto& handle : live_handles_) {
            const auto row = placement_.find(handle.incarnation);
            if (row == placement_.end() || !staged(row->second)) continue;
            const auto& leg = row->second;
            const bool exit_leg = leg.family == PineOrderFamily::ExitLimit
                || leg.family == PineOrderFamily::ExitStop
                || leg.family == PineOrderFamily::ExitTrail;
            if (!exit_leg) continue;
            if (!first) first = &leg;
            uniform = uniform && leg.family != PineOrderFamily::ExitTrail
                && leg.deferred_cohort && std::isnan(leg.requested_qty)
                && (std::isnan(leg.qty_percent)
                    || leg.qty_percent >= 100.0 - internal::kFullPercentEps)
                && leg.oca_name.empty() && std::isnan(leg.exit_levels.trail_points)
                && std::isnan(leg.exit_levels.trail_offset)
                && std::isnan(leg.exit_levels.trail_price)
                && leg.placement_cycle == current_position_cycle_
                && leg.projection_position_side == held_side
                && same_double_bits(leg.exit_levels.profit_ticks, first->exit_levels.profit_ticks)
                && same_double_bits(leg.exit_levels.loss_ticks, first->exit_levels.loss_ticks)
                && leg.comment == first->comment;
            legs.push_back(handle);
        }
        if (!uniform || !first) continue;
        // The position before this fill: the one entry these legs were placed
        // over, at its own levels.
        const auto entries = per_entry_open_entries(long_side);
        PerEntryExitChild prior{};
        std::size_t prior_count = 0;
        for (const auto& entry : entries) {
            if (entry.origin == added.origin) continue;
            prior = entry;
            ++prior_count;
        }
        if (prior_count != 1) continue;
        const double profit_ticks = first->exit_levels.profit_ticks;
        const double loss_ticks = first->exit_levels.loss_ticks;
        const auto own_level = [&](const PlacementSnapshot& leg) {
            if (leg.family == PineOrderFamily::ExitLimit) {
                return finite_positive(profit_ticks) && same_double_bits(leg.exit_levels.limit,
                    source_level_on_price_grid(prior.fill_price + side * profit_ticks * tick, tick));
            }
            return finite_positive(loss_ticks) && same_double_bits(leg.exit_levels.stop,
                source_level_on_price_grid(prior.fill_price - side * loss_ticks * tick, tick));
        };
        bool own = true;
        for (const auto& handle : legs) {
            const auto row = placement_.find(handle.incarnation);
            own = own && row != placement_.end() && own_level(row->second);
        }
        if (!own) continue;
        PerEntryExit exit;
        exit.exit_id = first->source_id;
        exit.cycle = current_position_cycle_;
        exit.long_side = long_side;
        exit.profit_ticks = profit_ticks;
        exit.loss_ticks = loss_ticks;
        exit.comment = first->comment;
        exit.children = {prior, added};
        for (const auto& handle : legs) {
            if (const auto row = placement_.find(handle.incarnation); row != placement_.end()) {
                row->second.per_entry_origin = prior.origin; invalidate_retirement();
                row->second.per_entry_units = prior.units;
            }
        }
        per_entry_exits_.push_back(std::move(exit));
        submit_per_entry_child(per_entry_exits_.back(), added, 0);
    }
}
 
// A leg of an entry's bracket that filled spends that bracket; a book left
// flat (or on another position) ends every bracket left.
void PineExecutionAdapter::per_entry_exits_after_fill(
        const std::optional<PlacementSnapshot>& placement,
        const native_order::ExecutionAppliedEvent& event) {
    if (per_entry_exits_.empty()) return;
    if (placement && placement->per_entry_origin != 0 && event.closed_units > 0.0) {
        for (auto& exit : per_entry_exits_) {
            if (exit.exit_id != placement->source_id) continue;
            for (auto& child : exit.children)
                if (child.origin == placement->per_entry_origin) child.consumed = true;
        }
    }
    const auto physical = detail::run_position(require_host());
    for (std::size_t index = per_entry_exits_.size(); index-- > 0;) {
        const auto& exit = per_entry_exits_[index];
        if (physical.signed_units == 0.0 || exit.cycle != current_position_cycle_
            || (physical.signed_units > 0.0) != exit.long_side) {
            end_per_entry_exit(index);
        }
    }
}
 
// TradingView's order at one point of the path, among the orders a held
// global exit with relative legs meets there beside an add of the held side
// (global_exit_per_entry_levels): stop and market orders before limit orders,
// and among the stop and market orders the buys before the sells; two orders
// on one tick meet at one point. A long's limit add that a gapped open passes
// together with the exit's stop fills after that stop closed the position,
// and waits for the next call for its own bracket (tests/fixtures/
// per_entry_exit). The native matcher breaks a same-point tie by queue order,
// so after the script those orders are re-priced in place
// (ReplaceOptions::keep_handle) into that order, as
// order_open_marketable_limit_entries does at an open. An add sized by the
// core (an unpriced default quantity, which a re-price would size again) or
// another trigger keeps the queue as it is.
void PineExecutionAdapter::order_per_entry_point_ties() {
    if (!detail::exit_binding_rule_switches().global_exit_per_entry_levels) return;
    const auto physical = detail::run_position(require_host());
    if (physical.signed_units == 0.0) return;
    const bool long_side = physical.signed_units > 0.0;
    const auto exit_leg = [&](const PlacementSnapshot& row) {
        return (row.family == PineOrderFamily::ExitLimit
                || row.family == PineOrderFamily::ExitStop)
            && row.from_entry.empty() && std::isnan(row.requested_qty) && row.oca_name.empty()
            && (finite_positive(row.exit_levels.profit_ticks)
                || finite_positive(row.exit_levels.loss_ticks))
            && std::isnan(row.exit_levels.trail_points)
            && std::isnan(row.exit_levels.trail_offset)
            && std::isnan(row.exit_levels.trail_price);
    };
    const auto add = [&](const PlacementSnapshot& row) {
        return row.opening && row.family == PineOrderFamily::Entry && row.is_long == long_side;
    };
    if (!any_live_row(live_handles_, placement_, exit_leg)
        || !any_live_row(live_handles_, placement_, add) || !per_entry_exit_scope()) {
        return;
    }
    auto& host = require_host();
    struct Ranked {
        std::uint64_t incarnation = 0;
        std::uint64_t request = 0;
        int rank = 0;
        std::uint64_t priority = 0;
    };
    detail::ExitScratchRows<Ranked> rows(*this);
    auto& versions = detail::exit_scratch_versions(rows.context());
    bool supported = true;
    detail::exit_scratch_working(rows.context(), host, [&](const NativeWorkingRequest& working) {
        const auto& definition = *working.definition;
        const auto found = placement_.find(definition.handle.incarnation);
        if (found == placement_.end()) return true;
        const bool leg = exit_leg(found->second);
        if (!leg && !add(found->second)) return true;
        const auto& trigger = definition.request.trigger;
        int order_class = 0;
        if (std::holds_alternative<native_order::Limit>(trigger)) {
            order_class = 1;
        } else if (!std::holds_alternative<native_order::Market>(trigger)
                   && !std::holds_alternative<native_order::Stop>(trigger)) {
            supported = false;
            return false;
        }
        if (std::holds_alternative<native_order::Sized>(definition.request.intent)) {
            supported = false;
            return false;
        }
        const bool buy = leg ? !long_side : long_side;
        rows.push_back({definition.handle.incarnation,
                        versions.request(rows.scope(), definition.request),
                        order_class * 2 + (buy ? 0 : 1),
                        definition.priority != 0 ? definition.priority
                                                 : definition.handle.incarnation});
        return true;
    });
    if (!supported) return;
    detail::ExitScratchRows<Ranked> by_priority(*this);
    rows.ordered(
        [](const Ranked& row) { return row.priority; },
        [&](const Ranked& row, std::size_t) { by_priority.push_back(row); return true; });
    native_order::ReplaceOptions reprice;
    reprice.keep_handle = true;
    std::size_t index = 0;
    bool unchanged_prefix = true;
    by_priority.ordered(
        [](const Ranked& row) { return static_cast<std::uint64_t>(row.rank); },
        [&](const Ranked& row, std::size_t) {
            unchanged_prefix = unchanged_prefix
                && by_priority[index].incarnation == row.incarnation;
            ++index;
            if (!unchanged_prefix) {
                const native_order::RequestHandle handle{rows.context().run, row.incarnation};
                (void)host.replace(handle, versions.request(row.request), reprice);
            }
            return true;
        });
}
 
void PineExecutionAdapter::end_per_entry_exit(std::size_t index) {
    const SourceId exit_id = per_entry_exits_[index].exit_id;
    per_entry_exits_.erase(per_entry_exits_.begin() + static_cast<std::ptrdiff_t>(index));
    const auto legs = per_entry_child_legs(exit_id, 0);
    if (legs.empty()) return;
    cancel_working_legs(legs);
    if (const auto family = bracket_families_.find(key_for(exit_id, SourceId{}));
        family != bracket_families_.end()) {
        family->second.remove_selected(legs);
        if (family->second.empty()) bracket_families_.erase(family);
    }
}
 
void PineExecutionAdapter::fill_pooc_close_exits(
        double raw_close, const NativeDecisionContext& context) {
    // TradingView's process_orders_on_close pass (lab tv w4-f08*, lane
    // W4-ENG-POOC-SAMEPASS): the calculation's market orders fill at the
    // close first -- a strategy.close, or an entry that reverses the held
    // side, voids that side's exits -- and then every exit leg the
    // calculation placed is decided against the same close: it fills there
    // when the close's tick reaches its level on the closing side (a sell
    // stop at or above it, a sell limit at or below it, and the mirror for a
    // buy), the stop leg first and at most one leg per exit order; otherwise
    // it rests for the next bar. That holds for a position held from an
    // earlier bar, one this close pass opened or reversed into (the exit
    // placed with its entry), and a from_entry "" exit, with or without
    // calc_on_order_fills. The close's tick, not the raw close, decides
    // (synthetic NYSE:F half-cent closes: a sell limit 25.047 over a raw
    // 25.045 close fills there, a sell stop 25.027 over a raw 25.025 close
    // rests, on either side and in either scope). The fill books the close,
    // a stop slipped like any stop fill (w4-f08s-pooc-slip).
    const auto physical = detail::run_position(require_host());
    if (physical.signed_units == 0.0 || !finite_positive(raw_close)) return;
    const bool closing_long = physical.signed_units > 0.0;
    const auto held_side = static_cast<std::int32_t>(
        closing_long ? PositionSide::LONG : PositionSide::SHORT);
    const double tick = staged_.syminfo.mintick;
    const double close_tick = source_bar_fill_tick(raw_close, tick);
    struct Group {
        std::uint64_t stop = 0;
        std::uint64_t stop_snapshot = 0;
        std::uint64_t limit = 0;
        std::uint64_t limit_snapshot = 0;
    };
    detail::ExitScratchRows<Group> groups(*this);
    detail::ExitScratchIndex keys(groups.context());
    auto& versions = detail::exit_scratch_versions(groups.context());
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& row = found->second;
        if (row.family != PineOrderFamily::ExitLimit
            && row.family != PineOrderFamily::ExitStop) continue;
        if (row.birth.from_fill()) continue;
        if (row.projection_created_bar != projection_bar_index(context)) continue;
        // The leg is the held position's: a named entry's own lots, or a
        // from_entry "" exit placed under this position or while flat
        // (TVDEF-DROPS R3: an exit belongs to the position it was placed
        // under).
        if (!row.from_entry.empty()
                ? !(cohort_exposure_for(row.from_entry) > 0.0)
                : (row.projection_position_side != held_side
                   && row.projection_position_side
                       != static_cast<std::int32_t>(PositionSide::FLAT))) {
            continue;
        }
        // A leg the calculation placed before the entry it names is never
        // applied by TradingView (w4-f08-* cell I); the pass leaves it be.
        if (!row.from_entry.empty()) {
            const auto cohort = cohorts_by_id_.find(row.from_entry);
            if (cohort != cohorts_by_id_.end() && !cohort->second.opened.empty()) {
                const auto parent = placement_.find(cohort->second.opened.back().incarnation);
                if (parent != placement_.end()
                    && parent->second.projection_created_bar == row.projection_created_bar
                    && parent->second.command_sequence > row.command_sequence) {
                    continue;
                }
            }
        }
        const bool stop_leg = row.family == PineOrderFamily::ExitStop;
        const double level = stop_leg ? row.exit_levels.stop : row.exit_levels.limit;
        if (!finite_positive(level)) continue;
        const detail::ExitScratchPairText key(row.source_id, row.from_entry);
        auto index = keys.find(key);
        if (index == detail::ExitScratchIndex::absent) {
            index = groups.size();
            keys.put(key, index);
            groups.push_back(Group{});
        }
        Group group = groups[index];
        if (stop_leg) {
            if (group.stop == 0) {
                group.stop = handle.incarnation;
                group.stop_snapshot = versions.placement(groups.scope(), row);
            }
        } else if (group.limit == 0) {
            group.limit = handle.incarnation;
            group.limit_snapshot = versions.placement(groups.scope(), row);
        }
        groups.set(index, group);
    }
    for (const auto& group : groups) {
        // An earlier exit of this pass may have closed the position.
        const double live_signed = detail::run_position(require_host()).signed_units;
        if (live_signed == 0.0 || (live_signed > 0.0) != closing_long) break;
        const double stop_level = group.stop != 0
            ? versions.placement(group.stop_snapshot).exit_levels.stop : kNaN;
        const double limit_level = group.limit != 0
            ? versions.placement(group.limit_snapshot).exit_levels.limit : kNaN;
        const bool fill_stop = group.stop != 0
            && (closing_long ? close_tick <= stop_level : close_tick >= stop_level);
        const bool fill_limit = group.limit != 0
            && (closing_long ? close_tick >= limit_level : close_tick <= limit_level);
        if (!fill_stop && !fill_limit) continue;
        const native_order::RequestHandle selected{
            groups.context().run, fill_stop ? group.stop : group.limit};
        if (!selected.incarnation) continue;
        const auto row = versions.placement(
            fill_stop ? group.stop_snapshot : group.limit_snapshot);
        const double live_held_units = std::abs(live_signed);
        double units = std::isfinite(row.projection_remaining_qty)
            ? std::max(0.0, row.projection_remaining_qty)
            : (std::isfinite(row.requested_qty) ? std::abs(row.requested_qty) : 0.0);
        if ((!std::isfinite(row.projection_remaining_qty) && !std::isfinite(row.requested_qty))
            || fill_time_global_exit(row)) {
            // A host-sized leg placed while flat carries no reservation yet,
            // and a from_entry "" exit that is the book's only exit sizes on
            // the position it fills against: it closes its share of what it
            // exits now (w4-f08-* cell J, w4-f19a-pooc cells A and B).
            units = quantize_close_units(
                row.from_entry.empty() ? live_held_units : cohort_exposure_for(row.from_entry),
                std::isfinite(row.qty_percent) ? row.qty_percent : 100.0);
            // A partial one keeps its placement reservation (resolve_terms).
            if (std::isfinite(row.qty_percent)
                && row.qty_percent < 100.0 - internal::kFullPercentEps
                && finite_positive(row.projection_remaining_qty)) {
                units = std::max(units, row.projection_remaining_qty);
            }
        }
        if (!(units > 0.0)) continue;
        // ab9714be pine_fills.cpp:1618 and pine_fills.cpp:1708-1723 spell
        // full-position coverage as `qty - kQtyEpsilon`, cap the quantity at
        // the whole position, and then book it through the WHOLE-position exit
        // instead of a sized reduction.  Earlier same-bar reissues in this pass
        // have already reduced the book, so the test reads the position fresh.
        // Submitting the reservation's stale binary64 residual as a sized
        // reduction instead is refused off-grid, and the sub-lot remainder it
        // strands is what the 1x-margin path later fragments.
        const bool covers_live_book = live_held_units > 0.0
            && units >= live_held_units - internal::kQtyEpsilon;
        cancel_bracket_siblings(selected);
        native_order::Request request;
        request.intent = covers_live_book
            ? native_order::OrderIntent{native_order::Flatten{}}
            : native_order::OrderIntent{
                native_order::Reduce{native_order::ExplicitUnits{units}}};
        request.label = row.source_id;
        request.comment = row.comment;
        request.trigger = native_order::Market{};
        PlacementSnapshot immediate = row;
        const bool stop_close = row.family == PineOrderFamily::ExitStop;
        // A stop leg books on the closing side's own path
        // (apply_fill_slippage(price, is_buy)): closing a SHORT is a BUY, so
        // the slip is ADDED to the close; closing a LONG is a SELL, so it is
        // subtracted. A limit leg is never slipped.
        immediate.forced_execution_price = nearest_tick(
            raw_close + (stop_close ? (closing_long ? -1.0 : 1.0) : 0.0)
                * config_.slippage * tick,
            tick);
        immediate.projection_predecessor = selected.incarnation;
        immediate.projection_predecessor_exit = true;
        const auto accepted = submit_or_replace(
            std::move(request), std::move(immediate), false,
            row.source_id + "\x1f" + row.from_entry
                + std::to_string(static_cast<int>(row.family)));
        if (accepted) execute_or_withdraw_close(*accepted, row.void_issue);
    }
}
 
// A carried trailing stop is reached where the bar's tick-built print reaches
// it, the level itself staying the raw running best +/- the offset: the
// static stop's rule (source_trigger_threshold), now for the stop a trail
// rides. TradingView, lab tv tape tests/fixtures/callback_lifecycle
// (NYSE:F 15m, calc_on_order_fills off): a synthetic short trailing
// 14 ticks behind a best of 20.385 rests at 20.525000000000002; a
// high of decimal 20.525 lies one ULP below that computed
// level, prints 20.53 and exits there; the raw compare would wait.
// The kernel's generic Trail compares the raw path with the raw level, so
// for one bar the adapter walks the bar's path as the kernel will (the best
// is tested on each leg and then moved by its end), finds the point the
// tick-built path first reaches the stop, and, only where that point comes
// before the one the raw compare would reach, re-prices the trail's distance
// for that bar so the kernel's own compare fires there. That is the direction
// the tape shows; a raw reach the tick-built path would not make (a print
// whose tick falls back inside the stop) is left to the kernel, as no tape
// decides it. The ride (retain_trigger_state) and the handle are kept; the
// source fill still books the level from the carried best and the source
// offset (resolve_terms). The opening print is the block above's;
// calc_on_order_fills and an intrabar path are left out, as no tape covers
// them.
void PineExecutionAdapter::retune_carried_trails_for_tick_reach(
        const Bar& bar, const NativeDecisionContext& context) {
    if (!detail::pine_callback_lifecycle_rule(detail::PineCallbackLifecycleRule::CarriedTrailTickReach)
        || trail_state_at_open_.empty() || !modeled_input() || config_.calc_on_order_fills
        || context.driver_statistics.intrabar_path_enabled) {
        return;
    }
    const double tick = staged_.syminfo.mintick;
    if (!finite_positive(tick) || !finite_positive(bar.open) || !finite_positive(bar.high)
        || !finite_positive(bar.low) || !finite_positive(bar.close)) {
        return;
    }
    const double held_units = detail::run_position(require_host()).signed_units;
    if (held_units == 0.0) return;
    const bool is_buy = held_units < 0.0;
    const bool high_first = source_path_uses_high_first(bar);
    const double path[3] = {high_first ? bar.high : bar.low,
                            high_first ? bar.low : bar.high, bar.close};
    const auto improves = [&](double best, double price) {
        return is_buy ? price < best : price > best;
    };
    for (const auto& working : require_host().native_working_requests()) {
        const auto& definition = *working.definition;
        const auto* trail = std::get_if<native_order::Trail>(&definition.request.trigger);
        const auto carried = trail_state_at_open_.find(definition.handle.incarnation);
        const auto found = placement_.find(definition.handle.incarnation);
        if (!trail || carried == trail_state_at_open_.end() || !carried->second.activated
            || found == placement_.end() || found->second.family != PineOrderFamily::ExitTrail
            || !(found->second.exit_levels.trail_offset >= 1.0)
            || !std::isfinite(found->second.retained_trail_best)
            || !std::holds_alternative<native_order::TrailTrack>(working.trigger_state)) {
            continue;
        }
        const double offset = trail->offset;
        double best = carried->second.best_price;
        // The replica must name the kernel's own level for the carried best,
        // or the walk below is not the kernel's.
        if (!(compat::pine::kernel_trail_stop_level(best, offset, is_buy, tick)
              == carried->second.current_level)) {
            continue;
        }
        const auto reached = [&](double price, double level, bool on_tick) {
            const double threshold = on_tick
                ? source_trigger_threshold(level, tick, is_buy, false) : level;
            return is_buy ? price >= threshold : price <= threshold;
        };
        // The opening print: reached on its tick, the block above took it;
        // reached raw, the kernel fills it there. Either way not this walk's.
        const double carried_level = compat::pine::kernel_trail_stop_level(best, offset, is_buy, tick);
        if (reached(bar.open, carried_level, true) || reached(bar.open, carried_level, false))
            continue;
        if (improves(best, bar.open)) best = bar.open;
        double bests[3] = {kNaN, kNaN, kNaN};
        int raw_point = -1;
        int tick_point = -1;
        for (int i = 0; i < 3; ++i) {
            bests[i] = best;
            const double level = compat::pine::kernel_trail_stop_level(best, offset, is_buy, tick);
            if (raw_point < 0 && reached(path[i], level, false)) raw_point = i;
            if (tick_point < 0 && reached(path[i], level, true)) tick_point = i;
            if (improves(best, path[i])) best = path[i];
        }
        // Only the tick-built point coming first is re-priced: none reached, or
        // the raw compare reaching at that point or before it, stays the kernel's.
        if (tick_point < 0 || (raw_point >= 0 && raw_point <= tick_point)) continue;
        // The kernel's compare at point i under a trailing distance d.
        const auto hits = [&](double distance, int i) {
            return reached(path[i], compat::pine::kernel_trail_stop_level(bests[i], distance, is_buy, tick), false);
        };
        const auto fires_first_at = [&](double distance) {
            for (int i = 0; i < 3; ++i)
                if (hits(distance, i)) return i;
            return -1;
        };
        // The widest distance the tick-built point still reaches.
        double retuned = is_buy ? path[tick_point] - bests[tick_point]
                                : bests[tick_point] - path[tick_point];
        for (int step = 0; step < 64 && retuned > 0.0 && !hits(retuned, tick_point); ++step)
            retuned = std::nextafter(retuned, 0.0);
        for (int step = 0; step < 64; ++step) {
            const double wider = std::nextafter(retuned, std::numeric_limits<double>::infinity());
            if (!hits(wider, tick_point)) break;
            retuned = wider;
        }
        if (!(retuned > 0.0) || fires_first_at(retuned) != tick_point) continue;
        native_order::Request request = definition.request;
        auto retuned_trail = *trail;
        retuned_trail.offset = retuned;
        retuned_trail.ticks.reset();
        request.trigger = retuned_trail;
        native_order::ReplaceOptions keep;
        keep.retain_trigger_state = true;
        keep.keep_handle = true;
        keep.keep_binding = detail::carry_reissue_bindings();
        const auto replaced = require_host().replace(definition.handle, request, keep);
        if (replaced.status != native_order::ReplaceStatus::Replaced) continue;
        carried_trail_retunes_.push_back({definition.handle, offset});
    }
}
 
// The bar is over: a trail the walk re-priced and that is still live rides
// its own distance again from the next bar on (retune_carried_trails_for_tick_reach).
void PineExecutionAdapter::restore_carried_trail_retunes() {
    if (carried_trail_retunes_.empty()) return;
    auto retunes = std::move(carried_trail_retunes_);
    carried_trail_retunes_.clear();
    for (const auto& [handle, offset] : retunes) {
        for (const auto& working : require_host().native_working_requests()) {
            const auto& definition = *working.definition;
            if (!(definition.handle == handle)) continue;
            const auto* trail = std::get_if<native_order::Trail>(&definition.request.trigger);
            if (!trail || trail->offset == offset) break;
            native_order::Request request = definition.request;
            auto restored = *trail;
            restored.offset = offset;
            restored.ticks.reset();
            request.trigger = restored;
            native_order::ReplaceOptions keep;
            keep.retain_trigger_state = true;
            keep.keep_handle = true;
            keep.keep_binding = detail::carry_reissue_bindings();
            (void)require_host().replace(definition.handle, request, keep);
            break;
        }
    }
}
 
void PineExecutionAdapter::on_bar_close_before_script(
        const Bar& bar, const NativeDecisionContext& context) {
    restore_carried_trail_retunes();
    // TradingView calls a short carried under process_orders_on_close at the
    // bar's high before the script runs at its close: the script reads the
    // called book, and its own close fills meet what the call left (lab tv
    // tapes tests/fixtures/margin_v6 w5-c1-seen-size: a reversal by the size
    // the script reads is 53.645, not the 55.1762 held before the call;
    // w5-m2-pooc-carried-close / -reverse / -none: 1.5312 @1802.01, then the
    // close's own fill; lane W5-ENG-MARGIN-V6). A slice at this bar's open
    // leaves the high still to be checked, on the book that slice left
    // (w5-m2-pooc-short-comm: a call at the open and one at the high of the
    // same bar, three times). This is the commissioned or slipped short that
    // schedule_margin_call_path takes no path check for; a fee-free one keeps
    // the kernel's path check and the checkpoint after the script.
    if (host_ == nullptr || !modeled_input() || !config_.process_orders_on_close
        || config_.calc_on_order_fills
        || (config_.commission_value == 0.0 && config_.slippage == 0)
        || !finite_positive(bar.high)) {
        return;
    }
    if (PF_RARE(short_path_points_scope(context))) {
        walk_short_path_points(bar, context);
        return;
    }
    if (detail::run_position(require_host()).signed_units < 0.0
        && position_open_script_bar_ != std::numeric_limits<std::int64_t>::min()
        && position_open_script_bar_ != context.script_bar_open_ms) {
        (void)submit_margin_call_slice(bar.high, context);
    }
}
 
void PineExecutionAdapter::on_bar_close(
        const Bar& bar, const NativeDecisionContext& context) {
    on_bar_close_policy(bar, context);
    if (context.is_terminal_sub_bar) {
        // Normal policy returns (quiet bars and margin checkpoints included)
        // all reach this boundary. Exceptions leave unfinished events intact.
        finish_admission_bar();
    }
}
 
void PineExecutionAdapter::finish_admission_bar() {
    fold_admission_events();
    admission_journal.retire_prefix(admission_events_folded_,
        admission_events_digest_, admission_events_last_);
}
 
void PineExecutionAdapter::on_bar_close_policy(
        const Bar& bar, const NativeDecisionContext& context) {
    // Quiet-bar gates (pine_quiet_bar.hpp), as at the opening. None fires on
    // an unbound adapter: its hooks still refuse through require_host().
    using detail::QuietHook;
    using detail::skip_quiet;
    const bool bound = host_ != nullptr;
    if (bound) fold_source_money();
    // The close-first fact lives for the script calculation that recorded
    // it: every entry() that reads it has run by now.
    close_first_script_bar_ = std::numeric_limits<std::int64_t>::min();
    close_first_side_ = 0;
    // A carried process_orders_on_close short's follow-up owed to this close
    // is booked now, after the script and ahead of the close's fills
    // (book_owed_close_follow_up).
    if (PF_RARE(owed_follow_up_bar_ != std::numeric_limits<std::int64_t>::min()) && bound
        && config_.process_orders_on_close) {
        book_owed_close_follow_up(bar, context);
    }
    // Quiet: the close fills are a process_orders_on_close pass outside fill
    // recalculation and streams, and fill only what this bar placed -- an
    // opening entry, or a limit or stop exit leg. "This bar" is the index
    // both passes test, projection_bar_index (the named input slot): on an
    // aggregated or magnified run it is not the script-bar interval_index,
    // and a gate reading that one skipped both passes there (the
    // order-schedule correction).
    const bool close_fill_pass = config_.process_orders_on_close
        && modeled_input() && !coof_recalc_active_;
    const bool entry_close_fill_pass = config_.process_orders_on_close
        && modeled_input() && !coof_recalc_active_;
    const int bar_index = projection_bar_index(context);
    if (!skip_quiet(QuietHook::PoocLimitEntryFills, bound && (!entry_close_fill_pass
            || !any_live_row(live_handles_, placement_, [&](const PlacementSnapshot& row) {
                   return row.family == PineOrderFamily::Entry && row.opening
                       && row.projection_created_bar == bar_index;
               })))) {
        flush_pooc_marketable_limit_entry_fills(bar, context);
    }
    if (!skip_quiet(QuietHook::PoocExitFills, bound && (!close_fill_pass
            || !any_live_row(live_handles_, placement_, [&](const PlacementSnapshot& row) {
                   return (row.family == PineOrderFamily::ExitLimit
                           || row.family == PineOrderFamily::ExitStop)
                       && row.projection_created_bar == bar_index;
               })))) {
        flush_pooc_marketable_exit_fills(bar, context);
    }
    // Quiet: no sell was deferred at this bar's open.
    if (!skip_quiet(QuietHook::DeferredSellAdmission,
                    bound && deferred_open_marketable_sells_.empty())) {
        admit_deferred_open_marketable_sells();
    }
    // Quiet: no flat stop entry was throttled.
    if (!skip_quiet(QuietHook::ThrottledReopens, bound && throttled_reopen_rearm_.empty()))
        rearm_throttled_reopens();
    // A tolerant stream can synthesize a pair-less script callback without a
    // separate open hook. Batch bars always pass through on_bar_open and keep
    // their completed arbitration observable after the run.
    if (last_bar_dual_entry_script_open_ms_ != context.script_bar_open_ms) {
        last_bar_dual_entry_path_ = 0;
        last_bar_dual_entry_script_open_ms_ = context.script_bar_open_ms;
    }
    // The script's orders are placed: TradingView's order at one point among
    // a held global exit's legs and an add beside it (order_per_entry_point_ties).
    if (bound) order_per_entry_point_ties();
    // Quiet: the terminal policy is a process_orders_on_close pass at
    // pyramiding 0 outside streams over two or more explicit-quantity
    // opening entries this bar placed.
    std::size_t explicit_entries = 0;
    if (config_.process_orders_on_close && config_.pyramiding == 0 && modeled_input()) {
        for (const auto& handle : live_handles_) {
            const auto found = placement_.find(handle.incarnation);
            if (found != placement_.end() && found->second.opening
                && found->second.family == PineOrderFamily::Entry
                && found->second.projection_created_bar == bar_index
                && finite_positive(found->second.requested_qty)) {
                ++explicit_entries;
            }
        }
    }
    if (!skip_quiet(QuietHook::TerminalExplicitMarket, bound && explicit_entries < 2))
        apply_terminal_explicit_market_policy(context);
    update_risk_state(bar.close);
    if (!modeled_input()) return;
    withdraw_waypoint_margin_calls();
    waypoint_chain_bar_ = std::numeric_limits<std::int64_t>::min();
    {
        const bool cancelled = close_margin_cancelled_bar_ == context.script_bar_open_ms;
        close_margin_cancelled_bar_ = std::numeric_limits<std::int64_t>::min();
        if (close_point_margin_scope() && close_point_margin_call(bar, context, cancelled))
            return;
    }
    // The native callback frame remains current after the source script
    // returns. Reproduce the legacy once-per-script-bar margin checkpoint at
    // the adverse path extreme, unless the earlier open/path policy already
    // applied a margin slice on this script bar.
    if (last_margin_call_script_bar_ == context.script_bar_open_ms) return;
    {
        auto closes = same_bar_close_alls(context);
        const double placed = detail::run_position(require_host()).signed_units;
        int fired = -1;
        if (submit_tv_money_long_margin_call(bar, context, &fired)) {
            if (fired == 3 && (!config_.process_orders_on_close
                               || detail::margin_rule_switches().close_point_reversal))
                size_close_alls_at_placement(closes, placed);
            if ((fired == 1 || fired == 2) && !closes.empty())
                (void)close_all_at_next_point(bar, fired, closes, context);
            return;
        }
    }
    // Quiet: the checkpoint below belongs to a commissioned full-margin short
    // outside process_orders_on_close, and does not apply to this run. A
    // carried short under process_orders_on_close was checked over the bar's
    // path before the script (schedule_margin_call_path), or at its high
    // there when commissioned or slipped (on_bar_close_before_script).
    if (skip_quiet(QuietHook::CloseMarginCheckpoints,
            bound
            && !(!config_.process_orders_on_close && config_.margin_short == 100.0
              && config_.commission_type == static_cast<int>(CommissionType::PERCENT)
              && config_.commission_value > 0.0))) {
        return;
    }
    const auto position = detail::run_position(require_host());
    // ab9714be pine_scheduler.cpp:262-283: in the non-POOC pass, process_margin_call
    // runs after invoke_chart_on_bar: a commissioned 1x short no check of the
    // bar called is checked once more at the bar's high here. An explicit-qty
    // MARKET short's entry bar is no longer deferred to this checkpoint (a
    // trim at the fill, then the high): TradingView checks it on the bar's
    // path from its opening print, as every slipped market short
    // (on_applied; lab tv tapes tests/fixtures/margin_open_print; lane TAIL-I).
    const bool non_pooc_commissioned_short = !config_.process_orders_on_close
        && position.signed_units < 0.0
        && config_.margin_short == 100.0
        && config_.commission_type == static_cast<int>(CommissionType::PERCENT)
        && config_.commission_value > 0.0;
    if (non_pooc_commissioned_short && finite_positive(bar.high)) {
        const double adverse = nearest_tick(bar.high, staged_.syminfo.mintick);
        (void)submit_margin_call_slice(adverse, context);
    }
    // Ordinary price-path slices are born at the native open/applied points
    // and matched by the generic driver at their actual waypoint.  This
    // post-calculation checkpoint owns the source-only rounded-money policy;
    // replaying the full bar's adverse quote here would incorrectly give a
    // close-time position access to prices it did not yet exist through.
}
 
namespace {
// A strategy.exit leg already marketable at the open's tick: a short's stop
// at or below it or its limit at or above it, a long's mirror.
bool exit_leg_marketable_at(const PineExitLevels& legs, bool short_book, double open_tick) noexcept {
    if (std::isfinite(legs.stop) && (short_book ? open_tick >= legs.stop : open_tick <= legs.stop))
        return true;
    return std::isfinite(legs.limit)
        && (short_book ? open_tick <= legs.limit : open_tick >= legs.limit);
}
} // namespace
 
// An exit leg (request `leg`) the fill of the entry request `opening` (id
// `id`) released onto its new book: bound to that request, bound to the id
// and materialized at that fill on the book's side, or a strategy.exit
// without from_entry placed while the book was flat after that entry, which
// the kernel reaches after the entry's fill at one point and so closes the
// book it opens. TradingView orders such a global exit at the open as a bound
// one: a short's call before its stop on the path, a long's open-marketable
// stop before any call (lab tv tapes tests/fixtures/margin_open_rules
// exit-order/global-*). A leg left from an earlier lot of the id -- another
// side's, or one placed before this fill's bar -- is not, nor is a global
// exit placed before the entry, which the open reaches while still flat.
bool PineExecutionAdapter::opening_released_leg(
        const PlacementSnapshot& row, std::uint64_t leg, std::uint64_t opening,
        const SourceId& id, bool short_book, const NativeDecisionContext& context) const {
    if (row.bracket_origin.incarnation == opening) return true;
    if (row.bracket_origin.incarnation != 0) return false;
    if (row.from_entry.empty())
        return leg > opening
            && row.projection_position_side == static_cast<std::int32_t>(PositionSide::FLAT);
    return row.from_entry == id
        && row.projection_created_bar == projection_bar_index(context)
        && row.projection_position_side
            == static_cast<std::int32_t>(short_book ? PositionSide::SHORT : PositionSide::LONG);
}
 
// Whether an exit leg of the book fills ahead of the opening checkpoint
// (on_applied): a strategy.exit stop or limit placed by this bar whose
// from_entry is in the live cycle. ab9714be pine_fills.cpp:2150-2169: a 1x
// short gives way to any leg its bar touches. The legs a market entry's fill
// at the bar's open releases (opening_released_leg), a long's as a short's,
// precede the check only when they are already marketable at that open -- a
// short's stop at or below the open's tick or its limit at or above it, a
// long's mirror -- and the check's call is booked at the fill ahead of a leg
// the bar reaches only after the open, one tick after it included (lab tv
// tapes tests/fixtures/margin_open_rules exit-order/: a short of 3.5 ETH
// filled off the 2483.19 open calls 0.0048 there before its 2485.69 stop
// fills 3.4952, and calls nothing before a stop 3 ticks below the open; lane
// PX-PIN-16B); `at_open` says such a leg precedes it. The book's other legs,
// which may be bound to an earlier lot of the id, keep ab9714be's rule.
// `filled`, an exit leg filling now, does not count, nor do the other legs of
// its strategy.exit call, and with it only the released legs are asked.
bool PineExecutionAdapter::priced_exit_precedes_opening(
        bool short_book, std::uint64_t opening, const SourceId& opening_id,
        const NativeDecisionContext& context, const PlacementSnapshot* filled,
        bool* at_open) const {
    const double open_tick = opening != 0
        ? nearest_tick(policy_script_bar_.open, staged_.syminfo.mintick) : kNaN;
    bool marketable_at_open = false;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& row = found->second;
        if (row.family != PineOrderFamily::ExitLimit
            && row.family != PineOrderFamily::ExitStop) {
            continue;
        }
        if (filled && row.command_sequence == filled->command_sequence
            && row.bracket_origin == filled->bracket_origin) {
            continue;
        }
        // A void global exit's leg is no leg for TradingView: it never
        // precedes the check, released or touched (void_global_issue).
        if (row.void_global_issue) continue;
        if (row.projection_created_bar < 0
            || row.projection_created_bar > projection_bar_index(context)) {
            continue;
        }
        // ab9714be pine_fills.cpp:7671-7674 removes an exit
        // whose from_entry has not filled in the live cycle
        // (the long a direct reversal just closed), so it
        // cannot fill and must not preempt the opening
        // checkpoint (pine_fills.cpp:6069-6102, 1386-1482).
        if (!row.from_entry.empty()
            && !from_entry_filled_this_cycle(row.from_entry)) {
            continue;
        }
        if (opening != 0
            && opening_released_leg(row, handle.incarnation, opening, opening_id, short_book,
                                    context)) {
            marketable_at_open = marketable_at_open
                || exit_leg_marketable_at(row.exit_levels, short_book, open_tick);
            continue;
        }
        if (filled || !short_book) continue;
        if ((std::isfinite(row.exit_levels.stop)
             && policy_script_bar_.high >= row.exit_levels.stop)
            || (std::isfinite(row.exit_levels.limit)
                && policy_script_bar_.low <= row.exit_levels.limit)) {
            if (at_open) *at_open = false;
            return true;
        }
    }
    if (at_open) *at_open = marketable_at_open;
    return marketable_at_open;
}
 
// The opening checkpoint at the fill that opened or grew a full-margin book
// (on_applied), at `fill`, the entry's own fill price: the call it takes at
// the fill's print. A market entry filling at a bar's open runs it after the
// exit legs marketable at that open have filled there (open_exit_first_bar_),
// on the book they leave.
void PineExecutionAdapter::run_opening_checkpoint(
        double fill, bool market, bool sibling_book, bool adds_book_last,
        const NativeDecisionContext& context) {
    const auto opened_position = detail::run_position(require_host());
    const double opening_exact_required = std::abs(opened_position.signed_units) * fill
        * staged_.syminfo.pointvalue * active_staged_fx(context.sub_bar_open_ms);
    const double opening_equity = require_host().native_marked_equity(fill);
    const bool defer_slipped_pooc_rounding =
        slipped_pooc_opening_money_scope(policy_script_bar_, context)
        && std::isfinite(opening_exact_required)
        && std::isfinite(opening_equity)
        && opening_equity >= opening_exact_required
        && opening_equity < source_money_round(opening_exact_required);
    // pine_fills.cpp:1441-1450 at ab9714be leaves this exact-funded
    // terminal POOC residual intact until the next opening print.
    // Genuine opening deficits retain the immediate checkpoint.
    // TradingView sizes a slipped market short's opening call at
    // the print its fill slipped from, and executes it there
    // with the call's own slippage (lab tv tapes
    // tests/fixtures/margin_v6 w5-qp-mkt-once and -reissue:
    // 0.0028 @1611.08 off the 1611.07 open that a 1611.06 fill
    // slipped from, none at the fill; lane W5-ENG-MARGIN-V6).
    const bool slipped_market_short = opened_position.signed_units < 0.0
        && config_.slippage != 0 && !config_.process_orders_on_close && market;
    const bool cash_contract_market_opening = config_.commission_value > 0.0
        && config_.commission_type == static_cast<int>(CommissionType::CASH_PER_CONTRACT)
        && !config_.process_orders_on_close && market;
    if (!defer_slipped_pooc_rounding && cash_contract_market_opening) {
        const double print = source_bar_fill_tick(
            fill - (opened_position.signed_units > 0.0 ? 1.0 : -1.0)
                * config_.slippage * staged_.syminfo.mintick,
            staged_.syminfo.mintick);
        const double units = source_margin_units(
            source_margin_money(print, context.sub_bar_open_ms), false);
        (void)submit_margin_call_units(print, context, units, true);
    } else if (!defer_slipped_pooc_rounding && slipped_market_short) {
        const double print = source_bar_fill_tick(
            fill + config_.slippage * staged_.syminfo.mintick,
            staged_.syminfo.mintick);
        const double held = std::abs(detail::run_position(require_host()).signed_units);
        if (submit_margin_call_slice(print, context)) {
            follow_margin_call(
                held - std::abs(detail::run_position(require_host()).signed_units),
                source_margin_fill_price(print, true), fill, context);
        }
    } else if (!defer_slipped_pooc_rounding) {
        // A sibling book's call can take a one-unit follow-up at
        // the bar's next path point (whole_unit_follow_up_due).
        const bool follow_up = sibling_book
            && whole_unit_follow_up_due(source_margin_units(source_margin_money(
                   fill, context.sub_bar_open_ms), true), fill);
        // The last of a bar's adds on a long: the call, and the
        // broker's follow-up after it (lagged_margin_follow_up_units),
        // are sized on the print the adds' fill slipped from, the
        // call executed there with its own slippage and the
        // follow-up taken at the bar's next path point. At margins
        // of 100 the book's shortfall is the same at any mark, so
        // the print decides the call only through its divisor: a
        // synthetic shortfall of 30.005 is 1.2002 lots of ETH over the
        // 25.00 print and 1.1992406... over the 25.02 fill slipped
        // from it. On a 0.0001 grid, the call is 4.8008, four times the
        // first lot floor, rather than 4.7968 from the slipped divisor
        // (int30-c4-grid-pk-mkt; lot floor before multiplying by four).
        const bool adds_book = adds_book_last && opened_position.signed_units > 0.0;
        const double print = source_bar_fill_tick(
            fill - config_.slippage * staged_.syminfo.mintick,
            staged_.syminfo.mintick);
        const auto print_money = adds_book
            ? source_margin_money(print, context.sub_bar_open_ms) : SourceMarginMoney{};
        const auto lots_before = adds_book
            ? require_host().native_open_lots(print) : std::vector<NativeOpenLot>{};
        const bool called = adds_book && config_.slippage != 0
            ? submit_margin_call_slice(print, context)
            : submit_margin_call_slice(fill, context, true);
        const double next = next_source_path_waypoint(
            policy_script_bar_, context.coordinate.path_phase, fill,
            source_path_uses_high_first(policy_script_bar_));
        if (called && follow_up && finite_positive(next))
            (void)submit_margin_call_units(next, context, 1.0, true);
        if (called && adds_book && finite_positive(next)) {
            const double taken = opened_position.signed_units
                - detail::run_position(require_host()).signed_units;
            const double more = lagged_margin_follow_up_units(
                lots_before, print_money, taken, source_margin_fill_price(print, false),
                context.sub_bar_open_ms);
            if (more > 0.0) (void)submit_margin_call_units(next, context, more, true);
        }
    }
}
 
void PineExecutionAdapter::on_applied(const native_order::ExecutionAppliedEvent& event,
                                      const NativeDecisionContext& context) {
    retired_row_scratch_.roster_pass_due = true;
    fold_source_money();
    // Nested reissues see new rows now, before the live maps' ordinary debit.
    if constexpr (PINEFORGE_POSITION_TAIL_DIAGNOSTICS::enabled) {
        if (position_tail_summary_) {
            auto& work = position_tail_summary_->work;
            const auto before = work.update_rows;
            ++work.reissue_updates;
            observe_position_tail_rows();
            work.reissue_rows += work.update_rows - before;
        } else {
            observe_position_tail_rows();
        }
    } else {
        observe_position_tail_rows();
    }
    // materialize_relative_exits can submit new legs. A submission inserts
    // into placement_ and may rehash it, so no reference or iterator into
    // placement_ may survive that call.
    std::optional<PlacementSnapshot> placement_snapshot;
    if (const auto placement = placement_.find(event.handle().incarnation);
        placement != placement_.end()) {
        placement_snapshot = placement->second;
    } else if (event.definition
               && event.definition->origin
                      == native_order::RequestOrigin::KernelLiquidation) {
        // R5: the kernel originates its own liquidation, so there is no
        // submit through submit_or_replace to record one. Adopt it into the
        // source placement table on arrival, with the same family the
        // adapter's own slice carried, so every Margin-family branch below --
        // the pending-sizing refresh, the bracket revival -- sees it exactly
        // as before.
        PlacementSnapshot adopted;
        adopted.family = PineOrderFamily::Margin;
        adopted.source_id = "__margin_call__";
        adopted.requested_qty = event.closed_units;
        adopted.forced_execution_price = event.resolved_price;
        adopted.sizing = sizing_snapshot();
        placement_.try_emplace(event.handle().incarnation, adopted); invalidate_retirement();
        placement_snapshot = adopted;
    }
    if (placement_snapshot && event.opened_units != 0.0
        && (placement_snapshot->family == PineOrderFamily::Entry
            || placement_snapshot->family == PineOrderFamily::Order)) {
        note_exit_rank_key(placement_snapshot->source_id);
    }
    if (placement_snapshot && event.closed_trade_count > 0) {
        for (std::size_t i = 0; i < event.closed_trade_count; ++i) {
            const std::size_t index = event.first_trade_index + i;
            set_exit_phase(index, static_cast<std::uint8_t>(context.coordinate.path_phase));
        }
        const bool from_bracket =
            placement_snapshot->family == PineOrderFamily::ExitLimit
            || placement_snapshot->family == PineOrderFamily::ExitStop
            || placement_snapshot->family == PineOrderFamily::ExitTrail;
        if (auto* pine_host = pine_view_of(&require_host())) {
            pine_host->adapter_label_bracket_trades(event, from_bracket);
        }
    }
    if (placement_snapshot && placement_snapshot->opening) {
        detail::ExitScratchRows<native_order::RequestHandle> paired_closes(*this);
        for (const auto& handle : live_handles_) {
            if (handle == event.handle()) continue;
            const auto pending = placement_.find(handle.incarnation);
            if (pending != placement_.end()
                && pending->second.paired_reversal_parent == event.handle()) {
                paired_closes.push_back(handle);
            }
        }
        for (const auto& handle : paired_closes) {
            const auto result = require_host().cancel(handle);
            if (result.status != native_order::CancelStatus::Cancelled) continue;
            if (const auto pending = placement_.find(handle.incarnation);
                pending != placement_.end()) {
                pending->second.cancellation = {
                    PineCancellationCause::Dependency, 1, 0,
                    event.handle().incarnation,
                    static_cast<std::int64_t>(placement_snapshot->source_sequence),
                    handle.incarnation, pending->second.placement_cycle,
                    pending->second.legs.revision(),
                    pending->second.requested_qty, kNaN};
            }
            retire(handle);
        }
    }
    if (placement_snapshot && event.closed_units > 0.0
        && detail::run_position(require_host()).signed_units == 0.0
        && (placement_snapshot->family == PineOrderFamily::Close
            || placement_snapshot->family == PineOrderFamily::CloseAll
            || placement_snapshot->family == PineOrderFamily::Order)) {
        const auto closed_side = static_cast<PositionSide>(
            placement_snapshot->projection_position_side);
        detail::ExitScratchRows<native_order::RequestHandle> stale_entries(*this);
        for (const auto& handle : live_handles_) {
            if (handle == event.handle()) continue;
            const auto found = placement_.find(handle.incarnation);
            if (found == placement_.end()) continue;
            const auto& pending = found->second;
            if (!pending.opening || pending.family != PineOrderFamily::Entry
                || pending.is_long != (closed_side == PositionSide::LONG)
                || pending.projection_position_side
                    != static_cast<std::int32_t>(closed_side)) {
                continue;
            }
            const bool resting_limit =
                pending.projection_created_bar < projection_bar_index(context)
                && finite_positive(pending.exit_levels.limit)
                && !finite_positive(pending.exit_levels.stop);
            // Under process_orders_on_close a stop entry resting from an
            // earlier bar survives the flat as a limit does: TradingView
            // fills it later and binds its exit (tests/fixtures/exit_binding
            // stop-entry-parent).
            const bool resting_stop =
                detail::exit_binding_rule_switches().resting_stop_entry_survives_close
                && config_.process_orders_on_close && !config_.calc_on_order_fills
                && margins_disabled()
                && pending.projection_created_bar < projection_bar_index(context)
                && finite_positive(pending.exit_levels.stop);
            const bool coqueued_within_cap =
                pending.projection_created_bar
                    == placement_snapshot->projection_created_bar
                && (!pending.projection_over_pyramiding
                    || (placement_snapshot->close_batch_calls != 0
                        && (finite_positive(pending.exit_levels.limit)
                            || finite_positive(pending.exit_levels.stop))));
            const bool preserved_stop =
                placement_snapshot->family == PineOrderFamily::CloseAll
                && pending.preserved_by_close_all == event.handle()
                && pending.preserved_close_all_bar
                    == placement_snapshot->projection_created_bar;
            const bool frozen_over_cap_transaction = pending.frozen_market_instruction
                && pending.projection_over_pyramiding;
            if (!resting_limit && !resting_stop && !coqueued_within_cap && !preserved_stop
                && !frozen_over_cap_transaction) {
                stale_entries.push_back(handle);
            }
        }
        for (const auto& handle : stale_entries) {
            const auto result = require_host().cancel(handle);
            if (result.status != native_order::CancelStatus::Cancelled) continue;
            if (const auto found = placement_.find(handle.incarnation);
                found != placement_.end()) {
                found->second.cancellation = {
                    PineCancellationCause::Dependency, 1, 0,
                    event.handle().incarnation,
                    static_cast<std::int64_t>(placement_snapshot->source_sequence),
                    handle.incarnation, found->second.placement_cycle,
                    found->second.legs.revision(), found->second.requested_qty, kNaN};
            }
            retire(handle);
        }
    }
    if (placement_snapshot
        && (placement_snapshot->family == PineOrderFamily::Close
            || placement_snapshot->family == PineOrderFamily::CloseAll)
        && event.closed_units > 0.0) {
        // ab9714be pine_fills.cpp:7461-7468: the close that flattened the book
        // is bound to the position cycle it was issued in.  Every exit created
        // while that position was open is Removed at the flat, before the
        // paired reversal entry of the NEXT cycle is released below, so the
        // stale bracket can neither fill against the fresh lot on this bar nor
        // be revived against a later reuse of the entry id
        // (pine_fills.cpp:7667-7675).  Only a bracket the script placed behind
        // this same close, for the close's own paired reversal, is reached by
        // the legacy queue walk after that entry filled and stays armed.
        if (detail::run_position(require_host()).signed_units == 0.0)
            retire_in_position_exits_at_flat(/*preserve_pending_parents=*/true,
                                             /*dormant_rows_only=*/false,
                                             &*placement_snapshot);
        detail::ExitScratchRows<std::uint64_t> after_close(*this);
        auto& versions = detail::exit_scratch_versions(after_close.context());
        std::size_t remaining = 0;
        for (std::size_t index = 0; index < pending_entries_.size(); ++index) {
            auto& entry = pending_entries_[index];
            if (entry.snapshot.paired_reversal_parent == event.handle()) {
                after_close.push_back(versions.pending(after_close.scope(), std::as_const(entry.request),
                                                       std::as_const(entry.snapshot),
                                                       std::as_const(entry.replacement_key)));
            } else {
                if (remaining != index) pending_write(pending_entries_[remaining]) = std::move(entry);
                ++remaining;
            }
        }
        pending_write(pending_entries_).resize(remaining);
        for (const auto version : after_close) {
            PendingEntry entry;
            std::as_const(versions).pending(version, entry.request, entry.snapshot, entry.replacement_key);
            entry.snapshot.paired_reversal_parent = {};
            entry.snapshot.market_admission = {};
            entry.request.owner = native_order::Independent{};
            // ab9714be pine_fills.cpp:8013-8018: a same-pass close flattens
            // first. A following opposite stop that the close's fill has not
            // gapped through stays resting and fills at the stop level on
            // the remaining path, not at the close's open print.
            const bool priced_stop = finite_positive(entry.snapshot.exit_levels.stop)
                && !finite_positive(entry.snapshot.exit_levels.limit)
                && !finite_positive(entry.snapshot.exit_levels.trail_points)
                && !finite_positive(entry.snapshot.exit_levels.trail_price)
                && !finite_positive(entry.snapshot.exit_levels.trail_offset);
            // A close the bar's own calculation executed (immediately = true)
            // fills at the bar's close, where nothing trades after it: the
            // entry the pass sent behind it waits for the next bar's open, as
            // it does when the close's fill is known before the entry is
            // sent (lab tv tapes te-coof-immediate-reentry-*,
            // tests/fixtures/coof_immediate_close; lane TAIL-E).
            const bool calculation_close = placement_snapshot->immediately
                && context.coordinate.provenance == NativePriceProvenance::Calculation;
            const bool marketable_now = !calculation_close
                && (!priced_stop
                    || pure_stop_entry_marketable_at(
                        entry.snapshot, event.resolved_price));
            if (marketable_now) {
                entry.snapshot.forced_execution_price = event.resolved_price;
                // ab9714be pine_fills.cpp:3848-3856 orders the full close
                // first, but each market fill still books its own side's
                // slippage off the shared open print (engine.hpp:1207-1210).
                // A released entry on the closed position's own side is a
                // buy after a sell (or the reverse), so it cannot reuse the
                // close's slipped price.
                const auto closed_side = static_cast<PositionSide>(
                    placement_snapshot->projection_position_side);
                if (!priced_stop && config_.slippage != 0
                    && closed_side != PositionSide::FLAT
                    && entry.snapshot.is_long == (closed_side == PositionSide::LONG)) {
                    entry.snapshot.forced_execution_price =
                        nearest_tick(event.raw_price, staged_.syminfo.mintick)
                        + (entry.snapshot.is_long ? 1.0 : -1.0) * config_.slippage
                            * staged_.syminfo.mintick;
                }
            }
            native_order::RequestHandle prior_flip_stop{};
            const bool self_touched = priced_stop && policy_script_bar_valid_
                && (entry.snapshot.is_long
                    ? policy_script_bar_.high >= entry.snapshot.exit_levels.stop
                    : policy_script_bar_.low <= entry.snapshot.exit_levels.stop);
            if (priced_stop && !marketable_now && self_touched) {
                std::uint64_t prior_seq = std::numeric_limits<std::uint64_t>::max();
                for (const auto& handle : live_handles_) {
                    const auto found = placement_.find(handle.incarnation);
                    if (found == placement_.end()) continue;
                    const auto& prior = found->second;
                    if (!prior.opening || prior.family != PineOrderFamily::Entry
                        || prior.is_long != entry.snapshot.is_long
                        || !finite_positive(prior.exit_levels.stop)
                        || finite_positive(prior.exit_levels.limit)
                        || prior.command_sequence >= entry.snapshot.command_sequence) {
                        continue;
                    }
                    const auto created = static_cast<PositionSide>(
                        prior.projection_position_side);
                    if (created == PositionSide::FLAT
                        || (created == PositionSide::LONG) == prior.is_long) {
                        continue;
                    }
                    const bool prior_touched = prior.is_long
                        ? policy_script_bar_.high >= prior.exit_levels.stop
                        : policy_script_bar_.low <= prior.exit_levels.stop;
                    if (!prior_touched || prior.command_sequence >= prior_seq) continue;
                    prior_seq = prior.command_sequence;
                    prior_flip_stop = handle;
                }
            }
            if (prior_flip_stop.incarnation != 0) {
                const double units = finite_positive(entry.snapshot.requested_qty)
                    ? std::abs(entry.snapshot.requested_qty)
                    : (finite_positive(entry.snapshot.sizing.frozen_units)
                        ? entry.snapshot.sizing.frozen_units
                        : std::abs(config_.default_qty_value));
                entry.request.intent = native_order::Transact{
                    entry.snapshot.is_long ? units : -units};
                entry.request.owner = native_order::WaitForApplied{prior_flip_stop};
            }
            const auto accepted = submit_or_replace(
                std::move(entry.request), std::move(entry.snapshot), true,
                entry.replacement_key);
            if (accepted && marketable_now && prior_flip_stop.incarnation == 0) {
                const auto outcome = require_host().execute_current(
                    {*accepted, NativeCurrentPriceRule::NearestTick});
                (void)outcome;
            }
        }
    }
    bool preclose_intraday_loss = false;
    // A fill at the open point that captured the day's start equity closes an
    // order carried from the previous day: its P&L is already in that equity,
    // so TradingView does not count it as the day's loss, market or priced
    // (lab tv tape tests/fixtures/intraday_loss_open_fill; lane W8A-SIGSTATE-1
    // R4). An intrabar fill keeps the own-fill exclusion
    // (test_risk_max_intraday_loss_tv t1).
    const bool day_open_fill = context.coordinate.path_phase == NativePathPhase::Open
        && context.sub_index == 0
        && context.script_bar_open_ms == day_ledger_.intraday_start_script_bar;
    if (event.closed_trade_count > 0 && risk_.max_intraday_loss > 0.0
        && !intraday_loss_orders_blocked() && !day_open_fill
        && std::isfinite(day_ledger_.intraday_start_equity)) {
        double closed_pnl = 0.0;
        const auto& host = require_host();
        for (std::size_t i = 0; i < event.closed_trade_count; ++i) {
            const auto index = event.first_trade_index + i;
            if (index < static_cast<std::size_t>(host.trade_count()))
                closed_pnl += host.get_trade(static_cast<int>(index)).pnl;
        }
        const double after = host.native_marked_equity(event.resolved_price);
        const double before = after - closed_pnl;
        const double loss = day_ledger_.intraday_start_equity - before;
        const double threshold = risk_.max_intraday_loss_percent
            ? day_ledger_.intraday_start_equity * risk_.max_intraday_loss / 100.0
            : risk_.max_intraday_loss;
        if (std::isfinite(risk_.max_intraday_loss) && !std::isfinite(threshold)) {
            engine_command_value_invalid_or_count("risk.threshold",
                EngineValueStage::risk, EngineValueReason::numeric_overflow);
        }
        const double epsilon = 1e-9 * std::max(1.0, std::abs(threshold));
        preclose_intraday_loss = std::isfinite(before) && threshold > 0.0
            && loss > 0.0 && loss + epsilon >= threshold;
    }
    last_applied_ordinal_ = event.ordinal;
    if (placement_snapshot && placement_snapshot->family == PineOrderFamily::Entry
        && std::abs(event.opened_units) > 0.0) {
        entry_openings_this_interval_ += 1;
        if (!throttled_reopen_rearm_.empty())
            rearm_throttled_reopens();
    }
    const double live_position = detail::run_position(require_host()).signed_units;
    const int next_sign = live_position > 0.0 ? 1 : (live_position < 0.0 ? -1 : 0);
    const bool flipped_position = current_position_sign_ != 0 && next_sign != 0
        && current_position_sign_ != next_sign;
    if (flipped_position && event.closed_units > 0.0) {
        // A reversal retires the complete prior physical side before opening
        // the new one.  The generic settlement event owns that fact; mirror
        // it into every source cohort so a later reuse of an old entry id
        // cannot reserve against already-closed exposure.
        std::vector<SourceId> preserved_cohorts;
        if (placement_snapshot) preserved_cohorts.push_back(placement_snapshot->source_id);
        for (const auto& handle : live_handles_) {
            const auto pending = placement_.find(handle.incarnation);
            if (pending != placement_.end()
                && pending->second.opening
                && pending->second.family == PineOrderFamily::Entry
                && pending->second.is_long == (live_position > 0.0)) {
                preserved_cohorts.push_back(pending->second.source_id);
            }
        }
        std::sort(preserved_cohorts.begin(), preserved_cohorts.end());
        // An empty, spilled cohort can still own queued exits. Membership uses
        // the logical table, not residency/exposure; the helper keeps the old
        // sorted owner order and exact successful scratch allocation.
        detail::ExitScratchRows<SourceId> closed_cohorts(*this);
        cancel_reversal_exit_owners(preserved_cohorts, closed_cohorts);
        // Selection handles are reserved before cancellation, exactly where
        // the full text selection used to be built. Its scope remains alive
        // through the remaining reversal cleanup below.
        //
        // The helper scans queued owners once. Debug checks every skipped id
        // against the old canceler's per-store predicates; Release never
        // walks historical ids here. Scratch failure status is propagated by
        // the same transaction/error boundary as the old selected row puts.
        // Empty bracket families still receive one cleanup pass per close.
        if (position_tail_summary_) position_tail_summary_->forget_origins();
        const auto held = cohorts_by_id_.held_rows();
        for (auto at = held.begin(); at != held.end();) {
            const auto current = at++;
            auto& cohort = *current;
            assert(cohort_opened_slot_count_ >= cohort.second.opened.size());
            cohort_opened_slot_count_ -= cohort.second.opened.size();
            ::pineforge::detail::clear_exposure_storage(cohort.second.opened);
            ::pineforge::detail::clear_exposure_storage(cohort.second.live_units_by_origin);
            cohorts_by_id_.refresh_held(current);
        }
        // ab9714be pine_strategy_host.cpp:244 / :261
        // reset_source_open_position_ledgers_before_book clears the close
        // ledgers when a position is opened or reversed, so unclosed units of
        // the prior position side cannot survive to admit a later close of that
        // side against the new position.
        close_logical_units_.clear();
        close_ledger_records_.clear();
        pyramiding_records_.clear();
        exit_tombstones_.clear();
    }
    if (next_sign != 0 && (current_position_sign_ == 0 || current_position_sign_ != next_sign)) {
        ++current_position_cycle_;
        position_tail_spill_.reset();
        position_open_script_bar_ = context.script_bar_open_ms;
        begin_position_tail_summary();
        position_open_epoch_ = broker_open_epoch_;
        position_open_bar_index_ = context.coordinate.interval_index;
        position_open_phase_ = context.coordinate.path_phase;
        position_open_priced_ = placement_snapshot
            && (finite_positive(placement_snapshot->exit_levels.limit)
                || finite_positive(placement_snapshot->exit_levels.stop)
                || placement_snapshot->family == PineOrderFamily::Order);
    }
    current_position_sign_ = next_sign;
    per_entry_exits_after_fill(placement_snapshot, event);
    if (placement_snapshot
        && (placement_snapshot->family == PineOrderFamily::ExitLimit
            || placement_snapshot->family == PineOrderFamily::ExitStop
            || placement_snapshot->family == PineOrderFamily::ExitTrail)
        && event.closed_units > 0.0 && live_position != 0.0
        // ab9714be pine_orders.cpp:330-337: execute_partial_exit_qty recognizes explicit requested quantity reductions
        && ((std::isfinite(placement_snapshot->requested_qty) && placement_snapshot->requested_qty > 0.0)
            || (std::isfinite(placement_snapshot->qty_percent) && placement_snapshot->qty_percent < 100.0 - 1e-9))) {
        // The exit tombstones (exit_child_tombstones): a partial strategy.exit
        // child that filled is never revived for the entry incarnation it
        // filled under -- the newest opening of its from_entry then -- by a
        // later call of the same exit or by an older leg of it, under
        // process_orders_on_close too, where the re-call at the fill bar's
        // close is marketable (tests/fixtures/admission_rules
        // c5b-pooc-tp-tombstone-marketable: the engine had re-bound TP1
        // for the unreserved two shares). An exit armed for a later opening
        // of the id fills as before (test_exit_bracket_pending_entry_leg).
        if (detail::margin_rule_switches().exit_child_tombstones
            && !placement_snapshot->from_entry.empty() && pinned_lot_grid()) {
            const std::uint64_t origin = entry_incarnation_of(placement_snapshot->from_entry);
            if (origin != 0)
                exit_tombstones_[placement_snapshot->source_id + "\x1f"
                                 + placement_snapshot->from_entry] = origin;
        }
        // ab9714be pine_fills.cpp:7012-7024: other pending orders with this
        // id count as siblings; same-bracket legs are one owner order.
        if (!partial_exit_sibling_live(*placement_snapshot, event.handle())) {
            consumed_partial_exit_cycles_.insert_or_assign(
                placement_snapshot->source_id + "\x1f" + placement_snapshot->from_entry,
                current_position_cycle_);
        }
    }
    if (placement_snapshot && placement_snapshot->family == PineOrderFamily::Order
        && placement_snapshot->oca_type == 1 && !placement_snapshot->oca_name.empty()) {
        const bool fully_filled = !std::isfinite(placement_snapshot->requested_qty)
            || event.filled_working >= placement_snapshot->requested_qty;
        if (fully_filled) {
            detail::ExitScratchRows<native_order::RequestHandle> siblings(*this);
            for (const auto& handle : live_handles_) {
                if (handle == event.handle()) continue;
                const auto peer = placement_.find(handle.incarnation);
                if (peer != placement_.end()
                    && (peer->second.family == PineOrderFamily::Order
                        || peer->second.family == PineOrderFamily::Entry)
                    && peer->second.oca_type == 1
                    && peer->second.oca_name == placement_snapshot->oca_name) {
                    siblings.push_back(handle);
                }
            }
            for (const auto& sibling : siblings) {
                const auto result = require_host().cancel(sibling);
                if (result.status == native_order::CancelStatus::Cancelled) retire(sibling);
            }
        }
    }
    // The over-fill lot a frozen strategy.close(id) or close_all() opened as it
    // crossed a carried short to a long (book_owed_close_follow_up) is a lot of
    // its own in the close ledger and the pyramiding records, under the close
    // order's label and ahead of the entry beside it: the nameless fills that
    // take it first in first out -- the next open's margin calls -- book it,
    // and a later strategy.close of that entry closes all of the entry's units
    // (switch close_follow_up_after_script; synthetic OANDA:EURUSD 15m:
    // strategy.close("LONG") closes 40000.00 and the entry "SHORT" opens
    // 40100.00). No script id names it, so it has no cohort.
    if (PF_RARE(placement_snapshot && placement_snapshot->crosses_zero
                && !placement_snapshot->opening)
        && (placement_snapshot->family == PineOrderFamily::Close
            || placement_snapshot->family == PineOrderFamily::CloseAll)
        && std::abs(event.opened_units) > 0.0 && live_position > 0.0
        && config_.process_orders_on_close
        && detail::margin_schedule_switches().close_follow_up_after_script) {
        const SourceId lot = placement_snapshot->family == PineOrderFamily::Close
            ? "__close__" + placement_snapshot->source_id : placement_snapshot->source_id;
        credit_close_ledger(lot, std::abs(event.opened_units));
        credit_pyramiding_record(lot, event.handle().incarnation, std::abs(event.opened_units));
    }
    if (placement_snapshot && placement_snapshot->opening
        && std::abs(event.opened_units) > 0.0) {
        withdraw_void_exits(placement_snapshot->source_id);
        // A market entry is one the script gave neither a limit nor a stop:
        // a limit entry marketable at a process_orders_on_close close fills
        // through a market request and is a limit entry here.
        settle_void_global_exits(!finite_positive(placement_snapshot->exit_levels.limit)
                                 && !finite_positive(placement_snapshot->exit_levels.stop));
        bind_pending_exits_to_fill(placement_snapshot->source_id);
        // Explicit brackets armed while their same-id parent was still flat
        // use origin zero as a temporary source binding. Once that parent
        // applies, bind those live legs to its actual incarnation and move
        // their replacement keys with it. A later reissue must replace the
        // carried legs before adding legs for another pending instance
        // (ab9714be:test_exit_bracket_pending_entry_leg.cpp:10-18).
        for (const auto& handle : live_handles_) {
            auto child = placement_.find(handle.incarnation);
            if (child == placement_.end()) continue;
            auto& snapshot = child->second;
            const bool exit = snapshot.family == PineOrderFamily::ExitLimit
                || snapshot.family == PineOrderFamily::ExitStop
                || snapshot.family == PineOrderFamily::ExitTrail;
            if (!exit || snapshot.from_entry != placement_snapshot->source_id
                || snapshot.bracket_origin.incarnation != 0
                || !std::isfinite(snapshot.requested_qty)) {
                continue;
            }
            const auto replacement = [&](std::uint64_t origin) {
                return snapshot.source_id + "\x1f" + snapshot.from_entry + "\x1f"
                    + std::to_string(static_cast<int>(snapshot.family)) + "\x1f"
                    + std::to_string(origin);
            };
            const auto old_key = checked_live_key(replacement(0));
            const auto old = live_by_source_key_.find(old_key);
            if (old != live_by_source_key_.end() && old->second == handle)
                live_by_source_key_.erase(old);
            snapshot.bracket_origin = event.handle(); invalidate_retirement();
            live_by_source_key_[checked_live_key(replacement(event.handle().incarnation))] = live_source_value(handle, replacement(event.handle().incarnation));
        }
        {
            const auto cohort = require_cohort(placement_snapshot->source_id);
            auto& facts = cohort->second;
            facts.cycle = event.cycle_after;
            if (std::find(facts.opened.begin(), facts.opened.end(), event.handle())
                    == facts.opened.end()) {
                facts.opened.push_back(event.handle());
                ++cohort_opened_slot_count_;
                cohorts_by_id_.refresh_held(cohort);
            }
            facts.live_units_by_origin[event.handle().incarnation]
                += std::abs(event.opened_units);
            cohorts_by_id_.refresh_held(cohort);
            if (position_tail_summary_)
                position_tail_summary_->open_origin(
                    event.handle().incarnation, event.opened_units > 0.0,
                    PINEFORGE_POSITION_TAIL_DIAGNOSTICS{});
            if (position_tail_summary_)
                position_tail_summary_->live_cohort(&*cohort, true);
        }
        credit_close_ledger(placement_snapshot->source_id, std::abs(event.opened_units));
        credit_pyramiding_record(placement_snapshot->source_id, event.handle().incarnation,
                                 std::abs(event.opened_units));
        record_opening_fee(*placement_snapshot, event);
        materialize_pending_bracket_legs(event);
        const auto created_side = static_cast<PositionSide>(
            placement_snapshot->projection_position_side);
        const bool consumed_deferred_carry =
            finite_positive(placement_snapshot->projection_tv_carry_qty)
            && created_side != PositionSide::FLAT
            && ((created_side == PositionSide::LONG) != placement_snapshot->is_long);
        if (consumed_deferred_carry) {
            for (const auto& handle : live_handles_) {
                if (handle == event.handle()) continue;
                const auto sibling = placement_.find(handle.incarnation);
                if (sibling == placement_.end()) continue;
                auto& candidate = sibling->second;
                if (!candidate.opening
                    || candidate.source_id == placement_snapshot->source_id
                    || candidate.projection_position_side
                        != placement_snapshot->projection_position_side
                    || candidate.projection_created_bar
                        > placement_snapshot->projection_created_bar) {
                    continue;
                }
                candidate.projection_tv_carry_qty = 0.0;
            }
        }
        materialize_relative_exits(*placement_snapshot, event);
        per_entry_exits_at_entry_fill(*placement_snapshot, event);
        const bool true_paired_transaction =
            placement_snapshot->paired_flat_market_candidate
            && finite_positive(placement_snapshot->paired_flat_market_own_qty)
            && finite_positive(placement_snapshot->paired_flat_market_transaction_qty)
            && placement_snapshot->paired_flat_market_transaction_qty
                > placement_snapshot->paired_flat_market_own_qty + 1e-10;
        if (!true_paired_transaction) {
            reconcile_deferred_exit_reservations(
                placement_snapshot->source_id,
                cohort_exposure_for(placement_snapshot->source_id));
        }
        flush_pending_bracket_legs(event.handle(), false);
        // ab9714be pine_fills.cpp:7652-7672 (finding-347): a leg re-issued for
        // a carried, already opened origin draws on the live position; it is
        // not this parent's pre-armed bracket and never waits for it.
        const auto carried_origin_leg = [&](const PlacementSnapshot& row) {
            return row.bracket_origin.incarnation != 0
                && row.bracket_origin != event.handle();
        };
        const bool partial_prearmed_parent = std::isfinite(
                [&]() {
                    double smallest = kNaN;
                    for (const auto& handle : live_handles_) {
                        const auto pending = placement_.find(handle.incarnation);
                        if (pending == placement_.end()) continue;
                        const auto& row = pending->second;
                        if ((row.family == PineOrderFamily::ExitStop
                             || row.family == PineOrderFamily::ExitLimit)
                            && row.from_entry == placement_snapshot->source_id
                            && row.projection_created_bar
                                == placement_snapshot->projection_created_bar
                            && !carried_origin_leg(row)
                            && std::isfinite(row.requested_qty)) {
                            smallest = std::isfinite(smallest)
                                ? std::min(smallest, row.requested_qty)
                                : row.requested_qty;
                        }
                    }
                    return smallest;
                }())
            && [&]() {
                for (const auto& handle : live_handles_) {
                    const auto pending = placement_.find(handle.incarnation);
                    if (pending == placement_.end()) continue;
                    const auto& row = pending->second;
                    if ((row.family == PineOrderFamily::ExitStop
                         || row.family == PineOrderFamily::ExitLimit)
                        && row.from_entry == placement_snapshot->source_id
                        && row.projection_created_bar
                            == placement_snapshot->projection_created_bar
                        && !carried_origin_leg(row)
                        && std::isfinite(row.requested_qty)
                        && row.requested_qty < std::abs(event.opened_units)) {
                        return true;
                    }
                }
                return false;
            }();
        const bool multiple_prearmed_parents = std::any_of(
            live_handles_.begin(), live_handles_.end(), [&](const auto& handle) {
                if (handle == event.handle()) return false;
                const auto pending = placement_.find(handle.incarnation);
                return pending != placement_.end() && pending->second.opening
                    && pending->second.family == PineOrderFamily::Entry
                    && pending->second.projection_created_bar
                        == placement_snapshot->projection_created_bar;
            });
        // A same-bar leg whose level is already marketable at the parent's
        // fill is a wrong-side scratch candidate; legacy scratches it at the
        // open for a sole MARKET parent only (test_prearmed_market_parent_gap_exit).
        const auto marketable_at_fill = [&](const PlacementSnapshot& row) {
            const bool long_position = event.opened_units > 0.0;
            const bool stop_marketable = finite_positive(row.exit_levels.stop)
                && (long_position ? event.resolved_price <= row.exit_levels.stop
                                  : event.resolved_price >= row.exit_levels.stop);
            const bool limit_marketable = finite_positive(row.exit_levels.limit)
                && (long_position ? event.resolved_price >= row.exit_levels.limit
                                  : event.resolved_price <= row.exit_levels.limit);
            return stop_marketable || limit_marketable;
        };
        // ab9714be pine_fills.cpp:7679-7700: TradingView evaluates a filled
        // parent's priced exits on the entry bar itself. With sibling pre-armed
        // parents on the same bar, only the wrong-side (marketable) legs wait
        // for the next opening; the right-side legs join the entry bar
        // (L9g; delta-3 P0-N4). A partial-quantity bracket waits entirely.
        if (partial_prearmed_parent || multiple_prearmed_parents) {
            detail::ExitScratchRows<native_order::RequestHandle> delayed_legs(*this);
            for (const auto& handle : live_handles_) {
                const auto pending = placement_.find(handle.incarnation);
                if (pending == placement_.end()) continue;
                const auto& row = pending->second;
                const bool matches_parent = row.from_entry.empty()
                    || row.from_entry == placement_snapshot->source_id;
                if ((row.family == PineOrderFamily::ExitStop
                     || row.family == PineOrderFamily::ExitLimit)
                    && matches_parent && row.per_entry_origin == 0
                    && row.projection_created_bar
                        == placement_snapshot->projection_created_bar
                    && !carried_origin_leg(row)
                    && (partial_prearmed_parent || marketable_at_fill(row))) {
                    delayed_legs.push_back(handle);
                }
            }
            for (const auto& handle : delayed_legs) {
                const auto pending = placement_.find(handle.incarnation);
                if (pending == placement_.end()) continue;
                const PlacementSnapshot row = pending->second;
                native_order::Request request;
                request.intent = native_order::HostSized{
                    native_order::HostSizedKind::Close, std::nullopt};
                request.label = row.source_id;
                request.comment = row.comment;
                request.owner = owner_for_close(row.from_entry, true);
                const bool exit_is_buy = event.opened_units < 0.0;
                if (row.family == PineOrderFamily::ExitStop) {
                    request.trigger = native_order::Stop{source_trigger_threshold(
                        row.exit_levels.stop, staged_.syminfo.mintick,
                        exit_is_buy, false)};
                } else {
                    request.trigger = native_order::Limit{source_trigger_threshold(
                        row.exit_levels.limit, staged_.syminfo.mintick,
                        exit_is_buy, true)};
                }
                const bool explicit_origin = std::isfinite(row.requested_qty)
                    && row.bracket_origin.incarnation != 0;
                const std::string origin_suffix = explicit_origin
                    ? "\x1f" + std::to_string(row.bracket_origin.incarnation) : "";
                const std::string group_name = row.oca_name.empty()
                    ? row.source_id + "\x1f" + row.from_entry + origin_suffix
                    : row.oca_name;
                request.group = group_for(group_name, 1);
                const std::string replacement_key = row.source_id + "\x1f"
                    + row.from_entry + "\x1f"
                    + std::to_string(static_cast<int>(row.family)) + origin_suffix;
                const auto cancelled = require_host().cancel(handle);
                if (cancelled.status != native_order::CancelStatus::Cancelled)
                    continue;
                retire(handle);
                delayed_market_orders_.push_back({
                    std::move(request), row, replacement_key,
                    broker_open_epoch_ + 1U});
            }
        }
        if (!partial_prearmed_parent) {
            std::optional<PlacementSnapshot> rearm;
            for (const auto& handle : live_handles_) {
                const auto pending = placement_.find(handle.incarnation);
                if (pending == placement_.end()) continue;
                const auto& row = pending->second;
                const bool matches_parent = row.from_entry.empty()
                    || row.from_entry == placement_snapshot->source_id;
                // An entry's own bracket of a per-entry global exit stands as
                // it was placed (per_entry_exits_at_entry_fill).
                if ((row.family != PineOrderFamily::ExitStop
                     && row.family != PineOrderFamily::ExitLimit)
                    || !matches_parent || row.per_entry_origin != 0
                    || row.projection_created_bar
                        != placement_snapshot->projection_created_bar
                    || carried_origin_leg(row)) {
                    continue;
                }
                // A from_entry "" exit placed while the position this fill
                // reversed was open belongs to that position (TVDEF-DROPS R3):
                // it never joins the new side's entry-bar path (lab tv
                // w4-f08b-pooc-coof cell S).
                if (row.from_entry.empty() && event.closed_units > 0.0
                    && row.projection_position_side
                        == static_cast<std::int32_t>(event.opened_units > 0.0
                                                         ? PositionSide::SHORT
                                                         : PositionSide::LONG)) {
                    continue;
                }
                const bool long_position = event.opened_units > 0.0;
                const bool stop_marketable = finite_positive(row.exit_levels.stop)
                    && (long_position ? event.resolved_price <= row.exit_levels.stop
                                      : event.resolved_price >= row.exit_levels.stop);
                const bool limit_marketable = finite_positive(row.exit_levels.limit)
                    && (long_position ? event.resolved_price >= row.exit_levels.limit
                                      : event.resolved_price <= row.exit_levels.limit);
                const bool equal_limit = finite_positive(row.exit_levels.limit)
                    && event.resolved_price == row.exit_levels.limit;
                if ((!stop_marketable && !limit_marketable) || equal_limit) {
                    rearm = row;
                    break;
                }
            }
            if (rearm) {
                // ab9714be pine_fills.cpp:7788-7800: a full prearmed MARKET
                // parent bracket that is not an immediate wrong-side scratch
                // joins the remaining entry-bar path. Reissuing from the
                // parent's Applied callback gives the generic requests that
                // exact birth floor and the now-known close direction. With
                // sibling parents the wrong-side leg was parked above, so
                // only the right-side levels are reissued here (L9g).
                const bool long_position = event.opened_units > 0.0;
                const bool stop_wrong_side = multiple_prearmed_parents
                    && finite_positive(rearm->exit_levels.stop)
                    && (long_position ? event.resolved_price <= rearm->exit_levels.stop
                                      : event.resolved_price >= rearm->exit_levels.stop);
                const bool limit_wrong_side = multiple_prearmed_parents
                    && finite_positive(rearm->exit_levels.limit)
                    && (long_position ? event.resolved_price >= rearm->exit_levels.limit
                                      : event.resolved_price <= rearm->exit_levels.limit)
                    && event.resolved_price != rearm->exit_levels.limit;
                exit(rearm->source_id, rearm->from_entry,
                     limit_wrong_side ? kNaN : rearm->exit_levels.limit,
                     stop_wrong_side ? kNaN : rearm->exit_levels.stop,
                     rearm->exit_levels.trail_points,
                     rearm->exit_levels.trail_offset,
                     rearm->exit_levels.trail_price,
                     rearm->qty_percent, rearm->comment,
                     rearm->requested_qty, rearm->oca_name,
                     rearm->exit_levels.profit_ticks,
                     rearm->exit_levels.loss_ticks);
            }
        }
        if (event.closed_units > 0.0 && event.opened_units > 0.0
            && config_.default_qty_type
                == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
            && config_.default_qty_value < 100.0) {
            // ab9714be pine_fills.cpp:3670-3780, famx NIFTY admit90:
            // after the opposite MARKET wins the gapped-open arbitration,
            // its newly materialized relative trail does not scratch the
            // admitted reversal at that same opening point.
            detail::ExitScratchRows<native_order::RequestHandle> prearmed_trails(*this);
            for (const auto& handle : live_handles_) {
                const auto pending = placement_.find(handle.incarnation);
                if (pending != placement_.end()
                    && pending->second.family == PineOrderFamily::ExitTrail
                    && pending->second.from_entry == placement_snapshot->source_id
                    && pending->second.projection_created_bar
                        == placement_snapshot->projection_created_bar) {
                    prearmed_trails.push_back(handle);
                }
            }
            for (const auto& handle : prearmed_trails) {
                const auto result = require_host().cancel(handle);
                if (result.status == native_order::CancelStatus::Cancelled)
                    retire(handle);
            }
        }
        // The generic cohort is already the quantity authority.  Rebind only
        // adapter lifecycle/reservation receipts after the opening becomes a
        // live physical fact; no request is resized or resubmitted here.
        detail::ExitScratchBatchRows<native_order::RequestHandle> handles(*this);
        for (const auto& handle : live_handles_) handles.push_back(handle);
        handles.finish();
        for (const auto& handle : handles) {
            const auto pending = placement_.find(handle.incarnation);
            if (pending == placement_.end()) continue;
            auto& candidate = pending->second;
            const bool exit = candidate.family == PineOrderFamily::ExitLimit
                || candidate.family == PineOrderFamily::ExitStop
                || candidate.family == PineOrderFamily::ExitTrail;
            if (!exit) continue;
            if (candidate.from_entry == placement_snapshot->source_id) {
                if (candidate.legs.target().incarnation
                    && candidate.legs.target().owner != current_position_cycle_) {
                    const exit_legs::Frame cause{event.ordinal,
                        context.coordinate.interval_index,
                        context.sub_count > 1 ? exit_legs::Domain::MagnifierFillRecalc
                                              : exit_legs::Domain::FillRecalc,
                        exit_legs::Phase::Observation};
                    const exit_legs::Action bind{candidate.legs.target(),
                        candidate.legs.revision(), cause,
                        exit_legs::BindOwner{current_position_cycle_}};
                    (void)candidate.legs.apply(candidate.legs.target(), bind); invalidate_retirement();
                }
                initialize_l4c_policy(candidate, handle);
            }
            const bool bound_preexit_add = placement_snapshot
                && placement_snapshot->opening && event.opened_units > 0.0
                && placement_snapshot->command_sequence < candidate.command_sequence;
            const bool selected_growth_source = placement_snapshot
                && placement_snapshot->reservation_growth_source.reservation_owner()
                && *placement_snapshot->reservation_growth_source.reservation_owner()
                    == handle.incarnation;
            if (candidate.reservation_expansion.capture() && handle != event.handle()
                && selected_growth_source
                && (candidate.reservation_expansion.population_open() || bound_preexit_add)) {
                if (bound_preexit_add && std::isfinite(candidate.projection_remaining_qty)) {
                    candidate.projection_remaining_qty += std::abs(event.opened_units);
                }
                if (candidate.reservation_expansion.population_open()) {
                    candidate.pooc_global_full_exit_dynamic_qty = false;
                    candidate.pooc_global_full_exit_tracks_bound_adds = false;
                    candidate.reservation_expansion.close_population(event.handle().incarnation);
                    candidate.pooc_global_full_exit_bound_add = bound_preexit_add;
                }
            }
        }
    }
    if (placement_snapshot && placement_snapshot->opening
        && placement_snapshot->reverse_to && event.closed_units > 0.0
        && event.opened_units > 0.0) {
        purge_brackets_after_applied_reversal(*placement_snapshot);
    }
    // A from_entry="" exit the script placed while the reversed position was
    // open belongs to that position, as every exit a flattening close
    // outlives does (retire_in_position_exits_at_flat): TradingView never
    // applies it to the side the reversal opens, on its entry bar or later,
    // in either direction (lane TVDEF-DROPS, tests/fixtures/tvdef_drops R3).
    // The kernel binds such a close to the book it first evaluates against;
    // one evaluated before this fill was already cancelled with that book
    // and waits for its terminal receipt: a cancel of it would record a
    // NotWorking event, so only a leg still working is cancelled here.
    if (placement_snapshot && placement_snapshot->opening
        && placement_snapshot->reverse_to && event.closed_units > 0.0
        && event.opened_units != 0.0) {
        const auto reversed_side = static_cast<std::int32_t>(
            event.opened_units > 0.0 ? PositionSide::SHORT : PositionSide::LONG);
        detail::ExitScratchRows<native_order::RequestHandle> reversed_global_exits(*this);
        for (const auto& handle : live_handles_) {
            const auto found = placement_.find(handle.incarnation);
            if (found == placement_.end()) continue;
            const auto& row = found->second;
            const bool exit = row.family == PineOrderFamily::ExitLimit
                || row.family == PineOrderFamily::ExitStop
                || row.family == PineOrderFamily::ExitTrail;
            // The reversal advanced the cycle above; the reversed position's
            // is the one before it.
            if (exit && row.from_entry.empty() && row.projection_position_side == reversed_side
                && row.placement_cycle == current_position_cycle_ - 1) {
                reversed_global_exits.push_back(handle);
            }
        }
        cancel_working_legs(reversed_global_exits);
        // The same exit may already wait off the book: a leg this fill found
        // marketable beside a second parent of the bar was parked for the next
        // open, its request cancelled (lane W3-ENG-EXIT-ALLOC, tape
        // w3f05-r1-two-parent-reversal-global-exit). It is void as well, and
        // leaving the queue records no kernel event.
        const auto reversed_global_leg = [&](const PlacementSnapshot& row) {
            return (row.family == PineOrderFamily::ExitLimit
                    || row.family == PineOrderFamily::ExitStop
                    || row.family == PineOrderFamily::ExitTrail)
                && row.from_entry.empty() && row.projection_position_side == reversed_side
                && row.placement_cycle == current_position_cycle_ - 1;
        };
        delayed_market_orders_.erase(std::remove_if(
            delayed_market_orders_.begin(), delayed_market_orders_.end(),
            [&](const auto& order) { return reversed_global_leg(order.snapshot); }),
            delayed_market_orders_.end());
        pending_write(pending_bracket_legs_).erase(std::remove_if(
            pending_bracket_legs_.begin(), pending_bracket_legs_.end(),
            [&](const PendingBracketLeg& leg) { return reversed_global_leg(leg.snapshot); }),
            pending_bracket_legs_.end());
    }
    if (placement_snapshot && placement_snapshot->family == PineOrderFamily::Margin
        && event.closed_units > 0.0) {
        refresh_pending_sizing_after_margin(event, context);
        // pine_fills.cpp:6399-6434's narrow MC-surplus receipt.  It is not
        // inferred from an arbitrary requested-minus-live quantity: the
        // source entry must have been reduced by this one-unit margin event
        // after its close-only placement, while its original cycle remains the
        // sole live long lot.  Snapshot mutation at an Applied boundary is a
        // pinned P5 write boundary.
        const auto physical = detail::run_position(require_host());
        std::uint64_t sole_live_entry_incarnation = 0;
        std::size_t live_entry_count = 0;
        for (const auto& cohort : cohorts_by_id_.held_rows()) {
            for (const auto& opening : cohort.second.opened) {
                const auto units = cohort.second.live_units_by_origin.find(
                    opening.incarnation);
                if (units == cohort.second.live_units_by_origin.end()
                    || !(units->second > 0.0)) {
                    continue;
                }
                sole_live_entry_incarnation = opening.incarnation;
                ++live_entry_count;
            }
        }
        const std::uint64_t source_fill_sequence =
            static_cast<PineStrategyHost&>(require_host()).broker_fill_event_seq_;
        if (live_entry_count == 1U && sole_live_entry_incarnation != 0
            && physical.signed_units > 0.0 && physical.lot_count == 1U
            && std::abs(event.closed_units - 1.0) < 1e-6
            && config_.default_qty_type
                == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
            && std::abs(config_.default_qty_value - 100.0) < 1e-12
            && config_.commission_type == static_cast<int>(CommissionType::PERCENT)
            && config_.commission_value == 0.0 && config_.slippage == 0
            && source_fill_sequence != 0) {
            signal_close_mc_event_bar_ = context.coordinate.interval_index;
            signal_close_mc_position_cycle_ = current_position_cycle_;
            signal_close_mc_entry_incarnation_ = sole_live_entry_incarnation;
            signal_close_mc_fill_seq_ = source_fill_sequence;
            signal_close_mc_remaining_qty_ = std::abs(physical.signed_units);
            signal_close_mc_before_qty_ = signal_close_mc_remaining_qty_
                + std::abs(event.closed_units);
        }
        std::uint64_t sole_entry_incarnation = 0;
        int live_entry_origins = 0;
        if (physical.signed_units != 0.0 && physical.lot_count == 1U) {
            for (const auto& cohort : cohorts_by_id_.held_rows()) {
                for (const auto& origin : cohort.second.opened) {
                    const auto units = cohort.second.live_units_by_origin.find(
                        origin.incarnation);
                    if (units == cohort.second.live_units_by_origin.end()
                        || !(units->second > 0.0)) {
                        continue;
                    }
                    const auto opening = placement_.find(origin.incarnation);
                    if (opening == placement_.end()
                        || !opening->second.opening
                        || opening->second.is_long != (physical.signed_units > 0.0)) {
                        continue;
                    }
                    sole_entry_incarnation = origin.incarnation;
                    ++live_entry_origins;
                }
            }
        }
        if (live_entry_origins != 1) sole_entry_incarnation = 0;
        last_margin_call_script_bar_ = context.script_bar_open_ms;
        last_margin_call_event_ordinal_ = event.ordinal;
        last_margin_call_entry_incarnation_ = sole_entry_incarnation;
        last_margin_call_position_cycle_ = current_position_cycle_;
        last_margin_call_at_script_close_ = policy_script_bar_valid_
            && policy_script_bar_.timestamp == context.script_bar_open_ms
            && nearest_tick(event.resolved_price, staged_.syminfo.mintick)
                == nearest_tick(policy_script_bar_.close, staged_.syminfo.mintick);
        last_margin_call_closed_units_ = event.closed_units;
        last_margin_call_remaining_units_ = std::abs(physical.signed_units);
        const auto state = detail::run_state(require_host());
        const auto* pine_host = pine_view_of(&require_host());
        const bool magnifier = pine_host
            && pine_host->scheduler_.bar_magnifier_enabled();
        const bool ordinary_margin_receipt = !config_.process_orders_on_close
            && !config_.calc_on_order_fills && !coof_recalc_active_
            && !magnifier
            && last_margin_call_at_script_close_;
        for (const auto& handle : live_handles_) {
            const auto found = placement_.find(handle.incarnation);
            if (found == placement_.end()) continue;
            auto& candidate = found->second;
            const double close_surplus = candidate.projection_tv_carry_qty
                - std::abs(physical.signed_units);
            const bool exact_margin_receipt = candidate.family == PineOrderFamily::Entry
                && candidate.affordability_close_only && !candidate.is_long
                && candidate.rounded_signal_cost_close_only
                && candidate.deferred_cohort
                && ordinary_margin_receipt
                && !std::isfinite(candidate.requested_qty)
                && !finite_positive(candidate.exit_levels.limit)
                && !finite_positive(candidate.exit_levels.stop)
                && !candidate.projection_after_close
                && candidate.projection_created_bar
                    == context.coordinate.interval_index
                && candidate.projection_position_side
                    == static_cast<std::int32_t>(PositionSide::LONG)
                && candidate.placement_cycle == current_position_cycle_
                && physical.signed_units > 0.0 && physical.lot_count == 1U
                && sole_entry_incarnation != 0
                && std::isfinite(close_surplus) && std::abs(close_surplus - 1.0) < 1e-6
                && std::abs(event.closed_units - 1.0) < 1e-6;
            if (exact_margin_receipt) {
                candidate.affordability_keep_mc_close_surplus = true;
                candidate.signal_close_mc_bar = candidate.projection_created_bar;
                candidate.signal_close_mc_entry_incarnation = sole_entry_incarnation;
                candidate.signal_close_mc_fill_seq = pine_host
                    ? pine_host->adapter_broker_fill_event_sequence() : 0;
                candidate.signal_close_mc_remaining_qty =
                    std::abs(physical.signed_units);
                if (live_entry_count == 1U && sole_live_entry_incarnation != 0) {
                    candidate.signal_close_mc_bar = candidate.projection_created_bar;
                    candidate.signal_close_mc_entry_incarnation =
                        sole_live_entry_incarnation;
                    candidate.signal_close_mc_fill_seq = source_fill_sequence;
                    candidate.signal_close_mc_remaining_qty =
                        std::abs(physical.signed_units);
                }
            }
        }
        revive_brackets_after_margin(event, context);
    }
    if (event.closed_units > 0.0) {
        const SourceId* fee_source = nullptr;
        if (placement_snapshot && !placement_snapshot->from_entry.empty())
            fee_source = &placement_snapshot->from_entry;
        consume_opening_fees(event, fee_source);
    }
    const bool current_debit_observed =
        current_debited_applied_ordinals_.erase(event.ordinal) != 0;
    if (!flipped_position && !current_debit_observed && event.closed_trade_count > 0)
        consume_closed_trade_rows(event,
            placement_snapshot ? &*placement_snapshot : nullptr);
    // The margin call's units have left their cohorts: the exits' queue
    // reserves the position that remains (rule PK).
    if (placement_snapshot && placement_snapshot->family == PineOrderFamily::Margin
        && event.closed_units > 0.0) {
        reconcile_exit_reservations_after_margin();
    }
    // ab9714be pine_fills.cpp:5883-5899 / pine_strategy_commands.cpp:
    // 2739-2811: once an opening applies, every deferred bracket family for
    // a now-live source cohort receives its reservation.  This also covers
    // the second half of a flat MARKET/MARKET transaction pair; its Applied
    // shape is not required to expose closed_units for the source reservation
    // boundary to be observable.
    if (placement_snapshot && placement_snapshot->opening) {
        const double physical_exposure =
            std::abs(detail::run_position(require_host()).signed_units);
        for (const auto& cohort : cohorts_by_id_.held_rows()) {
            const auto& id = cohort.first;
            const double exposure = cohort_exposure_for(cohort.second);
            const bool paired_source_transaction =
                placement_snapshot->paired_flat_market_candidate
                && finite_positive(
                    placement_snapshot->paired_flat_market_own_qty)
                && finite_positive(
                    placement_snapshot->paired_flat_market_transaction_qty)
                && placement_snapshot->paired_flat_market_transaction_qty
                    > placement_snapshot->paired_flat_market_own_qty + 1e-10;
            const double source_own = paired_source_transaction
                ? placement_snapshot->paired_flat_market_own_qty
                : physical_exposure;
            const bool intermediate_paired_gross = config_.pyramiding == 2
                && source_own > 0.0 && exposure > source_own + 1e-10;
            if (exposure > 0.0 && !intermediate_paired_gross)
                reconcile_deferred_exit_reservations(id, exposure);
        }
        // Exits for every entry (from_entry="") armed before this opening
        // queue for the position the same way: behind a full one created
        // earlier, a later one is left nothing (lane W3-ENG-EXIT-ALLOC, tape
        // w3f05-s11-pooc-qty-any-entry): the front full one keeps its dynamic
        // reservation and the unreserved ones behind it are cancelled. A full
        // one behind partial ones gets what they leave (lane W3B-ENG-GRID,
        // w3bf05-g8): the queue then hands the position out as it does for a
        // named entry's exits.
        if (physical_exposure > 0.0) {
            struct GlobalExit {
                std::uint64_t key = 0;
                std::uint64_t rank = 0;
                bool full = true;
                bool reserved = false;
                double units = 0.0;
            };
            detail::ExitScratchRows<GlobalExit> armed(*this);
            detail::ExitScratchIndex families(armed.context());
            detail::ExitScratchIndex members(armed.context());
            std::uint64_t member_ordinal = 0;
            for (const auto& handle : live_handles_) {
                const auto found = placement_.find(handle.incarnation);
                if (found == placement_.end()) continue;
                const auto& row = found->second;
                const bool exit = row.family == PineOrderFamily::ExitLimit
                    || row.family == PineOrderFamily::ExitStop
                    || row.family == PineOrderFamily::ExitTrail;
                if (!exit || !row.from_entry.empty()) continue;
                const bool reserved = std::isfinite(row.projection_remaining_qty);
                const bool full = !std::isfinite(row.requested_qty)
                    && (!std::isfinite(row.qty_percent)
                        || row.qty_percent >= 100.0 - internal::kFullPercentEps);
                // What a partial exit holds: its reservation, else its
                // explicit or percent share of the new position.
                const double units = reserved ? std::max(0.0, row.projection_remaining_qty)
                    : std::isfinite(row.requested_qty) ? std::abs(row.requested_qty)
                    : physical_exposure * (std::isfinite(row.qty_percent)
                        ? std::clamp(row.qty_percent, 0.0, 100.0) : 100.0) / 100.0;
                const auto key = key_for(row.source_id, row.from_entry);
                const auto rank = exit_queue_rank(placement_, row);
                auto index = families.find(key);
                if (index == detail::ExitScratchIndex::absent) {
                    index = armed.size();
                    families.put(key, index);
                    armed.push_back({key, rank, full, reserved, units});
                } else {
                    GlobalExit family = armed[index];
                    family.rank = std::min(family.rank, rank);
                    family.full = family.full && full;
                    family.reserved = family.reserved || reserved;
                    family.units = std::max(family.units, units);
                    armed.set(index, family);
                }
                members.put(key, handle.incarnation, member_ordinal++);
            }
            if (armed.size() > 1) {
                detail::ExitScratchRows<native_order::RequestHandle> behind(*this);
                bool behind_full = false;
                bool partial_ahead_of_full = false;
                double ahead = 0.0;
                armed.ordered(
                    [](const GlobalExit& family) { return family.rank; },
                    [&](const GlobalExit& family, std::size_t) {
                        if (behind_full) {
                            if (!family.reserved) {
                                members.each(family.key, [&](std::uint64_t incarnation) {
                                    behind.push_back({behind.context().run, incarnation});
                                    return true;
                                });
                            }
                            return true;
                        }
                        if (!family.full) {
                            ahead += family.units;
                            return true;
                        }
                        // A full exit already holding a reservation is its own
                        // family's business (reconcile_deferred_exit_reservations).
                        if (family.reserved) return true;
                        behind_full = true;
                        if (ahead > internal::kQtyEpsilon) partial_ahead_of_full = true;
                        return true;
                    });
                if (partial_ahead_of_full) {
                    reconcile_deferred_exit_reservations({}, physical_exposure);
                } else {
                    for (const auto& handle : behind) {
                        const auto result = require_host().cancel(handle);
                        if (result.status == native_order::CancelStatus::Cancelled)
                            retire(handle);
                    }
                }
            }
        }
    }
    if (placement_snapshot && placement_snapshot->family == PineOrderFamily::CloseAll
        && event.closed_units > 0.0) {
        const auto held = cohorts_by_id_.held_rows();
        for (auto at = held.begin(); at != held.end();) {
            const auto current = at++;
            ::pineforge::detail::clear_exposure_storage(current->second.live_units_by_origin);
            cohorts_by_id_.refresh_held(current);
        }
        if (position_tail_summary_) position_tail_summary_->forget_origins();
    }
    if (placement_snapshot && placement_snapshot->family == PineOrderFamily::Margin
        && event.closed_units > 0.0
        && detail::run_position(require_host()).signed_units != 0.0) {
        const auto physical = detail::run_position(require_host());
        auto revival = std::find_if(
            pending_margin_revivals_.begin(), pending_margin_revivals_.end(),
            [&](const PendingMarginRevival& pending) {
                const auto& row = pending.snapshot;
                const bool same_side = row.projection_position_side
                        == static_cast<std::int32_t>(PositionSide::LONG)
                    ? physical.signed_units > 0.0 : physical.signed_units < 0.0;
                const bool exposed = !row.from_entry.empty()
                    && cohort_exposure_for(row.from_entry) > 0.0;
                return same_side && exposed;
            });
        if (revival != pending_margin_revivals_.end()) {
            PlacementSnapshot snapshot = std::move(revival->snapshot);
            pending_margin_revivals_.erase(revival);
            const bool reached = physical.signed_units > 0.0
                ? event.resolved_price <= snapshot.exit_levels.stop
                : event.resolved_price >= snapshot.exit_levels.stop;
            native_order::Request request;
            request.intent = native_order::Reduce{
                native_order::ExplicitUnits{std::abs(physical.signed_units)}};
            request.label = snapshot.source_id;
            request.comment = snapshot.comment;
            if (!reached) {
                const bool exit_is_buy = physical.signed_units < 0.0;
                request.trigger = native_order::Stop{source_trigger_threshold(
                    snapshot.exit_levels.stop, staged_.syminfo.mintick,
                    exit_is_buy, false)};
            }
            snapshot.family = PineOrderFamily::ExitStop;
            snapshot.restored_after_margin = true;
            snapshot.requested_qty = std::abs(physical.signed_units);
            snapshot.qty_percent = 100.0;
            snapshot.projection_remaining_qty = kNaN;
            snapshot.fixed_exit_reservation = false;
            snapshot.forced_execution_price = reached
                ? event.resolved_price : kNaN;
            snapshot.market_admission = {};
            snapshot.cancellation = {};
            const auto family_key = key_for(snapshot.source_id, snapshot.from_entry);
            const SourceId replacement_key = snapshot.source_id + "\x1f"
                + snapshot.from_entry + "\x1fmargin-revival";
            const auto accepted = submit_or_replace(
                std::move(request), std::move(snapshot), false, replacement_key);
            if (accepted) {
                bracket_family(family_key).push_back(*accepted);
                if (reached) {
                    (void)require_host().execute_current(
                        {*accepted, NativeCurrentPriceRule::NearestTick});
                }
            }
        }
    }
    if (detail::run_position(require_host()).signed_units == 0.0) {
        detail::ExitScratchRows<SourceId> exit_owners(*this);
        const auto collect_owner = [&](const PlacementSnapshot& candidate) {
            const bool exit = candidate.family == PineOrderFamily::ExitLimit
                || candidate.family == PineOrderFamily::ExitStop
                || candidate.family == PineOrderFamily::ExitTrail;
            if (exit) exit_owners.push_back(candidate.from_entry);
        };
        for (const auto& handle : live_handles_) {
            const auto found = placement_.find(handle.incarnation);
            if (found != placement_.end()) collect_owner(found->second);
        }
        for (const auto& pending : pending_bracket_legs_) collect_owner(pending.snapshot);
        for (const auto& pending : pending_coof_requests_) collect_owner(pending.snapshot);
        for (const auto& shadow : source_shadow_pending_) collect_owner(shadow.snapshot);
        const auto pending_parent = [&](const detail::ExitScratchText& owner) {
            if (placement_snapshot && placement_snapshot->opening
                && placement_snapshot->source_id == owner) {
                return true;
            }
            for (const auto& handle : live_handles_) {
                if (event.terminal && handle == event.handle()) continue;
                const auto found = placement_.find(handle.incarnation);
                if (found != placement_.end() && found->second.opening
                    && found->second.family == PineOrderFamily::Entry
                    && found->second.source_id == owner) {
                    return true;
                }
            }
            return std::any_of(pending_entries_.begin(), pending_entries_.end(),
                [&](const PendingEntry& entry) {
                    return entry.snapshot.opening
                        && entry.snapshot.source_id == owner;
                });
        };
        exit_owners.ordered_text(
            [&](const detail::ExitScratchText& owner) {
                // A transient flat between two same-point reversal transactions
                // does not end the pending parent's lifecycle. Keep only that
                // parent's brackets; stale owners still retire immediately.
                if (!pending_parent(owner)) cancel_exit_orders_for_full_close(owner);
                return true;
            }, true);
        // ab9714be pine_fills.cpp:7461-7468 / 7667-7673: the owner scan above
        // only sees exits that are live or still pending, so a bracket that
        // already went dormant survives the flat in its projection row and is
        // revived against the next position that reuses its entry id.  The
        // legacy book Removes every in-position exit at the flat whatever its
        // current lifecycle state.
        retire_in_position_exits_at_flat(/*preserve_pending_parents=*/true,
                                         /*dormant_rows_only=*/true,
                                         /*paired_close=*/nullptr);
        position_tail_spill_.reset();
        if (position_tail_summary_)
            position_tail_summary_->invalidate(PositionTailGuard::Flat,
                                               PINEFORGE_POSITION_TAIL_DIAGNOSTICS{});
        position_open_script_bar_ = std::numeric_limits<std::int64_t>::min();
        position_open_bar_index_ = -1;
        position_open_phase_ = NativePathPhase::None;
        position_open_priced_ = false;
        open_entry_fees_.clear();
        close_logical_units_.clear();
        close_ledger_records_.clear();
        pyramiding_records_.clear();
        exit_tombstones_.clear();
        detail::ExitScratchRows<SourceId> ended_sources(*this);
        pending_margin_revivals_.clear();
        const auto held = cohorts_by_id_.held_rows();
        for (auto at = held.begin(); at != held.end();) {
            const auto current = at++;
            auto& cohort = *current;
            if (!cohort.second.opened.empty()) ended_sources.push_back(cohort.first);
            assert(cohort_opened_slot_count_ >= cohort.second.opened.size());
            cohort_opened_slot_count_ -= cohort.second.opened.size();
            ::pineforge::detail::clear_exposure_storage(cohort.second.opened);
            ::pineforge::detail::clear_exposure_storage(cohort.second.live_units_by_origin);
            cohorts_by_id_.refresh_held(current);
        }
        detail::ExitScratchBatchRows<native_order::RequestHandle> handles(*this);
        for (const auto& handle : live_handles_) handles.push_back(handle);
        handles.finish();
        for (const auto& handle : handles) {
            const auto found = placement_.find(handle.incarnation);
            if (found == placement_.end()) continue;
            const auto family = found->second.family;
            // ab9714be pine_orders.cpp:530-534: purge_exit_orders retires all exit and close orders when position flattens
            if (family == PineOrderFamily::ExitLimit
                || family == PineOrderFamily::ExitStop
                || family == PineOrderFamily::ExitTrail
                || family == PineOrderFamily::Close
                || family == PineOrderFamily::CloseAll
                // The slice is a full close of its from_entry's cycle: the owner
                // clears cycle_filled_entry_ids_ when the book goes flat
                // (ab9714be pine_strategy_host.cpp:245-251), so the bracket
                // retires with the rest instead of surviving into the next lot
                // that reuses the id.
                || family == PineOrderFamily::Margin) {
                // A margin call placed again for the next open is sized at
                // placement, not an exit of the book it was sized on: it fills
                // as placed on the book a close order flattened
                // (close_point_margin_call; lab tv tape w13-b2-cancel-close-f).
                if (family == PineOrderFamily::Margin && found->second.crosses_zero) continue;
                if (!found->second.from_entry.empty()
                    && !ended_sources.contains(found->second.from_entry)) {
                    continue;
                }
                (void)require_host().cancel(handle);
                retire(handle);
            }
        }
        bracket_shadowed_openings_.clear();
    }
    if (short_seed_.final_short.incarnation != 0 && event.handle() == short_seed_.final_short
        && config_.default_qty_type != static_cast<int>(QtyType::FIXED)) {
        short_seed_.report_swap_pending = true;
    }
    update_l4c_lifecycle(event, context);
    if (event.terminal) {
        const auto filled = placement_.find(event.handle().incarnation);
        // Share K1's named-only guard: global fills stay supersession evidence.
        if (filled != placement_.end() && event.closed_units > 0.0
            && unbound_limit_without_revival(filled->second))
            filled->second.filled_exit = true, invalidate_retirement();
        retire(event.handle());
    }
    if (event.ordinal != day_ledger_.observed_applied_ordinal) {
        day_ledger_.observed_applied_ordinal = event.ordinal;
        const auto day = chart_day_key(context.sub_bar_open_ms);
        if (event.closed_trade_count > 0) {
            const auto& host = require_host();
            for (std::size_t i = 0; i < event.closed_trade_count; ++i) {
                const auto index = event.first_trade_index + i;
                if (index >= static_cast<std::size_t>(host.trade_count())) continue;
                const double pnl = host.get_trade(static_cast<int>(index)).pnl;
                day_ledger_.intraday_realized += pnl;
                if (pnl < 0.0 && day != day_ledger_.last_loss_day) {
                    day_ledger_.last_loss_day = day;
                    if (day_ledger_.consecutive_loss_days
                        == std::numeric_limits<int>::max()) {
                        throw coded<std::overflow_error>(RunFailureCode::engine_invariant, {},
                                                         "closed trade counter exhausted");
                    }
                    ++day_ledger_.consecutive_loss_days;
                } else if (pnl > 0.0) {
                    day_ledger_.consecutive_loss_days = 0;
                }
            }
        }
    }
    // A fill that reduces the side it leaves open books its units against
    // the close ledger (a reversal or a flat has just cleared it).
    if (event.closed_units > 0.0 && !flipped_position
        && detail::run_position(require_host()).signed_units != 0.0) {
        observe_close_ledger(event, placement_snapshot ? &*placement_snapshot : nullptr);
    }
    if (placement_snapshot) {
        observe_intraday_cap(event, *placement_snapshot, context);
        if (placement_snapshot->family == PineOrderFamily::Margin
            && event.closed_units > 0.0) {
            last_margin_call_script_bar_ = context.script_bar_open_ms;
            const auto after_margin = detail::run_position(require_host());
            const bool one_x_long = after_margin.signed_units > 0.0
                && std::abs(config_.margin_long - 100.0) < 1e-12;
            if (context.coordinate.path_phase == NativePathPhase::Open
                && policy_script_bar_valid_
                && policy_script_bar_.timestamp == context.script_bar_open_ms
                && after_margin.signed_units != 0.0 && !one_x_long) {
                // A carried POOC short filled at the previous close rechecks
                // its already-slipped fill: mark and forced execution both
                // reuse event.resolved_price unchanged until margin is covered.
                // TradingView repeats at one price (tests/fixtures/margin_residual
                // px-f2b-eth-short-0/1, -eth-slip-3). Population confirmations:
                // third-party ETHUSDT.P 1D and OANDA:EURUSD strategies
                // also repeat their calls at the same slipped fill.
                // Not the calls after one sized at the source close
                // (run_close_sized_open_calls): those are TradingView's whole
                // sequence at that print.
                const auto unrepeated = PF_RARE(!unrepeated_margin_calls_.empty())
                    ? std::find(unrepeated_margin_calls_.begin(), unrepeated_margin_calls_.end(),
                                event.handle().incarnation)
                    : unrepeated_margin_calls_.end();
                const bool sequence_call = unrepeated != unrepeated_margin_calls_.end();
                if (sequence_call) unrepeated_margin_calls_.erase(unrepeated);
                const bool recheck_at_fill = config_.process_orders_on_close
                    && !config_.calc_on_order_fills && config_.slippage != 0
                    && after_margin.signed_units < 0.0
                    && position_open_phase_ == NativePathPhase::Close
                    && position_open_script_bar_ != context.script_bar_open_ms
                    && finite_positive(event.resolved_price) && !sequence_call;
                // ab9714be pine_fills.cpp:2525-2678 then :1266-1751:
                // after an opening slice, the survivor is checked over the
                // unconsumed bar suffix.  Submission from this Applied point
                // uses A35 remaining-path eligibility and sizes from the
                // already-reduced physical book.
                if (!recheck_at_fill || !submit_margin_call_slice(
                        event.resolved_price, context, false, event.resolved_price))
                    (void)schedule_margin_call_path(policy_script_bar_, context);
            }
            // A short's call at a path extreme owes the bar's next point its
            // lagged follow-up (schedule_lagged_short_follow_up).
            if (PF_RARE(after_margin.signed_units < 0.0
                        && detail::margin_schedule_switches().lagged_short_follow_up))
                schedule_lagged_short_follow_up(event, context);
        }
        if (placement_snapshot->family == PineOrderFamily::Risk
            && event.closed_units > 0.0) {
            risk_.intraday_block_day = chart_day_key(context.sub_bar_open_ms);
            risk_.intraday_cancel_pending = true;
        }
    }
    if (preclose_intraday_loss) {
        risk_.intraday_block_day = chart_day_key(context.sub_bar_open_ms);
        risk_.intraday_cancel_pending = true;
        if (detail::run_position(require_host()).signed_units != 0.0) {
            native_order::Request request;
            request.intent = native_order::Flatten{};
            request.comment = kIntradayLossComment;
            PlacementSnapshot snapshot;
            snapshot.family = PineOrderFamily::Risk;
            snapshot.source_id = "__intraday_loss__";
            snapshot.comment = request.comment;
            snapshot.sizing = sizing_snapshot();
            const auto accepted = submit_or_replace(
                std::move(request), std::move(snapshot), false,
                "__intraday_loss_close__");
            if (accepted) {
                (void)require_host().execute_current(
                    {*accepted, NativeCurrentPriceRule::NearestTick});
            }
        }
    }
    if (risk_.intraday_cancel_pending) {
        risk_.intraday_cancel_pending = false;
        cancel_all();
    }
    if (placement_snapshot && placement_snapshot->opening
        && std::abs(event.opened_units) > 0.0 && policy_script_bar_valid_) {
        // Legacy processes the opening-affordability checkpoint at the
        // matched entry price before the remainder of that bar's path.  The
        // native callback is at exactly that current execution point, so the
        // adapter can issue the generic reduction synchronously without a
        // second matching loop.
        const auto opened_position = detail::run_position(require_host());
        const double opening_margin = opened_position.signed_units < 0.0
            ? config_.margin_short : config_.margin_long;
        const bool full_margin_opening = opened_position.signed_units != 0.0
            && std::abs(opening_margin - 100.0) < 1e-12;
        const bool preopen_margin_already_scheduled = std::any_of(
            live_handles_.begin(), live_handles_.end(), [&](const auto& handle) {
                const auto pending = placement_.find(handle.incarnation);
                return pending != placement_.end()
                    && pending->second.family == PineOrderFamily::Margin
                    && pending->second.from_entry == placement_snapshot->source_id
                    && pending->second.source_id.rfind("__margin_preopen__", 0) == 0;
            });
        // As in resolve_terms: a flat stop entry is kept while a live or
        // queued entry shares its placement bar (erase_retired_rows, K8).
        const auto dual_stop_peer = [&](std::uint64_t incarnation, const PlacementSnapshot& peer) {
            return incarnation != event.handle().incarnation && peer.opening
                && peer.family == PineOrderFamily::Entry
                && peer.projection_position_side
                    == static_cast<std::int32_t>(PositionSide::FLAT)
                && peer.projection_created_bar
                    == placement_snapshot->projection_created_bar
                && peer.is_long != placement_snapshot->is_long
                && finite_positive(peer.exit_levels.stop)
                && !finite_positive(peer.exit_levels.limit);
        };
        const bool dual_stop_candidate = last_bar_dual_entry_path_ != 0
            && placement_snapshot->projection_position_side
                == static_cast<std::int32_t>(PositionSide::FLAT)
            && finite_positive(placement_snapshot->exit_levels.stop)
            && !finite_positive(placement_snapshot->exit_levels.limit);
        if (dual_stop_candidate)
            PINEFORGE_AUDIT_PLACEMENT_SCAN(placement_, dual_stop_peer);
        const bool flat_dual_stop_member = dual_stop_candidate
            && std::any_of(placement_.begin(), placement_.end(),
                [&](const auto& row) { return dual_stop_peer(row.first, row.second); });
        // Timestamped FX has its own base-equivalent opening checkpoint
        // (apply_fx_opening_margin_slice).  A generic fill-price retry here
        // would replay a rate epoch that was consumed while the host was
        // flat, producing a false margin row on the subsequent opening.
        const bool stable_opening_fx = staged_.account_fx_effective_from_ms.empty()
            || placement_snapshot->sizing.fx
                == active_staged_fx(context.sub_bar_open_ms);
        // A book two or more of one bar's flat entries of this side opened
        // here, this fill included, is margined as one once the last of them
        // has filled (flat_sibling_fill_follows): at that fill, or under
        // process_orders_on_close at the next open (lab tv tapes
        // tests/fixtures/margin_residual w5b-sb-*; lane W5B-ENG-MARGIN-RESIDUAL).
        const bool sibling_book = opened_position.lot_count >= 2
            && flat_sibling_book(*placement_snapshot, context.coordinate.interval_index,
                                 context.coordinate.path_phase);
        const bool sibling_fill_follows = sibling_book
            || opened_position.lot_count == 1
            ? flat_sibling_fill_follows(*placement_snapshot, event.handle()) : false;
        // So is a book the adds one bar placed on it grew: once the last of
        // them has filled, at that fill -- or under process_orders_on_close
        // at the next open, sized at the close (on_bar_open) -- four times
        // the lot-floored shortfall of the whole book, not a call after
        // each add (lab tv tapes tests/fixtures/add_sibling_margin; lane
        // TAIL-B).
        const bool placed_add = !sibling_book && add_entry_row(*placement_snapshot);
        const bool add_fill_follows = placed_add
            && add_sibling_fill_follows(*placement_snapshot, event.handle());
        const std::size_t filled_adds = placed_add && !add_fill_follows
            ? add_sibling_lots(placement_snapshot->placement_script_open_ms) : 0;
        const bool pooc_add_book = placed_add && config_.process_orders_on_close
            && !config_.calc_on_order_fills
            && !context.driver_statistics.intrabar_path_enabled
            && context.coordinate.path_phase == NativePathPhase::Close
            && (add_fill_follows || filled_adds >= 2);
        // The last of a bar's market adds: the grown book's call is taken at
        // this fill, a commissioned explicit short's too (its print, as a
        // slipped market short's), not at a later path point.
        const bool adds_book_last = placed_add && !config_.process_orders_on_close
            && filled_adds >= 2;
        const bool zero_fee_true_flat_default = !sibling_book
            && config_.default_qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
            && std::abs(config_.default_qty_value - 100.0) < 1e-12
            && config_.commission_value == 0.0
            && !std::isfinite(placement_snapshot->requested_qty)
            && placement_snapshot->projection_position_side
                == static_cast<std::int32_t>(PositionSide::FLAT)
            && !placement_snapshot->projection_after_close
            && std::holds_alternative<native_order::Market>(event.request().trigger)
            && placement_snapshot->sizing.price == event.resolved_price;
        if ((full_margin_opening || placement_snapshot->has_full_entry_bracket)
            && !preopen_margin_already_scheduled && stable_opening_fx) {
            const bool long_full_margin = opened_position.signed_units > 0.0
                && std::abs(config_.margin_long - 100.0) < 1e-12;
            const bool prearmed_entry_bar_margin = std::any_of(
                live_handles_.begin(), live_handles_.end(), [&](const auto& handle) {
                    const auto pending = placement_.find(handle.incarnation);
                    return pending != placement_.end()
                        && pending->second.family == PineOrderFamily::Margin
                        && pending->second.from_entry == placement_snapshot->source_id;
                });
            // A market entry opening the book from flat at the bar's open gives
            // way to the exit legs it releases only where they are already
            // marketable at that open: they fill there first and the check
            // runs on the book they leave, after them (open_exit_first_bar_).
            // Every other leg and fill -- a reversal, a stop or limit entry,
            // an add, a book of several entries, process_orders_on_close and
            // calc_on_order_fills -- keeps ab9714be's rule
            // (priced_exit_precedes_opening), though TradingView calls a
            // short reversal and a short stop entry gapped at the open before
            // their stop on the path too (lab tv tapes tests/fixtures/
            // margin_open_rules exit-order/reversal-*, stop-entry-*: known
            // divergences).
            const bool open_market_fill = detail::margin_opening_switches().open_marketable_exit_first
                && context.coordinate.path_phase == NativePathPhase::Open
                && context.sub_index == 0
                && policy_script_bar_.timestamp == context.script_bar_open_ms
                && std::holds_alternative<native_order::Market>(event.request().trigger)
                && !config_.process_orders_on_close && !config_.calc_on_order_fills
                && event.closed_units == 0.0 && opened_position.lot_count == 1
                && !sibling_book && !placed_add;
            bool exit_first_at_open = false;
            const bool short_preempted_by_priced_exit = priced_exit_precedes_opening(
                opened_position.signed_units < 0.0,
                open_market_fill ? event.handle().incarnation : 0, placement_snapshot->source_id,
                context, nullptr, &exit_first_at_open);
            // TradingView takes no call at the close fill that opens (or
            // reverses into) a commissioned process_orders_on_close position:
            // it calls that book at the next open instead (on_bar_open) --
            // a long for the units this checkpoint would take here, a short
            // at the close's mark (lab tv tapes tests/fixtures/margin_v6
            // w5-c2-pooc-rev-long, -rev-long-noslip and -rev-short: every
            // reversal's call at the next open, fifteen cells each; lane
            // W5-ENG-MARGIN-V6).
            const bool called_at_next_open = config_.process_orders_on_close
                && !config_.calc_on_order_fills
                && (config_.commission_value != 0.0 || sibling_book)
                && !context.driver_statistics.intrabar_path_enabled
                && context.coordinate.path_phase == NativePathPhase::Close
                && position_open_phase_ == NativePathPhase::Close
                && position_open_script_bar_ == context.script_bar_open_ms;
            const bool stopped_flat_reversal = opened_position.signed_units < 0.0
                && std::abs(config_.margin_short - 100.0) < 1e-12 && event.closed_units == 0.0
                && placement_snapshot->reverse_to
                && std::holds_alternative<native_order::Stop>(event.request().trigger)
                && context.coordinate.path_phase != NativePathPhase::Open;
            const bool priced_opening_waypoint = (stopped_flat_reversal
                || (long_full_margin && !std::isfinite(placement_snapshot->requested_qty)
                    && context.coordinate.path_phase != NativePathPhase::Open))
                && position_open_priced_
                && placement_snapshot->family == PineOrderFamily::Entry
                && std::holds_alternative<native_order::Stop>(event.request().trigger)
                && !sibling_book && !placed_add
                && !config_.process_orders_on_close && !config_.calc_on_order_fills
                && modeled_input() && !bar_magnifier_;
            // The 10-significant-digit long residual is same-currency,
            // pointvalue-one policy.  A non-unit point value does not inherit
            // an exact-money opening slice merely because the generic
            // floating ledger rounds its fill cost differently.
            // Margin rule 3: nor at the close fill that opens a
            // commission-free slipped full-margin long; the next open checks
            // it (slipped_long_margin_units).
            const bool slipped_long_called_at_next_open = config_.process_orders_on_close
                && long_full_margin && slipped_long_margin_scope()
                && context.coordinate.path_phase == NativePathPhase::Close
                && position_open_script_bar_ == context.script_bar_open_ms
                && slipped_long_unit_shortfall(nearest_tick(policy_script_bar_.close,
                                                       staged_.syminfo.mintick));
            const bool opening_check_due = !zero_fee_true_flat_default && !called_at_next_open
                && !priced_opening_waypoint && !slipped_long_called_at_next_open
                && !sibling_fill_follows && !add_fill_follows && !pooc_add_book
                && !flat_dual_stop_member && !prearmed_entry_bar_margin
                && !(long_full_margin && !sibling_book
                     && std::abs(staged_.syminfo.pointvalue - 1.0) > 1e-12);
            if (opening_check_due && !short_preempted_by_priced_exit
                && !same_point_pair_fill_follows(*placement_snapshot, event.handle(),
                                                 event.resolved_price)) {
                run_opening_checkpoint(
                    event.resolved_price,
                    std::holds_alternative<native_order::Market>(event.request().trigger),
                    sibling_book, adds_book_last, context);
            } else if (opening_check_due && exit_first_at_open
                       && !same_point_pair_fill_follows(*placement_snapshot, event.handle(),
                                                        event.resolved_price)) {
                // The exit legs marketable at this open fill there first: the
                // check is owed to the last of them, on the book they leave
                // (lab tv tapes tests/fixtures/margin_open_rules exit-order/).
                open_exit_first_bar_ = context.script_bar_open_ms;
                open_exit_first_origin_ = event.handle().incarnation;
                open_exit_first_id_ = placement_snapshot->source_id;
                open_exit_first_fill_ = event.resolved_price;
            }
            const bool terminal_pooc_open = config_.process_orders_on_close
                && position_open_phase_ == NativePathPhase::Close;
            if (!terminal_pooc_open && !flat_dual_stop_member
                && !prearmed_entry_bar_margin) {
                if (priced_opening_waypoint) {
                    (void)schedule_priced_opening_margin(
                        policy_script_bar_, context, event.resolved_price);
                } else if (long_full_margin) {
                    (void)schedule_tv_money_long_margin_before_trail(
                        policy_script_bar_, context);
                } else {
                    schedule_margin_call_path(policy_script_bar_, context);
                }
            }
        } else if (!full_margin_opening && !placement_snapshot->has_full_entry_bracket
                   && !preopen_margin_already_scheduled && stable_opening_fx
                   && leveraged_entry_bar_checked()
                   && !preopen_slice_class(*placement_snapshot, context)) {
            // A leveraged opening (margin below 100) has no fill-price trim,
            // but TradingView still checks its ENTRY bar over the path after
            // the fill: four lab tv tapes (tests/fixtures/margin_entry_bar)
            // book the margin call at that bar's low, as ab9714be's
            // entry-bar pass did (pine_fills.cpp:1025-1063 and :1535-1546,
            // the suffix after the opening's fill). The run shapes ab9714be
            // took no such suffix on keep their own routes here
            // (leveraged_entry_bar_checked), and so does the opening
            // schedule_preopen_margin_slice answers for, sliced or not
            // (preopen_slice_class). Admit the kernel's post-fill point for
            // this driver point: it measures the same suffix and sizes the
            // call with TradingView's money and slice
            // (resolve_margin_requirement, resolve_margin_call_units). Every
            // opening-side fill is admitted on its own bar -- the position's
            // first, an add on the same bar, and an add to a book carried in
            // from an earlier bar, which TradingView checks over the rest of
            // its bar on the combined book too (the intrabar margin correction,
            // pm2-m7b-lim-* and pm2-m7b-mkt-*) -- so an add re-sizes a call
            // armed on the smaller book.
            // The open's own check runs after the market adds that fill at
            // that open, on the book holding them and their entry fees
            // (switch open_check_after_add_fill): on OANDA:EURUSD at margin
            // 1 %, a synthetic short of 20000 adding 20000 at a 2.00000 open is
            // short of margin there only with the add and its fee, and
            // TradingView checks the combined book at that open before the path's
            // high-point check (lab tv tapes tests/fixtures/
            // margin_schedule_rules add-fee/, margin_open_rules add-open/).
            if (PF_RARE(detail::margin_opening_switches().open_check_after_add_fill)
                && placed_add && !add_fill_follows && !config_.process_orders_on_close
                && !config_.calc_on_order_fills && config_.slippage == 0
                && config_.commission_type == static_cast<int>(CommissionType::PERCENT)
                && config_.commission_value > 0.0
                && context.coordinate.path_phase == NativePathPhase::Open
                && std::holds_alternative<native_order::Market>(event.request().trigger)
                && policy_script_bar_.timestamp == context.script_bar_open_ms
                && staged_.account_fx_effective_from_ms.empty()
                && finite_positive(policy_script_bar_.open)) {
                (void)submit_margin_call_slice(
                    nearest_tick(policy_script_bar_.open, staged_.syminfo.mintick), context);
            }
            (void)schedule_margin_call_path(policy_script_bar_, context);
        }
        schedule_intraday_loss_path(policy_script_bar_, context);
    }
    if (placement_snapshot && placement_snapshot->family == PineOrderFamily::Close
        && context.coordinate.path_phase == NativePathPhase::Open
        && detail::run_position(require_host()).signed_units != 0.0
        && policy_script_bar_valid_ && !config_.process_orders_on_close
        && staged_.account_fx_effective_from_ms.empty()) {
        // The retired ordinary scheduler settled old MARKET closes before its
        // pre-script adverse-margin checkpoint.  Recompute the path slice from
        // the post-close physical book so a partial close cannot leave behind
        // a fixed liquidation request sized on the larger pre-open position.
        detail::ExitScratchRows<native_order::RequestHandle> stale_margin_requests(*this);
        for (const auto& handle : live_handles_) {
            const auto pending = placement_.find(handle.incarnation);
            if (pending != placement_.end()
                && pending->second.family == PineOrderFamily::Margin) {
                stale_margin_requests.push_back(handle);
            }
        }
        for (const auto& handle : stale_margin_requests) {
            const auto cancelled = require_host().cancel(handle);
            if (cancelled.status == native_order::CancelStatus::Cancelled)
                retire(handle);
        }
        (void)schedule_margin_call_path(policy_script_bar_, context);
    }
    // The opening checkpoint a market entry's fill at this open owes the exit
    // legs it released, marketable there (open_exit_first_bar_): due once the
    // last of them has filled -- at the open's price, on the bar's first
    // segment -- at the same open on the book they leave: a short of 3.5 ETH
    // whose 0.0004 stop fills at the open calls 0.0032 there, not 0.0048
    // before the stop nor nothing (lab tv tape tests/fixtures/
    // margin_open_rules exit-order/short-partial-stop-at-open). A book they
    // closed owes nothing.
    if (PF_RARE(open_exit_first_bar_ != std::numeric_limits<std::int64_t>::min())
        && placement_snapshot && event.closed_units > 0.0
        && (placement_snapshot->family == PineOrderFamily::ExitLimit
            || placement_snapshot->family == PineOrderFamily::ExitStop)) {
        const auto after_exit = detail::run_position(require_host());
        const bool short_book = after_exit.signed_units < 0.0;
        const bool owed = after_exit.signed_units != 0.0
            && open_exit_first_bar_ == context.script_bar_open_ms
            && policy_script_bar_.timestamp == context.script_bar_open_ms;
        const bool released_leg_at_open = owed
            && opening_released_leg(*placement_snapshot, event.handle().incarnation,
                                    open_exit_first_origin_,
                                    open_exit_first_id_, short_book, context)
            && exit_leg_marketable_at(placement_snapshot->exit_levels, short_book,
                                      nearest_tick(policy_script_bar_.open,
                                                   staged_.syminfo.mintick));
        if (!owed || (released_leg_at_open
                      && !priced_exit_precedes_opening(short_book, open_exit_first_origin_,
                                                       open_exit_first_id_, context,
                                                       &*placement_snapshot, nullptr))) {
            const double fill = open_exit_first_fill_;
            open_exit_first_bar_ = std::numeric_limits<std::int64_t>::min();
            open_exit_first_origin_ = 0;
            open_exit_first_id_.clear();
            open_exit_first_fill_ = 0.0;
            if (owed) {
                // The check is the open's: its path, and its follow-up, go on from there.
                NativeDecisionContext at_open = context;
                at_open.coordinate.path_phase = NativePathPhase::Open;
                run_opening_checkpoint(fill, true, false, false, at_open);
            }
        }
    }
    if (placement_snapshot && event.closed_units > 0.0
        && (placement_snapshot->family == PineOrderFamily::ExitLimit
            || placement_snapshot->family == PineOrderFamily::ExitStop
            || placement_snapshot->family == PineOrderFamily::ExitTrail)
        && policy_script_bar_valid_
        && policy_script_bar_.timestamp == context.script_bar_open_ms
        && !config_.process_orders_on_close && !config_.calc_on_order_fills
        && staged_.account_fx_effective_from_ms.empty()) {
        // ab9714be pine_scheduler.cpp:267-282: the ordinary margin call runs
        // once after every order of the bar, on the post-fill book; only an
        // adverse extreme that strictly precedes the priced exit's fill takes
        // the slice ahead of it (pine_fills.cpp:2224), and that slice has
        // already settled by now, as has a carried open-price slice
        // (pine_scheduler.cpp:177-183).  A path slice still live here was sized on
        // the pre-exit position, so re-size it from the reduced book.  The
        // 1x-long TV-money slice keeps its own scheduler.
        const auto after_exit = detail::run_position(require_host());
        const bool one_x_long = after_exit.signed_units > 0.0
            && std::abs(config_.margin_long - 100.0) < 1e-12;
        detail::ExitScratchRows<native_order::RequestHandle> stale_margin_requests(*this);
        for (const auto& handle : live_handles_) {
            const auto pending = placement_.find(handle.incarnation);
            if (pending != placement_.end()
                && pending->second.family == PineOrderFamily::Margin) {
                stale_margin_requests.push_back(handle);
            }
        }
        if (!one_x_long && !stale_margin_requests.empty()) {
            for (const auto& handle : stale_margin_requests) {
                const auto cancelled = require_host().cancel(handle);
                if (cancelled.status == native_order::CancelStatus::Cancelled)
                    retire(handle);
            }
            if (after_exit.signed_units != 0.0)
                (void)schedule_margin_call_path(policy_script_bar_, context);
        } else if (!one_x_long) {
            // R5: under the kernel margin model the live path slice is the
            // kernel's, so there is no source row here to cancel and the
            // scan above finds nothing. The re-size still has to happen --
            // a slice sized on the pre-exit book must not survive the exit
            // and execute against the remainder -- so admit the kernel's own
            // check point for this driver point instead. Gated on a resting
            // slice in margin_check_allowed, so a point where the legacy
            // broker did nothing stays a point where nothing is done.
            kernel_margin_resize_point_ = context.coordinate.ordinal;
            if (after_exit.signed_units != 0.0)
                (void)schedule_margin_call_path(policy_script_bar_, context);
        }
    }
    apply_fx_opening_margin_slice(event, context);
    refresh_pending_view();
    // ab9714be pine_fills.cpp:7026-7033 and pine_orders.cpp:444-480:
    // after a priced from_entry bracket leg fills, every same-id MARKET
    // pyramid add opened on this bar is still open behind the leg's own
    // (FIFO) reduction; the owner covers it at the leg's booked price as a
    // second fill of the same order.
    if (placement_snapshot && event.closed_units > 0.0
        && (placement_snapshot->family == PineOrderFamily::ExitLimit
            || placement_snapshot->family == PineOrderFamily::ExitStop
            || placement_snapshot->family == PineOrderFamily::ExitTrail)
        && !placement_snapshot->from_entry.empty()
        && detail::run_position(require_host()).signed_units != 0.0
        && current_position_cycle_ > 0) {
        auto* pine = pine_view_of(&require_host());
        const auto cohort = cohorts_by_id_.find(placement_snapshot->from_entry);
        if (pine && cohort != cohorts_by_id_.end()) {
            // The kernel books lot rows in script-bar space. This owner-side
            // cohort rule intentionally compares the explicit chart source
            // index to keep Pine's sampling cadence separate from that book.
            const auto state = detail::run_state(*pine);
            const int ratio = state.spec && !state.spec->timeframe_undetected
                ? tf_ratio(state.spec->input_tf, state.spec->script_tf) : 1;
            const int bar = pine->scheduler_.bar_magnifier_enabled() || ratio > 1 || ratio == -1
                ? pine->scheduler_.source_bar_index_for(context)
                : context.coordinate.interval_index;
            detail::ExitScratchRows<native_order::RequestHandle> adds(*this);
            detail::ExitScratchIndex opened(adds.context());
            detail::ExitScratchIndex selected_adds(adds.context());
            for (const auto& opening : cohort->second.opened)
                opened.put(opening.incarnation, 0);
            double units = 0.0;
            for (const auto& lot : pine->pyramid_entries_) {
                if (!market_pyramid_add(lot.entry_incarnation)
                    || lot.entry_bar_index != bar
                    || lot.entry_id != placement_snapshot->from_entry
                    || !(lot.qty > internal::kQtyEpsilon)) {
                    continue;
                }
                if (opened.find(lot.entry_incarnation) == detail::ExitScratchIndex::absent)
                    continue;
                adds.push_back({adds.context().run, lot.entry_incarnation});
                selected_adds.put(lot.entry_incarnation, 0);
                units += lot.qty;
            }
            // The cover stands behind the leg's own reduction of an OLDER lot
            // of the id: a leg whose fill reduced only the add, or (FIFO) a
            // lot of another id, keeps to its own quantity
            // (tests/fixtures/ki62_same_id_cover).
            bool drained_older = false;
            for (std::size_t i = 0; i < event.closed_trade_count; ++i) {
                const std::size_t row = event.first_trade_index + i;
                drained_older = drained_older || (row < pine->trades_.size()
                    && pine->trades_[row].entry_id == placement_snapshot->from_entry
                    && selected_adds.find(pine->trades_[row].entry_incarnation)
                        == detail::ExitScratchIndex::absent);
            }
            if (!adds.empty() && units > 0.0 && drained_older) {
                native_order::Request request;
                request.intent = native_order::Reduce{native_order::ExplicitUnits{units}};
                request.label = placement_snapshot->source_id;
                request.comment = placement_snapshot->comment;
                request.trigger = native_order::Market{};
                request.owner = detail::exit_scratch_versions(adds.context()).freeze_openings(
                    adds.context().run, current_position_cycle_, adds.size(), &adds,
                    [](void* opaque, std::uint64_t index, native_order::RequestHandle& result) {
                        const auto& rows = *static_cast<const detail::ExitScratchRows<
                            native_order::RequestHandle>*>(opaque);
                        if (index >= rows.size()) return detail::ScratchStatus::not_found;
                        try {
                            result = rows[index];
                            return detail::ScratchStatus::ok;
                        } catch (const detail::ExitScratchError& error) {
                            return error.status();
                        }
                    });
                request.group = native_order::NoGroup{};
                PlacementSnapshot cover = *placement_snapshot;
                cover.requested_qty = units;
                cover.immediately = true;
                cover.deferred_cohort = false;
                cover.forced_execution_price = event.resolved_price;
                const auto accepted = submit_or_replace(
                    std::move(request), std::move(cover), false,
                    placement_snapshot->source_id + "\x1f" + placement_snapshot->from_entry
                        + "\x1f" + "cover");
                if (accepted) {
                    (void)require_host().execute_current(
                        {*accepted, NativeCurrentPriceRule::NearestTick});
                }
            }
        }
    }
    // A same-bar strategy.close or close_all that fills at a
    // process_orders_on_close close is followed there by the reversing stop
    // entries the close pass left for it (the recalculation fill-order correction).
    if (placement_snapshot && event.closed_units > 0.0
        && (placement_snapshot->family == PineOrderFamily::Close
            || placement_snapshot->family == PineOrderFamily::CloseAll)
        && placement_snapshot->projection_created_bar == projection_bar_index(context)
        && config_.process_orders_on_close && !config_.calc_on_order_fills
        && modeled_input() && !coof_recalc_active_
        && event.cursor.point.path_phase == NativePathPhase::Close) {
        fill_pooc_close_entries(event.raw_price, context, /*after_close=*/true);
    }
    // Once the calculation's last order that fills at a process_orders_on_close
    // close has filled there, the pass decides the calculation's exits,
    // including those placed with the entry that just opened or reversed the
    // position (fill_pooc_close_exits; lane W4-ENG-POOC-SAMEPASS).
    // The close-pass immediate of a priced entry fills with the calculation's
    // own provenance; its exits are decided once the last one has filled.
    const bool close_pass_entry_filled = placement_snapshot
        && placement_snapshot->family == PineOrderFamily::Entry && placement_snapshot->opening
        && context.coordinate.provenance == NativePriceProvenance::Calculation
        && std::isfinite(placement_snapshot->forced_execution_price)
        && (std::isfinite(placement_snapshot->exit_levels.limit)
            || std::isfinite(placement_snapshot->exit_levels.stop))
        && !pooc_close_entry_immediate_pending(context, &event.handle());
    if (placement_snapshot && config_.process_orders_on_close
        && modeled_input() && !coof_recalc_active_
        && (context.coordinate.provenance == NativePriceProvenance::AfterCalculationClose
            || close_pass_entry_filled)
        && placement_snapshot->projection_created_bar == projection_bar_index(context)
        && (placement_snapshot->opening
            || placement_snapshot->family == PineOrderFamily::Close
            || placement_snapshot->family == PineOrderFamily::CloseAll
            || placement_snapshot->family == PineOrderFamily::Order)
        && !pooc_close_market_pending(context)) {
        fill_pooc_close_exits(event.raw_price, context);
    }
    // A path point's call leaves a book the rest of the path checks again
    // (schedule_margin_call_path).
    if (placement_snapshot && placement_snapshot->waypoint_margin_call
        && event.closed_units > 0.0 && policy_script_bar_valid_
        && waypoint_chain_bar_ == context.script_bar_open_ms
        && detail::run_position(require_host()).signed_units != 0.0) {
        const bool high_first = source_path_uses_high_first(policy_script_bar_);
        const auto phase = context.coordinate.path_phase;
        const int filled_at = phase == NativePathPhase::Open ? 0
            : phase == NativePathPhase::Close ? 3
            : ((phase == NativePathPhase::High) == high_first ? 1 : 2);
        const double print = filled_at == 0 ? policy_script_bar_.open
            : filled_at == 3 ? policy_script_bar_.close
            : phase == NativePathPhase::High ? policy_script_bar_.high : policy_script_bar_.low;
        withdraw_waypoint_margin_calls();
        // A call so taken is followed as one the kernel's check takes.
        follow_margin_call(event.closed_units, event.resolved_price, print, context);
        if (detail::run_position(require_host()).signed_units != 0.0)
            (void)rest_waypoint_margin_call(policy_script_bar_, filled_at + 1, 3, context);
    }
    // The kernel's path check calls as the opening print does, and is
    // followed alike (follow_margin_call).
    if (event.definition
        && event.definition->origin == native_order::RequestOrigin::KernelLiquidation
        && event.closed_units > 0.0) {
        follow_margin_call(event.closed_units, event.resolved_price, event.raw_price, context);
    }
}
 
int PineExecutionAdapter::short_seed_collision_role_v1(native_order::RequestHandle handle) const noexcept {
    // Only the plan actually selected at the qualifying broker open projects
    // executable roles. Retained immutable handles are lifecycle/hash facts,
    // not historical role authority.
    if (!short_seed_.active) return 0;
    if (handle == short_seed_.long_entry) return 1;
    if (handle == short_seed_.materialize_long) return 2;
    if (handle == short_seed_.final_short) return 3;
    return 0;
}
 
bool PineExecutionAdapter::take_intraday_loss_relabel(std::uint64_t ordinal) noexcept {
    const bool relabel = intraday_loss_relabel_ordinals_.erase(ordinal) != 0;
    // The host clears exit_id immediately after this receipt is taken.
    if (relabel && position_tail_summary_)
        position_tail_summary_->invalidate(PositionTailGuard::Relabel,
                                           PINEFORGE_POSITION_TAIL_DIAGNOSTICS{});
    return relabel;
}
 
std::vector<PineExecutionAdapter::FixturePendingSnapshot>
PineExecutionAdapter::fixture_pending_snapshots() const {
    std::vector<FixturePendingSnapshot> rows;
    rows.reserve(live_handles_.size() + pending_entries_.size()
                 + pending_bracket_legs_.size()
                 + pending_same_bar_commands_.size()
                 + pending_coof_requests_.size()
                 + source_shadow_pending_.size());
    // One above every incarnation a row was ever remembered under, erased
    // rows included (the retired-row compaction).
    std::uint64_t next_incarnation = std::max<std::uint64_t>(1, placement_.high_water() + 1);
    struct StagedParentProjection {
        SourceId id;
        std::uint64_t command_sequence = 0;
        std::uint64_t incarnation = 0;
    };
    std::vector<StagedParentProjection> staged_parents;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found != placement_.end()) rows.push_back({handle.incarnation, found->second, false});
    }
    for (const auto& pending : pending_entries_) {
        const std::uint64_t incarnation = next_incarnation++;
        rows.push_back({incarnation, pending.snapshot, true});
        staged_parents.push_back({pending.snapshot.source_id,
                                  pending.snapshot.command_sequence,
                                  incarnation});
    }
    std::vector<std::uint64_t> pending_bracket_families;
    for (const auto& pending : pending_bracket_legs_) {
        if (std::find(pending_bracket_families.begin(), pending_bracket_families.end(),
                      pending.family_key) != pending_bracket_families.end()) {
            continue;
        }
        pending_bracket_families.push_back(pending.family_key);
        std::uint64_t incarnation = 0;
        if (pending.snapshot.defer_until_post_parent_calculation
            && pending.snapshot.legs.target().incarnation != 0) {
            incarnation = pending.snapshot.legs.target().incarnation;
        } else {
            const auto parent = std::find_if(
                staged_parents.begin(), staged_parents.end(),
                [&](const StagedParentProjection& row) {
                    return row.id == pending.snapshot.from_entry
                        && pending.snapshot.command_sequence >= row.command_sequence;
                });
            if (parent != staged_parents.end()) {
                incarnation = parent->incarnation
                    + (pending.snapshot.command_sequence - parent->command_sequence);
                next_incarnation = std::max(next_incarnation, incarnation + 1);
            } else {
                incarnation = next_incarnation++;
            }
        }
        rows.push_back({incarnation, pending.snapshot, true});
    }
    for (const auto& pending : pending_same_bar_commands_)
        rows.push_back({0, pending.snapshot, true});
    for (const auto& pending : pending_coof_requests_)
        rows.push_back({0, pending.snapshot, true});
    for (const auto& shadow : source_shadow_pending_)
        rows.push_back({0, shadow.snapshot, true});
    return rows;
}
 
double PineExecutionAdapter::fixture_close_logical_units(
        const SourceId& id) const noexcept {
    const auto found = close_logical_units_.find(id);
    return found == close_logical_units_.end() ? 0.0 : found->second;
}
 
std::vector<PineExecutionAdapter::FixtureCloseCallsite>
PineExecutionAdapter::fixture_close_callsites() const {
    std::vector<FixtureCloseCallsite> result;
    result.reserve(close_batch_callsites_.size());
    for (const auto& row : close_batch_callsites_) {
        const auto& site = row.second;
        result.push_back({site.token, site.active, site.target, site.calls,
                          site.id, site.comment, site.queue_sequence});
    }
    return result;
}
 
PineCancellationReceipt*
PineExecutionAdapter::fixture_mutable_cancellation(int index) noexcept {
    if (index < 0 || index >= static_cast<int>(live_handles_.size())) return nullptr;
    const auto handle = live_handles_[static_cast<std::size_t>(index)];
    const auto found = placement_.find(handle.incarnation);
    return found == placement_.end() ? nullptr : &found->second.cancellation;
}
 
void PineExecutionAdapter::fixture_remove_entry_without_named_cancel(
        const SourceId& id) {
    pending_write(pending_entries_).erase(std::remove_if(
        pending_entries_.begin(), pending_entries_.end(),
        [&](const PendingEntry& pending) {
            return pending.snapshot.family == PineOrderFamily::Entry
                && pending.snapshot.source_id == id;
        }), pending_entries_.end());
    std::vector<native_order::RequestHandle> matches;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found != placement_.end()
            && found->second.family == PineOrderFamily::Entry
            && found->second.source_id == id) {
            matches.push_back(handle);
        }
    }
    for (const auto& handle : matches) {
        const auto result = require_host().cancel(handle);
        if (result.status == native_order::CancelStatus::Cancelled) retire(handle);
    }
    named_entry_cancel_tokens_.erase(id);
}
 
void PineExecutionAdapter::set_risk_direction(int direction) noexcept { risk_.direction = direction; }
void PineExecutionAdapter::set_risk_max_cons_loss_days(int value) noexcept { risk_.max_cons_loss_days = value; }
void PineExecutionAdapter::set_risk_max_drawdown(double value, bool percent) noexcept {
    risk_.max_drawdown = value;
    if (percent) risk_.max_drawdown_percent = true;
}
void PineExecutionAdapter::set_risk_max_intraday_loss(double value, bool percent) noexcept {
    risk_.max_intraday_loss = value;
    if (percent) risk_.max_intraday_loss_percent = true;
}
void PineExecutionAdapter::set_risk_max_position_size(double value) noexcept { risk_.max_position_size = value; }
PineReplayRiskConfig PineExecutionAdapter::capture_replay_risk_config() const noexcept {
    PineReplayRiskConfig snapshot;
    snapshot.direction = risk_.direction;
    snapshot.max_cons_loss_days = risk_.max_cons_loss_days;
    snapshot.max_drawdown = risk_.max_drawdown;
    snapshot.max_drawdown_percent = risk_.max_drawdown_percent;
    snapshot.max_intraday_loss = risk_.max_intraday_loss;
    snapshot.max_intraday_loss_percent = risk_.max_intraday_loss_percent;
    snapshot.max_position_size = risk_.max_position_size;
    snapshot.cap_attachment = cap.attachment();
    snapshot.cap_configuration = cap.configuration();
    snapshot.cap_declared = cap.declared();
    return snapshot;
}
void PineExecutionAdapter::restore_replay_risk_config(
    const PineReplayRiskConfig& snapshot) noexcept {
    risk_.direction = snapshot.direction;
    risk_.max_cons_loss_days = snapshot.max_cons_loss_days;
    risk_.max_drawdown = snapshot.max_drawdown;
    risk_.max_drawdown_percent = snapshot.max_drawdown_percent;
    risk_.max_intraday_loss = snapshot.max_intraday_loss;
    risk_.max_intraday_loss_percent = snapshot.max_intraday_loss_percent;
    risk_.max_position_size = snapshot.max_position_size;
    cap.restore_replay_configuration(snapshot.cap_attachment, snapshot.cap_configuration,
                                     snapshot.cap_declared);
}
void PineExecutionAdapter::set_margin_call_enabled(bool enabled) noexcept {
    source_margin_call_enabled_ = enabled;
}
void PineExecutionAdapter::mark_market_pyramid_add(std::uint64_t incarnation) {
    market_pyramid_adds_.insert(incarnation);
}
void PineExecutionAdapter::enable_intraday_cap() noexcept { cap.attach(); }
void PineExecutionAdapter::attach_execution_adapter() noexcept { priority.attach(); }
 
std::vector<native_order::RequestHandle> PineExecutionAdapter::take_first_open_newborns() {
    auto result = std::move(first_open_newborns_);
    first_open_newborns_.clear();
    return result;
}
 
void PineExecutionAdapter::refresh_pending_view() noexcept {
    ++pending_projection_version_;
    projected_pending_valid_ = false;
    std::vector<int>{}.swap(projected_pending_indexes_);
    std::vector<int>{}.swap(projected_pending_next_);
}
 
int PineExecutionAdapter::projected_raw_pending_size() const noexcept {
    const std::size_t total = live_handles_.size()
        + pending_same_bar_commands_.size() + pending_entries_.size()
        + pending_bracket_legs_.size() + pending_coof_requests_.size()
        + source_shadow_pending_.size();
    return total > static_cast<std::size_t>(std::numeric_limits<int>::max())
        ? std::numeric_limits<int>::max() : static_cast<int>(total);
}
 
bool PineExecutionAdapter::projected_raw_pending_at(
        int index, const PlacementSnapshot*& snapshot,
        native_order::RequestHandle& handle) const noexcept {
    ++projected_raw_pending_calls_; snapshot = nullptr;
    handle = {};
    if (index < 0) return false;
    std::size_t offset = static_cast<std::size_t>(index);
    if (offset < live_handles_.size()) {
        handle = live_handles_[offset];
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) return false;
        snapshot = &found->second;
        return true;
    }
    offset -= live_handles_.size();
    const auto locate = [&](const auto& rows, auto read) {
        if (offset >= rows.size()) {
            offset -= rows.size();
            return false;
        }
        snapshot = &read(rows[offset]);
        return true;
    };
    if (locate(pending_same_bar_commands_,
               [](const PendingSameBarCommand& row) -> const PlacementSnapshot& {
                   return row.snapshot;
               })) return true;
    if (locate(pending_entries_,
               [](const PendingEntry& row) -> const PlacementSnapshot& {
                   return row.snapshot;
               })) return true;
    if (locate(pending_bracket_legs_,
               [](const PendingBracketLeg& row) -> const PlacementSnapshot& {
                   return row.snapshot;
               })) return true;
    if (locate(pending_coof_requests_,
               [](const PendingCoofRequest& row) -> const PlacementSnapshot& {
                   return row.snapshot;
               })) return true;
    return locate(source_shadow_pending_,
                  [](const SourceShadowPending& row) -> const PlacementSnapshot& {
                      return row.snapshot;
                  });
}
 
bool PineExecutionAdapter::same_projected_order(
        const PlacementSnapshot& left,
        const PlacementSnapshot& right) noexcept {
    const auto is_exit = [](PineOrderFamily family) {
        return family == PineOrderFamily::ExitLimit
            || family == PineOrderFamily::ExitStop
            || family == PineOrderFamily::ExitTrail;
    };
    if (!is_exit(left.family) || !is_exit(right.family)) return false;
    return left.source_id == right.source_id
        && left.from_entry == right.from_entry
        && left.bracket_origin == right.bracket_origin;
}
 
bool PineExecutionAdapter::ensure_projected_pending_index() const try {
    const auto placements_version = placement_.pending_observer_version_;
    if (projected_pending_valid_
        && projected_pending_version_ == pending_projection_version_
        && projected_placement_version_ == placements_version) return true;
    struct Key {
        std::string_view source, from, session;
        std::uint64_t run, origin;
        bool operator==(const Key& other) const noexcept {
            return source == other.source && from == other.from
                && session == other.session && run == other.run
                && origin == other.origin;
        }
    };
    struct Hash {
        std::size_t operator()(const Key& key) const noexcept {
            std::size_t hash = 0;
            const auto add = [&](std::size_t value) {
                hash ^= value + 0x9e3779b9U + (hash << 6U) + (hash >> 2U);
            };
            const std::hash<std::string_view> text;
            add(text(key.source)); add(text(key.from)); add(text(key.session));
            add(std::hash<std::uint64_t>{}(key.run));
            add(std::hash<std::uint64_t>{}(key.origin));
            return hash;
        }
    };
    const int raw_count = projected_raw_pending_size();
    std::vector<int> indexes;
    std::vector<int> next(static_cast<std::size_t>(raw_count), -1);
    std::unordered_map<Key, int, Hash> exits;
    indexes.reserve(static_cast<std::size_t>(raw_count));
    exits.reserve(static_cast<std::size_t>(raw_count));
    // A group's first raw slot survives; later slots form an ordered chain.
    for (int raw = 0; raw < raw_count; ++raw) {
        const PlacementSnapshot* row = nullptr;
        native_order::RequestHandle handle;
        if (!projected_raw_pending_at(raw, row, handle) || !row) continue;
        const bool exit = row->family == PineOrderFamily::ExitLimit
            || row->family == PineOrderFamily::ExitStop
            || row->family == PineOrderFamily::ExitTrail;
        if (exit) {
            const auto& origin = row->bracket_origin;
            const Key key{row->source_id, row->from_entry, std::string_view(origin.run.session_key.string()),
                          origin.run.run_number, origin.incarnation};
            auto inserted = exits.emplace(key, raw);
            if (!inserted.second) {
                next[static_cast<std::size_t>(inserted.first->second)] = raw;
                inserted.first->second = raw;
                continue;
            }
        }
        indexes.push_back(raw);
    }
    // Publish complete integer indexes only; failed allocation leaves exact scans in charge.
    projected_pending_indexes_.swap(indexes);
    projected_pending_next_.swap(next);
    projected_pending_version_ = pending_projection_version_;
    projected_placement_version_ = placements_version;
    projected_pending_valid_ = true; return true;
} catch (const std::bad_alloc&) { projected_pending_valid_ = false; return false; }
 
int PendingIntentView::size() const noexcept {
    return owner_ ? owner_->projected_pending_size() : 0;
}
 
int PendingIntentView::probe_fill_qty(int index, double fill_price, double* qty,
                                      int* close_only, int* partition) const noexcept {
    if (!owner_ || !qty || !close_only || !partition) return -1;
    const PlacementSnapshot* row = nullptr;
    native_order::RequestHandle handle;
    if (!owner_->projected_pending_at(index, row, handle) || !row) return -1;
    const auto& snapshot = *row;
    *qty = kNaN;
    *close_only = 0;
    *partition = -1;
    if (!snapshot.opening) return 1;
 
    const auto physical = detail::run_position(owner_->require_host());
    const bool opposite = physical.signed_units != 0.0
        && ((physical.signed_units > 0.0) != snapshot.is_long);
    bool kernel_close_only = false;
    bool sized = false;
    if (snapshot.frozen_market_instruction
        && finite_positive(snapshot.frozen_market_transaction_units)) {
        if (opposite) {
            *qty = std::max(0.0, snapshot.frozen_market_transaction_units
                                  - std::abs(physical.signed_units));
            *partition = 1;
            kernel_close_only = !(*qty > 1e-10);
            sized = true;
        } else if (owner_->fixed_unmargined_market_batch_scope()) {
            // Match precommit's batch boundary without an unpersisted scope flag.
            *qty = snapshot.frozen_market_transaction_units;
            *partition = 1;
            sized = true;
        } else if (physical.signed_units != 0.0
                   && ((physical.signed_units > 0.0) == snapshot.is_long)
                   && snapshot.projection_over_pyramiding) {
            *qty = snapshot.frozen_market_transaction_units;
            *partition = 1;
            sized = true;
        } else if (physical.signed_units == 0.0
                   && finite_positive(snapshot.frozen_market_own_units)
                   && snapshot.frozen_market_transaction_units
                        > snapshot.frozen_market_own_units + 1e-10) {
            *qty = snapshot.frozen_market_transaction_units;
            *partition = 1;
            sized = true;
        }
    }
    const bool default_stop_shape = snapshot.family == PineOrderFamily::Entry
        && !std::isnan(snapshot.exit_levels.stop)
        && std::isnan(snapshot.exit_levels.limit)
        && std::isnan(snapshot.requested_qty)
        && owner_->config_.default_qty_type
            == static_cast<int>(QtyType::PERCENT_OF_EQUITY)
        && finite_positive(snapshot.sizing.frozen_units);
    const bool default_stop = default_stop_shape
        && finite_positive(fill_price)
        && snapshot.projection_position_side
            == static_cast<std::int32_t>(PositionSide::FLAT);
    const bool unpriced_market = std::isnan(snapshot.exit_levels.limit)
        && std::isnan(snapshot.exit_levels.stop)
        && std::isnan(snapshot.exit_levels.trail_offset)
        && std::isnan(snapshot.exit_levels.trail_price);
    const bool limit_route = (snapshot.family == PineOrderFamily::Entry
                               || snapshot.family == PineOrderFamily::Order)
        && !std::isnan(snapshot.exit_levels.limit);
    double sized_price = fill_price;
    if (!limit_route && std::isfinite(sized_price)) {
        sized_price += (snapshot.is_long ? 1.0 : -1.0)
            * owner_->config_.slippage * owner_->staged_.syminfo.mintick;
    }
    const bool typed_entry = snapshot.family == PineOrderFamily::Entry
        && (snapshot.qty_type == static_cast<int>(QtyType::CASH)
            || snapshot.qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY));
    if (!sized && finite_positive(snapshot.requested_qty)) {
        // A typed quantity is money: the units its fill books at this price
        // (resolve_terms), not the cash or percentage number itself.
        *qty = typed_entry
            ? owner_->typed_entry_units(snapshot, sized_price,
                                        owner_->sizing_snapshot().fx, handle).value_or(0.0)
            : snapshot.requested_qty;
        *partition = 0;
        sized = true;
    } else if (!sized && default_stop) {
        *qty = snapshot.sizing.frozen_units;
        *partition = 1;
        sized = true;
    } else if (!sized && !default_stop_shape && unpriced_market
               && finite_positive(snapshot.sizing.frozen_units)) {
        *qty = snapshot.sizing.frozen_units;
        *partition = 1;
        sized = true;
    }
    if (!sized) {
        const int type = owner_->config_.default_qty_type;
        if (type == static_cast<int>(QtyType::CASH)
            || type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)) {
            // The quantity resolve_terms books at this fill (its at-fill
            // branch): the source's money on its own sizing equity, converted
            // by the kernel with the percentage fee reserve and floored by the
            // source -- default_sizing_units, the one conversion.
            PineSizingSnapshot sizing = owner_->sizing_snapshot();
            sizing.price = sized_price;
            sizing.mark = sized_price;
            if (finite_positive(sized_price)) {
                owner_->mark_sizing_equity(sizing, sized_price);
            } else {
                sizing.equity = kNaN;
                sizing.strategy_equity = kNaN;
            }
            *qty = owner_->default_sizing_units(sizing);
        } else {
            *qty = floor_quantity_grid(owner_->config_.default_qty_value,
                                       owner_->staged_.quantity_grid);
        }
        *partition = 3;
    }
 
    const bool prior_cycle_close_only = snapshot.family == PineOrderFamily::Entry
        && opposite
        && snapshot.projection_position_side
            != (physical.signed_units > 0.0
                ? static_cast<std::int32_t>(PositionSide::LONG)
                : static_cast<std::int32_t>(PositionSide::SHORT))
        && !snapshot.projection_predecessor_market;
    *close_only = (snapshot.affordability_close_only || prior_cycle_close_only
                   || kernel_close_only) ? 1 : 0;
    return 0;
}
 
int PendingIntentView::level_resolved(int index) const noexcept {
    if (!owner_) return -1;
    const PlacementSnapshot* snapshot = nullptr;
    native_order::RequestHandle handle;
    if (!owner_->projected_pending_at(index, snapshot, handle) || !snapshot) return -1;
    // Share the row lookup with effective_levels, which already has it.
    // Cohort state remains a current read, outside the position index.
    return owner_->projected_level_resolved(*snapshot);
}
 
int PendingIntentView::effective_levels(int index, double* stop, double* limit,
                                        double* trail_activation) const noexcept {
    if (!owner_ || !stop || !limit || !trail_activation) return -1;
    const PlacementSnapshot* row = nullptr;
    native_order::RequestHandle handle;
    if (!owner_->projected_pending_at(index, row, handle) || !row) return -1;
    const auto& snapshot = *row;
    const double tick = owner_->staged_.syminfo.mintick;
    const auto physical = detail::run_position(owner_->require_host());
    const bool long_side = physical.signed_units > 0.0;
    const double entry = owner_->require_host().position_avg_price();
    *stop = snapshot.exit_levels.stop;
    *limit = snapshot.exit_levels.limit;
    double trail_points = snapshot.exit_levels.trail_points;
    double trail_price = snapshot.exit_levels.trail_price;
    double profit_ticks = snapshot.exit_levels.profit_ticks;
    double loss_ticks = snapshot.exit_levels.loss_ticks;
    if (snapshot.family == PineOrderFamily::ExitLimit
        || snapshot.family == PineOrderFamily::ExitStop
        || snapshot.family == PineOrderFamily::ExitTrail) {
        for (int raw = owner_->projected_pending_next(index); raw >= 0; raw = owner_->projected_raw_pending_next(raw)) {
            const PlacementSnapshot* sibling = nullptr;
            native_order::RequestHandle sibling_handle;
            if (!owner_->projected_raw_pending_at(raw, sibling, sibling_handle)
                || !sibling || !PineExecutionAdapter::same_projected_order(snapshot, *sibling)) {
                continue;
            }
            if (!std::isnan(sibling->exit_levels.stop)) *stop = sibling->exit_levels.stop;
            if (!std::isnan(sibling->exit_levels.limit)) *limit = sibling->exit_levels.limit;
            if (!std::isnan(sibling->exit_levels.trail_points))
                trail_points = sibling->exit_levels.trail_points;
            if (!std::isnan(sibling->exit_levels.trail_price))
                trail_price = sibling->exit_levels.trail_price;
            if (!std::isnan(sibling->exit_levels.profit_ticks))
                profit_ticks = sibling->exit_levels.profit_ticks;
            if (!std::isnan(sibling->exit_levels.loss_ticks))
                loss_ticks = sibling->exit_levels.loss_ticks;
        }
    }
    // The legacy C observer reports the executable levels, not merely the
    // raw tick offsets retained at the command.  Keep the source tick
    // derivation at the projection boundary where it is observable.
    const bool position_live = physical.signed_units != 0.0 && std::isfinite(entry);
    const bool resolved = position_live && owner_->projected_level_resolved(snapshot) == 1;
    const double direction = long_side ? 1.0 : -1.0;
    if ((snapshot.family == PineOrderFamily::ExitLimit
         || snapshot.family == PineOrderFamily::ExitStop
         || snapshot.family == PineOrderFamily::ExitTrail)
        && resolved) {
        if (std::isnan(*limit) && !std::isnan(profit_ticks)) {
            *limit = source_level_on_price_grid(
                entry + direction * profit_ticks * tick, tick);
        }
        if (std::isnan(*stop) && !std::isnan(loss_ticks)) {
            *stop = source_level_on_price_grid(
                entry - direction * loss_ticks * tick, tick);
        }
    }
    *trail_activation = kNaN;
    if (!std::isnan(trail_points)) {
        if (resolved) {
            const double ticks = source_trail_points_ticks(trail_points, tick);
            *trail_activation = compat::pine::snap_trail_level_to_tick_grid(
                entry + direction * ticks * tick, tick);
        }
    } else {
        *trail_activation = trail_price;
    }
    return 0;
}
 
int PendingIntentView::copy_v1(int index, pf_pending_order_v1_t* out) const noexcept {
    if (!owner_ || !out) return -1;
    const PlacementSnapshot* row = nullptr;
    native_order::RequestHandle handle;
    if (!owner_->projected_pending_at(index, row, handle) || !row) return -1;
    const PlacementSnapshot& snapshot = *row;
 
    std::memset(out, 0, sizeof(*out));
    out->struct_version = 1;
    out->size = static_cast<std::uint32_t>(sizeof(*out));
    if (snapshot.family == PineOrderFamily::Close) {
        copy_pending_prefixed_string("__close__", snapshot.source_id,
                                     out->id, &out->id_truncated,
                                     &out->id_hash64);
    } else {
        copy_pending_string(snapshot.source_id, out->id,
                            &out->id_truncated, &out->id_hash64);
    }
    copy_pending_string(snapshot.from_entry, out->from_entry, &out->from_entry_truncated,
                        &out->from_entry_hash64);
    copy_pending_string(snapshot.oca_name, out->oca_name, &out->oca_name_truncated,
                        &out->oca_name_hash64);
    copy_pending_string(snapshot.comment, out->comment, &out->comment_truncated,
                        &out->comment_hash64);
    out->type = mirror_order_type(snapshot.family);
    out->is_long = snapshot.is_long ? 1U : 0U;
    out->limit_price = snapshot.exit_levels.limit;
    out->stop_price = snapshot.exit_levels.stop;
    out->trail_points = snapshot.exit_levels.trail_points;
    out->trail_price = snapshot.exit_levels.trail_price;
    out->trail_offset = snapshot.exit_levels.trail_offset;
    out->profit_ticks = snapshot.exit_levels.profit_ticks;
    out->loss_ticks = snapshot.exit_levels.loss_ticks;
    if (snapshot.family == PineOrderFamily::ExitLimit
        || snapshot.family == PineOrderFamily::ExitStop
        || snapshot.family == PineOrderFamily::ExitTrail) {
        for (int raw = owner_->projected_pending_next(index); raw >= 0; raw = owner_->projected_raw_pending_next(raw)) {
            const PlacementSnapshot* sibling = nullptr;
            native_order::RequestHandle sibling_handle;
            if (!owner_->projected_raw_pending_at(raw, sibling, sibling_handle)
                || !sibling || !PineExecutionAdapter::same_projected_order(snapshot, *sibling)) {
                continue;
            }
            if (!std::isnan(sibling->exit_levels.limit))
                out->limit_price = sibling->exit_levels.limit;
            if (!std::isnan(sibling->exit_levels.stop))
                out->stop_price = sibling->exit_levels.stop;
            if (!std::isnan(sibling->exit_levels.trail_points))
                out->trail_points = sibling->exit_levels.trail_points;
            if (!std::isnan(sibling->exit_levels.trail_price))
                out->trail_price = sibling->exit_levels.trail_price;
            if (!std::isnan(sibling->exit_levels.trail_offset))
                out->trail_offset = sibling->exit_levels.trail_offset;
            if (!std::isnan(sibling->exit_levels.profit_ticks))
                out->profit_ticks = sibling->exit_levels.profit_ticks;
            if (!std::isnan(sibling->exit_levels.loss_ticks))
                out->loss_ticks = sibling->exit_levels.loss_ticks;
        }
    }
    out->qty = snapshot.family == PineOrderFamily::Close
        ? snapshot.requested_qty
        : (std::isfinite(snapshot.projection_remaining_qty)
            ? snapshot.projection_remaining_qty : snapshot.requested_qty);
    out->qty_type = snapshot.qty_type;
    out->qty_percent = snapshot.qty_percent;
    out->oca_type = snapshot.oca_type;
    out->created_bar = snapshot.projection_created_bar;
    out->created_seq = static_cast<std::int64_t>(snapshot.source_sequence);
    out->incarnation = handle.incarnation;
    out->created_by_same_id_replacement = snapshot.projection_predecessor != 0
        && snapshot.family != PineOrderFamily::Order ? 1U : 0U;
    out->replaced_default_market_incarnation = snapshot.projection_predecessor_market
        ? snapshot.projection_predecessor : 0;
    out->declined_by_replaced_short_market = snapshot.cancellation.cause
        == PineCancellationCause::Replacement ? 1U : 0U;
    out->replaced_exit_order_incarnation = snapshot.projection_predecessor_exit
        ? snapshot.projection_predecessor : 0;
    out->recreated_after_named_cancelled_entry_incarnation =
        snapshot.recreated_after_named_cancelled_entry_incarnation;
    out->named_cancel_surviving_exit_incarnation = snapshot.named_cancel_surviving_exit_incarnation;
    out->stop_limit_activated = snapshot.stop_limit_activated ? 1U : 0U;
    out->coof_suppress_stop_on_entry_bar = snapshot.exit_activation.holds_stop() ? 1U : 0U;
    out->coof_suppress_limit_on_entry_bar = snapshot.exit_activation.holds_limit() ? 1U : 0U;
    out->created_during_coof_recalc = snapshot.birth.from_fill() ? 1U : 0U;
    out->coof_born_at_close_recalc = snapshot.birth.at_terminal_fill() ? 1U : 0U;
    out->coof_born_mid_bar = compat::pine::historical_cascade_reach(snapshot.birth_reach) ? 1U : 0U;
    out->coof_cascade_seg_i = snapshot.coof_cascade_seg_i;
    out->coof_cascade_inflight_fires = snapshot.coof_cascade_inflight_fires ? 1U : 0U;
    out->created_position_side = snapshot.projection_position_side;
    out->created_position_cycle_seq = snapshot.placement_cycle;
    out->created_after_position_close_in_bar = snapshot.projection_after_close ? 1U : 0U;
    out->over_pyramiding_cap_at_placement = snapshot.projection_over_pyramiding ? 1U : 0U;
    out->same_id_stop_deferred_close_all_bar = snapshot.cancellation.cause
        == PineCancellationCause::Dependency ? snapshot.projection_created_bar : -1;
    out->same_id_stop_deferred_close_all_incarnation = snapshot.cancellation.cause
        == PineCancellationCause::Dependency ? snapshot.cancellation.target_incarnation : 0;
    out->reverses_same_bar_market_from_flat =
        snapshot.projection_opposite_market_predecessor ? 1U : 0U;
    out->paired_flat_market_candidate = snapshot.paired_flat_market_candidate ? 1U : 0U;
    out->paired_flat_market_own_qty = snapshot.paired_flat_market_own_qty;
    out->paired_flat_market_signal_close = snapshot.paired_flat_market_signal_close;
    out->paired_flat_market_signal_equity = snapshot.paired_flat_market_signal_equity;
    out->paired_flat_market_signal_margin_pct = snapshot.paired_flat_market_signal_margin_pct;
    out->paired_flat_market_signal_pointvalue = snapshot.paired_flat_market_signal_pointvalue;
    out->paired_flat_market_signal_fx = snapshot.paired_flat_market_signal_fx;
    out->paired_flat_market_peer_seq = snapshot.paired_flat_market_peer_seq;
    out->paired_flat_market_transaction_qty = snapshot.paired_flat_market_transaction_qty;
    out->default_flat_market_gross_candidate = snapshot.paired_flat_market_candidate
        && !std::isfinite(snapshot.requested_qty) ? 1U : 0U;
    out->tv_carry_qty = snapshot.projection_tv_carry_qty;
    out->frozen_default_qty = snapshot.sizing.frozen_units;
    out->default_stop_placement_qty = snapshot.sizing.frozen_units;
    out->default_stop_placement_equity = snapshot.projection_default_stop_equity;
    out->default_stop_placement_signal_close = snapshot.projection_default_stop_signal_close;
    out->default_stop_sizing_price = snapshot.sizing.price;
    out->sizing_equity = snapshot.sizing.equity;
    out->sizing_price = snapshot.sizing.price;
    out->sizing_fx = snapshot.sizing.fx;
    out->sizing_mark = snapshot.sizing.mark;
    out->opening_affordability_exemption_candidate = snapshot.opening
        && !std::isfinite(snapshot.requested_qty)
        && snapshot.projection_position_side == static_cast<std::int32_t>(PositionSide::FLAT) ? 1U : 0U;
    out->explicit_flat_admission_candidate = snapshot.opening
        && std::isfinite(snapshot.requested_qty)
        && snapshot.projection_position_side == static_cast<std::int32_t>(PositionSide::FLAT) ? 1U : 0U;
    out->explicit_placement_equity = snapshot.projection_explicit_equity;
    out->explicit_slipped_signal_close = snapshot.projection_explicit_signal_close;
    out->affordability_placement_equity = snapshot.projection_affordability_equity;
    out->affordability_signal_price = snapshot.projection_affordability_signal_price;
    out->affordability_held_qty = snapshot.projection_affordability_held_qty;
    out->affordability_close_only = snapshot.affordability_close_only ? 1U : 0U;
    out->rounded_signal_cost_close_only = snapshot.rounded_signal_cost_close_only ? 1U : 0U;
    // The source command boundary itself is the truthful placement
    // observation after the legacy admission draft owner was retired.  Its
    // original sizing tuple is the immutable adapter snapshot captured by
    // entry()/order(); no allocation or reconstructed executable book is
    // involved in this projection.
    out->market_admission_observation_present = snapshot.opening ? 1U : 0U;
    out->market_admission_observation_original_sizing_present =
        snapshot.opening ? 1U : 0U;
    out->market_admission_observation_requested_quantity = snapshot.requested_qty;
    out->market_admission_observation_quantity_type = snapshot.qty_type;
    out->market_admission_observation_buy = snapshot.is_long ? 1U : 0U;
    out->market_admission_observation_prices_limit = snapshot.exit_levels.limit;
    out->market_admission_observation_prices_stop = snapshot.exit_levels.stop;
    copy_pending_string(snapshot.source_id,
                        out->market_admission_observation_id,
                        &out->market_admission_observation_id_truncated,
                        &out->market_admission_observation_id_hash64);
    copy_pending_string(snapshot.oca_name,
                        out->market_admission_observation_oca_name,
                        &out->market_admission_observation_oca_name_truncated,
                        &out->market_admission_observation_oca_name_hash64);
    out->market_admission_observation_placement_equity = snapshot.sizing.equity;
    out->market_admission_observation_signal_close = snapshot.sizing.price;
    out->market_admission_observation_original_sizing_quantity =
        snapshot.requested_qty;
    out->market_admission_observation_original_sizing_equity = snapshot.sizing.equity;
    out->market_admission_observation_original_sizing_price = snapshot.sizing.price;
    out->market_admission_observation_original_sizing_mark = snapshot.sizing.mark;
    out->market_admission_observation_original_sizing_fx = snapshot.sizing.fx;
    out->signal_close_mc_bar = snapshot.signal_close_mc_bar;
    out->signal_close_mc_entry_incarnation = snapshot.signal_close_mc_entry_incarnation;
    out->signal_close_mc_fill_seq = snapshot.signal_close_mc_fill_seq;
    out->signal_close_mc_remaining_qty = snapshot.signal_close_mc_remaining_qty;
    out->requested_partial = (!snapshot.opening && std::isfinite(snapshot.qty_percent)
        && snapshot.qty_percent < 100.0) || (!snapshot.opening
        && std::isfinite(snapshot.requested_qty)) ? 1U : 0U;
    out->full_percent_exit_request = !snapshot.opening && !std::isfinite(snapshot.requested_qty)
        && (!std::isfinite(snapshot.qty_percent) || snapshot.qty_percent == 100.0) ? 1U : 0U;
    out->pooc_global_full_exit_dynamic_qty = snapshot.pooc_global_full_exit_dynamic_qty ? 1U : 0U;
    out->pooc_global_full_exit_tracks_bound_adds = snapshot.pooc_global_full_exit_tracks_bound_adds ? 1U : 0U;
    out->pooc_global_full_exit_bound_add = snapshot.pooc_global_full_exit_bound_add ? 1U : 0U;
    out->created_while_in_position = !snapshot.opening
        && snapshot.projection_position_side != static_cast<std::int32_t>(PositionSide::FLAT)
        ? 1U : 0U;
    out->sbmt_member = snapshot.frozen_market_instruction ? 1U : 0U;
    out->sbmt_own_qty = snapshot.frozen_market_instruction
        ? snapshot.frozen_market_own_units : kNaN;
    out->sbmt_tx_qty = snapshot.frozen_market_instruction
        ? snapshot.frozen_market_transaction_units : kNaN;
    out->sbmt_kept_over_cap = snapshot.frozen_market_instruction
        && snapshot.projection_over_pyramiding ? 1U : 0U;
    out->sbmt_close_qty = snapshot.frozen_market_targeted_close
        ? snapshot.requested_qty : kNaN;
    out->sbmt_close_buy = snapshot.frozen_market_targeted_close
        && snapshot.projection_position_side == static_cast<std::int32_t>(PositionSide::SHORT)
        ? 1U : 0U;
    out->suppress_as_declined_reversal_close = snapshot.cancellation.cause
        == PineCancellationCause::Dependency ? 1U : 0U;
    out->dormant_bracket = snapshot.legs.dormant() ? 1U : 0U;
    out->dormant_reissue_pending = snapshot.legs.pending_replacement() ? 1U : 0U;
    out->dormant_original_stop_price = snapshot.legs.original_stop();
    out->dormant_hold_bar = snapshot.legs.hold_bar();
    out->dormant_reversal_kill_bar = snapshot.legs.excluded_bar();
    out->dormant_trail_best = snapshot.legs.trail_best();
    out->dormant_trail_best_start = snapshot.legs.trail_prefix();
    out->dormant_trail_leg_dead = snapshot.legs.retired(exit_legs::Leg::Trail) ? 1U : 0U;
    out->suppressed_close_consumed_ledger_qty = snapshot.cancellation.close_claim_consumed;
    out->suppressed_close_retired_ledger_qty = snapshot.cancellation.close_claim_retired;
    out->short_seed_collision_role = owner_->short_seed_.active ? owner_->short_seed_collision_role_v1(handle) : 0;
    out->replaced_order_incarnation = snapshot.projection_predecessor;
    out->birth_timestamp = snapshot.birth.timestamp();
    out->birth_cause = static_cast<std::int32_t>(snapshot.birth.cause());
    out->birth_bar = snapshot.birth.bar();
    out->birth_cursor_domain = static_cast<std::int32_t>(snapshot.birth.cursor().domain());
    out->birth_cursor_position = static_cast<std::int32_t>(snapshot.birth.cursor().position());
    out->birth_cursor_index = snapshot.birth.cursor().index();
    out->birth_cursor_count = snapshot.birth.cursor().count();
    out->birth_cursor_price = snapshot.birth.cursor_price();
    out->birth_first_fill = snapshot.birth.first_fill();
    out->birth_last_fill = snapshot.birth.last_fill();
    out->birth_evaluation_ordinal = snapshot.birth.evaluation_ordinal();
    out->pine_birth_reach = static_cast<std::int32_t>(snapshot.birth_reach);
    out->pine_frozen_market_instruction_kind = snapshot.frozen_market_instruction ? 1U : 0U;
    out->pine_frozen_market_instruction_own_units = snapshot.frozen_market_own_units;
    out->pine_frozen_market_instruction_transaction_units =
        snapshot.frozen_market_transaction_units;
    copy_pending_string(snapshot.frozen_market_targeted_close
                            ? std::string_view(snapshot.source_id) : std::string_view{},
                        out->pine_frozen_market_instruction_target_id,
                        &out->pine_frozen_market_instruction_target_id_truncated,
                        &out->pine_frozen_market_instruction_target_id_hash64);
    const bool explicit_units = std::isfinite(snapshot.requested_qty);
    const bool percentage = !explicit_units && std::isfinite(snapshot.qty_percent);
    out->quantity_intent_kind = explicit_units ? 2U : (percentage ? 3U : 1U);
    out->quantity_intent_units = explicit_units ? snapshot.requested_qty : 0.0;
    out->quantity_intent_numerator = percentage ? snapshot.qty_percent : 0.0;
    out->quantity_intent_denominator = percentage ? 100.0 : 0.0;
    const double exposure = snapshot.from_entry.empty() ? 0.0
        : owner_->cohort_exposure_for(snapshot.from_entry);
    out->quantity_reservation_present = snapshot.deferred_cohort && exposure > 0.0 ? 1U : 0U;
    out->quantity_reservation_units = out->quantity_reservation_present ? exposure : 0.0;
    out->quantity_reservation_basis_units = out->quantity_reservation_present ? exposure : 0.0;
    out->leg_activation_present = snapshot.leg_activation.bounds() ? 1U : 0U;
    out->leg_activation_owner_cycle = snapshot.leg_activation.bounds()
        ? snapshot.leg_activation.bounds()->position_cycle : 0;
    out->leg_activation_stop_first_bar = snapshot.leg_activation.bounds()
        ? snapshot.leg_activation.bounds()->stop_first_bar : 0;
    out->leg_activation_limit_first_bar = snapshot.leg_activation.bounds()
        ? snapshot.leg_activation.bounds()->limit_first_bar : 0;
    const auto& activation = snapshot.exit_activation.evidence();
    out->pine_exit_activation_present = activation ? 1U : 0U;
    out->pine_exit_activation_owner_cycle_at_birth = activation ? activation->position_cycle : 0;
    out->pine_exit_activation_entry_bar_at_birth = activation ? activation->entry_bar : 0;
    out->pine_exit_activation_direction_at_birth = activation ? activation->direction : 0;
    out->pine_exit_activation_cursor_price_at_birth = activation ? activation->cursor_price : 0.0;
    out->pine_exit_activation_stop_level_at_birth = activation ? activation->stop_level : 0.0;
    out->pine_exit_activation_limit_level_at_birth = activation ? activation->limit_level : 0.0;
    out->pine_exit_activation_limit_continuation_present = activation
        && activation->limit_continuation ? 1U : 0U;
    out->pine_exit_activation_limit_continuation_cause = activation
        && activation->limit_continuation
        ? static_cast<std::int32_t>(activation->limit_continuation->cause) : 0;
    out->pine_exit_activation_limit_continuation_fill = activation
        && activation->limit_continuation
        ? activation->limit_continuation->observed_fill_sequence : 0;
    const auto& expansion = snapshot.reservation_expansion.capture();
    out->reservation_expansion_present = expansion ? 1U : 0U;
    out->reservation_expansion_position_cycle = expansion ? expansion->position_cycle : 0;
    out->reservation_expansion_side = expansion ? static_cast<std::int32_t>(expansion->side) : 0;
    out->reservation_expansion_first_later_admission_present = expansion
        && expansion->first_later_admission ? 1U : 0U;
    out->reservation_expansion_first_later_admission = expansion
        && expansion->first_later_admission ? *expansion->first_later_admission : 0;
    out->reservation_growth_source_present = snapshot.reservation_growth_source.reservation_owner()
        ? 1U : 0U;
    out->reservation_growth_source_reservation_owner = snapshot.reservation_growth_source.reservation_owner()
        ? *snapshot.reservation_growth_source.reservation_owner() : 0;
 
    const auto target = snapshot.legs.target();
    const auto& definition = snapshot.legs.current_definition();
    out->legs_target_incarnation = target.incarnation;
    out->legs_target_owner = target.owner;
    out->legs_revision = snapshot.legs.revision();
    out->legs_definition_incarnation = definition.incarnation();
    out->legs_definition_revision = definition.revision();
    out->legs_definition_value_present = definition.has_value() ? 1U : 0U;
    out->legs_definition_limit_price = definition.has_value() ? definition.prices().limit_price : kNaN;
    out->legs_definition_stop_price = definition.has_value() ? definition.prices().stop_price : kNaN;
    out->legs_definition_trail_points = definition.has_value() ? definition.prices().trail_points : kNaN;
    out->legs_definition_trail_price = definition.has_value() ? definition.prices().trail_price : kNaN;
    out->legs_definition_trail_offset = definition.has_value() ? definition.prices().trail_offset : kNaN;
    out->legs_definition_profit_ticks = definition.has_value() ? definition.prices().profit_ticks : kNaN;
    out->legs_definition_loss_ticks = definition.has_value() ? definition.prices().loss_ticks : kNaN;
    const auto& retirements = snapshot.legs.retirements();
    const auto copy_retirement = [&](std::size_t number, std::uint64_t& generation,
                                     std::uint8_t& present, std::uint64_t& receipt_generation,
                                     std::uint64_t& event, std::int64_t& bar,
                                     std::uint32_t& domain, std::uint32_t& phase) {
        const auto leg = static_cast<exit_legs::Leg>(number);
        generation = snapshot.legs.generation(leg);
        const auto& receipt = retirements[number];
        present = receipt ? 1U : 0U;
        receipt_generation = receipt ? receipt->generation : 0;
        event = receipt ? receipt->cause.event : 0;
        bar = receipt ? receipt->cause.bar : 0;
        domain = receipt ? static_cast<std::uint32_t>(receipt->cause.domain) : 0U;
        phase = receipt ? static_cast<std::uint32_t>(receipt->cause.phase) : 0U;
    };
    copy_retirement(0, out->legs_generation0, out->legs_retirement0_present,
                    out->legs_retirement0_generation, out->legs_retirement0_cause_event,
                    out->legs_retirement0_cause_bar, out->legs_retirement0_cause_domain,
                    out->legs_retirement0_cause_phase);
    copy_retirement(1, out->legs_generation1, out->legs_retirement1_present,
                    out->legs_retirement1_generation, out->legs_retirement1_cause_event,
                    out->legs_retirement1_cause_bar, out->legs_retirement1_cause_domain,
                    out->legs_retirement1_cause_phase);
    copy_retirement(2, out->legs_generation2, out->legs_retirement2_present,
                    out->legs_retirement2_generation, out->legs_retirement2_cause_event,
                    out->legs_retirement2_cause_bar, out->legs_retirement2_cause_domain,
                    out->legs_retirement2_cause_phase);
    const auto& suspension = snapshot.legs.suspension();
    out->legs_suspension_present = suspension ? 1U : 0U;
    out->legs_suspension_cause_event = suspension ? suspension->cause.event : 0;
    out->legs_suspension_cause_bar = suspension ? suspension->cause.bar : 0;
    out->legs_suspension_cause_domain = suspension
        ? static_cast<std::uint32_t>(suspension->cause.domain) : 0U;
    out->legs_suspension_cause_phase = suspension
        ? static_cast<std::uint32_t>(suspension->cause.phase) : 0U;
    out->legs_suspension_legs_count = suspension
        ? static_cast<std::uint32_t>(suspension->legs.size()) : 0U;
    const auto suspended_leg = [&](std::size_t number) -> std::uint32_t {
        return suspension && suspension->legs.size() > number
            ? static_cast<std::uint32_t>(suspension->legs[number]) : UINT32_MAX;
    };
    out->legs_suspension_legs_item0 = suspended_leg(0);
    out->legs_suspension_legs_item1 = suspended_leg(1);
    out->legs_suspension_legs_item2 = suspended_leg(2);
    out->legs_suspension_hold_present = suspension && suspension->hold ? 1U : 0U;
    if (suspension && suspension->hold) {
        const auto& hold = *suspension->hold;
        out->legs_suspension_hold_requested_event = hold.requested.event;
        out->legs_suspension_hold_requested_bar = hold.requested.bar;
        out->legs_suspension_hold_requested_domain = static_cast<std::uint32_t>(hold.requested.domain);
        out->legs_suspension_hold_requested_phase = static_cast<std::uint32_t>(hold.requested.phase);
        out->legs_suspension_hold_target_incarnation = hold.target.incarnation;
        out->legs_suspension_hold_target_owner = hold.target.owner;
        out->legs_suspension_hold_revision = hold.revision;
    }
    out->legs_suspension_revival_definition_limit_price = kNaN;
    out->legs_suspension_revival_definition_stop_price = kNaN;
    out->legs_suspension_revival_definition_trail_points = kNaN;
    out->legs_suspension_revival_definition_trail_price = kNaN;
    out->legs_suspension_revival_definition_trail_offset = kNaN;
    out->legs_suspension_revival_definition_profit_ticks = kNaN;
    out->legs_suspension_revival_definition_loss_ticks = kNaN;
    const auto* revival = suspension && suspension->revival_definition
        ? &*suspension->revival_definition : nullptr;
    out->legs_suspension_revival_definition_present = revival ? 1U : 0U;
    if (revival) {
        out->legs_suspension_revival_definition_incarnation = revival->incarnation();
        out->legs_suspension_revival_definition_revision = revival->revision();
        out->legs_suspension_revival_definition_value_present = revival->has_value() ? 1U : 0U;
        if (revival->has_value()) {
            const auto& prices = revival->prices();
            out->legs_suspension_revival_definition_limit_price = prices.limit_price;
            out->legs_suspension_revival_definition_stop_price = prices.stop_price;
            out->legs_suspension_revival_definition_trail_points = prices.trail_points;
            out->legs_suspension_revival_definition_trail_price = prices.trail_price;
            out->legs_suspension_revival_definition_trail_offset = prices.trail_offset;
            out->legs_suspension_revival_definition_profit_ticks = prices.profit_ticks;
            out->legs_suspension_revival_definition_loss_ticks = prices.loss_ticks;
        }
    }
    out->legs_suspension_replacement_revival_definition_limit_price = kNaN;
    out->legs_suspension_replacement_revival_definition_stop_price = kNaN;
    out->legs_suspension_replacement_revival_definition_trail_points = kNaN;
    out->legs_suspension_replacement_revival_definition_trail_price = kNaN;
    out->legs_suspension_replacement_revival_definition_trail_offset = kNaN;
    out->legs_suspension_replacement_revival_definition_profit_ticks = kNaN;
    out->legs_suspension_replacement_revival_definition_loss_ticks = kNaN;
    const auto* replacement = suspension && suspension->replacement
        ? &*suspension->replacement : nullptr;
    out->legs_suspension_replacement_present = replacement ? 1U : 0U;
    if (replacement) {
        out->legs_suspension_replacement_queue_predecessor = replacement->queue_predecessor;
        const auto& definition = replacement->revival_definition;
        out->legs_suspension_replacement_revival_definition_incarnation = definition.incarnation();
        out->legs_suspension_replacement_revival_definition_revision = definition.revision();
        out->legs_suspension_replacement_revival_definition_value_present =
            definition.has_value() ? 1U : 0U;
        if (definition.has_value()) {
            const auto& prices = definition.prices();
            out->legs_suspension_replacement_revival_definition_limit_price = prices.limit_price;
            out->legs_suspension_replacement_revival_definition_stop_price = prices.stop_price;
            out->legs_suspension_replacement_revival_definition_trail_points = prices.trail_points;
            out->legs_suspension_replacement_revival_definition_trail_price = prices.trail_price;
            out->legs_suspension_replacement_revival_definition_trail_offset = prices.trail_offset;
            out->legs_suspension_replacement_revival_definition_profit_ticks = prices.profit_ticks;
            out->legs_suspension_replacement_revival_definition_loss_ticks = prices.loss_ticks;
        }
        const auto& release = replacement->release;
        out->legs_suspension_replacement_release_requested_event = release.requested.event;
        out->legs_suspension_replacement_release_requested_bar = release.requested.bar;
        out->legs_suspension_replacement_release_requested_domain =
            static_cast<std::uint32_t>(release.requested.domain);
        out->legs_suspension_replacement_release_requested_phase =
            static_cast<std::uint32_t>(release.requested.phase);
        out->legs_suspension_replacement_release_target_incarnation = release.target.incarnation;
        out->legs_suspension_replacement_release_target_owner = release.target.owner;
        out->legs_suspension_replacement_release_revision = release.revision;
    }
    out->legs_suspension_window_present = suspension && suspension->window ? 1U : 0U;
    out->legs_suspension_window_best = kNaN;
    out->legs_suspension_window_prefix = kNaN;
    if (suspension && suspension->window) {
        const auto& window = *suspension->window;
        out->legs_suspension_window_excluded_event = window.excluded.event;
        out->legs_suspension_window_excluded_bar = window.excluded.bar;
        out->legs_suspension_window_excluded_domain = static_cast<std::uint32_t>(window.excluded.domain);
        out->legs_suspension_window_excluded_phase = static_cast<std::uint32_t>(window.excluded.phase);
        out->legs_suspension_window_best = window.best;
        out->legs_suspension_window_prefix = window.prefix;
    }
    const auto& last = snapshot.legs.last_action();
    out->legs_last_present = last ? 1U : 0U;
    out->legs_last_suspend_legs_item0 = UINT32_MAX;
    out->legs_last_suspend_legs_item1 = UINT32_MAX;
    out->legs_last_suspend_legs_item2 = UINT32_MAX;
    out->legs_last_suspend_window_best = kNaN;
    out->legs_last_suspend_window_prefix = kNaN;
    out->legs_last_suspend_retire_item0 = UINT32_MAX;
    out->legs_last_suspend_retire_item1 = UINT32_MAX;
    out->legs_last_suspend_retire_item2 = UINT32_MAX;
    out->legs_last_stage_revival_definition_limit_price = kNaN;
    out->legs_last_stage_revival_definition_stop_price = kNaN;
    out->legs_last_stage_revival_definition_trail_points = kNaN;
    out->legs_last_stage_revival_definition_trail_price = kNaN;
    out->legs_last_stage_revival_definition_trail_offset = kNaN;
    out->legs_last_stage_revival_definition_profit_ticks = kNaN;
    out->legs_last_stage_revival_definition_loss_ticks = kNaN;
    out->legs_last_restore_legs_item0 = UINT32_MAX;
    out->legs_last_restore_legs_item1 = UINT32_MAX;
    out->legs_last_restore_legs_item2 = UINT32_MAX;
    out->legs_last_observe_high = kNaN;
    out->legs_last_observe_low = kNaN;
    out->legs_last_cancel_legs_item0 = UINT32_MAX;
    out->legs_last_cancel_legs_item1 = UINT32_MAX;
    out->legs_last_cancel_legs_item2 = UINT32_MAX;
    if (last) {
        out->legs_last_target_incarnation = last->target.incarnation;
        out->legs_last_target_owner = last->target.owner;
        out->legs_last_expected_revision = last->expected_revision;
        out->legs_last_cause_event = last->cause.event;
        out->legs_last_cause_bar = last->cause.bar;
        out->legs_last_cause_domain = static_cast<std::uint32_t>(last->cause.domain);
        out->legs_last_cause_phase = static_cast<std::uint32_t>(last->cause.phase);
        out->legs_last_operation = static_cast<std::uint32_t>(last->operation.index());
        if (const auto* bind = std::get_if<exit_legs::BindOwner>(&last->operation)) {
            out->legs_last_bind_owner = bind->owner;
        } else if (const auto* suspended = std::get_if<exit_legs::Suspend>(&last->operation)) {
            const auto copy_leg = [](const std::vector<exit_legs::Leg>& legs,
                                     std::size_t index) -> std::uint32_t {
                return index < legs.size() ? static_cast<std::uint32_t>(legs[index])
                                           : UINT32_MAX;
            };
            out->legs_last_suspend_legs_count =
                static_cast<std::uint32_t>(suspended->legs.size());
            out->legs_last_suspend_legs_item0 = copy_leg(suspended->legs, 0);
            out->legs_last_suspend_legs_item1 = copy_leg(suspended->legs, 1);
            out->legs_last_suspend_legs_item2 = copy_leg(suspended->legs, 2);
            out->legs_last_suspend_hold_present = suspended->hold ? 1U : 0U;
            if (suspended->hold) {
                const auto& hold = *suspended->hold;
                out->legs_last_suspend_hold_requested_event = hold.requested.event;
                out->legs_last_suspend_hold_requested_bar = hold.requested.bar;
                out->legs_last_suspend_hold_requested_domain =
                    static_cast<std::uint32_t>(hold.requested.domain);
                out->legs_last_suspend_hold_requested_phase =
                    static_cast<std::uint32_t>(hold.requested.phase);
                out->legs_last_suspend_hold_target_incarnation = hold.target.incarnation;
                out->legs_last_suspend_hold_target_owner = hold.target.owner;
                out->legs_last_suspend_hold_revision = hold.revision;
            }
            out->legs_last_suspend_window_present = suspended->window ? 1U : 0U;
            if (suspended->window) {
                const auto& window = *suspended->window;
                out->legs_last_suspend_window_excluded_event = window.excluded.event;
                out->legs_last_suspend_window_excluded_bar = window.excluded.bar;
                out->legs_last_suspend_window_excluded_domain =
                    static_cast<std::uint32_t>(window.excluded.domain);
                out->legs_last_suspend_window_excluded_phase =
                    static_cast<std::uint32_t>(window.excluded.phase);
                out->legs_last_suspend_window_best = window.best;
                out->legs_last_suspend_window_prefix = window.prefix;
            }
            out->legs_last_suspend_retire_count =
                static_cast<std::uint32_t>(suspended->retire.size());
            out->legs_last_suspend_retire_item0 = copy_leg(suspended->retire, 0);
            out->legs_last_suspend_retire_item1 = copy_leg(suspended->retire, 1);
            out->legs_last_suspend_retire_item2 = copy_leg(suspended->retire, 2);
        } else if (const auto* stage =
                       std::get_if<exit_legs::StageReplacement>(&last->operation)) {
            const auto& relation = stage->relation;
            out->legs_last_stage_queue_predecessor = relation.queue_predecessor;
            const auto& definition = relation.revival_definition;
            out->legs_last_stage_revival_definition_incarnation = definition.incarnation();
            out->legs_last_stage_revival_definition_revision = definition.revision();
            out->legs_last_stage_revival_definition_value_present =
                definition.has_value() ? 1U : 0U;
            if (definition.has_value()) {
                const auto& prices = definition.prices();
                out->legs_last_stage_revival_definition_limit_price = prices.limit_price;
                out->legs_last_stage_revival_definition_stop_price = prices.stop_price;
                out->legs_last_stage_revival_definition_trail_points = prices.trail_points;
                out->legs_last_stage_revival_definition_trail_price = prices.trail_price;
                out->legs_last_stage_revival_definition_trail_offset = prices.trail_offset;
                out->legs_last_stage_revival_definition_profit_ticks = prices.profit_ticks;
                out->legs_last_stage_revival_definition_loss_ticks = prices.loss_ticks;
            }
            const auto& release = relation.release;
            out->legs_last_stage_release_requested_event = release.requested.event;
            out->legs_last_stage_release_requested_bar = release.requested.bar;
            out->legs_last_stage_release_requested_domain =
                static_cast<std::uint32_t>(release.requested.domain);
            out->legs_last_stage_release_requested_phase =
                static_cast<std::uint32_t>(release.requested.phase);
            out->legs_last_stage_release_target_incarnation = release.target.incarnation;
            out->legs_last_stage_release_target_owner = release.target.owner;
            out->legs_last_stage_release_revision = release.revision;
        } else if (const auto* restore = std::get_if<exit_legs::Restore>(&last->operation)) {
            out->legs_last_restore_legs_count =
                static_cast<std::uint32_t>(restore->legs.size());
            const auto copy_leg = [&](std::size_t index) -> std::uint32_t {
                return index < restore->legs.size()
                    ? static_cast<std::uint32_t>(restore->legs[index]) : UINT32_MAX;
            };
            out->legs_last_restore_legs_item0 = copy_leg(0);
            out->legs_last_restore_legs_item1 = copy_leg(1);
            out->legs_last_restore_legs_item2 = copy_leg(2);
        } else if (const auto* complete =
                       std::get_if<exit_legs::CompleteBarrier>(&last->operation)) {
            out->legs_last_complete_completed_event = complete->completed.event;
            out->legs_last_complete_completed_bar = complete->completed.bar;
            out->legs_last_complete_completed_domain =
                static_cast<std::uint32_t>(complete->completed.domain);
            out->legs_last_complete_completed_phase =
                static_cast<std::uint32_t>(complete->completed.phase);
            out->legs_last_complete_requested_present = complete->requested ? 1U : 0U;
            if (complete->requested) {
                const auto& requested = *complete->requested;
                out->legs_last_complete_requested_requested_event = requested.requested.event;
                out->legs_last_complete_requested_requested_bar = requested.requested.bar;
                out->legs_last_complete_requested_requested_domain =
                    static_cast<std::uint32_t>(requested.requested.domain);
                out->legs_last_complete_requested_requested_phase =
                    static_cast<std::uint32_t>(requested.requested.phase);
                out->legs_last_complete_requested_target_incarnation =
                    requested.target.incarnation;
                out->legs_last_complete_requested_target_owner = requested.target.owner;
                out->legs_last_complete_requested_revision = requested.revision;
            }
        } else if (const auto* observe = std::get_if<exit_legs::Observe>(&last->operation)) {
            out->legs_last_observe_high = observe->high;
            out->legs_last_observe_low = observe->low;
            out->legs_last_observe_direction = observe->direction;
            out->legs_last_observe_fold = static_cast<std::uint32_t>(observe->fold);
        } else if (const auto* cancel = std::get_if<exit_legs::Cancel>(&last->operation)) {
            out->legs_last_cancel_legs_count =
                static_cast<std::uint32_t>(cancel->legs.size());
            const auto copy_leg = [&](std::size_t index) -> std::uint32_t {
                return index < cancel->legs.size()
                    ? static_cast<std::uint32_t>(cancel->legs[index]) : UINT32_MAX;
            };
            out->legs_last_cancel_legs_item0 = copy_leg(0);
            out->legs_last_cancel_legs_item1 = copy_leg(1);
            out->legs_last_cancel_legs_item2 = copy_leg(2);
        }
    }
    const auto& admission = snapshot.market_admission;
    const auto& observation = admission.observation();
    if (observation) out->market_admission_observation_present = 1U;
    if (observation) {
        out->market_admission_observation_command = observation->command;
        out->market_admission_observation_kind = static_cast<std::int64_t>(observation->kind);
        out->market_admission_observation_birth_cause =
            static_cast<std::int64_t>(observation->birth.cause());
        out->market_admission_observation_birth_bar = observation->birth.bar();
        out->market_admission_observation_birth_timestamp = observation->birth.timestamp();
        out->market_admission_observation_birth_cursor_domain =
            static_cast<std::int64_t>(observation->birth.cursor().domain());
        out->market_admission_observation_birth_cursor_position =
            static_cast<std::int64_t>(observation->birth.cursor().position());
        out->market_admission_observation_birth_cursor_index = observation->birth.cursor().index();
        out->market_admission_observation_birth_cursor_count = observation->birth.cursor().count();
        out->market_admission_observation_birth_cursor_price = observation->birth.cursor_price();
        out->market_admission_observation_birth_first_fill = observation->birth.first_fill();
        out->market_admission_observation_birth_last_fill = observation->birth.last_fill();
        out->market_admission_observation_birth_evaluation_ordinal =
            observation->birth.evaluation_ordinal();
        copy_pending_string(observation->id, out->market_admission_observation_id,
            &out->market_admission_observation_id_truncated,
            &out->market_admission_observation_id_hash64);
        out->market_admission_observation_requested_quantity = observation->requested_quantity;
        out->market_admission_observation_quantity_type = observation->quantity_type;
        out->market_admission_observation_buy = observation->buy ? 1U : 0U;
        out->market_admission_observation_prices_limit = observation->prices.limit;
        out->market_admission_observation_prices_stop = observation->prices.stop;
        copy_pending_string(observation->oca_name, out->market_admission_observation_oca_name,
            &out->market_admission_observation_oca_name_truncated,
            &out->market_admission_observation_oca_name_hash64);
        out->market_admission_observation_oca_type = observation->oca_type;
        const auto& configuration = observation->configuration;
        out->market_admission_observation_configuration_process_on_close =
            configuration.process_on_close ? 1U : 0U;
        out->market_admission_observation_configuration_calc_on_fills =
            configuration.calc_on_fills ? 1U : 0U;
        out->market_admission_observation_configuration_magnifier =
            configuration.magnifier ? 1U : 0U;
        out->market_admission_observation_configuration_fill_recalculation =
            configuration.fill_recalculation ? 1U : 0U;
        out->market_admission_observation_configuration_scheduler =
            configuration.scheduler ? 1U : 0U;
        out->market_admission_observation_configuration_slippage = configuration.slippage;
        out->market_admission_observation_configuration_pyramiding = configuration.pyramiding;
        out->market_admission_observation_configuration_default_quantity_type =
            configuration.default_quantity_type;
        out->market_admission_observation_configuration_default_quantity_value =
            configuration.default_quantity_value;
        out->market_admission_observation_configuration_long_margin = configuration.long_margin;
        out->market_admission_observation_configuration_short_margin = configuration.short_margin;
        out->market_admission_observation_configuration_commission_value =
            configuration.commission_value;
        out->market_admission_observation_configuration_commission_type =
            configuration.commission_type;
        out->market_admission_observation_configuration_pointvalue = configuration.pointvalue;
        out->market_admission_observation_configuration_fx = configuration.fx;
        out->market_admission_observation_configuration_quantity_step =
            configuration.quantity_step;
        out->market_admission_observation_configuration_mintick = configuration.mintick;
        out->market_admission_observation_configuration_risk_direction =
            configuration.risk_direction;
        out->market_admission_observation_configuration_loss_days_limit =
            configuration.loss_days_limit;
        out->market_admission_observation_configuration_drawdown_limit =
            configuration.drawdown_limit;
        out->market_admission_observation_configuration_intraday_loss_limit =
            configuration.intraday_loss_limit;
        out->market_admission_observation_configuration_position_limit =
            configuration.position_limit;
        out->market_admission_observation_configuration_fill_cap_active =
            configuration.fill_cap_active ? 1U : 0U;
        out->market_admission_observation_configuration_risk_halted =
            configuration.risk_halted ? 1U : 0U;
        out->market_admission_observation_bar = observation->bar;
        out->market_admission_observation_placement_side = observation->placement_side;
        out->market_admission_observation_placement_cycle = observation->placement_cycle;
        out->market_admission_observation_prior_close_quantity =
            observation->prior_close_quantity;
        out->market_admission_observation_held_quantity = observation->held_quantity;
        out->market_admission_observation_held_entries = observation->held_entries;
        out->market_admission_observation_realized_equity = observation->realized_equity;
        out->market_admission_observation_placement_equity = observation->placement_equity;
        out->market_admission_observation_signal_close = observation->signal_close;
        out->market_admission_observation_quantized_fixed_quantity =
            observation->quantized_fixed_quantity;
        out->market_admission_observation_original_sizing_present =
            observation->original_sizing ? 1U : 0U;
        if (observation->original_sizing) {
            out->market_admission_observation_original_sizing_quantity =
                observation->original_sizing->quantity;
            out->market_admission_observation_original_sizing_equity =
                observation->original_sizing->equity;
            out->market_admission_observation_original_sizing_price =
                observation->original_sizing->price;
            out->market_admission_observation_original_sizing_mark =
                observation->original_sizing->mark;
            out->market_admission_observation_original_sizing_fx =
                observation->original_sizing->fx;
        }
        out->market_admission_observation_explicit_equity = observation->explicit_equity;
        out->market_admission_observation_explicit_price = observation->explicit_price;
    }
    out->market_admission_review_present = admission.review() ? 1U : 0U;
    if (admission.review()) {
        out->market_admission_review_sequence = admission.review()->sequence;
        out->market_admission_review_checkpoint =
            static_cast<std::int64_t>(admission.review()->checkpoint);
        out->market_admission_review_bar = admission.review()->bar;
        out->market_admission_review_target_command = admission.review()->target_command;
    }
    out->market_admission_sizing_revision_present = admission.sizing_revision() ? 1U : 0U;
    if (admission.sizing_revision()) {
        out->market_admission_sizing_revision_sequence = admission.sizing_revision()->sequence;
        out->market_admission_sizing_revision_cause_fill =
            admission.sizing_revision()->cause_fill;
        out->market_admission_sizing_revision_bar = admission.sizing_revision()->bar;
        out->market_admission_sizing_revision_target_command =
            admission.sizing_revision()->target_command;
    }
    out->cancellation_cause = static_cast<std::int32_t>(snapshot.cancellation.cause);
    out->cancellation_state = snapshot.cancellation.state;
    out->cancellation_close_claim_release = snapshot.cancellation.close_claim_release;
    out->cancellation_source_incarnation = snapshot.cancellation.source_incarnation;
    out->cancellation_source_sequence = snapshot.cancellation.source_sequence;
    out->cancellation_target_incarnation = snapshot.cancellation.target_incarnation;
    out->cancellation_target_owner = snapshot.cancellation.target_owner;
    out->cancellation_target_revision = snapshot.cancellation.target_revision;
    out->cancellation_close_claim_consumed = snapshot.cancellation.close_claim_consumed;
    out->cancellation_close_claim_retired = snapshot.cancellation.close_claim_retired;
    return 0;
}
 
int PendingIntentView::short_seed_collision_role(int index) const noexcept {
    if (!owner_) return -1;
    const PlacementSnapshot* snapshot = nullptr;
    native_order::RequestHandle handle;
    if (!owner_->projected_pending_at(index, snapshot, handle) || !snapshot) return -1;
    if (!owner_->short_seed_.active) return 0;
    return owner_->short_seed_collision_role_v1(handle);
}
int PendingIntentView::last_bar_dual_entry_path() const noexcept { return owner_ ? owner_->last_bar_dual_entry_path_ : 0; }
double PendingIntentView::trail_best_price() const noexcept {
    return owner_ && owner_->host_ ? owner_->host_->trail_best_price() : kNaN;
}
 
// The entry/reversal fill ordering, family F10: the own units of the opposite MARKET
// entries this source bar placed that are still pending (batched or live), or
// NaN when one of them carries no explicit quantity. TradingView adds them to
// the later call's transaction. A call of the caller's own id is the one the
// caller replaces, not a pending one, and a typed, OCA-named or
// fill-recalculation market is a book the tapes do not measure (NaN, lane
// W6B-ENG-PAIRS).
double PineExecutionAdapter::pending_opposite_market_units(
        bool is_long, std::int64_t script_open_ms, const SourceId& id) const {
    double units = 0.0;
    bool unsized = false;
    const auto add = [&](const PlacementSnapshot& row, double own) {
        if (!row.opening || row.family != PineOrderFamily::Entry || row.is_long == is_long
            || row.placement_script_open_ms != script_open_ms || row.source_id == id
            || finite_positive(row.exit_levels.limit)
            || finite_positive(row.exit_levels.stop)
            || finite_positive(row.exit_levels.trail_points)
            || finite_positive(row.exit_levels.trail_price)
            || finite_positive(row.exit_levels.trail_offset)) {
            return;
        }
        const bool measured = row.oca_name.empty() && !row.birth.from_fill()
            && (row.qty_type < 0 || row.qty_type == static_cast<int>(QtyType::FIXED));
        if (measured && finite_positive(own)) units += own;
        else unsized = true;
    };
    for (const auto& prior : pending_same_bar_commands_) {
        add(prior.snapshot, finite_positive(prior.snapshot.frozen_market_own_units)
            ? prior.snapshot.frozen_market_own_units : prior.snapshot.requested_qty);
    }
    for (const auto& prior : pending_entries_) add(prior.snapshot, kNaN);
    for (const auto& handle : live_handles_) {
        const auto prior = placement_.find(handle.incarnation);
        if (prior != placement_.end()) add(prior->second, prior->second.requested_qty);
    }
    return unsized ? kNaN : units;
}
 
// The flat-entry pair handling: whether the opening fill of a flat entry is the
// first of a same-point pair whose opposite member, placed on the same bar,
// fills at this same price next. TradingView checks the margin of such a pair
// once both have filled: a commissioned pair whose one transaction the
// commission leaves just short of the equity is booked with no margin call
// (lab tv w6b-p1c-pair-gross-percent MM-SF-U and MS-SF-U).
bool PineExecutionAdapter::same_point_pair_fill_follows(
        const PlacementSnapshot& filled, const native_order::RequestHandle& filled_handle,
        double price) const {
    if (!filled.opening || filled.family != PineOrderFamily::Entry
        || filled.projection_position_side != static_cast<std::int32_t>(PositionSide::FLAT)
        || !finite_positive(filled.requested_qty) || !finite_positive(price)
        || !same_point_pair_scope()) {
        return false;
    }
    return std::any_of(live_handles_.begin(), live_handles_.end(),
        [&](const native_order::RequestHandle& handle) {
            if (handle == filled_handle) return false;
            const auto found = placement_.find(handle.incarnation);
            if (found == placement_.end()) return false;
            const auto& row = found->second;
            if (!row.opening || row.family != PineOrderFamily::Entry
                || row.is_long == filled.is_long
                || row.projection_created_bar != filled.projection_created_bar
                || row.projection_position_side
                    != static_cast<std::int32_t>(PositionSide::FLAT)
                || !finite_positive(row.requested_qty) || !row.oca_name.empty()
                || row.birth.from_fill()
                || !(row.qty_type < 0 || row.qty_type == static_cast<int>(QtyType::FIXED))) {
                return false;
            }
            const bool stop = finite_positive(row.exit_levels.stop);
            const bool limit = finite_positive(row.exit_levels.limit);
            if (stop && limit) return false;
            if (stop) return row.is_long ? row.exit_levels.stop <= price
                                         : row.exit_levels.stop >= price;
            if (limit) return row.is_long ? row.exit_levels.limit >= price
                                          : row.exit_levels.limit <= price;
            return true;
        });
}
 
// The flat-entry pair handling, item 3. Under process_orders_on_close a flat pair
// of one market call and one priced opposite call, both of this bar and the
// priced one already marketable at the close, fills at that close in the
// order and with the quantities of W6's rules: the rank of each leg (buy
// market, buy stop, sell market, sell stop, buy limit, sell limit), the later
// call as one transaction of its own quantity plus the earlier call's when
// that one is the market, the earlier call its own (lab tv w6-f10d-pooc-pair
// and w6-f10e-pooc-coof-pair MS-SF, SM-SF, LM-SF, LM-LF, ML-SF). The close
// pass had filled the priced leg first, before the market leg of
// apply_terminal_explicit_market_policy, each with its own quantity. A
// market pair keeps that policy's own route. True when the pair filled here.
bool PineExecutionAdapter::fill_pooc_close_pair(
        double raw_close, const NativeDecisionContext& context) {
    const double tick = staged_.syminfo.mintick;
    const double close_tick = source_bar_fill_tick(raw_close, tick);
    if (config_.pyramiding != 0 || config_.slippage != 0 || config_.close_entries_rule_any
        || config_.commission_value != 0.0 || config_.margin_long != 100.0
        || config_.margin_short != 100.0 || bar_magnifier_
        || config_.default_qty_type != static_cast<int>(QtyType::FIXED)
        || risk_.direction != 0 || risk_.max_cons_loss_days != 0
        || risk_.max_drawdown > 0.0 || risk_.max_intraday_loss > 0.0
        || risk_.max_position_size > 0.0 || risk_.halted || cap.active()
        || !finite_positive(close_tick)
        || detail::run_position(require_host()).signed_units != 0.0) {
        return false;
    }
    struct Leg {
        native_order::RequestHandle handle;
        PlacementSnapshot row;
        bool priced = false;
        int rank = 0;
    };
    std::vector<Leg> legs;
    const int bar_index = projection_bar_index(context);
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& row = found->second;
        if (!row.opening || (row.family != PineOrderFamily::Entry
                             && row.family != PineOrderFamily::Order)) {
            continue;
        }
        if (row.projection_created_bar != bar_index) return false;  // a resting entry
        const bool stop = finite_positive(row.exit_levels.stop);
        const bool limit = finite_positive(row.exit_levels.limit);
        if (row.family != PineOrderFamily::Entry
            || row.projection_position_side != static_cast<std::int32_t>(PositionSide::FLAT)
            || !finite_positive(row.requested_qty)
            || !(row.qty_type < 0 || row.qty_type == static_cast<int>(QtyType::FIXED))
            || !row.oca_name.empty() || row.birth.from_fill() || row.birth.at_terminal_fill()
            || (stop && limit) || row.direction_gate
            || finite_positive(row.exit_levels.trail_points)
            || finite_positive(row.exit_levels.trail_price)
            || finite_positive(row.exit_levels.trail_offset)) {
            return false;
        }
        if (stop && (row.is_long ? close_tick < row.exit_levels.stop
                                 : close_tick > row.exit_levels.stop)) {
            return false;
        }
        if (limit && (row.is_long ? close_tick > row.exit_levels.limit
                                  : close_tick < row.exit_levels.limit)) {
            return false;
        }
        legs.push_back({handle, row, stop || limit,
                        limit ? (row.is_long ? 4 : 5)
                              : (stop ? (row.is_long ? 1 : 3) : (row.is_long ? 0 : 2))});
    }
    if (legs.size() != 2 || legs[0].row.is_long == legs[1].row.is_long
        || legs[0].priced == legs[1].priced) {
        return false;
    }
    if (legs[1].row.command_sequence < legs[0].row.command_sequence) std::swap(legs[0], legs[1]);
    // legs[0] is the earlier call; the later one adds its quantity when it
    // is the market.
    const double pending = legs[0].priced ? 0.0 : legs[0].row.requested_qty;
    std::vector<std::pair<Leg*, double>> order = {
        {&legs[0], legs[0].row.requested_qty},
        {&legs[1], legs[1].row.requested_qty + pending},
    };
    if (legs[1].rank < legs[0].rank) std::swap(order[0], order[1]);
    // TradingView's admission of that transaction is unmeasured here: one
    // over the equity at the close keeps the legacy route.
    const double equity = require_host().native_marked_equity(close_tick);
    const double required = (legs[1].row.requested_qty + pending) * close_tick
        * staged_.syminfo.pointvalue * active_staged_fx(context.sub_bar_open_ms);
    if (!std::isfinite(required) || !std::isfinite(equity) || required > equity) return false;
    bool filled = false;
    for (const auto& [leg, units] : order) {
        native_order::Request request;
        request.intent = native_order::Transact{leg->row.is_long ? units : -units};
        request.label = leg->row.source_id;
        request.comment = leg->row.comment;
        request.trigger = native_order::Market{};
        PlacementSnapshot immediate = leg->row;
        immediate.cancellation = {};
        immediate.market_admission = {};
        immediate.reverse_to = false;
        immediate.terms_priced_reverse = false;
        immediate.forced_execution_price = close_tick;
        const auto accepted = submit_or_replace(
            std::move(request), std::move(immediate), true, leg->row.source_id);
        if (!accepted) return filled;
        auto& placed = placement_.at(accepted->incarnation);
        placed.projection_position_side = leg->row.projection_position_side; invalidate_retirement();
        (void)require_host().execute_current(
            {*accepted, NativeCurrentPriceRule::NearestTick});
        filled = true;
    }
    return filled;
}
 
// The flat-entry pair handling, item 2: under pyramiding above 1 the queued
// market's quantity joins the later call's transaction on the book the tapes
// measure only (w6b-p2a, w6b-p2b): the call and one other entry-like order,
// both of this script bar, nothing resting from an earlier one. A larger book
// keeps its legacy route (test_dual_entry_placement_sizing_l4b MM cases).
bool PineExecutionAdapter::same_point_two_leg_book(
        const SourceId& id, std::int64_t script_open_ms) const {
    std::size_t others = 0;
    bool foreign = false;
    const auto count = [&](const PlacementSnapshot& row) {
        if (!row.opening || (row.family != PineOrderFamily::Entry
                             && row.family != PineOrderFamily::Order)
            || row.source_id == id) {
            return;
        }
        if (row.placement_script_open_ms == script_open_ms) ++others;
        else foreign = true;
    };
    for (const auto& prior : pending_same_bar_commands_) count(prior.snapshot);
    for (const auto& prior : pending_entries_) count(prior.snapshot);
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found != placement_.end()) count(found->second);
    }
    return !foreign && others == 1;
}
 
// The entry/reversal fill ordering, family F10. TradingView fills the entries that
// reach one fill point in a fixed order of side and kind -- buy market, buy
// stop, sell market, sell stop, buy limit, sell limit -- and entries of one
// rank in the order they were placed (lab tv w6-f10a-open-pair,
// w6-f10b-limit-class and w6-f10c-same-side-class, tests/fixtures/
// same_point_entries). The kernel breaks a tie at one cursor oldest request
// first, so after a source evaluation this queues the flat entries it placed
// in that order: every request from the first one out of order on is
// re-priced in place (ReplaceOptions::keep_handle), which keeps its handle
// and ranks it newest. Only entries already marketable at the evaluation's
// price can share the next fill point, and a pure-stop book is
// defer_open_marketable_sells' at that open. The scope is the flat
// explicit-quantity family same_bar_market_tx_scope() settles as one broker
// batch of frozen transactions, which is what the tapes measure, widened by
// same_point_pair_scope() to the configurations lane W6B-ENG-PAIRS measured.
void PineExecutionAdapter::order_same_point_entries() {
    if (!has_live_family(PineOrderFamily::Entry) || !host_ || live_handles_.size() < 2 || !same_point_pair_scope()) return;
    auto& host = require_host();
    if (detail::run_position(host).signed_units != 0.0) return;
    const auto point = detail::callback_point(host);
    if (!point || !finite_positive(point->price)) return;
    const int bar = projection_bar_index(point->decision);
    const double signal = point->price;
    struct Candidate {
        native_order::RequestHandle handle;
        int rank = 0;
        std::uint64_t queue = 0;
    };
    std::vector<Candidate> candidates;
    bool pure_stops = true;
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        if (found == placement_.end()) continue;
        const auto& row = found->second;
        const bool stop = finite_positive(row.exit_levels.stop);
        const bool limit = finite_positive(row.exit_levels.limit);
        if (row.family != PineOrderFamily::Entry || !row.opening
            || row.projection_created_bar != bar
            || row.projection_position_side != static_cast<std::int32_t>(PositionSide::FLAT)
            || !finite_positive(row.requested_qty)
            || !(row.qty_type < 0 || row.qty_type == static_cast<int>(QtyType::FIXED))
            || !row.oca_name.empty() || row.birth.from_fill() || (stop && limit)
            || finite_positive(row.exit_levels.trail_points)
            || finite_positive(row.exit_levels.trail_price)
            || finite_positive(row.exit_levels.trail_offset)
            || (stop && (row.is_long ? row.exit_levels.stop > signal
                                     : row.exit_levels.stop < signal))
            || (limit && (row.is_long ? row.exit_levels.limit < signal
                                      : row.exit_levels.limit > signal))) {
            continue;
        }
        pure_stops = pure_stops && stop;
        candidates.push_back({handle, limit ? (row.is_long ? 4 : 5)
                                            : (stop ? (row.is_long ? 1 : 3)
                                                    : (row.is_long ? 0 : 2)), 0});
    }
    if (candidates.size() < 2 || pure_stops) return;
    // Under pyramiding above 1 the rank covers the books lane W6B-ENG-PAIRS
    // measured -- a two-leg pair, or legs of one side -- and nothing else:
    // a third entry-like order of either side, one resting from an earlier
    // bar, or a replaced or cancelled call keeps the legacy source order its
    // pinned cases assert (test_dual_entry_placement_sizing_l4b MM cases).
    if (config_.pyramiding > 1) {
        if (source_batch_mutated_) return;
        for (const auto& candidate : candidates) {
            const auto found = placement_.find(candidate.handle.incarnation);
            if (found != placement_.end() && found->second.replaced_opening) return;
        }
        const auto buys = [](const Candidate& c) { return c.rank == 0 || c.rank == 1 || c.rank == 4; };
        const auto buy_count = std::count_if(candidates.begin(), candidates.end(), buys);
        const bool both_sides = buy_count != 0
            && buy_count != static_cast<std::ptrdiff_t>(candidates.size());
        if (both_sides && candidates.size() > 2) return;
        for (const auto& handle : live_handles_) {
            const auto found = placement_.find(handle.incarnation);
            if (found == placement_.end() || !found->second.opening
                || (found->second.family != PineOrderFamily::Entry
                    && found->second.family != PineOrderFamily::Order)) {
                continue;
            }
            const bool candidate = std::any_of(candidates.begin(), candidates.end(),
                [&](const Candidate& c) { return c.handle == handle; });
            if (!candidate) return;
        }
    }
    const auto working = host.native_working_requests();
    const auto definition = [&](const native_order::RequestHandle& handle) {
        const auto row = std::find_if(working.begin(), working.end(),
            [&](const NativeWorkingRequest& request) {
                return request.definition->handle == handle;
            });
        return row == working.end() ? nullptr : row->definition.get();
    };
    for (auto& candidate : candidates) {
        const auto* live = definition(candidate.handle);
        if (!live) return;
        candidate.queue = live->priority != 0 ? live->priority : live->handle.incarnation;
    }
    std::stable_sort(candidates.begin(), candidates.end(),
                     [](const Candidate& left, const Candidate& right) {
                         if (left.rank != right.rank) return left.rank < right.rank;
                         return left.queue < right.queue;
                     });
    std::size_t first = candidates.size();
    std::uint64_t highest = 0;
    for (std::size_t index = 0; index < candidates.size(); ++index) {
        if (candidates[index].queue < highest) {
            first = index;
            break;
        }
        highest = candidates[index].queue;
    }
    native_order::ReplaceOptions in_place;
    in_place.keep_handle = true;
    for (std::size_t index = first; index < candidates.size(); ++index) {
        const auto& handle = candidates[index].handle;
        const auto* live = definition(handle);
        if (!live) return;
        const native_order::Request request = live->request;
        const auto result = host.replace(handle, request, in_place);
        if (result.status != native_order::ReplaceStatus::Replaced) return;
        // This changes order only, through the same live bookkeeping.
        // Preserve the existing survivor order and append the moved handle.
        requeue_live(handle);
    }
}
 
// L18 dependency adapter. L8c supplies the approved global prefix end and
// L6b-4 supplies the bound scratch directory. No sink text/curve API is
// involved: DESIGN 3.8 permits a second private unlinked scratch file.
void PineExecutionAdapter::preserve_position_tail_before_seal(
        std::size_t global_end, const std::string& scratch_directory) {
    auto* pine = pine_view_of(host_);
    if (!pine || global_end < pine->trades_.base() || global_end > pine->trades_.size()) {
        throw coded<std::logic_error>(RunFailureCode::engine_invariant, {},
                                      "invalid Pine position-tail seal prefix");
    }
    observe_position_tail_rows(); // never miss a row retired by the row source
    detail::PositionTailBinding::preserve(position_tail_spill_, pine->trades_, global_end,
        position_open_script_bar_, scratch_directory,
        pine->cache_policy_for_run().position_tail_pages);
}
 
PineExecutionAdapter::PositionTailWork
PineExecutionAdapter::position_tail_work() const noexcept {
    return position_tail_summary_ ? position_tail_summary_->work : PositionTailWork{};
}
 
void PineExecutionAdapter::observe_position_tail_rows() {
    if (!position_tail_summary_) return;
    auto* pine = pine_view_of(host_);
    // Short-seed presentation swaps incarnations after Applied returns.
    // Non-Pine hosts can amend rows without the Pine permutation seam.
    if (!pine || short_seed_.final_short.incarnation != 0) {
        position_tail_summary_->invalidate(
            !pine ? PositionTailGuard::NonPineHost : PositionTailGuard::ShortSeed,
            PINEFORGE_POSITION_TAIL_DIAGNOSTICS{});
        return;
    }
    const auto& host = require_host();
    position_tail_summary_->observe(pine->trades_.base(), host.closed_trade_count(),
        [&](std::size_t index) -> Trade { return host.get_trade(static_cast<int>(index)); },
        PINEFORGE_POSITION_TAIL_DIAGNOSTICS{});
}
 
void PineExecutionAdapter::begin_position_tail_summary() {
    if (!position_tail_summary_)
        position_tail_summary_ = std::make_shared<detail::AdapterPositionTailSummary>();
    auto* pine = pine_view_of(host_);
    if (!pine || short_seed_.final_short.incarnation != 0) {
        position_tail_summary_->invalidate(
            !pine ? PositionTailGuard::NonPineHost : PositionTailGuard::ShortSeed,
            PINEFORGE_POSITION_TAIL_DIAGNOSTICS{});
        return;
    }
    // L18 has just reset the old spill. Replay the resident reachable suffix
    // once, retaining equality at the opening mark, including old margin ids.
    const auto& host = require_host();
    position_tail_summary_->begin_position(position_open_script_bar_, pine->trades_.base(),
        host.closed_trade_count(),
        [&](std::size_t index) -> Trade { return host.get_trade(static_cast<int>(index)); },
        PINEFORGE_POSITION_TAIL_DIAGNOSTICS{});
    const bool is_long = detail::run_position(require_host()).signed_units > 0.0;
    for (const auto& cohort : cohorts_by_id_.held_rows()) {
        if (cohort.second.live_units_by_origin.empty()) continue;
        position_tail_summary_->live_cohort(&cohort, true);
        for (const auto& origin : cohort.second.live_units_by_origin)
            position_tail_summary_->open_origin(origin.first, is_long,
                                                PINEFORGE_POSITION_TAIL_DIAGNOSTICS{});
    }
}
 
double PineStrategyHost::default_entry_qty(double fill_price) const {
    // TradingView does not validate this query's hypothetical price before
    // applying the declared sizing mode: fixed sizing ignores it, while
    // money sizing returns zero for NaN/zero and a signed grid quantity for
    // a negative price. Observation only: no order or driver state changes.
    if (adapter_.config_.default_qty_type == static_cast<int>(QtyType::FIXED)) {
        return floor_quantity_grid(adapter_.config_.default_qty_value,
                                   adapter_.staged_.quantity_grid);
    }
    auto sizing = adapter_.sizing_snapshot();
    sizing.price = fill_price;
    if (!std::isfinite(fill_price) || fill_price == 0.0) return 0.0;
    if (fill_price > 0.0) return adapter_.default_sizing_units(sizing);
    sizing.price = -fill_price;
    const auto sized = adapter_.default_sizing_shape(sizing);
    if (!sized) return 0.0;
    const auto units = native_sized_units(
        *sized, -fill_price, sizing.equity, sizing.fx);
    // The core computes the positive-magnitude quotient once; apply the source
    // lot floor before restoring the negative hypothetical price's sign.
    return units ? -adapter_.default_sizing_lot_floor(*units) : 0.0;
}
 
} // namespace pineforge::source
 
#include "exit_payload_codec.inc"
 
namespace pineforge::source {
 
// These definitions are appended so existing source citations
// keep their line numbers. Only the retained window is addressable; the
// original count and append digest remain the source hash's logical words.
const native_order::RequestHandle& OriginRoster::operator[](std::size_t global) const {
    if (global < base_ || global >= size()) {
        throw coded<std::logic_error>(RunFailureCode::engine_invariant, {},
                                      "origin roster read outside retained window");
    }
    return items_[global - base_];
}
 
void OriginRoster::append_positions_of(const native_order::RequestHandle& handle,
                                       std::vector<std::size_t>& out) const {
    const auto found = positions_.find(handle.incarnation);
    if (found == positions_.end()) return;
    for (const auto position : found->second)
        if ((*this)[position] == handle) out.push_back(position);
}
 
void OriginRoster::retire_before(std::size_t global) {
    if (global < base_ || global > size()) {
        throw coded<std::logic_error>(RunFailureCode::engine_invariant, {},
                                      "origin roster retirement outside retained window");
    }
    if (global == base_) return;
    // Commit the non-allocating edits first. A compaction allocation failure
    // may abort the run, but cannot leave the index using the previous base.
    for (auto at = positions_.begin(); at != positions_.end();) {
        auto& positions = at->second;
        const auto kept = std::lower_bound(positions.begin(), positions.end(), global);
        positions.erase(positions.begin(), kept);
        if (positions.empty()) at = positions_.erase(at);
        else ++at;
    }
    items_.erase(items_.begin(), items_.begin() + static_cast<std::ptrdiff_t>(global - base_));
    base_ = global;
    if (items_.empty()) {
        decltype(items_){}.swap(items_);
        decltype(positions_){}.swap(positions_);
        return;
    }
    // An old peak must not leave a historical vector, inner vector or bucket
    // allocation resident. Slack is bounded by the current retained window.
    if (items_.capacity() / 4 > items_.size())
        decltype(items_)(items_).swap(items_);
    for (auto& row : positions_) {
        auto& positions = row.second;
        if (positions.capacity() / 4 > positions.size())
            std::vector<std::size_t>(positions).swap(positions);
    }
    if (positions_.bucket_count() / 4 > positions_.size())
        positions_.rehash(positions_.size());
}
 
// Called at an outermost bar open, after terminal receipts, placement-row
// erasure and cohort_remove. Keeping an origin's own retained row is more
// conservative than keeping only live placements, and preserves every old
// row reader. Explicit names in live/queued placements also pin an origin
// whose own row has gone. No persistent release bitmap or lookup is added.
void PineExecutionAdapter::retire_origin_prefixes() {
    RetirementObservation observation(*this);
    auto& work = retirement_work_;
    ++work.prefix_sweeps;
    cohorts_by_id_.spill_implicitly();
    if (detail::retain_retired_rows()) return;
    // Skip prefix retirement while every nonempty front still has a placement;
    // later name and ownership checks cannot release such a front. Erasure
    // invalidates this fact; new/restored cohorts are empty and origins append
    // after remember. Without that guarantee, run the full retirement walk.
    if (retired_row_scratch_.origin_fronts_pinned) return;
    // The front row alone can pin each retained window. Check before building
    // named, so a resting bracket/stop pair allocates no retirement scratch.
    if (std::all_of(cohorts_by_id_.begin(), cohorts_by_id_.end(), [this](const auto& row) {
            auto& counters = retirement_work_;
            ++counters.cohort_rows;
            ++counters.certificate_rows;
            const auto& members = row.second.origins.members();
            if (members.empty()) return true;
            ++counters.fronts_tested;
            const bool present = placement_.contains(members.front().incarnation);
            if (!present) ++counters.missing_fronts;
            return present;
        })) { retired_row_scratch_.origin_fronts_pinned = true; return; }
    IExecutionConsumer* consumer = bound_consumer();
    if (!consumer) return;
    const auto& core = as_native_consumer(*consumer).request_core();
    std::vector<std::uint64_t> named;
    const auto name = [&](std::uint64_t incarnation) {
        if (incarnation != 0) named.push_back(incarnation);
    };
    const auto snapshot_names = [&](const PlacementSnapshot& row) {
        name(row.bracket_origin.incarnation);
        name(row.paired_reversal_parent.incarnation);
        name(row.preserved_by_close_all.incarnation);
        name(row.projection_predecessor);
        name(row.legs.target().incarnation);
        name(row.reservation_growth_owner_incarnation);
    };
    const auto request_names = [&](const native_order::Request& request) {
        if (const auto* wait = std::get_if<native_order::WaitForApplied>(&request.owner)) {
            name(wait->parent.incarnation);
        } else if (const auto* opening = std::get_if<native_order::BindOpening>(&request.owner)) {
            name(opening->opening.incarnation);
        } else if (const auto* openings = std::get_if<native_order::BindOpenings>(&request.owner)) {
            for (const auto& opening : openings->openings) name(opening.incarnation);
        }
    };
    const auto live_names = [&](const native_order::RequestHandle& handle) {
        name(handle.incarnation);
        const auto at = placement_.find(handle.incarnation);
        if (at != placement_.end()) snapshot_names(at->second);
    };
    for (const auto& handle : live_handles_) live_names(handle);
    for (const auto& live : core.live()) {
        live_names(live.handle());
        request_names(live.definition->request);
        if (live.definition->root) name(live.definition->root->incarnation);
    }
    for (const auto& leg : pending_bracket_legs_) {
        snapshot_names(leg.snapshot); request_names(leg.request);
    }
    for (const auto& entry : pending_entries_) {
        snapshot_names(entry.snapshot); request_names(entry.request);
    }
    for (const auto& order : delayed_market_orders_) {
        snapshot_names(order.snapshot); request_names(order.request);
    }
    for (const auto& sell : deferred_open_marketable_sells_) snapshot_names(sell.snapshot);
    for (const auto& row : throttled_reopen_rearm_) snapshot_names(row);
    for (const auto& command : pending_same_bar_commands_) {
        snapshot_names(command.snapshot); request_names(command.request);
    }
    for (const auto& shadow : source_shadow_pending_) snapshot_names(shadow.snapshot);
    for (const auto& pending : pending_coof_requests_) {
        snapshot_names(pending.snapshot); request_names(pending.request);
    }
    for (const auto& revival : pending_margin_revivals_) snapshot_names(revival.snapshot);
    for (const auto& leg : anchored_relative_legs_) {
        name(leg.handle.incarnation); name(leg.parent.incarnation); request_names(leg.request);
    }
    std::sort(named.begin(), named.end());
    named.erase(std::unique(named.begin(), named.end()), named.end());
    for (auto& row : cohorts_by_id_) {
        ++work.cohort_rows;
        auto& facts = row.second;
        auto& origins = facts.origins;
        std::size_t through = origins.base();
        for (const auto& origin : origins) {
            ++work.fronts_tested;
            const bool present = placement_.contains(origin.incarnation);
            if (present
                || std::binary_search(named.begin(), named.end(), origin.incarnation)
                || facts.live_units_by_origin.find(origin.incarnation)
                    != facts.live_units_by_origin.end()
                || std::find(facts.opened.begin(), facts.opened.end(), origin) != facts.opened.end()
                || core.cohort_contains(facts.handle, origin)) {
                if (!present && through == origins.base()) ++work.missing_fronts_pinned;
                break;
            }
            ++through;
        }
        const auto old_base = origins.base();
        origins.retire_before(through);
        work.origins_retired += through - old_base;
        if (origins.members().empty()) {
            if (auto* index = adapter_lookup_index(consumer, this, run_counter_, false))
                index->cohort_sides.erase(facts.handle.value);
        }
    }
    cohorts_by_id_.spill_implicitly();
    if (auto* index = adapter_lookup_index(consumer, this, run_counter_, false)) {
        auto& sides = index->cohort_sides;
        if (sides.bucket_count() / 4 > sides.size()) sides.rehash(sides.size());
    }
}
 
PineExecutionAdapter::RetirementPopulation
PineExecutionAdapter::retirement_population() const {
    RetirementPopulation result;
    result.live = live_handles_.size();
    result.pending = pending_bracket_legs_.size() + pending_entries_.size()
        + delayed_market_orders_.size() + deferred_open_marketable_sells_.size()
        + throttled_reopen_rearm_.size() + pending_same_bar_commands_.size()
        + source_shadow_pending_.size() + pending_coof_requests_.size()
        + pending_margin_revivals_.size() + anchored_relative_legs_.size();
    const auto owners = [&](const native_order::Request& request) {
        if (const auto* wait = std::get_if<native_order::WaitForApplied>(&request.owner))
            result.owners += wait->parent.incarnation != 0;
        else if (const auto* opening = std::get_if<native_order::BindOpening>(&request.owner))
            result.owners += opening->opening.incarnation != 0;
        else if (const auto* openings = std::get_if<native_order::BindOpenings>(&request.owner))
            for (const auto& opening : openings->openings)
                result.owners += opening.incarnation != 0;
    };
    for (const auto& leg : pending_bracket_legs_) owners(leg.request);
    for (const auto& entry : pending_entries_) owners(entry.request);
    for (const auto& order : delayed_market_orders_) owners(order.request);
    for (const auto& command : pending_same_bar_commands_) owners(command.request);
    for (const auto& request : pending_coof_requests_) owners(request.request);
    for (const auto& leg : anchored_relative_legs_) owners(leg.request);
    result.opened = cohort_opened_slot_count_;
    result.m = result.live + result.pending + result.owners + result.opened;
    result.R = placement_.size() - result.live;
    result.C = cohorts_by_id_.size();
    placement_.visit_rows([&](std::uint64_t incarnation, const PlacementSnapshot& row) {
        if (row.family == PineOrderFamily::ExitLimit || row.family == PineOrderFamily::ExitStop
            || row.family == PineOrderFamily::ExitTrail) {
            const bool live = std::any_of(live_handles_.begin(), live_handles_.end(),
                [&](const auto& handle) { return handle.incarnation == incarnation; });
            if (!live) ++result.retired_exit_rows;
        }
        return false;
    });
    return result;
}
 
} // namespace pineforge::source
 
namespace pineforge::source {
 
OriginRoster OriginRoster::from_retired(std::size_t count, std::uint64_t digest) {
    OriginRoster result;
    result.base_ = count;
    result.digest_ = digest;
    return result;
}
 
PineExecutionAdapter::CohortFacts::Record
PineExecutionAdapter::CohortFacts::retired_record() const noexcept {
    static_assert(sizeof(Record) == 40, "retired cohort scratch record");
    return {handle.value, cycle, origins.size(), origins.digest(), erased_opening_sides};
}
 
PineExecutionAdapter::CohortFacts
PineExecutionAdapter::CohortFacts::restore_record(const Record& row, bool /*arena_backed*/) {
    if (row.handle == 0 || static_cast<std::uint64_t>(
            static_cast<std::size_t>(row.origin_count)) != row.origin_count
        || row.erased_sides > 3) {
        ::pineforge::detail::raise_scratch_io_error(EIO, "scratch cohort invalid record");
    }
    CohortFacts facts;
    facts.handle.value = row.handle;
    facts.cycle = row.cycle;
    facts.origins = OriginRoster::from_retired(
        static_cast<std::size_t>(row.origin_count), row.origin_digest);
    facts.erased_opening_sides = static_cast<std::uint8_t>(row.erased_sides);
    return facts;
}
 
bool PineExecutionAdapter::CohortFacts::spillable() const noexcept {
    return origins.members().empty() && opened.empty() && live_units_by_origin.empty();
}
 
bool PineExecutionAdapter::CohortFacts::held() const noexcept {
    // Predicate and held-walk design credited to the contributor of external PR #458.
    return !opened.empty() || !live_units_by_origin.empty();
}
 
// The one place that binds the scratch
// directory of every adapter-owned L19l table -- part A's cohort and
// entry-rank tables, part C's placement-minima and consumed-cycle tables --
// the way set_successor_roots_directory binds every table of the kernel core.
// ScratchFile and IdPairStore accept the directory they already hold, so
// calling both public names (this and set_auxiliary_tables_directory) with
// one directory is harmless. A different directory once a table's file is
// open throws std::logic_error from that table: bind after reset_for_run and
// before the first id, as the declaration says.
void PineExecutionAdapter::set_id_tables_directory(const std::string& directory) {
    cohorts_by_id_.set_directory(directory);
    exit_rank_keys_.set_directory(directory);
    placement_.set_auxiliary_tables_directory(directory);
    consumed_partial_exit_cycles_.set_directory(directory);
    if (!position_tail_summary_)
        position_tail_summary_ = std::make_shared<detail::AdapterPositionTailSummary>();
    position_tail_summary_->set_directory(directory);
}
 
void PineExecutionAdapter::set_cache_policy_for_run(const CacheDefaults& policy) {
    cohorts_by_id_.set_cache_capacity(policy.cohort_id_pages);
    exit_rank_keys_.set_cache_capacity(policy.exit_rank_pages);
    placement_.set_cache_capacity(policy.erased_minima_pages, policy.retained_sequence_pages);
    consumed_partial_exit_cycles_.set_cache_capacity(policy.consumed_cycle_pages);
}
 
PineExecutionAdapter::CohortTable::iterator
PineExecutionAdapter::require_cohort(const SourceId& id) {
    auto found = cohorts_by_id_.find(id);
    if (found == cohorts_by_id_.end()) {
        throw coded<std::logic_error>(RunFailureCode::engine_invariant, {},
                                      "accepted opening has no source cohort");
    }
    return found;
}
 
} // namespace pineforge::source
 
// Keep the new storage wiring together, away from part A's
// cohort / entry-id changes in this translation unit. These paths and file
// offsets describe storage of existing state, not additional broker state.
namespace pineforge::source {
 
void PlacementTable::set_auxiliary_tables_directory(const std::string& directory) {
    erased_minima_.set_directory(directory); sequence_index_.reset();
}
 
void PlacementTable::bind_auxiliary_scratch_tables(const std::shared_ptr<::pineforge::detail::ScratchSlab>& slab) {
    erased_minima_.bind_scratch_tables(slab, ::pineforge::detail::ScratchResource::erased_data,
                                      ::pineforge::detail::ScratchResource::erased_index);
    sequence_index_.reset();
}
 
void PlacementTable::fixture_use_memory_auxiliary_tables() {
    if (high_water_ != 0)
        throw coded<std::logic_error>(
            RunFailureCode::engine_invariant, {},
            "placement auxiliary fixture backend changed after use");
    erased_minima_.fixture_use_memory_reference(); sequence_index_.reset();
}
 
std::uint64_t PlacementTable::auxiliary_disk_bytes() const noexcept {
    return erased_minima_.disk_bytes();
}
 
// Part C's name for the merged binding: set_id_tables_directory above binds
// the placement minima and consumed-cycle tables together with part A's tables.
void PineExecutionAdapter::set_auxiliary_tables_directory(const std::string& directory) {
    set_id_tables_directory(directory);
}
 
void PineExecutionAdapter::fixture_use_memory_auxiliary_tables() {
    placement_.fixture_use_memory_auxiliary_tables();
    consumed_partial_exit_cycles_.fixture_use_memory_reference();
}
 
std::uint64_t PineExecutionAdapter::fixture_auxiliary_disk_bytes() const noexcept {
    return placement_.auxiliary_disk_bytes() + consumed_partial_exit_cycles_.disk_bytes();
}
 
} // namespace pineforge::source
 
#include "../scratch_table_binders.hpp"
#include <pineforge/run_failure.hpp>
 
namespace pineforge::detail {
 
// The tree and IdPair lanes fill their respective backend-owned seams;
// the foundation's begin calls and binder declarations remain unchanged.
void bind_tree_scratch_tables(source::PineExecutionAdapter& adapter,
                              const std::shared_ptr<ScratchSlab>& slab) {
    // Refuse a late rebind before either table can change backing/bytes.
    if (adapter.cohorts_by_id_.size() != 0 || adapter.exit_rank_keys_.size() != 0)
        throw coded<std::logic_error>(RunFailureCode::engine_invariant, {},
            "tree scratch backend changed after use");
    adapter.cohorts_by_id_.bind_scratch(slab, ScratchResource::cohort);
    adapter.exit_rank_keys_.bind_scratch(slab, ScratchResource::exit_rank);
}
 
void bind_id_pair_scratch_tables(source::PineExecutionAdapter& adapter,
                                 const std::shared_ptr<ScratchSlab>& slab) {
    adapter.placement_.bind_auxiliary_scratch_tables(slab);
    adapter.consumed_partial_exit_cycles_.bind_scratch_tables(
        slab, ScratchResource::consumed_data, ScratchResource::consumed_index);
}
 
} // namespace pineforge::detail
 
namespace pineforge::source {
 
void PineExecutionAdapter::require_cohort_ticket(const SourceId* prospective) const {
    cohorts_by_id_.require_inserts([&](auto&& visit) {
        if (prospective) visit(*prospective);
        for (const auto& row : pending_same_bar_commands_)
            if (row.opening) visit(row.snapshot.source_id);
        for (const auto& row : pending_entries_) visit(row.snapshot.source_id);
        for (const auto& row : pending_coof_requests_)
            if (row.opening) visit(row.snapshot.source_id);
        for (const auto& row : delayed_market_orders_)
            if (row.snapshot.family == PineOrderFamily::Entry
                || row.snapshot.family == PineOrderFamily::Order)
                visit(row.snapshot.source_id);
        for (const auto& row : deferred_open_marketable_sells_) visit(row.snapshot.source_id);
    });
}
 
void PineExecutionAdapter::require_exit_rank_key(const SourceId& id) const {
    // Preserve the 27/28 cutoff: an ignored 28th key needs no ticket, even
    // when its string would exceed the admitted aggregate byte allowance.
    if (exit_rank_keys_.size() > 26) return;
    exit_rank_keys_.require_insert(id);
}
 
void PineExecutionAdapter::require_tree_precommit(const NativePrecommitView& view) const {
    // The kernel calls PRECOMMIT only for an Applied-ready candidate, before
    // financial effects. Capacity is a coded infrastructure exception, never
    // a trading Refuse. This mirrors note_exit_rank_key's on_applied predicate.
    if (!view.account.would_open || view.inspected_opened_units == 0.0) return;
    const auto row = placement_.find(view.target.incarnation);
    if (row != placement_.end()
        && (row->second.family == PineOrderFamily::Entry
            || row->second.family == PineOrderFamily::Order))
        require_exit_rank_key(row->second.source_id);
}
 
} // namespace pineforge::source
 
namespace pineforge::source {
 
std::uint64_t PineExecutionAdapter::checked_live_key(const SourceId& spelling) const {
    const auto key = key_for(spelling);
    const auto existing = live_by_source_key_.find(key);
    if (existing == live_by_source_key_.end()) return key;
    // Unrepresented keys retain the original hash-only insert/replace/read/erase.
    if (existing->second.identity.shape == detail::LiveSourceIdentity::Shape::Unverified)
        return key;
    const auto previous = placement_.find(existing->second.incarnation);
    if (previous == placement_.end()) {
        throw coded<std::logic_error>(RunFailureCode::engine_invariant, {},
                                      "Pine live source key has no placement");
    }
    if (!existing->second.identity.matches(spelling, previous->second.source_id,
                                           previous->second.from_entry)) {
        throw coded<std::logic_error>(RunFailureCode::engine_invariant,
                                      {{"reason", "order_key_hash_collision"}},
                                      "Pine live source key collision");
    }
    return key;
}
 
detail::LiveSourceHandle PineExecutionAdapter::live_source_value(
        native_order::RequestHandle handle, const SourceId& spelling) const {
    const auto row = placement_.find(handle.incarnation);
    if (row == placement_.end()) {
        throw coded<std::logic_error>(RunFailureCode::engine_invariant, {},
                                      "Pine live source key has no placement");
    }
    const auto& snapshot = row->second;
    const detail::LiveSourceHandle value{handle, spelling, snapshot.source_id, snapshot.from_entry};
#ifdef PINEFORGE_TEST_SOURCE_KEY_MASK
    // Only the test adapter objects define this seam; the shipped object has
    // no missing-spelling throw path, runtime switch, diagnostic state or log.
    if (value.identity.shape == detail::LiveSourceIdentity::Shape::Unverified) {
        throw coded<std::logic_error>(RunFailureCode::engine_invariant, {},
                                      "Pine live source key spelling is not represented");
    }
#endif
    return value;
}
 
} // namespace pineforge::source
 
namespace pineforge::source {
 
#ifndef PINEFORGE_FULL_CLOSE_EXIT_ORACLE
#define PINEFORGE_FULL_CLOSE_EXIT_ORACLE() false
#endif
#ifndef PINEFORGE_FULL_CLOSE_EXIT_CALL
#define PINEFORGE_FULL_CLOSE_EXIT_CALL() ((void)0)
#endif
 
void PineExecutionAdapter::cancel_reversal_exit_owners(
        const std::vector<SourceId>& preserved,
        detail::ExitScratchRows<SourceId>& selection) {
    const auto exempt = [&](const SourceId& id) {
        return std::binary_search(preserved.begin(), preserved.end(), id);
    };
    // The public-run fixture executes the old selection on a separate run.
    // Shipped objects have no runtime switch or additional adapter state.
    if (PINEFORGE_FULL_CLOSE_EXIT_ORACLE()) {
        cohorts_by_id_.for_each_sorted_id([&](const SourceId& id) {
            if (!exempt(id)) selection.push_back(id);
        });
        selection.ordered_text([&](const detail::ExitScratchText& id) {
            cancel_exit_orders_for_full_close(id);
            return true;
        });
        return;
    }
 
    // Logical size is stored in the disk index; neither size nor these few
    // exemption lookups walk historical ids. Repeated exemptions count once.
    std::uint64_t count = cohorts_by_id_.size();
    const SourceId* previous = nullptr;
    for (const auto& id : preserved) {
        if (previous && *previous == id) continue;
        previous = &id;
        if (cohorts_by_id_.contains(id)) --count;
    }
    if (count == 0) return;
 
    // Snapshot only current queues: cancellation erases from these stores.
    // Non-exit shadows, pending-bound rows and COOF-reachable legs are safe
    // supersets; the original canceler retains their exact policy decisions.
    std::vector<SourceId> owners;
    for (const auto& row : pending_bracket_legs_) owners.push_back(row.snapshot.from_entry);
    for (const auto& row : pending_coof_requests_) owners.push_back(row.snapshot.from_entry);
    for (const auto& row : source_shadow_pending_) owners.push_back(row.snapshot.from_entry);
    for (const auto& row : pending_relative_exits_) owners.push_back(row.from_entry);
    for (const auto& row : anchored_relative_legs_) owners.push_back(row.from_entry);
    for (const auto& handle : live_handles_) {
        const auto row = placement_.find(handle.incarnation);
        if (row == placement_.end()) continue;
        const auto family = row->second.family;
        if (family == PineOrderFamily::ExitLimit || family == PineOrderFamily::ExitStop
            || family == PineOrderFamily::ExitTrail) owners.push_back(row->second.from_entry);
    }
    std::sort(owners.begin(), owners.end());
    owners.erase(std::unique(owners.begin(), owners.end()), owners.end());
    owners.erase(std::remove_if(owners.begin(), owners.end(), [&](const SourceId& id) {
        return exempt(id) || !cohorts_by_id_.contains(id);
    }), owners.end());
    assert(owners.size() <= count);
 
    // Every old text append allocated an ordinal/text pair before ANY cancel.
    // Reserve that entire prefix, including the candidates' pairs, once.
    // Returning the status through exit_scratch_edit preserves its exact
    // carried-I/O / rollback / ExitScratchError mapping on every failure.
    auto& context = selection.context();
    if (count > std::numeric_limits<std::uint64_t>::max() / 2)
        detail::exit_scratch_failure(detail::ScratchStatus::programming_error);
    detail::exit_scratch_edit(context, [&] {
        return context.store.advance_handles(2 * count);
    });
 
    // Even a no-owner cancel erased empty families. Preserve that effect once,
    // in the original family iteration order, independent of historical ids.
    for (auto family = bracket_families_.begin(); family != bracket_families_.end();) {
        if (family->second.empty()) family = bracket_families_.erase(family);
        else ++family;
    }
 
#ifndef NDEBUG
    // Independent skip oracle: recompute each actual old per-store predicate,
    // without executing cancels, copying an adapter or trusting the owner scan.
    const bool keep_pending_bound =
        detail::exit_binding_rule_switches().pending_bound_exit_survives_flat;
    cohorts_by_id_.for_each_sorted_id([&](const SourceId& id) {
        if (exempt(id) || std::binary_search(owners.begin(), owners.end(), id)) return;
        const auto matches = [&](const PlacementSnapshot& row) {
            const bool exit = row.family == PineOrderFamily::ExitLimit
                || row.family == PineOrderFamily::ExitStop
                || row.family == PineOrderFamily::ExitTrail;
            return exit && !(keep_pending_bound && row.pending_bound_exit)
                && row.from_entry == id;
        };
        assert(std::none_of(pending_bracket_legs_.begin(), pending_bracket_legs_.end(),
            [&](const PendingBracketLeg& row) { return matches(row.snapshot); }));
        assert(std::none_of(pending_coof_requests_.begin(), pending_coof_requests_.end(),
            [&](const PendingCoofRequest& row) { return matches(row.snapshot); }));
        assert(std::none_of(source_shadow_pending_.begin(), source_shadow_pending_.end(),
            [&](const SourceShadowPending& row) { return matches(row.snapshot); }));
        assert(std::none_of(pending_relative_exits_.begin(), pending_relative_exits_.end(),
            [&](const PendingRelativeExit& row) { return row.from_entry == id; }));
        if (!id.empty())
            assert(std::none_of(anchored_relative_legs_.begin(), anchored_relative_legs_.end(),
                [&](const AnchoredRelativeLeg& row) { return row.from_entry == id; }));
        for (const auto& handle : live_handles_) {
            const auto row = placement_.find(handle.incarnation);
            assert(row == placement_.end() || !matches(row->second)
                || coof_leg_reaches_exit(row->second));
        }
        assert(std::none_of(bracket_families_.begin(), bracket_families_.end(),
            [](const auto& family) { return family.second.empty(); }));
    });
#endif
 
    for (const auto& id : owners) {
        PINEFORGE_FULL_CLOSE_EXIT_CALL();
        cancel_exit_orders_for_full_close(id);
    }
    // A skipped cancel creates empty handles/removed scopes, but no records.
    // Their ordinals are not folded by hash_exit_scratch; preserve the final
    // counter too, so scopes created after this helper keep their old keys.
    // Real cancels cannot publish a hash: cancel / parent-terminal draining
    // only retire requests, without an Applied or source callback. Their own
    // transient rows have been erased before this counter is advanced.
    const auto skipped = count - static_cast<std::uint64_t>(owners.size());
    if (skipped > (std::numeric_limits<std::uint64_t>::max() - context.next_scope) / 2)
        detail::exit_scratch_failure(detail::ScratchStatus::programming_error);
    context.next_scope += 2 * skipped;
}
 
// Keep live-family counters in step with live membership at this shared
// writer, so policy readers need no independent scans. Placement rows stay
// present while their handles are live (erase_retired_rows roots them).
void PineExecutionAdapter::remember_live(const native_order::RequestHandle& handle,
                                        PlacementSnapshot&& snapshot) {
    invalidate_retirement();
    const auto previous = placement_.find(handle.incarnation);
    const bool already_live = previous != placement_.end()
        && std::find(live_handles_.begin(), live_handles_.end(), handle) != live_handles_.end();
    if (already_live) count_live(previous->second, false);
    if (previous != placement_.end() || snapshot.projection_predecessor != 0)
        retired_row_scratch_.roster_pass_due = true;
    const auto inserted = placement_.try_emplace(handle.incarnation, std::move(snapshot));
    if (!inserted.second) placement_.replace(handle.incarnation, std::move(snapshot));
    if (!already_live) pending_write(live_handles_).push_back(handle);
    count_live(placement_.at(handle.incarnation), true);
    assert_live_counts();
}
 
void PineExecutionAdapter::forget_live(const native_order::RequestHandle& handle) noexcept {
    const auto removed = std::remove(pending_write(live_handles_).begin(), live_handles_.end(), handle);
    if (removed != live_handles_.end()) {
        assert(std::distance(removed, live_handles_.end()) == 1);
        const auto row = placement_.find(handle.incarnation);
        assert(row != placement_.end());
        if (row != placement_.end()) count_live(row->second, false);
        pending_write(live_handles_).erase(removed, live_handles_.end());
    }
    assert_live_counts();
}
 
void PineExecutionAdapter::requeue_live(const native_order::RequestHandle& handle) {
    // order_same_point_entries moves an existing row, never a new admission.
    assert(std::find(live_handles_.begin(), live_handles_.end(), handle) != live_handles_.end());
    forget_live(handle);
    pending_write(live_handles_).push_back(handle);
    count_live(placement_.at(handle.incarnation), true);
    assert_live_counts();
}
 
void PineExecutionAdapter::clear_live() noexcept {
    pending_write(live_handles_).clear();
    for (auto& count : retired_row_scratch_.live_families) count = 0;
    retired_row_scratch_.origin_fronts_pinned = true;
}
 
void PineExecutionAdapter::erase_placement(std::uint64_t incarnation) {
    assert(std::none_of(live_handles_.begin(), live_handles_.end(),
        [&](const auto& handle) { return handle.incarnation == incarnation; }));
    // A retained front might now be unpinned. Until a complete all-of proves
    // otherwise, run the original retirement algorithm on every call: queued
    // references, owners, opened lots and kernel membership can all change.
    retired_row_scratch_.origin_fronts_pinned = false;
    invalidate_retirement();
    if (placement_.erase(incarnation)) ++retirement_work_.rows_erased;
}
 
void PineExecutionAdapter::count_live(const PlacementSnapshot& row, bool adding) noexcept {
    const auto change = [&](std::size_t slot) {
        auto& count = retired_row_scratch_.live_families[slot];
        if (adding) ++count;
        else { assert(count != 0); --count; }
    };
    change(static_cast<std::size_t>(row.family));
    if (row.family == PineOrderFamily::Order
        && !finite_positive(row.exit_levels.limit) && !finite_positive(row.exit_levels.stop))
        change(RetiredRowScratch::market_order_slot);
    // submit_or_replace initializes dynamic quantity only for !opening;
    // initialize_l4c_policy captures expansion only for an exit family.
    // A replacement may carry an immutable capture into any family. Include
    // it too: close_population never erases a capture; any later creation is
    // on an exit-family row, which already belongs to this policy population.
    if (!row.opening || row.family == PineOrderFamily::ExitLimit
        || row.family == PineOrderFamily::ExitStop || row.family == PineOrderFamily::ExitTrail
        || row.reservation_expansion.capture().has_value())
        change(RetiredRowScratch::exit_policy_slot);
}
 
void PineExecutionAdapter::assert_live_counts() const noexcept {
#ifndef NDEBUG
    std::size_t actual[RetiredRowScratch::family_count + 2]{};
    for (const auto& handle : live_handles_) {
        const auto found = placement_.find(handle.incarnation);
        assert(found != placement_.end());
        if (found == placement_.end()) continue;
        const auto& row = found->second;
        ++actual[static_cast<std::size_t>(row.family)];
        if (row.family == PineOrderFamily::Order
            && !finite_positive(row.exit_levels.limit)
            && !finite_positive(row.exit_levels.stop))
            ++actual[RetiredRowScratch::market_order_slot];
        if (!row.opening || row.family == PineOrderFamily::ExitLimit
            || row.family == PineOrderFamily::ExitStop || row.family == PineOrderFamily::ExitTrail
            || row.reservation_expansion.capture().has_value())
            ++actual[RetiredRowScratch::exit_policy_slot];
    }
    for (std::size_t i = 0; i < RetiredRowScratch::family_count + 2; ++i)
        assert(actual[i] == retired_row_scratch_.live_families[i]);
#endif
}
 
bool PineExecutionAdapter::has_live_family(PineOrderFamily family) const noexcept {
    assert_live_counts();
    return retired_row_scratch_.live_families[static_cast<std::size_t>(family)] != 0;
}
 
bool PineExecutionAdapter::has_live_exit_policy() const noexcept {
    assert_live_counts();
    return retired_row_scratch_.live_families[RetiredRowScratch::exit_policy_slot] != 0;
}
 
bool PineExecutionAdapter::has_live_trail_policy() const noexcept {
    assert_live_counts();
    const auto& counts = retired_row_scratch_.live_families;
    return counts[static_cast<std::size_t>(PineOrderFamily::Entry)] != 0
        || counts[static_cast<std::size_t>(PineOrderFamily::ExitStop)] != 0
        || counts[static_cast<std::size_t>(PineOrderFamily::ExitTrail)] != 0;
}
 
// Original exact scans serve allocation failures and independent Debug checks.
int PineExecutionAdapter::scan_projected_pending_size(
        const PineExecutionAdapter& owner) noexcept {
    const int raw_count = owner.projected_raw_pending_size();
    int count = 0;
    for (int index = 0; index < raw_count; ++index) {
        const PlacementSnapshot* candidate = nullptr;
        native_order::RequestHandle handle;
        if (!owner.projected_raw_pending_at(index, candidate, handle) || !candidate) continue;
        bool duplicate = false;
        if (candidate->family == PineOrderFamily::ExitLimit
            || candidate->family == PineOrderFamily::ExitStop
            || candidate->family == PineOrderFamily::ExitTrail) {
            for (int prior = 0; prior < index; ++prior) {
                const PlacementSnapshot* earlier = nullptr;
                native_order::RequestHandle earlier_handle;
                if (owner.projected_raw_pending_at(prior, earlier, earlier_handle) && earlier
                    && same_projected_order(*candidate, *earlier)) {
                    duplicate = true;
                    break;
                }
            }
        }
        if (!duplicate && count != std::numeric_limits<int>::max()) ++count;
    }
    return count;
}
 
bool PineExecutionAdapter::scan_projected_pending_at(
        const PineExecutionAdapter& owner, int index, const PlacementSnapshot*& snapshot,
        native_order::RequestHandle& handle, int* raw_index) noexcept {
    snapshot = nullptr;
    handle = {};
    if (raw_index) *raw_index = -1;
    if (index < 0) return false;
    const int raw_count = owner.projected_raw_pending_size();
    int projected = 0;
    for (int raw = 0; raw < raw_count; ++raw) {
        const PlacementSnapshot* candidate = nullptr;
        native_order::RequestHandle candidate_handle;
        if (!owner.projected_raw_pending_at(raw, candidate, candidate_handle) || !candidate) continue;
        bool duplicate = false;
        if (candidate->family == PineOrderFamily::ExitLimit
            || candidate->family == PineOrderFamily::ExitStop
            || candidate->family == PineOrderFamily::ExitTrail) {
            for (int prior = 0; prior < raw; ++prior) {
                const PlacementSnapshot* earlier = nullptr;
                native_order::RequestHandle earlier_handle;
                if (owner.projected_raw_pending_at(prior, earlier, earlier_handle) && earlier
                    && same_projected_order(*candidate, *earlier)) {
                    duplicate = true;
                    break;
                }
            }
        }
        if (duplicate) continue;
        if (projected++ == index) {
            snapshot = candidate;
            handle = candidate_handle;
            if (raw_index) *raw_index = raw;
            return true;
        }
    }
    return false;
}
 
int PineExecutionAdapter::projected_pending_size() const noexcept {
    if (!ensure_projected_pending_index()) return scan_projected_pending_size(*this);
    const int count = static_cast<int>(projected_pending_indexes_.size());
#ifndef NDEBUG
    if (projected_raw_pending_size() <= 256)
        assert(count == scan_projected_pending_size(*this));
#endif
    return count;
}
 
bool PineExecutionAdapter::projected_pending_at(
        int index, const PlacementSnapshot*& snapshot,
        native_order::RequestHandle& handle) const noexcept {
    snapshot = nullptr;
    handle = {};
    bool found = false;
    if (index >= 0) {
        if (!ensure_projected_pending_index())
            return scan_projected_pending_at(*this, index, snapshot, handle);
        if (static_cast<std::size_t>(index) < projected_pending_indexes_.size())
            found = projected_raw_pending_at(
                projected_pending_indexes_[static_cast<std::size_t>(index)], snapshot, handle);
    }
#ifndef NDEBUG
    if (projected_raw_pending_size() <= 256) {
        const PlacementSnapshot* expected_snapshot = nullptr;
        native_order::RequestHandle expected_handle;
        const bool expected_found = scan_projected_pending_at(
            *this, index, expected_snapshot, expected_handle);
        assert(found == expected_found);
        assert(snapshot == expected_snapshot);
        assert(handle == expected_handle);
    }
#endif
    return found;
}
 
int PineExecutionAdapter::projected_pending_next(int index) const noexcept {
    if (!projected_pending_valid_) {
        const PlacementSnapshot* snapshot = nullptr;
        native_order::RequestHandle handle;
        int raw = -1;
        if (!scan_projected_pending_at(*this, index, snapshot, handle, &raw)) return -1;
        return projected_raw_pending_next(raw);
    }
    return projected_raw_pending_next(
        projected_pending_indexes_[static_cast<std::size_t>(index)]);
}
 
int PineExecutionAdapter::projected_raw_pending_next(int raw) const noexcept {
    // Stay on the scan for the whole observer call, including sibling merges.
    // The next independent accessor retries the index build.
    if (raw < 0) return -1;
    if (!projected_pending_valid_)
        return raw < projected_raw_pending_size() - 1 ? raw + 1 : -1;
    return projected_pending_next_[static_cast<std::size_t>(raw)];
}
 
int PineExecutionAdapter::projected_level_resolved(
        const PlacementSnapshot& snapshot) const noexcept {
    if (snapshot.from_entry.empty()) return 1;
    const auto cohort = cohorts_by_id_.find_resident(snapshot.from_entry);
    return cohort != cohorts_by_id_.end() && !cohort->second.opened.empty() ? 1 : 0;
}
 
} // namespace pineforge::source
 
namespace pineforge::source {
 
// Retained identities and the current tail's dependencies use an independent
// store. Neither its handles nor its physical layout enter the broker hash.
// The comparison index has logarithmic population cost and fixed resident
// workspace; it is not a constant-time radix directory.
struct PlacementTable::SequenceIndex {
    using Status = ::pineforge::detail::ScratchStatus;
    using Handle = ::pineforge::detail::ScratchHandle;
    using Buffer = ::pineforge::detail::ScratchBuffer;
    using Bytes = ::pineforge::detail::ScratchBytes;
    using Field = ::pineforge::detail::ScratchField;
    static constexpr auto absent = std::numeric_limits<std::uint64_t>::max();
 
    // A length-delimited exact identity, followed by big-endian sequence and
    // incarnation words. Domains 0 and 1 index retained singles and pairs.
    // Domain 3 watches query answers. Domain 2 orders fallback dependencies
    // by their answer before their from-entry bytes, for bounded range checks.
    class Key final : public ::pineforge::detail::ScratchByteSource {
    public:
        Key(unsigned domain, std::string_view id,
            std::optional<std::string_view> from = std::nullopt,
            std::uint64_t sequence = 0, std::uint64_t incarnation = 0)
            : domain_(domain), id_(id), from_(from),
              sequence_(sequence), incarnation_(incarnation) {
            if (id.size() > absent - 33
                || (from && from->size() > absent - 33 - id.size()))
                throw std::length_error("retained identity key is too long");
        }
        std::uint64_t prefix_size() const noexcept {
            return 9 + id_.size() + (from_ ? 8 + from_->size() : 0);
        }
        std::uint64_t id_prefix_size() const noexcept { return 9 + id_.size(); }
        std::uint64_t size() const noexcept override { return prefix_size() + 16; }
        Status read(std::uint64_t offset, Buffer destination) const noexcept override {
            if (offset > size() || destination.size > size() - offset
                || (destination.size && !destination.data)) return Status::programming_error;
            for (std::size_t index = 0; index < destination.size; ++index)
                destination.data[index] = static_cast<std::byte>(byte(offset + index));
            return Status::ok;
        }
    private:
        static unsigned char word(std::uint64_t value, std::uint64_t at) noexcept {
            return static_cast<unsigned char>(value >> (8 * (7 - at)));
        }
        unsigned char byte(std::uint64_t at) const noexcept {
            if (at == 0) return static_cast<unsigned char>(domain_);
            --at;
            if (at < 8) return word(id_.size(), at);
            at -= 8;
            if (at < id_.size()) return static_cast<unsigned char>(id_[at]);
            at -= id_.size();
            if (domain_ == 2) {
                if (at < 8) return word(sequence_, at);
                at -= 8;
            }
            if (from_) {
                if (at < 8) return word(from_->size(), at);
                at -= 8;
                if (at < from_->size()) return static_cast<unsigned char>((*from_)[at]);
                at -= from_->size();
            }
            if (domain_ == 2) return word(incarnation_, at);
            return at < 8 ? word(sequence_, at) : word(incarnation_, at - 8);
        }
        unsigned domain_;
        std::string_view id_;
        std::optional<std::string_view> from_;
        std::uint64_t sequence_, incarnation_;
    };
 
    static Status compare(void* context, const ::pineforge::detail::ScratchByteSource& a,
                          const ::pineforge::detail::ScratchByteSource& b, int& order) noexcept {
        ++static_cast<SequenceIndex*>(context)->operations;
        std::array<std::byte, 128> left{}, right{};
        const auto common = std::min(a.size(), b.size());
        for (std::uint64_t offset = 0; offset < common;) {
            const auto count = static_cast<std::size_t>(
                std::min<std::uint64_t>(left.size(), common - offset));
            auto status = a.read(offset, {left.data(), count});
            if (status != Status::ok) return status;
            status = b.read(offset, {right.data(), count});
            if (status != Status::ok) return status;
            const int compared = std::memcmp(left.data(), right.data(), count);
            if (compared != 0) { order = compared; return Status::ok; }
            offset += count;
        }
        order = a.size() < b.size() ? -1 : b.size() < a.size() ? 1 : 0;
        return Status::ok;
    }
 
    static std::unique_ptr<::pineforge::detail::ScratchBacking> make_backing(
            CacheCapacity capacity) {
        // Derived identities are not command scopes. The factory snapshots
        // the observer, so isolate their accounting without changing the
        // backing selection, shared byte budget or failure propagation.
        struct RestoreObserver {
            ::pineforge::detail::ScratchIoObserver previous =
                detail::set_command_scratch_io_observer({});
            ~RestoreObserver() { detail::set_command_scratch_io_observer(previous); }
        } restore;
        // One allowance sizes the shared slab in both prefix and read phases.
        auto backing = ::pineforge::detail::make_command_scratch_backing(512, capacity);
        const auto observer = detail::sequence_cache_observer;
        if (observer.created) observer.created(observer.context, *backing);
        return backing;
    }
 
    mutable std::uint64_t operations = 0;
    std::unique_ptr<::pineforge::detail::ScratchBacking> backing;
    ::pineforge::detail::CommandScratchStore store{
        {2, 512, 1, 1, {0x6578697473657131ULL, this, compare},
         ::pineforge::detail::ScratchOpenMode::create_empty}, backing.get()};
    bool certified = false;
 
    explicit SequenceIndex(CacheCapacity capacity)
        : backing(make_backing(capacity)) { require(store.status()); }
    void require(Status status) const {
        if (status == Status::ok) return;
        if (status == Status::io_error)
            ::pineforge::detail::rethrow_carried_scratch_failure(store.carried_failure());
        throw coded<std::logic_error>(
            status == Status::io_error ? RunFailureCode::scratch_io_failed
                                       : RunFailureCode::engine_invariant,
            {}, "retained sequence index operation failed");
    }
    struct Transaction {
        SequenceIndex& index;
        explicit Transaction(SequenceIndex& value) : index(value) {
            ++index.operations;
            index.require(index.store.begin());
        }
        ~Transaction() {
            if (index.store.transaction_active()) (void)index.store.rollback();
        }
        void commit() {
            ++index.operations;
            index.require(index.store.commit(::pineforge::detail::ScratchDurability::buffered));
        }
    };
    Handle seek(const Key& key) const {
        ++operations;
        Handle handle = ::pineforge::detail::scratch_no_handle;
        const auto status = store.lower_bound(key, handle);
        if (status != Status::end) require(status);
        return handle;
    }
    bool matches(Handle handle, const Key& key, std::uint64_t bytes) const {
        if (handle == ::pineforge::detail::scratch_no_handle) return false;
        ::pineforge::detail::ScratchRecordInfo info{};
        ++operations;
        require(store.point(handle, info));
        if (info.key_bytes < bytes || (bytes == key.size() && info.key_bytes != bytes))
            return false;
        std::array<std::byte, 128> left{}, right{};
        for (std::uint64_t offset = 0; offset < bytes;) {
            const auto count = static_cast<std::size_t>(
                std::min<std::uint64_t>(left.size(), bytes - offset));
            ++operations;
            require(store.read(handle, Field::key, offset, {left.data(), count}));
            require(key.read(offset, {right.data(), count}));
            if (std::memcmp(left.data(), right.data(), count) != 0) return false;
            offset += count;
        }
        return true;
    }
    Handle find(const Key& key) const {
        const auto handle = seek(key);
        return matches(handle, key, key.size()) ? handle : ::pineforge::detail::scratch_no_handle;
    }
    std::uint64_t minimum(unsigned domain, std::string_view id,
                          std::optional<std::string_view> from = std::nullopt) const {
        const Key probe(domain, id, from);
        const auto handle = seek(probe);
        if (!matches(handle, probe, probe.prefix_size())) return absent;
        std::array<std::byte, 8> bytes{};
        ++operations;
        require(store.read(handle, Field::key, probe.prefix_size(), {bytes.data(), bytes.size()}));
        std::uint64_t result = 0;
        for (const auto byte : bytes)
            result = (result << 8) | std::to_integer<unsigned char>(byte);
        return result;
    }
    void put(const Key& key, Bytes bytes = {}) {
        ::pineforge::detail::ScratchSpanSource value(bytes);
        Handle handle = ::pineforge::detail::scratch_no_handle;
        ++operations;
        require(store.put(key, value, handle));
    }
    void erase(const Key& key) {
        const auto handle = find(key);
        if (handle == ::pineforge::detail::scratch_no_handle)
            throw coded<std::logic_error>(RunFailureCode::engine_invariant, {},
                                          "retained sequence identity is absent");
        ++operations;
        require(store.erase(handle));
    }
    void insert(std::uint64_t incarnation, const PlacementSnapshot& row) {
        put(Key(0, row.source_id, std::nullopt, row.command_sequence, incarnation));
        put(Key(1, row.source_id, row.from_entry, row.command_sequence, incarnation));
    }
    void remove(std::uint64_t incarnation, const PlacementSnapshot& row) {
        erase(Key(0, row.source_id, std::nullopt, row.command_sequence, incarnation));
        erase(Key(1, row.source_id, row.from_entry, row.command_sequence, incarnation));
    }
    void clear_dependencies() {
        certified = false;
        Transaction transaction(*this);
        const Key first(2, {});
        for (auto handle = seek(first); handle != ::pineforge::detail::scratch_no_handle;
             handle = seek(first)) {
            ++operations;
            require(store.erase(handle));
        }
        transaction.commit();
    }
    void watch(unsigned domain, std::string_view id,
               std::optional<std::string_view> from, std::uint64_t minimum) {
        const Key key(domain, id, from, domain == 2 ? minimum : 0);
        if (find(key) != ::pineforge::detail::scratch_no_handle) return;
        Transaction transaction(*this);
        put(key, {reinterpret_cast<const std::byte*>(&minimum), sizeof minimum});
        transaction.commit();
    }
    template<class Erased>
    std::uint64_t combined_minimum(unsigned domain, std::string_view id,
                                   std::optional<std::string_view> from,
                                   const Erased& erased) const {
        auto current = minimum(domain, id, from);
        const auto historical = from ? erased.lookup(id, *from) : erased.lookup(id);
        return historical ? std::min(current, *historical) : current;
    }
    template<class Erased>
    void check_pair(std::string_view id, std::string_view from, const Erased& erased) {
        if (!certified) return;
        const auto handle = find(Key(3, id, from));
        if (handle == ::pineforge::detail::scratch_no_handle) return;
        std::uint64_t previous = absent;
        ++operations;
        require(store.read(handle, Field::value, 0,
                           {reinterpret_cast<std::byte*>(&previous), sizeof previous}));
        const auto paired = combined_minimum(1, id, from, erased);
        const auto current = paired != absent
            ? paired : combined_minimum(0, id, std::nullopt, erased);
        if (previous != current) { certified = false; return; }
        // A pair can begin/end using the fallback while its final answer
        // stays identical. Maintain that dependency without dirtying the tail.
        const Key fallback(2, id, from, previous);
        const auto dependency = find(fallback);
        if (paired == absent && dependency == ::pineforge::detail::scratch_no_handle)
            put(fallback);
        else if (paired != absent && dependency != ::pineforge::detail::scratch_no_handle) {
            ++operations;
            require(store.erase(dependency));
        }
    }
    template<class Erased>
    void check_fallbacks(std::string_view id, const Erased& erased) {
        if (!certified) return;
        const Key first(2, id);
        const auto handle = seek(first);
        if (!matches(handle, first, first.id_prefix_size())) return;
        const auto current = combined_minimum(0, id, std::nullopt, erased);
        std::array<std::byte, 8> bytes{};
        ++operations;
        require(store.read(handle, Field::key, first.id_prefix_size(), {bytes.data(), bytes.size()}));
        std::uint64_t minimum = 0;
        for (const auto byte : bytes)
            minimum = (minimum << 8) | std::to_integer<unsigned char>(byte);
        if (minimum != current) { certified = false; return; }
        if (current == absent) return;
        // Every remaining fallback must have this exact answer. One lower
        // bound rules out the whole greater-answer range, without a tail walk.
        const Key greater(2, id, std::nullopt, current + 1);
        if (matches(seek(greater), greater, greater.id_prefix_size())) certified = false;
    }
};
 
PlacementTable::SequenceIndex& PlacementTable::sequence_index() const {
    if (!sequence_index_) {
        auto next = std::make_shared<SequenceIndex>(sequence_cache_capacity_);
        SequenceIndex::Transaction transaction(*next);
        // A deferred first insertion leaves at most one row to build.
        // Failed derived writes or a backing rebind can need a recovery walk.
        visit_rows([&](std::uint64_t incarnation, const PlacementSnapshot& row) {
            ++sequence_rows_;
            next->insert(incarnation, row);
            return false;
        });
        transaction.commit();
        sequence_index_ = std::move(next);
    }
    return *sequence_index_;
}
 
void PlacementTable::prepare_place(std::uint64_t incarnation) {
    // All allocation precedes the backed update. place() then only moves an
    // owning pointer into reserved storage, so it cannot fail after commit.
    const auto reserve = [](auto& rows, std::size_t required) {
        if (required <= rows.capacity()) return;
        const auto grown = rows.capacity()
            + std::min(rows.capacity(), rows.max_size() - rows.capacity());
        rows.reserve(std::max(required, grown));
    };
    if (old_only_) {
        reserve(old_, old_.size() + 1U);
        return;
    }
    if (window_rows_ == 0 && (old_.empty() || incarnation > old_.back().first)) {
        reserve(window_, 1);
    } else if (incarnation < base_) {
        reserve(old_, old_.size() + 1);
    } else {
        const auto index = head_ + static_cast<std::size_t>(incarnation - base_);
        constexpr std::size_t kDenseFloor = 64;
        const auto span = std::max(window_.size() - head_,
                                   static_cast<std::size_t>(incarnation - base_) + 1U);
        const bool dense = span <= kDenseFloor || span <= 4U * window_rows_;
        if (window_rows_ != 0 && !dense) {
            reserve(old_, old_.size() + window_rows_ + 1U);
            for (std::size_t slot = head_; slot < window_.size(); ++slot) {
                if (!window_[slot]) continue;
                old_.emplace_back(
                    base_ + static_cast<std::uint64_t>(slot - head_),
                    std::move(window_[slot]));
                ++placement_work_;
            }
            window_.clear();
            head_ = 0;
            window_rows_ = 0;
            base_ = std::numeric_limits<std::uint64_t>::max();
            old_only_ = true;
            return;
        }
        if (index >= window_.size()) reserve(window_, index + 1);
    }
}
 
void PlacementTable::change_sequences(std::uint64_t incarnation,
                                     const PlacementSnapshot* before,
                                     const PlacementSnapshot* after) {
    static_assert(std::is_nothrow_move_assignable_v<PlacementSnapshot>,
                  "placement publication must not fail after its identity update");
    // The first insertion has no index or certified answer to maintain.
    // Avoid claiming an arena region before the authoritative cohort/rank
    // stores admit it. The next mutation or query builds from retained rows.
    if (!before && size_ == 0 && !sequence_index_) return;
    if (before && after && before->source_id == after->source_id
        && before->from_entry == after->from_entry
        && before->command_sequence == after->command_sequence) return;
    try {
        auto& index = sequence_index();
        SequenceIndex::Transaction transaction(index);
        if (before) index.remove(incarnation, *before);
        if (after) index.insert(incarnation, *after);
        // Erasure transfers the identical minima to erased_minima_; its
        // combined query answers therefore do not change at all.
        if (after) {
            if (before) index.check_pair(before->source_id, before->from_entry, erased_minima_);
            index.check_pair(after->source_id, after->from_entry, erased_minima_);
            if (before) index.check_fallbacks(before->source_id, erased_minima_);
            index.check_fallbacks(after->source_id, erased_minima_);
        }
        transaction.commit();
    } catch (...) {
        // Placements are still unchanged. Discard all possibly stale derived
        // handles; the next use reconstructs from the authoritative rows.
        sequence_index_.reset();
        throw;
    }
}
 
std::array<std::uint64_t, 2> PlacementTable::retained_sequences(
        const SourceId& id, const SourceId& from) const {
    constexpr auto absent = SequenceIndex::absent;
    if (size_ == 0 && !sequence_index_) return {absent, absent};
    const auto& index = sequence_index();
    return {index.minimum(0, id), index.minimum(1, id, from)};
}
 
std::array<std::uint64_t, 5> PlacementTable::sequence_work() const noexcept {
    if (!sequence_index_) return {sequence_queries_, sequence_rows_, 0, 0, 0};
    const auto stats = sequence_index_->store.stats();
    return {sequence_queries_, sequence_rows_, sequence_index_->operations,
            stats.page_reads + stats.page_writes + stats.syncs, stats.resident_bytes};
}
 
bool PlacementTable::exit_sequences_certified() const noexcept {
    return sequence_index_ && sequence_index_->certified;
}
 
void PlacementTable::begin_exit_sequence_certificate() {
    sequence_index().clear_dependencies();
}
 
void PlacementTable::watch_exit_sequence(const SourceId& id, const SourceId& from) {
    auto& index = sequence_index();
    const auto paired = index.combined_minimum(1, id, from, erased_minima_);
    const auto answer = paired != SequenceIndex::absent
        ? paired : index.combined_minimum(0, id, std::nullopt, erased_minima_);
    index.watch(3, id, from, answer);
    // A finite paired minimum masks the any-entry fallback completely.
    if (paired != SequenceIndex::absent) return;
    index.watch(2, id, from, answer);
}
 
void PlacementTable::certify_exit_sequences() noexcept {
    if (sequence_index_) sequence_index_->certified = true;
}
 
PineExecutionAdapter::ExitGroupWork PineExecutionAdapter::exit_group_work() const noexcept {
    auto result = exit_group_work_;
    const auto sequence = placement_.sequence_work();
    result.sequence_queries = sequence[0];
    result.sequence_rows = sequence[1];
    result.sequence_index_operations = sequence[2];
    result.sequence_index_pages = sequence[3];
    result.sequence_index_resident_bytes = sequence[4];
    result.retained_placements = placement_.size();
    return result;
}
 
bool PineExecutionAdapter::exit_group_certified(const TradeLedger& trades) const noexcept {
    const auto& certificate = exit_group_certificate_;
    return certificate.rows_valid && certificate.ledger == &trades
        && certificate.base == trades.base() && certificate.end == trades.size()
        && placement_.exit_sequences_certified();
}
 
void PineExecutionAdapter::invalidate_exit_group(std::size_t first, std::size_t count) noexcept {
    auto& certificate = exit_group_certificate_;
    // The preceding row is a dependency too: a key rewrite can merge it
    // into the formerly certified group without changing the ledger size.
    const auto boundary = certificate.start == 0 ? 0 : certificate.start - 1;
    if (count && first < certificate.end
        && (first >= boundary || count > boundary - first))
        certificate.rows_valid = false;
}
 
void PineExecutionAdapter::certify_exit_group(const TradeLedger& trades, std::size_t start, bool ordered) {
    exit_group_certificate_.rows_valid = false;
    placement_.begin_exit_sequence_certificate();
    for (std::size_t index = start; index < trades.size(); ++index) {
        ++exit_group_work_.tail_rows;
        const Trade& row = trades[index];
        placement_.watch_exit_sequence(row.exit_id, row.entry_id);
    }
    placement_.certify_exit_sequences();
    exit_group_certificate_ = {&trades, trades.base(), start, trades.size(), ordered};
}
 
void PineExecutionAdapter::finish_exit_group_sort(
        ::pineforge::detail::CommandScratchStore& scratch,
        const ::pineforge::detail::ScratchStoreStats& before) noexcept {
    const auto after = scratch.stats();
    exit_group_work_.scratch_operations += (after.page_reads - before.page_reads)
        + (after.page_writes - before.page_writes) + (after.syncs - before.syncs);
    // The permutation changes positions, preserving the watched key set.
    // Publish only after all replacements and scratch rollback succeeded.
    exit_group_certificate_.rows_valid = true;
}
 
} // namespace pineforge::source
 
namespace pineforge::source {
namespace {
template<class T>
bool retirement_capacity_excessive(const std::vector<T>& values) {
    // Express size * 4 < capacity without overflowing the size type.
    return values.capacity() != 0 && values.size() <= (values.capacity() - 1) / 4;
}
 
template<class T>
void compact_retirement_set(std::vector<T>& values) {
    if (retirement_capacity_excessive(values)) std::vector<T>(values).swap(values);
}
 
template<class T>
void canonical_retirement_set(std::vector<T>& values, bool compact) {
    // Refill includes duplicate references. Keep room for them after the
    // distinct set is formed, so an unchanged refill never has to regrow.
    if (compact) compact_retirement_set(values);
    std::sort(values.begin(), values.end());
    values.erase(std::unique(values.begin(), values.end()), values.end());
}
} // namespace
 
bool PineExecutionAdapter::capture_retirement_inputs(RetirementInputs& inputs) const {
    inputs.roots.clear();
    inputs.askable.clear();
    inputs.groups.clear();
    inputs.bar_numbers.clear();
    inputs.marks.clear();
    const auto root = [&](std::uint64_t value) {
        if (value != 0) inputs.roots.push_back(value);
    };
    const auto snapshot = [&](const PlacementSnapshot& value) {
        root(value.bracket_origin.incarnation);
        root(value.paired_reversal_parent.incarnation);
        root(value.preserved_by_close_all.incarnation);
        root(value.projection_predecessor);
        root(value.legs.target().incarnation);
        root(value.reservation_growth_owner_incarnation);
        if (value.sequential_group != 0) inputs.groups.push_back(value.sequential_group);
        if (value.projection_created_bar_pinned)
            inputs.bar_numbers.push_back(value.projection_created_bar);
    };
    const auto request = [&](const native_order::Request& value) {
        if (const auto* wait = std::get_if<native_order::WaitForApplied>(&value.owner)) {
            root(wait->parent.incarnation);
        } else if (const auto* opening = std::get_if<native_order::BindOpening>(&value.owner)) {
            root(opening->opening.incarnation);
        } else if (const auto* openings = std::get_if<native_order::BindOpenings>(&value.owner)) {
            for (const auto& opening : openings->openings) root(opening.incarnation);
        }
    };
    for (const auto& handle : live_handles_) {
        root(handle.incarnation);
        inputs.askable.push_back(handle.incarnation);
        const auto row = placement_.find(handle.incarnation);
        if (row == placement_.end()) continue;
        if (row->second.sequential_group != 0)
            inputs.groups.push_back(row->second.sequential_group);
        if (row->second.family == PineOrderFamily::Entry)
            inputs.bar_numbers.push_back(row->second.projection_created_bar);
    }
    for (const auto& cohort : cohorts_by_id_.held_rows()) {
        for (const auto& opening : cohort.second.opened) {
            root(opening.incarnation);
            inputs.askable.push_back(opening.incarnation);
        }
    }
    if (auto* pine = pine_view_of(host_))
        for (const auto& lot : pine->pyramid_entries_) root(lot.entry_incarnation);
    for (const auto& handle : first_open_newborns_) root(handle.incarnation);
    for (const auto& entry : live_by_source_key_) root(entry.second.incarnation);
    for (const auto& leg : pending_bracket_legs_) { snapshot(leg.snapshot); request(leg.request); }
    for (const auto& entry : pending_entries_) { snapshot(entry.snapshot); request(entry.request); }
    for (const auto& order : delayed_market_orders_) { snapshot(order.snapshot); request(order.request); }
    for (const auto& sell : deferred_open_marketable_sells_) snapshot(sell.snapshot);
    for (const auto& value : throttled_reopen_rearm_) snapshot(value);
    for (const auto& command : pending_same_bar_commands_) { snapshot(command.snapshot); request(command.request); }
    for (const auto& shadow : source_shadow_pending_) snapshot(shadow.snapshot);
    for (const auto& pending : pending_coof_requests_) { snapshot(pending.snapshot); request(pending.request); }
    for (const auto& revival : pending_margin_revivals_) snapshot(revival.snapshot);
    for (const auto& leg : anchored_relative_legs_) {
        root(leg.handle.incarnation); root(leg.parent.incarnation); request(leg.request);
    }
    root(materializing_parent_.incarnation);
    for (const auto* plan : {&short_seed_, &pending_short_seed_.plan}) {
        root(plan->long_entry.incarnation);
        root(plan->materialize_long.incarnation);
        root(plan->final_short.incarnation);
    }
    root(short_seed_long_candidate_.incarnation);
    for (const auto mark : market_pyramid_adds_) inputs.marks.push_back(mark);
    if (auto* consumer = bound_consumer()) {
        const auto& native = as_native_consumer(*consumer);
        for (const auto& working : native.request_core().live())
            root(working.definition->handle.incarnation);
        assert(native.event_window_start() <= receipt_cursor_ + 1);
        native.visit_commands_after(receipt_cursor_, [&](const native_order::CommandEvent& command) {
            std::visit([&](const auto& event) {
                using Event = std::decay_t<decltype(event)>;
                if constexpr (std::is_same_v<Event, native_order::RejectedEvent>
                              || std::is_same_v<Event, native_order::NativeRiskEvent>) {
                    // These events name no request.
                } else if constexpr (std::is_same_v<Event, native_order::ReplacedEvent>) {
                    root(event.predecessor().incarnation); root(event.successor().incarnation);
                } else if constexpr (std::is_same_v<Event, native_order::ReplaceRejectedEvent>) {
                    root(event.target().incarnation);
                } else if constexpr (std::is_same_v<Event, native_order::NotWorkingEvent>
                                     || std::is_same_v<Event, native_order::InvalidHandleEvent>) {
                    root(event.target.incarnation);
                } else {
                    if (event.definition) root(event.definition->handle.incarnation);
                    if constexpr (std::is_same_v<Event, native_order::ReservationReducedEvent>
                                  || std::is_same_v<Event, native_order::DeferredGroupAdjustmentEvent>)
                        root(event.recipient.incarnation);
                }
            }, command);
            return false;
        });
    }
    // Multiplicity can fall while the distinct sets stay equal. Report that
    // capacity debt before canonicalization so it can invalidate the gate.
    const bool excess_capacity = retirement_capacity_excessive(inputs.roots)
        || retirement_capacity_excessive(inputs.askable)
        || retirement_capacity_excessive(inputs.groups)
        || retirement_capacity_excessive(inputs.bar_numbers)
        || retirement_capacity_excessive(inputs.marks);
    const bool compact = !retirement_gate_.certified;
    canonical_retirement_set(inputs.roots, compact);
    canonical_retirement_set(inputs.askable, compact);
    canonical_retirement_set(inputs.groups, compact);
    canonical_retirement_set(inputs.bar_numbers, compact);
    canonical_retirement_set(inputs.marks, compact);
    return excess_capacity;
}
 
void PineExecutionAdapter::observe_retirement_expiry(
        const PlacementSnapshot& value, std::int64_t interval) noexcept {
    auto& gate = retirement_gate_;
    const bool close_age = value.family == PineOrderFamily::Close && value.immediately;
    const bool stop_age = value.opening && value.family == PineOrderFamily::Entry
        && value.projection_position_side == static_cast<std::int32_t>(PositionSide::FLAT)
        && finite_positive(value.exit_levels.stop) && !finite_positive(value.exit_levels.limit);
    if ((close_age || stop_age) && value.projection_created_bar >= interval)
        gate.interval_expiry = std::min(gate.interval_expiry,
            static_cast<std::int64_t>(value.projection_created_bar) + 1);
    if ((value.family == PineOrderFamily::Entry || value.family == PineOrderFamily::Order)
        && value.placement_script_open_ms >= last_broker_open_ms_)
        gate.broker_expiry = std::min(gate.broker_expiry, value.placement_script_open_ms);
}
 
void PineExecutionAdapter::finish_retirement_phases() {
    const std::size_t base = detail::run_consumer(require_host()).closed_trade_prefix().base;
    if (exit_phase_final_ < base)
        throw coded<std::logic_error>(RunFailureCode::engine_invariant, {},
                                       "exit-phase fold precedes the sealed prefix");
    for (; exit_phase_final_ < base + trade_exit_phase_.size(); ++exit_phase_final_)
        exit_phase_digest_ = fold_exit_phase(exit_phase_digest_,
                                             trade_exit_phase_.at(exit_phase_final_ - base));
    detail::run_consumer(require_host()).finish_exit_phase_restart();
}
 
void PineExecutionAdapter::erase_retired_rows(const NativeDecisionContext& context) {
    auto& gate = retirement_gate_;
    if (detail::retain_retired_rows() || !bound_consumer()
        || placement_.size() <= live_handles_.size()) {
        gate = {};
        sweep_retired_rows(context, retirement_work_);
        return;
    }
    const bool excess_capacity = capture_retirement_inputs(gate.current);
    const auto interval = static_cast<std::int64_t>(context.coordinate.interval_index);
    const bool unchanged = gate.certified && gate.cycle == current_position_cycle_
        && interval >= gate.interval && interval < gate.interval_expiry
        && last_broker_open_ms_ >= gate.broker_open && last_broker_open_ms_ <= gate.broker_expiry
        && gate.current == gate.saved;
    if (unchanged && !excess_capacity) {
#ifndef NDEBUG
        // Use the original reader on these very inputs, including its phase
        // publication. Only retirement state must remain unchanged.
        const auto count = placement_.size();
        const auto erased = placement_.erased_rows();
        const auto digest = placement_.erased_digest();
        const auto before = retirement_validation_state();
        RetirementWork validation;
        sweep_retired_rows(context, validation);
        assert(placement_.size() == count && placement_.erased_rows() == erased
            && placement_.erased_digest() == digest
            && "unchanged retirement sweep erased a placement");
        assert(retired_row_scratch_.doomed.empty()
            && "unchanged retirement sweep found an erasable placement");
        assert(retirement_validation_state() == before
            && "unchanged retirement sweep changed placement, pin or cohort state");
        retirement_work_.validation_sweeps += validation.placement_sweeps;
        retirement_work_.validation_row_visits += validation.row_visits;
#else
        finish_retirement_phases();
#endif
        return;
    }
    gate.certified = false;
    std::swap(gate.saved, gate.current);
    // Saved inputs are only compared, so only their distinct values need
    // space. The refill buffer is compacted at its raw size during capture.
    compact_retirement_set(gate.saved.roots);
    compact_retirement_set(gate.saved.askable);
    compact_retirement_set(gate.saved.groups);
    compact_retirement_set(gate.saved.bar_numbers);
    compact_retirement_set(gate.saved.marks);
    gate.interval_expiry = gate.broker_expiry = std::numeric_limits<std::int64_t>::max();
    const auto erased = placement_.erased_rows();
    sweep_retired_rows(context, retirement_work_);
    // Refresh both buffers even after a removal, releasing obsolete capacity
    // while uncertified and warming the next refill before certification.
    capture_retirement_inputs(gate.current);
    // A removal can expose a new representative. Do not certify its result
    // until a later original sweep has proved there is no more work.
    if (placement_.erased_rows() != erased || !retired_row_scratch_.doomed.empty()) return;
    if (!(gate.current == gate.saved)) return;
    gate.cycle = current_position_cycle_;
    gate.interval = interval;
    gate.broker_open = last_broker_open_ms_;
    gate.certified = true;
}
 
#ifndef NDEBUG
std::array<std::uint64_t, 3> PineExecutionAdapter::retirement_validation_state() const {
    // Bounded workspace: stream the same objects before and after, including
    // object bytes, owned names and lifecycle payloads. No historical copy.
    BrokerStateHashSink placements;
    placements.u(placement_.size());
    placements.u(placement_.high_water());
    placements.u(placement_.erased_rows());
    placements.u(placement_.erased_digest());
    placement_.visit_rows([&](std::uint64_t incarnation, const PlacementSnapshot& row) {
        placements.u(incarnation);
        placements.bytes(&row, sizeof(row));
        placements.s(row.source_id); placements.s(row.from_entry);
        placements.s(row.comment); placements.s(row.oca_name); placements.s(row.close_first_id);
        row.legs.visit(placements);
        return false;
    });
    std::uint64_t pins = 0, cohorts = 0;
    for (const auto& entry : bracket_families_) {
        BrokerStateHashSink row;
        row.u(entry.first); row.u(entry.second.settled_count()); row.u(entry.second.settled_digest());
        for (const auto& handle : entry.second.working_tail()) row.u(handle.incarnation);
        for (const auto& fact : entry.second.consumed_facts()) { row.u(fact.first); row.u(fact.second); }
        pins ^= row.h;
    }
    for (const auto mark : market_pyramid_adds_) {
        BrokerStateHashSink row;
        row.u(mark);
        pins ^= row.h;
    }
    BrokerStateHashSink witnesses;
    const auto& sweep = retired_row_scratch_;
    for (const auto* names : {&sweep.roots, &sweep.askable_origins,
                             &sweep.candidate_names, &sweep.first_reissues, &sweep.released}) {
        witnesses.u(names->size());
        for (const auto value : *names) witnesses.u(value);
    }
    witnesses.u(sweep.origin_pins.size());
    for (const auto* pin : sweep.origin_pins)
        witnesses.u(reinterpret_cast<std::uintptr_t>(pin));
    for (const auto* memo : {&sweep.unsuperseded, &sweep.reissues}) {
        witnesses.u(memo->size());
        for (const auto& value : *memo) { witnesses.u(value.first); witnesses.u(value.second); }
    }
    witnesses.u(sweep.reissue_high_water); witnesses.i(sweep.reissue_cycle);
    pins ^= witnesses.h;
    for (const auto& entry : cohorts_by_id_.resident_rows()) {
        const auto& facts = entry.second;
        BrokerStateHashSink row;
        row.s(entry.first); row.u(facts.handle.value); row.i(facts.cycle);
        row.u(facts.origins.base()); row.u(facts.origins.size()); row.u(facts.origins.digest());
        row.u(facts.origins.members().size());
        if (!facts.origins.members().empty()) row.u(facts.origins.members().front().incarnation);
        row.u(facts.erased_opening_sides);
        for (const auto& opening : facts.opened) row.u(opening.incarnation);
        std::uint64_t units = 0;
        for (const auto& value : facts.live_units_by_origin) {
            BrokerStateHashSink unit;
            unit.u(value.first); unit.d(value.second);
            units ^= unit.h;
        }
        row.u(units);
        cohorts ^= row.h;
    }
    BrokerStateHashSink summary;
    summary.u(cohorts_by_id_.size()); summary.u(cohorts);
    summary.u(settled_bracket_digest_); summary.u(settled_bracket_families_.size());
    summary.b(retired_row_scratch_.origin_fronts_pinned);
    return {placements.h, pins, summary.h};
}
#endif
} // namespace pineforge::source
 
#include "pine_adapter_probe.hpp"
 
namespace pineforge::source::detail {
 
CohortExposureFold fold_cohort_exposure(
        const OriginRoster& origins,
        const std::unordered_map<std::uint64_t, double>& live_units_by_origin) noexcept {
    if (live_units_by_origin.empty() || origins.members().empty()) return {0.0, 0, 0};
    std::uint64_t steps = 0;
    std::uint8_t path = 1;
    if (origins.members().size() > 4 * live_units_by_origin.size() + 16) {
        // Positions are disjoint across incarnations and ascending within
        // each row. Sorting all occurrences restores the roster's order.
        struct Term { std::size_t position; double units; };
        Term buf[kCohortFoldStack];
        std::size_t n = 0;
        std::size_t mapped = 0;
        bool abandoned = false;
        for (const auto& unit : live_units_by_origin) {
            ++steps;
            const auto* positions = origins.positions_of(unit.first);
            if (!positions) continue;
            for (const auto position : *positions) {
                ++steps;
                ++mapped;
                if (n == kCohortFoldStack) {
                    abandoned = true;
                    continue;
                }
                buf[n++] = {position, unit.second};
            }
        }
        if (!abandoned) {
            std::sort(buf, buf + n, [](const Term& a, const Term& b) noexcept {
                return a.position < b.position;
            });
            // Deterministic sort charge: P * ceil(log2 P), zero for P <= 1.
            std::uint64_t levels = 0;
            for (auto remaining = n > 0 ? n - 1 : 0; remaining; remaining >>= 1)
                ++levels;
            steps += static_cast<std::uint64_t>(n) * levels;
            double total = 0.0;
            for (std::size_t i = 0; i < n; ++i) {
                ++steps;
                const double units = buf[i].units;
                if (std::isfinite(units) && units > 0.0) total += units;
            }
            return {std::isfinite(total) && total > 0.0 ? total : 0.0, steps, 2};
        }
        // The partial stack gather is discarded. Comparing this charge with
        // M keeps either overflow completion bounded by the frozen selector.
        const auto mapped_count = static_cast<std::uint64_t>(mapped);
        const auto row_count =
            static_cast<std::uint64_t>(live_units_by_origin.size());
        // The selector has P + 1 passes. Each pass can inspect all R rows
        // and all P positions, including positions in exhausted rows.
        const auto charge_max = std::numeric_limits<std::uint64_t>::max();
        const auto charge_add = [charge_max](std::uint64_t left,
                                             std::uint64_t right) noexcept {
            return right > charge_max - left ? charge_max : left + right;
        };
        const auto charge_mul = [charge_max](std::uint64_t left,
                                             std::uint64_t right) noexcept {
            return left != 0 && right > charge_max / left
                ? charge_max : left * right;
        };
        const auto pass_count = mapped_count == charge_max
            ? charge_max : mapped_count + 1;
        const auto selector_charge =
            charge_mul(pass_count, charge_add(row_count, mapped_count));
        path = 3;
        if (static_cast<std::uint64_t>(origins.members().size()) >= selector_charge) {
            // Frozen selector, kept term-for-term so its acceptance-ordered
            // floating-point additions remain the old fold's additions.
            double total = 0.0;
            bool have_previous = false;
            std::size_t previous = 0;
            for (;;) {
                bool have_next = false;
                std::size_t next = 0;
                double units = 0.0;
                for (const auto& unit : live_units_by_origin) {
                    ++steps;
                    const auto* positions = origins.positions_of(unit.first);
                    if (!positions) continue;
                    for (const auto position : *positions) {
                        ++steps;
                        if (have_previous && position <= previous) continue;
                        if (!have_next || position < next) {
                            have_next = true;
                            next = position;
                            units = unit.second;
                        }
                        break;
                    }
                }
                if (!have_next) break;
                if (std::isfinite(units) && units > 0.0) total += units;
                have_previous = true;
                previous = next;
            }
            return {std::isfinite(total) && total > 0.0 ? total : 0.0, steps, path};
        }
    }
    double total = 0.0;
    for (const auto& origin : origins) {
        ++steps;
        const auto unit = live_units_by_origin.find(origin.incarnation);
        if (unit == live_units_by_origin.end()) continue;
        const double units = unit->second;
        if (std::isfinite(units) && units > 0.0) total += units;
    }
    return {std::isfinite(total) && total > 0.0 ? total : 0.0, steps, path};
}
 
#ifdef PINEFORGE_COHORT_EXPOSURE_FIXTURES
void verify_cohort_exposure(
        const OriginRoster& origins,
        const std::unordered_map<std::uint64_t, double>& live_units_by_origin,
        double actual) noexcept {
    // Frozen selector: deliberately independent of the production fold.
    double total = 0.0;
    // `live_units_by_origin` is a lookup table.  Quantities must follow the
    // cohort's deterministic source insertion order, never its hash buckets.
    // Only roster positions whose incarnation has a unit row can contribute:
    // step through just those, ascending, rather than the id's whole entry
    // history. Allocation-free (the pending-order readback calls this).
    bool have_previous = false;
    std::size_t previous = 0;
    for (;;) {
        bool have_next = false;
        std::size_t next = 0;
        double units = 0.0;
        for (const auto& unit : live_units_by_origin) {
            const auto* positions = origins.positions_of(unit.first);
            if (!positions) continue;
            for (const auto position : *positions) {
                if (have_previous && position <= previous) continue;
                if (!have_next || position < next) {
                    have_next = true;
                    next = position;
                    units = unit.second;
                }
                break;
            }
        }
        if (!have_next) break;
        if (std::isfinite(units) && units > 0.0) total += units;
        have_previous = true;
        previous = next;
    }
    const double expected = std::isfinite(total) && total > 0.0 ? total : 0.0;
    if (std::memcmp(&actual, &expected, sizeof expected) != 0) std::abort();
}
#endif
 
LookupIndexCounts probe_lookup_index(const NativeHostCache* cache) noexcept {
    if (cache == nullptr || typeid(*cache) != typeid(AdapterLookupIndex)) return {};
    const auto& index = static_cast<const AdapterLookupIndex&>(*cache);
    LookupIndexCounts counts{true, index.cohort_sides.size(), index.unbound.size()};
    std::size_t kind = 0;
    for (const auto& by_origin : index.legs_by_origin) {
        counts.legs_by_origin_keys[kind] = by_origin.size();
        for (const auto& row : by_origin)
            counts.legs_by_origin_ids[kind] += row.second.size();
        ++kind;
    }
    counts.immediate_closes_keys = index.immediate_closes_by_bar.size();
    for (const auto& row : index.immediate_closes_by_bar)
        counts.immediate_closes_ids += row.second.size();
    return counts;
}
 
} // namespace pineforge::source::detail
 
namespace pineforge::source {
 
// Storage policy and work counters are derived observers, outside broker
// state. Keep these bodies after the adapter's cited implementation regions.
void PlacementTable::reset_storage_work() noexcept {
    old_only_ = false;
    placement_work_ = 0;
    lookup_work_ = 0;
    removal_work_ = 0;
}
 
void PlacementTable::grow_window(std::size_t index) {
    placement_work_ += static_cast<std::uint64_t>(index + 1U - window_.size());
    window_.resize(index + 1U);
}
 
void PlacementTable::place_old(std::uint64_t incarnation,
                               std::unique_ptr<PlacementSnapshot> node) {
    // Monotone incarnations append; an earlier incarnation still uses the
    // same sorted representation and shifts only the rows above it.
    const auto at = old_.empty() || incarnation > old_.back().first
        ? old_.end()
        : std::lower_bound(old_.begin(), old_.end(), incarnation,
            [this](const auto& entry, std::uint64_t key) {
                ++lookup_work_;
                return entry.first < key;
            });
    placement_work_ += static_cast<std::uint64_t>(old_.end() - at) + 1U;
    old_.emplace(at, incarnation, std::move(node));
}
 
bool PlacementTable::compact_old() noexcept {
    if (!old_only_) return false;
    if (old_.empty()) {
        old_only_ = false;
        base_ = high_water_ + 1U;
    }
    return true;
}
 
} // namespace pineforge::source