[luisleo526]

This closes the gap that #319 listed under its known gaps: a timeframe.isminutes or timeframe.isseconds flag used as a value. No public issue tracks it, so there is no Fixes line.

timeframe.isminutes and timeframe.isseconds are Pine bools, and TradingView accepts them anywhere a bool goes. Passing either one to a user function, or reading it through history (flag[1]), did not compile: g++ stopped with could not convert 'p' from 'std::string' to 'bool' (function argument) or cannot convert 'bool' to 'std::string' (history read).

//@version=6
strategy("t1", initial_capital = 1000000, currency = currency.NONE)
q(p) => p ? 2 : 1
qty = q(timeframe.isminutes)
if bar_index > 6 and bar_index % 7 == 3
    strategy.entry("L", strategy.long, qty = qty)
if bar_index > 6 and bar_index % 7 == 5
    strategy.close("L")

What changes

Cause. The signature registry declares both flags as bool, but a second table (VARIABLE_STORAGE_COMPATIBILITY, added so that a stored flag kept its generated C++ when bool text conversion was fixed) gave them string storage, and the analyzer looked that table up before the registry. So a parameter that received one of the flags was a std::string and a history read of one was a string series. The other timeframe flags (isintraday, isdaily, ...) were not in that table and already worked.

Change. The table is deleted and the analyzer reads the timeframe variable's type from the registry (pineforge_codegen/signatures.py, pineforge_codegen/analyzer/base.py: 1 line added, 10 removed). Both flags are now bool everywhere, like the other timeframe flags. No member-name special case, nothing added to any refusal list. str.tostring(timeframe.isminutes) still prints true / false, directly, stored in a variable, through a function argument and through history.

Verification

• Full suite on a host without the engine checkout, base main and this head, same command: base 13,944 passed, 0 failed; head 13,942 passed, 0 failed; nothing fails only on the head. The counts differ for two reasons that are not failures: 2 passed fewer, because two frozen-C++ rows (timeframe.isminutes / timeframe.isseconds as the initializer in test_bool_conditions_keep_complete_reference_cpp) pinned the old string storage that this change removes; 34 skipped more, because the native rows need the engine and skip on this host on both trees (16 new rows, plus 18 from three existing tests that now enumerate all eight timeframe bools instead of two).
• Engine-paired run on the cloud runner (compile environment present), against engine main 84120311: 20,522 passed, 235 skipped, 0 failed; compile corpus 312 passed; the parity gate step passes.
• Red first. Sixteen new native rows (each timeframe bool, through a function parameter and through history) compile and run the script and compare the quantity it prints and fills with a Pine if computed in the same script from the flag itself. On main plus these rows and no source change, exactly four fail (isminutes and isseconds, parameter and history), with the g++ errors above, and the other twelve pass as controls; on this head all sixteen pass. These rows run on a 15-minute chart and prove that the flags keep their bool type through a parameter and through history; they are not TradingView values.
• Against TradingView: four small scripts (the two flags, each through a function argument and through history; the quantity of the entry is 2 where the flag is true and 1 where it is false) were exported from TradingView on a 60-minute chart and compared with the engine's output by entry time: on this head the exported quantities equal TradingView's on all 205 entries of each script (isminutes is true and isseconds is false on a 60-minute chart: quantity 2 for the two isminutes scripts and 1 for the two isseconds scripts, so the four rows export two distinct tapes, not four independent datasets); on main none of the four compiles. The text-conversion rows and the input-history rows measured for the previous change are unchanged.
• Translated before and after over 4,278 source rows in three sets (a second set of scripts 1,939, the population 1,384, the tests tree with the corpus 955) and 52 import pairs (10 distinct sources in 52 library environments): nothing changes, nothing is newly refused or translated. 17 sources of those sets use timeframe.isminutes (none uses timeframe.isseconds); all 17 translate exactly as before, because none of them passes the flag through a parameter or history. Over a further 188 sources nothing changes either (none of them uses either flag).
• The 312-row bool-text table and the 20 strategy.order comment rows of the previous change give the same result on this head as on main.
• Full-population parity sweep of this exact head, paired with engine main d129cc03, against the active baseline: PASS, no improvement and no regression. 7,989 probes are comparable and every one is measured on both sides; the hard gate evaluates 1,009 with 0 moves and 0 regressions, the target gate evaluates 6,980 with 0 moves up or down, and no band gains or loses an entrant. The gate verdict is recorded for this engine and codegen pair and reads back as PASS, no-improve-no-regression; advancing the baseline after the merge is a separate step.

🤖 Generated with Claude Code

[graphify-labs]

Graphify reviewed this change.

Worth a look — the grounded gate found no coupling regressions or blocking issues, but 1 advisory finding(s) below merit a look before merge.

Not checked: tests were not run; formal verification proved 0 of 1 changed function(s) (1 not verified).

Formal verification. PR-changed functions: 0/1 verified (0 proven, 0 may-equivalent, 0 distinguished) · 1 not verified (1 unsupported).

Not verified on this run: \_visit\_MemberAccess (unsupported).

---

Graphify review — findings

Drops the VARIABLE_STORAGE_COMPATIBILITY override so timeframe.* member access in Analyzer._visit_MemberAccess resolves only from TIMEFRAME_VARIABLES, with PineType.STRING still the default for any key missing from that table. That removes the stored-as-string path for timeframe.isminutes and timeframe.isseconds, so their type now depends entirely on whether the table registers them as bool. Tests now build their bool list from TIMEFRAME_BOOLS instead of the removed table, and a new native test checks that timeframe predicates passed through a parameter or read from history select and fill the same quantity as the Pine reference.

Worth a look

• timeframe.isminutes/isseconds may fall back to STRING after the compat table was removed — pineforge_codegen/analyzer/base.py:8286 · Escalate · medium
  • NOT verified (no proof, no reproducing execution) — needs human review

Analysis details — impact, health, verification

Impact & health

Graphify review

Impact — 3919 functions depend on the 333 functions this change touches.

Health — this change adds coupling hotspots:

• worse: _run_native() — 4 callers, 3 callees

Verification — 3919 functions in the blast radius were not formally verified this run (proofs are advisory here).

Gate & verification

graphify gate

PASS — objectively clean (no health regressions, tests not run — proofs not run this pass (advisory)). Grounded, not self-assessed.

Advisory (not blocking):

• verification_scope: 2862 function(s) in the blast radius were not formally verified this run

Cross-repo impact

Cross-repo impact

No cross-repo impact detected among the indexed peer repo(s).

1 peer repo(s) in this group are not yet indexed — cross-repo impact may be incomplete.

Cross-repo linkage is derived (SCIP-moniker matches are sound; name/contract matches are heuristic) and ADVISORY — it never affects this check's conclusion.

Formal verification

Could not verify: Could not verify \_visit\_MemberAccess.

The verifier did not have enough to check \_visit\_MemberAccess, so it is saying so rather than guessing. No false assurance is the whole point.

Guarantee: No guarantee either way, this is an honest abstention, not a pass.

Note: Reason: method — first parameter is `self`, which needs a constructed instance (not synthesizable)

· 1 more finding(s) on lines outside this diff (see the check run).