fix(security): latch finer-than-chart request.security history reads to calling-bar boundary

request.security(sym, tf, ta.<fn>(...)[k], lookahead=barmerge.lookahead_on)
where tf is FINER than the script/chart TF (e.g. so2TF="5" read from a 15m
chart) fed the read-before-push history-offset machinery (added for #30/#31)
one native-security-period value late instead of one CALLING-bar late: the
security's own aggregator completes R = script_seconds/requested_seconds
times per calling bar, and hist.push() fired (unconditionally on
is_complete) on every one of those completions, so hist[0] silently drifted
to "one security-period behind the LAST completion of THIS calling bar"
instead of "the last completion of the PREVIOUS calling bar".

Add SecurityEvalState::publish_gate_tf_seconds (validate_security_timeframes):
nonzero only for a plain (non-security_lower_tf) request.security whose
target TF is strictly finer than script_tf and evenly divides it. In
feed_security_eval_state's aggregator branch, gate the is_complete flag
passed to evaluate_security() on wall-clock bucket-end alignment with the
script_tf boundary, instead of passing the raw completion flag through
unconditionally. The underlying TA state (compute/recompute dispatch) is
driven by current_sub_bar_count, independent of this flag, so intermediate
completions still advance the indicator correctly -- only the exposed
history buffer's publish cadence changes. No-op (field stays 0) for every
coarser-or-equal-TF security and every request.security_lower_tf call.

3commas-3commas-triple-rsi-dca-long-risk-adjusted-averaging-strategy
(so2Rsi = request.security(sym, "5", ta.rsi(close,7)[1], lookahead=
barmerge.lookahead_on) on a 15m chart): 50.5% -> 100.0% match vs
TradingView (108/108 trades, 100% exact price). Full corpus
(252 strategies) + ctest (77) unchanged: excellent=251/anomaly=1,
tier-for-tier identical to baseline. Spot-checked every other
lookahead_on + history-offset request.security call site in the standard
corpus (6 other slugs, all coarser-than-chart target TFs, e.g. "D"/"W"/
240/60) -- byte-identical engine_trades.csv/engine_verify.json output,
confirming zero blast radius outside this one finer-than-chart case.

Author: luisleo526

include/pineforge/engine.hpp

@@ -1076,6 +1076,39 @@ class BacktestEngine {
         bool lower_tf_use_input = false;
         int lower_tf_input_aggregation_ratio = 1;
         std::vector<Bar> lower_tf_input_buffer;
+        // Plain ``request.security`` (not ``_lower_tf``) with a requested TF
+        // STRICTLY FINER than script_tf (e.g. so2TF="5" read from a 15m
+        // chart): the security's own aggregator completes multiple times
+        // (script_seconds / requested_seconds) per calling/script bar. A
+        // history-offset read (``expr[1]`` inside the security call, see
+        // the ``*_hist`` push/read machinery in codegen) is meant to expose
+        // "the value already confirmed as of the close of the PREVIOUS
+        // calling bar" — i.e. the publish granularity is the CALLING bar,
+        // not the security's own (finer) period. Without this, the
+        // read-before-push ``hist[0]`` gets refreshed on every one of the
+        // R completions inside the current calling bar, so by the time
+        // on_bar() reads it the value has silently drifted to "one
+        // security-period behind the LAST completion of THIS SAME calling
+        // bar" (e.g. the middle of 3 sub-periods) instead of "the last
+        // completion of the PREVIOUS calling bar" — an aliasing bug
+        // confirmed against TradingView-exported trades on a triple-RSI
+        // DCA strategy using so2Rsi = request.security(sym, "5",
+        // ta.rsi(close,7)[1], lookahead=barmerge.lookahead_on) on a 15m
+        // chart (finer target under lookahead + offset).
+        //
+        // When nonzero, this holds the requested TF's duration in seconds
+        // (script_seconds % this == 0 verified at validate time) and gates
+        // ``feed_security_eval_state``'s aggregator branch: only the
+        // completion whose bucket END aligns to a script_tf boundary is
+        // passed through to ``evaluate_security`` as ``is_complete = true``
+        // (letting codegen's ``hist.push()`` fire); all other completions
+        // within the same calling bar are still evaluated (so the
+        // underlying TA state keeps advancing at native/security
+        // resolution) but are passed ``is_complete = false`` so they do not
+        // advance the exposed history buffer. Zero (the default) means "not
+        // applicable" (target TF is coarser than or equal to script_tf, the
+        // already-correct case) and leaves behavior unchanged.
+        int publish_gate_tf_seconds = 0;
     };
 
     std::vector<SecurityEvalState> security_eval_states_;

src/engine_security.cpp

@@ -116,6 +116,7 @@ void BacktestEngine::validate_security_timeframes(const std::string& input_tf) {
         state.lower_tf_use_input = false;
         state.lower_tf_input_aggregation_ratio = 1;
         state.lower_tf_input_buffer.clear();
+        state.publish_gate_tf_seconds = 0;
         if (state.tf.empty()) continue;
 
         int lower_ratio = 0;
@@ -222,6 +223,19 @@ void BacktestEngine::validate_security_timeframes(const std::string& input_tf) {
                 requested_seconds / input_seconds;
             state.lower_tf_ratio = script_seconds / requested_seconds;
             state.lower_tf_seconds = requested_seconds;
+        } else if (!is_calendar_month && script_seconds > 0
+                   && requested_seconds < script_seconds
+                   && script_seconds % requested_seconds == 0) {
+            // Plain request.security with a target TF finer than the
+            // script/chart TF (e.g. so2TF="5" on a 15m chart): the
+            // security's own aggregator completes multiple times per
+            // calling bar. A history-offset read (``expr[1]``) must expose
+            // the value confirmed as of the PREVIOUS calling bar, not
+            // whatever native sub-period last completed inside the
+            // CURRENT calling bar. Gate publication (see
+            // feed_security_eval_state) to only the completion whose
+            // bucket end aligns with a script_tf boundary.
+            state.publish_gate_tf_seconds = requested_seconds;
         }
     }
 }
@@ -405,7 +419,27 @@ void BacktestEngine::feed_security_eval_state(SecurityEvalState& state, const Ba
         if (state.heikinashi) apply_ha(ab.bar, /*commit=*/true);
         state.current_bar = ab.bar;
         state.eval_complete_count++;
-        evaluate_security(state.sec_id, ab.bar, true);
+        // For a plain request.security whose target TF is strictly finer
+        // than script_tf (publish_gate_tf_seconds > 0), the security's own
+        // aggregator completes multiple times per calling/script bar.
+        // Only the completion whose bucket END lands on a script_tf
+        // boundary is "the last completion of THIS calling bar" — that's
+        // the one a history-offset read (``expr[1]``) should latch as
+        // "confirmed as of the previous calling bar" the NEXT time the
+        // calling script reads it. Suppress ``is_complete`` (so codegen's
+        // gated hist.push() does not fire) for every other, intermediate
+        // completion; the underlying TA state keeps advancing regardless
+        // (compute()/recompute() dispatch is driven by
+        // current_sub_bar_count, not by this flag) — only the exposed
+        // history buffer's advance is gated. eval_complete_count/current_bar
+        // bookkeeping above stays driven by the real completion.
+        bool publish = true;
+        if (state.publish_gate_tf_seconds > 0 && script_tf_seconds_ > 0) {
+            int64_t bucket_end_sec =
+                ab.bar.timestamp / 1000 + state.publish_gate_tf_seconds;
+            publish = (bucket_end_sec % script_tf_seconds_) == 0;
+        }
+        evaluate_security(state.sec_id, ab.bar, publish);
     } else if (state.lookahead_on) {
         if (state.heikinashi) apply_ha(ab.bar, /*commit=*/false);
         state.current_bar = ab.bar;