if (std::isnan(qty_value)) {

return calc_qty(fill_price);

}

// qty_step_ lot-size flooring applies uniformly regardless of how the

// caller's qty was derived — including this FIXED branch, which is the

// common ``strategy.entry(qty=someComputedExpr)`` shape (e.g. a DCA base/

// safety-order qty = orderSizeUsd/close). See apply_qty_step's doc

// comment (engine.hpp) for the verified TV behavior this mirrors.

if (qty_type < 0 || qty_type == static_cast<int>(QtyType::FIXED)) {

return apply_qty_step(qty_value);

}

if (qty_type == static_cast<int>(QtyType::PERCENT_OF_EQUITY)) {

const double equity =

percent_commission_live_equity(current_bar_.close);

if (!std::isfinite(equity)) return 0.0;

double cash = reserve_percent_commission(equity * (qty_value / 100.0));

// Reject (qty 0) on a non-finite / non-positive fill price — a degenerate

// $0/NaN print must NOT size as the raw % number (silent wrong-qty bug).

// One contract's currency exposure is fill_price × pointvalue (1.0 for

// crypto/equity — legacy math unchanged; futures divide the budget by

// the full per-contract notional). cash is account-currency (equity is);

// convert to quote currency via account_currency_fx_ before dividing by

// the quote-currency fill_price — same convention as calc_qty() in

// engine.hpp. fx=1.0 is a no-op.

return (std::isfinite(fill_price) && fill_price > 0.0)

? apply_qty_step((cash / active_account_currency_fx())

/ (fill_price * syminfo_.pointvalue)) : 0.0;

}

if (qty_type == static_cast<int>(QtyType::CASH)) {

return (std::isfinite(fill_price) && fill_price > 0.0)

? apply_qty_step((qty_value / active_account_currency_fx())

/ (fill_price * syminfo_.pointvalue)) : 0.0;

}

return apply_qty_step(qty_value);

double explicit_qty, int explicit_qty_type,

PositionSide created_position_side,

bool close_only_opposite,

bool is_priced_entry,

double tv_carry_qty,

int created_bar,

bool later_same_tick_entry,

bool paired_flat_market_transaction,

bool explicit_qty_prequantized,

uint64_t entry_incarnation) {

// Degenerate-bar guard: never open a position at a non-finite fill price

// (e.g. a NaN/Inf print). Dropping the fill keeps trade output finite and

// a single bad tick from poisoning the backtest. Clean feeds never hit this.

if (!std::isfinite(fill_price)) return;

PositionSide requested = is_long ? PositionSide::LONG : PositionSide::SHORT;

bool is_opposite_entry = position_side_ != PositionSide::FLAT && position_side_ != requested;

bool direction_blocked =

(risk_direction_ == RiskDirection::LONG_ONLY && !is_long)

|| (risk_direction_ == RiskDirection::SHORT_ONLY && is_long);

if (is_opposite_entry && direction_blocked) {

double exit_fill = apply_slippage(fill_price, position_side_ == PositionSide::SHORT);

execute_market_exit(exit_fill);

if (!paired_flat_market_transaction) purge_exit_orders();

return;

}

// Check risk rules before allowing entry

if (!check_risk_allow_entry(is_long)) return;

// Apply slippage: buy fills higher, sell fills lower. LIMIT-triggered

// fills (current_fill_is_limit_) take the unslipped limit-or-better

// path instead — TV does not slip limit fills.

fill_price = apply_fill_slippage(fill_price, is_long);

if (position_side_ == PositionSide::FLAT) {

enter_market_from_flat(id, is_long, fill_price, explicit_qty, explicit_qty_type,

created_position_side, is_priced_entry, tv_carry_qty,

created_bar,

/*explicit_qty_prequantized=*/

(explicit_qty_prequantized

|| paired_flat_market_transaction),

entry_incarnation);

return;

}

if (position_side_ == requested) {

add_to_pyramid_market(id, is_long, fill_price, explicit_qty, explicit_qty_type,

created_position_side, is_priced_entry,

entry_incarnation);

return;

}

if (created_position_side == PositionSide::FLAT && close_only_opposite) {

close_opposite_then_enter(

id, is_long, fill_price, explicit_qty, explicit_qty_type,

/*purge_pending_exits=*/!paired_flat_market_transaction,

/*explicit_qty_prequantized=*/

(explicit_qty_prequantized

|| paired_flat_market_transaction),

entry_incarnation);

return;

}

if (later_same_tick_entry) {

sequential_same_tick_reversal_fill(id, is_long, fill_price, explicit_qty,

explicit_qty_type,

entry_incarnation);

return;

}

// ``close_only_opposite`` reaches here for a created_position_side != FLAT

// reduce-only flip (the FLAT bracket case returned above via

// close_opposite_then_enter). This is either a deferred-flip carry that

// reverses a later position cycle, or the equality-only same-cycle frozen

// transaction whose whole broker movement is consumed by the close. Both

// close the live opposite position without opening their own leg.

flip_market_position_to(id, is_long, fill_price, explicit_qty, explicit_qty_type,

explicit_qty_prequantized,

/*close_only=*/close_only_opposite,

entry_incarnation);

if (position_side_ == PositionSide::FLAT) {

return;

}

// Apply slippage: closing long = sell (lower), closing short = buy

// (higher). LIMIT-triggered exits (TP brackets) take the unslipped

// limit-or-better path via apply_fill_slippage.

bool is_buy = (position_side_ == PositionSide::SHORT);

fill_price = apply_fill_slippage(fill_price, is_buy);

bool was_long = (position_side_ == PositionSide::LONG);

// Emit one Trade per pyramid entry (matches TradingView reporting)

for (auto& pe : pyramid_entries_) {

emit_close_trade(pe, pe.qty, fill_price, was_long);

}

reset_position_state_to_flat();

double fill_price, bool was_long) {

double qty_closed = 0.0;

std::vector<PyramidEntry> remaining;

for (auto& pe : pyramid_entries_) {

bool eligible = (from_entry == nullptr) || (pe.entry_id == *from_entry);

if (!eligible || qty_closed >= qty_limit - kQtyEpsilon) {

remaining.push_back(pe);

continue;

}

double close_qty = std::min(pe.qty, qty_limit - qty_closed);

double keep_qty = pe.qty - close_qty;

qty_closed += close_qty;

emit_close_trade(pe, close_qty, fill_price, was_long);

if (keep_qty > kQtyEpsilon) {

// Scale the accumulated USD excursion to the kept slice so the

// remaining entry's extremes stay consistent with its reduced

// qty (update_per_trade_extremes accumulates (diff) * pe.qty).

double keep_scale = keep_qty / pe.qty;

PyramidEntry kept = pe;

kept.qty = keep_qty;

kept.max_runup *= keep_scale;

kept.max_drawdown *= keep_scale;

// Percent and per-contract fees follow the surviving quantity.

// CASH_PER_ORDER remains one fee for the accepted entry order,

// matching calc_commission's established qty-independent shape.

if (std::isfinite(kept.entry_commission_account)

&& commission_type_ != CommissionType::CASH_PER_ORDER) {

kept.entry_commission_account *= keep_scale;

}

remaining.push_back(std::move(kept));

}

}

pyramid_entries_ = std::move(remaining);

position_qty_ -= qty_closed;

return qty_closed;

double fill_price, double qty_to_close, PositionReductionCause cause) {

if (position_side_ == PositionSide::FLAT || pyramid_entries_.empty()) return;

const double qty_before = position_qty_;

qty_to_close = std::clamp(qty_to_close, 0.0, position_qty_);

if (qty_to_close <= kQtyEpsilon) return;

bool is_buy = (position_side_ == PositionSide::SHORT);

fill_price = apply_fill_slippage(fill_price, is_buy);

bool was_long = (position_side_ == PositionSide::LONG);

// Close FIFO across all pyramid entries, creating trade records.

fifo_drain(/*from_entry=*/nullptr, qty_to_close, fill_price, was_long);

settle_position_after_partial_exit(qty_before, cause);

PositionReductionCause cause) {

if (position_side_ == PositionSide::FLAT || pyramid_entries_.empty()) return;

double pct = std::clamp(qty_percent, 0.0, 100.0);

double qty_to_close = position_qty_ * (pct / 100.0);

// Percent-derived partial exit resolved at FILL time (an exit placed

// while still FLAT carries no reserved qty): floor the lot to the

// instrument qty step exactly like the placement-time path in

// compute_exit_reserved_qty — see apply_exit_qty_step for the TV

// dust-remainder evidence. Full exits (pct == 100%) stay exact.

if (pct < 100.0 - kFullPercentEps) {

qty_to_close = apply_exit_qty_step(qty_to_close);

}

execute_partial_exit_qty(fill_price, qty_to_close, cause);

const std::string& from_entry,

PositionReductionCause cause) {

if (position_side_ == PositionSide::FLAT || pyramid_entries_.empty()) return;

const double qty_before = position_qty_;

bool is_buy = (position_side_ == PositionSide::SHORT);

fill_price = apply_fill_slippage(fill_price, is_buy);

bool was_long = (position_side_ == PositionSide::LONG);

std::vector<PyramidEntry> remaining;

for (auto& pe : pyramid_entries_) {

if (pe.entry_id == from_entry) {

emit_close_trade(pe, pe.qty, fill_price, was_long);

position_qty_ -= pe.qty;

} else {

remaining.push_back(pe);

}

}

pyramid_entries_ = std::move(remaining);

settle_position_after_partial_exit(qty_before, cause);

double fill_price, const std::string& from_entry, double qty_to_close,

PositionReductionCause cause) {

if (position_side_ == PositionSide::FLAT || pyramid_entries_.empty()) return;

if (!std::isfinite(qty_to_close) || qty_to_close <= kQtyEpsilon) return;

const double qty_before = position_qty_;

bool is_buy = (position_side_ == PositionSide::SHORT);

fill_price = apply_fill_slippage(fill_price, is_buy);

bool was_long = (position_side_ == PositionSide::LONG);

fifo_drain(&from_entry, qty_to_close, fill_price, was_long);

settle_position_after_partial_exit(qty_before, cause);

const std::string& from_entry,

double qty_percent,

PositionReductionCause cause) {

if (position_side_ == PositionSide::FLAT || pyramid_entries_.empty()) return;

double matched_qty = 0.0;

for (const auto& pe : pyramid_entries_) {

if (pe.entry_id == from_entry) matched_qty += pe.qty;

}

if (matched_qty <= kQtyEpsilon) return;

double pct = std::clamp(qty_percent, 0.0, 100.0);

double qty_to_close = matched_qty * (pct / 100.0);

if (qty_to_close <= kQtyEpsilon) return;

execute_partial_exit_by_entry_qty(fill_price, from_entry, qty_to_close, cause);

double fill_price,

PositionReductionCause cause) {

if (order.from_entry.empty()) return 0.0;

if (position_side_ == PositionSide::FLAT || pyramid_entries_.empty()) return 0.0;

// Scope to a PRICED bracket (stop/limit/trail). A plain market close /

// close_all already flattens the whole position through its own path.

bool priced_bracket = !std::isnan(order.stop_price)

|| !std::isnan(order.limit_price)

|| !std::isnan(order.trail_points)

|| !std::isnan(order.trail_price);

if (!priced_bracket) return 0.0;

const double qty_before = position_qty_;

bool is_buy = (position_side_ == PositionSide::SHORT);

double slipped = apply_fill_slippage(fill_price, is_buy);

bool was_long = (position_side_ == PositionSide::LONG);

std::vector<PyramidEntry> remaining;

remaining.reserve(pyramid_entries_.size());

double closed = 0.0;

for (auto& pe : pyramid_entries_) {

if (pe.market_pyramid_add

&& pe.entry_bar_index == bar_index_

&& pe.entry_id == order.from_entry) {

emit_close_trade(pe, pe.qty, slipped, was_long);

closed += pe.qty;

} else {

remaining.push_back(pe);

}

}

if (closed <= kQtyEpsilon) return 0.0; // nothing covered

pyramid_entries_ = std::move(remaining);

position_qty_ -= closed;

settle_position_after_partial_exit(qty_before, cause);

return closed;

if (oca_name.empty()) return;

pending_orders_.erase(

std::remove_if(pending_orders_.begin(), pending_orders_.end(),

[&](const PendingOrder& o) {

return o.oca_name == oca_name && o.id != exclude_id;

}),

pending_orders_.end());

const std::string& exclude_id,

double filled_qty) {

if (oca_name.empty()) return;

if (!(filled_qty > 0.0)) return; // nothing to subtract

pending_orders_.erase(

std::remove_if(pending_orders_.begin(), pending_orders_.end(),

[&](PendingOrder& o) {

if (o.oca_name != oca_name || o.id == exclude_id) return false;

if (std::isnan(o.qty)) return true; // default-sized: cancel

o.qty -= filled_qty;

return o.qty <= kOcaQtyEpsilon;

}),

pending_orders_.end());

if (retain_for_pending_entries) {

// End-of-bar flat-purge: the position is flat, but a from_entry-bound

// EXIT bracket whose parent ENTRY is still a PENDING order (e.g. a limit

// entry that could not fill on its creation bar) must be RETAINED — once

// the entry fills on a later bar the bracket fires, matching TV. Only

// brackets with no live/pending parent entry are stale and dropped.

std::unordered_set<std::string> pending_entry_ids;

for (const auto& o : pending_orders_) {

if (o.type == OrderType::ENTRY || o.type == OrderType::MARKET) {

pending_entry_ids.insert(o.id);

}

}

pending_orders_.erase(

std::remove_if(pending_orders_.begin(), pending_orders_.end(),

[&](const PendingOrder& o) {

return o.type == OrderType::EXIT

&& !(!o.from_entry.empty()

&& pending_entry_ids.count(o.from_entry));

}),

pending_orders_.end());

return;

}

pending_orders_.erase(

std::remove_if(pending_orders_.begin(), pending_orders_.end(),

[](const PendingOrder& o) { return o.type == OrderType::EXIT; }),

pending_orders_.end());

double fill_price, bool was_long) {

// Realized PnL scales by the instrument point value ($ per point per

// contract). Crypto/equity (pointvalue=1) is unchanged; futures (e.g. ES=50)

// multiply the price-difference PnL. The price-difference component is in

// the symbol's QUOTE currency; multiply by account_currency_fx_ (default

// 1.0, no-op for the corpus) to report in the strategy's ACCOUNT currency

// — same conversion the margin gate (engine_strategy_commands.cpp) already

// applies. Commission is already account-currency-native (calc_commission

// applies the same fx factor internally for its PERCENT case; cash-per-*

// is account-currency by construction), so it is NOT scaled again here.

const double pv = syminfo_.pointvalue;

double pnl = (was_long ? (fill_price - pe.price) : (pe.price - fill_price))

* close_qty * pv * active_account_currency_fx();

const double entry_commission = calc_commission(pe.price, close_qty);

const double exit_commission = calc_commission(fill_price, close_qty);

pnl -= entry_commission + exit_commission;

// TV "Net P&L %" convention (arbitrated 2026-06-12 vs TV export,

// trade #258 short: 102.44 USD on 2276.66 entry => 4.50%): NET pnl

// as a percent of entry cost (entry_price * qty * pointvalue, same

// account_currency_fx_ conversion as pnl above so the ratio is

// currency-invariant). Long/no-commission degenerates to the old

// (exit/entry-1) form; shorts diverge on large moves ((entry/exit-1)

// was wrong). Computed AFTER the commission subtraction above — order

// matters.

const double entry_cost = pe.price * close_qty * pv

* active_account_currency_fx();

double pnl_pct = (entry_cost > 0.0) ? (pnl / entry_cost) * 100.0 : 0.0;

Trade trade;

trade.entry_time = pe.time;

trade.exit_time = current_bar_.timestamp;

trade.entry_price = pe.price;

trade.exit_price = fill_price;

trade.qty = close_qty;

trade.pnl = pnl;

trade.pnl_pct = pnl_pct;

trade.is_long = was_long;

trade.entry_bar_index = pe.entry_bar_index;

trade.exit_bar_index = bar_index_;

trade.entry_id = pe.entry_id;

trade.entry_incarnation = pe.entry_incarnation;

trade.entry_comment = pe.entry_comment;

trade.commission = entry_commission + exit_commission;

// Excursions: TV's per-trade excursion includes the exit fill itself —

// a stop-out's adverse excursion is at least the loss at the SL fill and

// a take-profit's favorable excursion includes the move to the TP fill.

// The per-bar sampler (update_per_trade_extremes) cannot see this: exit

// fills happen inside process_pending_orders and the pyramid entry is

// removed before the next sample, so same-bar entry+exit trades would

// otherwise report 0/0. Fold the fill price in here. The carried

// per-entry extreme is scaled to the closed slice (close_qty/pe.qty) so

// a partial close reports the slice's USD excursion, matching TV's

// per-trade-record qty. Both fields stay >= 0 (Pine accessor convention);

// the TV-export sign flip happens only in the CSV writer.

double slice = (pe.qty > kQtyEpsilon) ? (close_qty / pe.qty) : 1.0;

double fill_fav = (was_long ? (fill_price - pe.price) : (pe.price - fill_price))

* close_qty;

double runup = std::max(pe.max_runup * slice, fill_fav);

double drawdown = std::max(pe.max_drawdown * slice, -fill_fav);

// Priced (stop/limit/trail) exits fill mid-bar: the bar-path extremes the

// assumed OHLC path reaches BEFORE the exit fill belong to this trade's

// excursion, but per-bar sampling never sees them (the entry is removed

// before the next update_per_trade_extremes). Fold them in here, honoring

// the entry-side masks when the trade opened on this same bar (an extreme

// that precedes the ENTRY fill is not part of the trade either).

// TRAIL fills: the peak that armed the trail (fill +/- offset) is a

// pre-fill favorable excursion no bar-boundary sample sees (TV reports

// MFE == peak for trail exits).

if (!std::isnan(fold_exit_trail_peak_)) {

double peak_fav = (was_long ? (fold_exit_trail_peak_ - pe.price)

: (pe.price - fold_exit_trail_peak_))

* close_qty;

runup = std::max(runup, peak_fav);

}

if (fold_exit_path_extremes_) {

double fill_pos = 0.0;

if (internal::first_touch_position(current_bar_, fill_price, &fill_pos)) {

const bool high_first = internal::bar_path_uses_high_first(current_bar_);

const double high_pos = high_first ? 1.0 : 2.0;

const double low_pos = high_first ? 2.0 : 1.0;

const bool same_bar = (pe.entry_bar_index == bar_index_);

if (high_pos < fill_pos && !(same_bar && pe.skip_entry_bar_high)) {

double hi_fav = (was_long ? (current_bar_.high - pe.price)

: (pe.price - current_bar_.high)) * close_qty;

runup = std::max(runup, hi_fav);

drawdown = std::max(drawdown, -hi_fav);

}

if (low_pos < fill_pos && !(same_bar && pe.skip_entry_bar_low)) {

double lo_fav = (was_long ? (current_bar_.low - pe.price)

: (pe.price - current_bar_.low)) * close_qty;

runup = std::max(runup, lo_fav);

drawdown = std::max(drawdown, -lo_fav);

}

}

}

// TV reports excursions on the NET OPEN-PROFIT basis: the entry-leg

// commission is deducted from the favorable/adverse extremes (verified

// numerically on pyramid-cash-fractional-commission-01 — TV's exported

// excursions differ from the gross price excursion by exactly

// qty * cash_per_contract on every trade, both columns). Favorable is

// floored at 0 (TV never exports a negative favorable excursion —

// confirmed across all 757k corpus rows); adverse grows by the entry

// commission (open profit at the entry tick is already -commission).

// Both fields remain >= 0 here (Pine positive-drawdown convention).

// runup/drawdown are quote-currency (price-diff × qty); convert to

// account currency via account_currency_fx_ (default 1.0, no-op) before

// combining with entry_commission, which is already account-currency

// (see calc_commission) — same convention as pnl above.

trade.max_runup = std::max(

0.0, runup * pv * active_account_currency_fx() - entry_commission);

trade.max_drawdown = drawdown * pv * active_account_currency_fx()

+ entry_commission;

const double trade_pnl = trade.pnl;

trades_.push_back(std::move(trade));

net_profit_sum_ += trade_pnl;

if (trade_pnl > 0) { gross_profit_sum_ += trade_pnl; win_trades_count_++; }

else if (trade_pnl < 0) { gross_loss_sum_ += trade_pnl; loss_trades_count_++; }

else { ++eventrades_count_; } // strategy.eventrades: exact zero P&L (TV uses == 0)

// Update risk state: intraday PnL and consecutive loss day tracking

intraday_pnl_ += pnl;

if (pnl < 0.0) {

BarTime bt = _decompose_bar_time_chart_tz();

int cur_day = bt.dayofmonth * 100 + bt.month;

if (cur_day != last_loss_day_) {

last_loss_day_ = cur_day;

cons_loss_day_count_++;

}

} else if (pnl > 0.0) {

cons_loss_day_count_ = 0;

}

position_side_ = PositionSide::FLAT;

position_cycle_seq_ = 0;

position_entry_price_ = 0.0;

opening_affordability_pending_ = false;

opening_affordability_eligible_ = false;

commissioned_all_in_market_long_opening_affordability_ = false;

opening_affordability_default_long_reversal_ = false;

close_then_short_opening_requires_adverse_retry_ = false;

commissioned_all_in_market_short_lifecycle_ = false;

default_market_direct_short_reversal_lifecycle_ = false;

opening_affordability_raw_fill_base_ =

std::numeric_limits<double>::quiet_NaN();

position_entry_time_ = 0;

position_qty_ = 0.0;

position_entry_count_ = 0;

position_open_bar_ = -1;

trail_best_price_ = std::numeric_limits<double>::quiet_NaN();

pyramid_entries_.clear();

id_unclosed_qty_.clear();

// Bracket legs live for the POSITION cycle, so the provenance that keeps

// them alive dies exactly here — going flat is what makes a from_entry

// bracket stale and un-fireable against a future same-id position.

cycle_filled_entry_ids_.clear();

close_reserved_qty_.clear();

close_two_call_first_qty_.clear();

callsite_close_reserved_qty_.clear();

callsite_close_two_call_first_qty_.clear();

consumed_partial_exit_ids_.clear();

double qty_before, PositionReductionCause cause) {

if (position_qty_ <= kQtyEpsilon || pyramid_entries_.empty()) {

reset_position_state_to_flat();

} else {

double total_qty = 0, weighted_sum = 0;

for (auto& pe : pyramid_entries_) {

weighted_sum += pe.price * pe.qty;

total_qty += pe.qty;

}

position_entry_price_ = weighted_sum / total_qty;

// TV returns a pyramid slot when the entry is retired by a close-path

// order — the grid-bot family depends on it (3commas-ena: 1021 fills

// over 64 reused ids, 776 entries between flats under a cap of 200,

// never more than 50 CONCURRENT entries). TV does NOT return the slot

// when the entry is drained by strategy.exit bracket fills

// (thulashimohanr 2026-03-29: the 03-26 entry was fully retired by two

// T1 fills and TV still refused the third entry).

if (cause == PositionReductionCause::BRACKET_EXIT) {

position_entry_count_ =

std::max(position_entry_count_, (int)pyramid_entries_.size());

} else {

position_entry_count_ = (int)pyramid_entries_.size();

}

// The one-contract floor-zero rule belongs to an otherwise unmodified

// commissioned all-in short lifecycle. Any script-driven surviving

// reduction changes that shape. Broker margin-call reductions are the

// sole exception: TV preserves the lifecycle across its own cascade.

if (cause != PositionReductionCause::MARGIN_CALL

&& position_side_ == PositionSide::SHORT

&& position_qty_ + kQtyEpsilon < qty_before) {

commissioned_all_in_market_short_lifecycle_ = false;

default_market_direct_short_reversal_lifecycle_ = false;

}

}

double qty, const std::string& id,

uint64_t entry_incarnation) {

position_side_ = requested;

position_cycle_seq_ = next_position_cycle_seq_++;

position_entry_price_ = fill_price;

// The shared post-dispatch lifecycle hook queues the new fill's event.

// Clear prior-cycle provenance now so reversals cannot expose it even

// transiently.

opening_affordability_pending_ = false;

opening_affordability_eligible_ = false;

commissioned_all_in_market_long_opening_affordability_ = false;

opening_affordability_default_long_reversal_ = false;

close_then_short_opening_requires_adverse_retry_ = false;

commissioned_all_in_market_short_lifecycle_ = false;

default_market_direct_short_reversal_lifecycle_ = false;

opening_affordability_raw_fill_base_ =

std::numeric_limits<double>::quiet_NaN();

position_entry_time_ = current_bar_.timestamp;

position_qty_ = qty;

position_entry_count_ = 1;

position_open_bar_ = bar_index_;

trail_best_price_ = fill_price;

pyramid_entries_.clear();

id_unclosed_qty_.clear();

cycle_filled_entry_ids_.clear();

close_reserved_qty_.clear();

close_two_call_first_qty_.clear();

callsite_close_reserved_qty_.clear();

callsite_close_two_call_first_qty_.clear();

consumed_partial_exit_ids_.clear();

pyramid_entries_.push_back({fill_price, current_bar_.timestamp, qty, id, bar_index_});

pyramid_entries_.back().entry_incarnation = entry_incarnation;

snapshot_entry_commission(pyramid_entries_.back());

id_unclosed_qty_[id] += qty;

cycle_filled_entry_ids_.insert(id);

PositionSide created_position_side,

int created_bar) {

for (auto& other : pending_orders_) {

if (other.id == id) continue;

if (other.created_position_side != created_position_side) continue;

if (other.tv_carry_qty <= 0.0) continue;

// Cycle-scope: only consume siblings placed no later than the

// firing order's own placement. Siblings placed in a LATER bar

// captured carry from a DIFFERENT source position cycle and own

// their carry — TV does not pre-emptively wipe them.

if (other.created_bar > created_bar) continue;

other.tv_carry_qty = 0.0;

}

double fill_price, double explicit_qty,

int explicit_qty_type,

PositionSide created_position_side,

bool is_priced_entry, double tv_carry_qty,

int created_bar,

bool explicit_qty_prequantized,

uint64_t entry_incarnation) {

const bool carry_was_long =

created_position_side == PositionSide::LONG;

const bool tv_deferred_flip =

is_priced_entry

&& tv_carry_qty > 0.0

&& (carry_was_long ? !is_long : is_long);

double base_qty = explicit_qty_prequantized

? explicit_qty

: calc_qty_for_type(fill_price, explicit_qty, explicit_qty_type);

double qty = tv_deferred_flip ? (tv_carry_qty + base_qty) : base_qty;

if (tv_deferred_flip) {

consume_tv_carry_from_siblings(id, created_position_side, created_bar);

}

// NOTE: for EXPLICIT-qty market entries the margin check is performed at

// SIGNAL time inside strategy_entry / queue_deferred_close_order, NOT here

// at fill time. This matches TV's broker emulator, which rejects entries

// whose qty * SIGNAL_BAR_CLOSE exceeds equity. By the time we reach this

// fill-side helper such an order has already been admitted (or rejected)

// at signal time, and the next-bar slippage between signal close and fill

// open should NOT flip a TV-accepted entry into a reject. The empirical

// base — parity-probe-{03..06} + ies-probe-08 — is entirely explicit-qty /

// pct<100 / headroom sizing, so the claim is scoped to it. The one FROZEN

// default-sized carve-out that TV DOES re-check and drop at fill (a

// percent==100, zero-commission, true-flat above-lot gap) is handled by

// the gap-reject gate in apply_filled_order_to_state, upstream of this

// helper — a dropped order never reaches enter_market_from_flat.

PositionSide requested = is_long ? PositionSide::LONG : PositionSide::SHORT;

open_fresh_position(requested, fill_price, qty, id, entry_incarnation);

double fill_price, double explicit_qty,

int explicit_qty_type,

PositionSide created_position_side,

bool is_priced_entry,

uint64_t entry_incarnation) {

PositionSide requested = is_long ? PositionSide::LONG : PositionSide::SHORT;

bool flat_armed_priced =

is_priced_entry && created_position_side == PositionSide::FLAT;

bool pre_armed_opposite_priced =

is_priced_entry

&& created_position_side != PositionSide::FLAT

&& created_position_side != requested;

if (!flat_armed_priced && !pre_armed_opposite_priced

&& position_entry_count_ >= pyramiding_) {

return;

}

double new_qty = calc_qty_for_type(fill_price, explicit_qty, explicit_qty_type);

// Zero-lot add safety net. The fill kernel (apply_filled_order_to_state's

// zero-lot decline) consumes such an order before it reaches here; should

// any path bypass that gate, never materialize a qty-0 pyramid lot nor

// spend a pyramiding slot on it — TV does not place the order at all.

if (!(new_qty > kQtyEpsilon)) return;

double total_qty = position_qty_ + new_qty;

position_entry_price_ = (position_entry_price_ * position_qty_ + fill_price * new_qty) / total_qty;

position_qty_ = total_qty;

position_entry_count_++;

trail_best_price_ = fill_price;

pyramid_entries_.push_back({fill_price, current_bar_.timestamp, new_qty, id, bar_index_});

pyramid_entries_.back().entry_incarnation = entry_incarnation;

snapshot_entry_commission(pyramid_entries_.back());

// KI-62: only a same-direction MARKET add is scratched by a same-bar

// from_entry bracket exit; a priced pyramid add is not this collision.

pyramid_entries_.back().market_pyramid_add = !is_priced_entry;

id_unclosed_qty_[id] += new_qty;

cycle_filled_entry_ids_.insert(id);

double fill_price, double explicit_qty,

int explicit_qty_type,

bool purge_pending_exits,

bool explicit_qty_prequantized,

uint64_t entry_incarnation) {

double tx_qty = explicit_qty_prequantized

? explicit_qty

: calc_qty_for_type(fill_price, explicit_qty, explicit_qty_type);

double close_qty = std::min(tx_qty, position_qty_);

// execute_partial_exit_qty applies slippage internally (mirrors its other

// callers, e.g. execute_partial_exit_by_percent). Pass the RAW fill_price —

// pre-slipping here would double-slip the close leg (issue #27).

execute_partial_exit_qty(fill_price, close_qty);

// The ordinary close-only-opposite path historically purges stale exits.

// A confirmed same-source flat MARKET pair is different: both transaction

// legs execute inside process_pending_orders, where erasing the vector

// would invalidate the active order reference and filled-index ledger.

// Its stale exits follow flip_market_position_to's safe next-pass cleanup.

if (purge_pending_exits) purge_exit_orders();

double remainder = tx_qty - close_qty;

if (remainder <= kQtyEpsilon) {

return;

}

fill_price = apply_fill_slippage(fill_price, is_long);

PositionSide requested = is_long ? PositionSide::LONG : PositionSide::SHORT;

open_fresh_position(

requested, fill_price, remainder, id, entry_incarnation);

double fill_price, double explicit_qty,

int explicit_qty_type,

bool explicit_qty_prequantized,

bool close_only,

uint64_t entry_incarnation) {

// For the close we need exit slippage based on closing direction.

// Closing a long = sell (price - slip); closing a short = buy (price + slip).

// fill_price already has entry slippage applied; un-slip it before

// re-applying with the exit direction.

double raw_price = fill_price;

if (slippage_ != 0 && !current_fill_is_limit_) {

// LIMIT-triggered entry fills were never slipped (limit-or-better

// path), so there is no entry slip to back out for the close leg.

double slip = slippage_ * syminfo_mintick_;

raw_price = is_long ? (fill_price - slip) : (fill_price + slip);

}

// Flag-aware close leg: a limit-triggered flip's close leg follows the

// entry leg's limit semantics (unslipped, limit-or-better) for internal

// consistency with the sibling close_opposite_then_enter path — both

// legs land at the identical unslipped snapped price. No direct TV

// evidence yet (needs a limit-flip slippage>0 export) — corpus provably

// indifferent at slippage=0.

double exit_fill = apply_fill_slippage(raw_price, position_side_ == PositionSide::SHORT);

bool was_long = (position_side_ == PositionSide::LONG);

// Emit one Trade per pyramid entry (matches TradingView reporting)

for (auto& pe : pyramid_entries_) {

emit_close_trade(pe, pe.qty, exit_fill, was_long);

}

// The old lots are fully realized above. Clear their live position/PnL

// and entry-fee snapshots before sizing the incoming leg; otherwise a

// percent-typed reversal adds stale open PnL and debits the already-

// realized entry commission a second time.

reset_position_state_to_flat();

if (close_only) {

// Priced-entry reduce-only cases: either this order was armed during a

// prior cycle and flips a later opposite position, or its same-cycle

// frozen transaction exactly equals the grown live opposite position.

// In both cases close the whole position and stay flat; do NOT open.

// See apply_entry_order_fill's close_only_opposite predicates.

return;

}

// Default-sized MARKET quantities are frozen and exchange-quantized at

// signal time. Every sibling dispatch path preserves that provenance;

// ordinary flips must not feed the frozen contracts through qty_step a

// second time (binary64 can turn 1.3410 into 1.3409 on the second floor).

// Explicit/FIXED quantities keep their normal single fill-side floor.

double new_qty = explicit_qty_prequantized

? explicit_qty

: calc_qty_for_type(fill_price, explicit_qty, explicit_qty_type);

PositionSide requested = is_long ? PositionSide::LONG : PositionSide::SHORT;

open_fresh_position(requested, fill_price, new_qty, id, entry_incarnation);