Pine adapter: limit reach, exit binding, carried trail, margin-call schedule - #341

…or to the pending entry id

TradingView binds a strategy.exit(id, from_entry = X) when the script calls
it: to X's open lots if X holds any, else to the id X while an order of X is
working, else the call is ignored. An exit bound to the id survives a close,
close_all, the flat and a cancel and re-entry of X, and binds to X's next
fill (36 synthetic controls, two byte-identical exports each, and the ten
pending-* tapes of tests/fixtures/global_exit_children). Each part has its own
switch in ExitBindingRuleSwitches, all on:

- pending_bound_exit_survives_flat: an exit called in position for an id
  with no lot but a limit or stop order working is bound to the id
  (PlacementSnapshot::pending_bound_exit, hashed while set, cleared by the
  id's fill). retire_in_position_exits_at_flat and
  cancel_exit_orders_for_full_close leave it; a strategy.cancel of the id's
  order keeps the call (id_bound_exits_, hashed while non-empty) and the
  id's next entry order re-arms it.
- global_exit_binds_working_entries: a global exit called flat waits for
  the fill of the limit and stop entries working instead of ending on the
  flat book.
- resting_stop_entry_survives_close: under process_orders_on_close an
  earlier bar's stop entry survives a close's flat, as a limit does.
- priced_add_at_cap_not_placed: under process_orders_on_close a priced add
  of an id holding no lot, still at the pyramiding cap once its bar's
  closes are done, leaves the book at the next opening; each add is judged
  at that one opening.

Every part acts only with margin requirements off (margin_long =
margin_short = 0) and without calc_on_order_fills, the tapes' setting; the
two exit parts on whole exits at absolute levels whose parent rests at a
level, the stop-entry and cap parts under process_orders_on_close. Inside
these gates the parts also change shapes no tape covers, as the pin's
reference model predicts them: a parent on the other side of the position,
a strategy.order parent, a market re-entry after the cancel, a cancel and
re-entry on the exit's own bar, a short-side cap and a cap above 1. Open
edges without a tape: a stop-limit entry, which the stop part keeps; a
global exit called flat without process_orders_on_close, which also waits,
and its taking by another id's first fill; an add at the cap marketable at
its own close, which fills there before the cap part judges it, as before;
an add whose own bar's close frees the slot, which stays, as before (the
pin's model rejects it at the call). Every witness table keeps its pins.
tests/test_exit_binding_tapes asserts all 36 controls, each part's tapes
with the part off, the engine before the rule with every part off, and
backtest == forward stream on every control both ways. The ten pending-*
tapes are asserted. Doc anchors re-anchored.

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>

…rder

Two TradingView rules, each behind its own default-on, test-only switch.

Carried trail tick reach (PineCallbackLifecycleRule::CarriedTrailTickReach).
With calc_on_order_fills off, a trailing stop carried from an earlier bar is
reached where the bar's tick-built print reaches it; the level stays the raw
running best +/- the offset, as a static stop's does. The kernel's generic
Trail compares the raw path with the raw level, so on_bar_open walks the bar
as the kernel will and, only where the tick-built point comes before the raw
compare's, re-prices the trail's distance for that bar (ride and handle
kept); on_bar_close_before_script restores it. A raw reach whose tick-built
print falls back inside the stop stays the kernel's, as before: no tape
decides that direction. Tape: tests/fixtures/callback_lifecycle/
carried-trail-14 (NYSE:F, 14 ticks behind a 10.345 best, the 10.485 high
prints 10.49 and exits at 17:45, not 18:15); it leaves known_divergences.json
and pins the switch in rule_off_departures.json. test_callback_lifecycle_tapes
also replays it as a bar-by-bar stream with 1 and 30 warm-up bars: the stream
books the backtest's trades and TradingView's rows, and with the switch off
both depart from TradingView the same way.

The walk's copy of the kernel's trailing-stop level is
compat::pine::kernel_trail_stop_level (include/pineforge/compat/pine/
trail_ticks.hpp, header-only). test_kernel_trail_stop_replica holds it, bit
for bit, to native_matching::checked_trail_stop on every best a trail moves
to on the tape's bars, ladder bests in both spellings on four price ticks,
half-tick and off-grid bests, and whole-tick and fractional distances (45,057
levels). The unit includes a source-layer header, so a kernel-only build
skips it.

Trailing exits in the point order
(MarginRuleSwitches::point_order_trailing_exits). A stop or limit leg of a
strategy.exit that also carries trail_points, trail_offset or trail_price
counts as a protective exit at the open, like any other: the gapped stop
fills before the opening margin check. Tapes (lab tv --no-note, 3
byte-identical exports each, predictions written first):
tests/fixtures/admission_rules/point_order_and_book/
gapstop-percent-trail-points and -trail-offset, c2's script with
trail_points (and a trail_offset) on the exit; TradingView books c2's rows
(112 call, 8744 at the 12.26 gap).

No kernel, grader or codegen change; no stream gate. The new adapter state
(the trails re-priced for the bar in flight) is hashed only while set.
Docs: switch table and evidence counts, the callback-lifecycle README, the
row on per-kind tick quantization; doc anchors re-anchored (digit-only).

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>

…th, lagged follow-ups, pending vetoes, frozen reversal closes, adds at the signal close, long-call G + L money

TradingView's margin-call schedule rules, each behind its own default-on,
test-only switch (detail::MarginScheduleSwitches, appended at the header's
end); adapter only, no kernel, grader or codegen change, no stream gate.

- short_call_gate: a short's call of X units at mark p is taken only where
  X p' m > Q p' m - E(p), p' its slipped print (source_margin_units); the
  one-unit band is its one-unit case. An opening checkpoint at a fill keeps
  the earlier rules, and so does the repeat at one price: a
  process_orders_on_close short's open call repeated at its own fill
  (recheck_at_fill), a follow-up the pin calls ungated, is sized ungated
  (submit_margin_call_slice at an already-resolved price).
- short_path_points: a carried process_orders_on_close short (commissioned
  or slipped, nothing resting) is checked at both extremes and the close
  before the script, not at its high alone (walk_short_path_points). It is
  ablated together with close_call_follow_up_at_open: each corrects its own
  bars, and with one off the other's equity error moves a later open call.
- lagged_short_follow_up: after a short's call, the lot-by-lot check at its
  fill with the called units out and unbooked; the last still-short check's
  restore, four times, at the bar's next path point, ungated (fractional lot
  grids; outside process_orders_on_close only where margin_follow_up_units
  does not already follow the call, pinned there by lag/outside-pooc-close
  and lag/outside-pooc-extreme).
- pending_veto_first: a deficit the open's check vetoed is checked at the
  first path point whose segment touches a resting whole exit, before it;
  after a call there the exit fills at that point's print. It stands down
  unless that exit, with the other leg of its strategy.exit, is the book's
  one resting order, the shape its tapes pin.
- frozen_reversal_close: a reversal entry placed at a close where a margin
  call is booked after the script closes the quantity the script saw and
  opens the excess on the other side (resolve_terms).
- add_signal_close: a same-side add's whole-book requirement at the
  tick-built signal close (validate_precommit), at margin 100 only.
- whole_share_lagged_follow_up: a long's lagged follow-up on whole-share
  grids too (lagged_margin_follow_up_units).
- long_call_gain_loss: a commission-free long's one-unit call reads
  initial + (G + L) inside gain_loss_regime(); fee-bearing books keep the
  closed-trade equity (no tape pins them).
- close_call_follow_up_at_open: a process_orders_on_close short's call sized
  at the previous close and executed at the open is followed there once, at
  its own fill: four times the lot-floored shortfall, or one unit under one
  lot of it (margin_follow_up_units).

New durable state (a follow-up owed at a path point, a close's after-script
call) is folded into the adapter state hash only while set.

Tapes: the 67 short-cutoff-gate tapes of tests/fixtures/margin_call_rules are
asserted now (244/266 match; initial/short-s5-minus01, schedule-q9p1305-s5,
-s6 and literals/literal-21 leave the known list), and
tests/fixtures/margin_schedule_rules holds 39 synthetic controls (each exported
twice, byte-identical): 35 match, 4 are listed; every tape also replays as a
stream with identical closed trades, and three mechanism cases on synthetic or
patched bars reach the branches no tape does (the walk's close call owing the
next open, the pending veto on the open's segment and beside a resting
entry). test_margin_open_print_tapes asserts its three tapes to their last
bar (443, 445 and 667 trades). test_margin_rules_forward_replay samples four
more tapes.

Docs: switch table and evidence counts in docs/pine-adapter-kernel-notes.md;
doc anchors re-anchored (digit-only).

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>