round 7e: trail fills snap directionally at sub-tick opens, trail_points/offset tick rounding, trail activation on the quantized bar, Pine tolerant compare inside ta.dmi - #184

…nd7/candidate-d

…own / down>up / up>0

TradingView's Pine float relationals treat two finite values as EQUAL when
|a - b| <= 1e-10 — an absolute, magnitude-independent band, inclusive at
exactly 1e-10 — and its builtins decide on the same predicate. Inside
ta.dmi the `up > down and up > 0` selection therefore books NEITHER
directional movement on an exact-decimal tie, where the engine's strict
IEEE compare handed the move to one side.

Pin (round 7 family K, boztilkiserhan serhan-1 wma-adx-trailing NYSE:F@15,
campaign notes log-20260905t084532z-25b09a71 and log-20260905t085626z-aff373d2):
  * scratchpad/r7/pins/f15-plusdm-perbar-0714 (one qty-encoded lot per bar
    over 2025-07-14..18) locates the single differing bar: 07-15 19:30Z,
    up = 11.58 - 11.565, down = 11.54 - 11.525, both 0.015 in decimal and
    1.78e-15 apart as doubles; TV's plusDM is 0.
  * f15-dmi-internals-0718 / f15-wma-adx-sense-0718 (+ two history starts):
    TV rma(plusDM,18) 0.006907 vs strict 0.006939, +DI 16.92562 vs
    17.00417, ADX 24.22236 vs 23.571 at the 07-18 14:15Z signal — the bar
    whose ADX > 24 short fires on TV only. Replaying the registry 15m bars
    with the tolerant compare gives 0.006907 / 16.9256 / 24.2223.
  * f15-eps-{abs,rel} (20 decisions, this session) pin the band itself:
    equal for d = 1e-11..1e-14 at 11.5, 1e-10 vs 0 EQUAL (inclusive),
    1.1e-10 vs 0 greater, a relative 1e-11 diff greater at m >= 100 —
    bit-for-bit the codegen's KI-73 predicate (visit_expr.py
    _emit_float_relational).

include/pineforge/pine_float_compare.hpp carries the predicate (pine_float_
eq/ne/gt/lt/ge/le, na -> false); ta.percentrank's src[i] <= src, which
already used a private copy of the band, reads the shared constant.

Surveyed and left alone (unpinned): ta.supertrend's close vs band and band
carry compares, ta.sar's high/low vs sar/ep, ta.mfi's src vs src[1] — the
same shape on derived doubles but no tape yet; ta.crossover/crossunder/
cross stay strict (round 7 family D pin: the cross decides on the exact
sign of the residual); obv/wad/pivot compare raw prints where the band
cannot matter.

tests/test_dmi_parity.cpp: the 07-15 19:30Z tie -> +DI = -DI = 0, clear
differences unchanged, the up > 0 band, and the 20 sensor decisions.

Co-Authored-By: Claude Fable 5.1 <[email protected]>
Claude-Session: https://claude.ai/code/session_01FhcjTNYXowGbf116WBsgLF

…best kept)

TradingView tests a trailing stop's ACTIVATION (trail_points / trail_price)
against the bar's OHLC quantized to the tick — the round-6 stop / limit
trigger rule (design-stop-tick-rounding) extended to the trail's arming —
while the trail's running best stays the raw print (round 5). The engine
tested the raw bar, so a sub-tick extreme that TradingView reads as
touching the level left the trail dormant and slid the exit 1-4 bars.

Pin (round 7 family K, boztilkiserhan serhan-1 wma-adx-trailing NYSE:F@15,
campaign note log-20260905t084531z-57cedc55): three `lab tv` tapes on
NYSE:F 15m 2025-04-10..18, fixed 100 shares, scratchpad/r7/pins/
f15-trail-0415-{reissue,fixed760,fixed754} — a short entered 04-15 14:45Z
@9.49 with strategy.exit(trail_points = close * 0.008 / syminfo.mintick,
trail_offset = 0) re-issued every bar, or fixed 7.60 / 7.54 ticks (all
ceil to 8 -> activation 9.41) — ALL exit on the 15:45Z bar @9.41. That
bar's raw low is 9.415 (> 9.41: the engine's no-activate, exit slid to
16:45Z) and its quantized low is 9.41 (9.415 is 9.41499.. in binary),
which reaches the activation; offset 0 exits one-shot at the level. The
same slide shows on 06-20 (15:30Z vs 19:45Z) and 2026-01-21 (15:30Z vs
16:15Z) and on the serhan1 wma-rsi sibling (exitP90 0.0064 residual).

engine_path_resolve.cpp:
  * a dormant exit-at-activation trail's activation reach is found on the
    tick-quantized path segment (select_exit_segment_levels reports it
    apart from an ACTIVE trail's level, which stays on the raw path;
    collect_cross_events_split gains the trail_activation_level leg);
  * update_exit_trail_state arms on the quantized segment end while the
    running best takes the raw end;
  * compute_exit_trail_state reads the carried raw best tick-quantized for
    the arming test (the broker read the bars that produced it).
  The open-gap test (try_exit_open_gap_fill) is untouched — unpinned, and
  owned by round7/trail-fill-snap. The round-6 stopround-xt-L-trail pin
  (raw best: a quantized 14.04 would have printed 14.01 where TradingView
  exits at the next open) still holds — test_stop_tick_rounding passes.

tests/test_trail_activation_tick_bar.cpp: the three tapes replayed on the
registry 15m bars (exit 15:45Z @9.41 — was 16:45Z), a 9-tick control that
must NOT fire, and resolver-level pins (activation on the tick leg with
its chronology, an offset trail arming on the quantized extreme and
trailing the raw best, the carried best read quantized, a raw reach
unchanged).

Co-Authored-By: Claude Fable 5.1 <[email protected]>
Claude-Session: https://claude.ai/code/session_01FhcjTNYXowGbf116WBsgLF

…egistry NYSE:F bars)

Round 7 family K mechanism 3 (mukhlisilahi universal-backtest-pro NYSE:F@15,
campaign note log-20260905t084530z-66c3f27e) diagnosed the probe's chart
EMAs as running on the 15m AGGREGATE close of
  [o, h, l, c, v] = request.security(syminfo.tickerid, tf_input,
                                     [open, high, low, close, volume])
instead of TradingView's native 1D close (77/77 TV entries reproduce with
the native close, 76/77 engine entries with the aggregate), and named the
engine's tuple path as the suspect.

The engine's tuple path is NOT the defect. The codegen lowers the tuple body
to one evaluator assigning every element from the completed bucket
(`_req_sec_0_3 = bar.close`), and feed_security_input substitutes the native
row (substitute_native_security_bar) before any evaluator is dispatched, so
the scalar and tuple forms read the same bar. This test pins it on the
registry's own prints — NYSE:F 15m 2025-04-22 / 04-23 (feed 80f404ae85ef)
against the exchange's 1D rows (feed e3dd3a88e85b): with the feed installed
the tuple is the native row verbatim under both "D" and "1D" (04-22 close
9.65 where the last 15m print is 9.655; 04-23 9.835 / 10.0054 / 9.71 /
9.78 / 158,691,527 against the aggregate 9.83 / 10.0 / 9.715 / 9.765),
without it the aggregate — the values the probe's runs actually carried.

Why the runs carried the aggregate: the harness routes the native-daily
ladder candidate only when the source names the daily timeframe by LITERAL
("D" / "1D") — pineforge-lab scripts/verify_routing.py
executable_uses_daily_security, whose docstring excludes a variable
timeframe on purpose — and this script's timeframe is
input.timeframe("D") bound to `tf_input`, so the candidate never ran
(verify report db81fe845ec4: no securityFeed field, inputs null -> the
default "D"). The fix is the harness's routing (route an input.timeframe
whose default is daily, or route whenever the lane declares a 1D feed and
the argument is not a non-daily literal); no engine change.

Co-Authored-By: Claude Fable 5.1 <[email protected]>
Claude-Session: https://claude.ai/code/session_01FhcjTNYXowGbf116WBsgLF

…/candidate-e