Strategy Builder Reference

Breakout followed by pullback retest

compare

entryexitgate

LEVEL comparison on continuous values: left op right, true every bar the relation holds. USE WHEN: gating on a sustained condition (e.g. close > SMA(200), RSI < 30 throughout the consolidation). DO NOT USE for one-shot edge events — use 'cross' to fire once on the crossing bar. DO NOT USE for membership in a discrete set — use 'in_set'. For named zones inspect builder_discover(action='get', ref='workflow:named_anchor_zone'); for anchor fields use value_ref:anchor.

cross

EDGE event on continuous values: fires once on the bar where left crosses right (was below/above, now the other side). USE WHEN: price crosses a moving average, indicator crosses a level (e.g. RSI crosses 30), Stochastic K crosses D. DO NOT USE for discrete/categorical refs like supertrend.direction ({-1,+1}) — use 'transition' instead. DO NOT USE when you want every bar the relation holds — use 'compare' for level/state semantics. For named zones inspect builder_discover(action='get', ref='workflow:named_anchor_zone').

in_set

entrygate

LEVEL membership on discrete/categorical values: true every bar value ∈ members (or its negation). USE WHEN: gating on SuperTrend direction == +1, regime label in {bull, neutral}. DO NOT USE on continuous values — use 'compare' instead. Cleaner than anyOf(compare(value == m) ...). The discrete-valued counterpart to 'compare'.

range

entryexitgate

LEVEL interval on continuous values: true every bar low <= subject <= high, with EACH bound's inclusivity set separately — low_inclusive and high_inclusive are BOTH REQUIRED, because the two two-bound sites this replaces disagree (band_level inside is exclusive on both edges, zone membership is inclusive on both), so any default would be a silent choice between them. USE WHEN: 'RSI between 30 and 70', 'price inside the Bollinger band', any half-open window like [30, 70) that a single flag cannot express. Bounds may be signal refs, not just constants, so they can be moving series. DO NOT USE for a one-sided threshold — use 'compare'. DO NOT USE for membership in a discrete set — use 'in_set'. A literal interval that is empty (low above high, or equal bounds with an exclusive end) is refused at construction rather than shipped as a strategy that never fires.

spread

Spread between two instruments (ratio, difference, log_ratio, zscore)

transition

EDGE event on discrete/categorical values: fires once on the bar where ref's value differs from the prior bar (optionally constrained to a (from, to) pair). USE WHEN: SuperTrend direction flips (-1 → +1), regime label changes, any small-set categorical ref changes value. DO NOT USE on continuous values like price or RSI — use 'cross' for those. The discrete-valued counterpart to 'cross'.

Price levels

4 conditions

fvg

Fair Value Gap -- 3-candle imbalance zones

liquidity_sweep

Sweep below support then reclaim

order_block

Order Block -- institutional S/R zone

ote

OTE -- Fibonacci retracement zone

Patterns

3 conditions

candle_pattern

Candlestick patterns (bullish_engulfing, bearish_engulfing, hammer, doji, morning_star, three_white_soldiers, etc. — see full enum via builder_discover(action='get', ref='condition:candle_pattern'))

flag_pattern

Flag chart pattern (momentum + consolidation + breakout)

pennant_pattern

Pennant chart pattern

Temporal

3 conditions

at_least

At least N of M conditions true on same bar — e.g. 3 of [CCI < -100, Donchian lower touch, volume spike, bullish divergence, hammer candle]

consecutive

Condition true for N consecutive bars (or N of M with strict=false) — e.g. close > SMA(100) for 5 consecutive bars. The window INCLUDES the current bar, so for 'X now but not in the preceding N bars' use window_bars=N+1 with min_true=2; window_bars=N with min_true=1 can never fire alongside X

latch

entryexitgate

EDGE with memory: true on the one close where `fire` holds after `arm` held on an earlier close, then disarmed. USE WHEN an event must follow a precondition — price re-enters a band after leaving it (arm=outside, fire=inside), first touch of a level after being clear of it, a rising edge of any condition (arm=not(c), fire=c). `arm` wins if both are true on one close; if either side has no value the result has none and the latch keeps its state. Never reset by positions. Children are inline conditions or condition_refs; it cannot hold a schedule or a stop/target. DO NOT USE for a plain level — use 'compare'.

Time & events

4 conditions

at_session

Execute N minutes after the session open or before the session close, on every session (anchor:open|close, offset_minutes: int >= 0 after the open, <= 0 before the close; -5 with close = five minutes before the close, half-days resolved against that date's real close). Schedules the decision at that instant and fills from the 1-minute execution clock, on ANY timeframe. The rule is evaluated ONLY then and places a market order, so other conditions on it are sampled at that moment; never put a protective exit on one. Equity only: refused for crypto (24h sessions have no open or close; use at_time). Only an entry or an exit trigger, alone or under all_of.

at_time

Execute at a specific clock time (e.g. 'buy at 10:16'). Time is HH:MM in the exchange session timezone. Schedules the decision at that instant and fills from the 1-minute execution clock, so the time is exact on ANY strategy timeframe -- daily included. The rule is evaluated ONLY then, so other conditions on it are sampled at that moment; never put a protective exit on one. A time outside that date's session (15:30 on a 13:00 half-day) simply does not occur that day, so an exit on one holds the position instead of firing.

calendar_schedule

Periodic schedule (daily, weekly, monthly). Also the way to trigger once at an exact wall-clock time in a named timezone (time + tz, e.g. every='1d', time='10:30', tz='America/New_York'), including on 24/7 assets.

eod_flatten

exit

End-of-day flatten exit: the position is flat from N minutes before the session close until the close. At close - N (resolved against the DATE's real close, so a half-day flattens early instead of being missed) it closes the position and cancels any resting entry; entries decided in the window are skipped as policy:eod_flat_window. A daily/hourly entry filling at the open is flattened the same session. A scheduled entry at or after close - N is refused at compile. Attach it as its own exit. Equity only: refused for crypto (24h sessions have no close).

Risk management

2 conditions

fixed_targets

exit

Fixed stop-loss / take-profit / time-stop (supports take_profit_tiers for staged partial exits)

trailing_stop

exit

Trailing stop from the extreme price since entry; trail distance is either an ATR multiple (atr_multiplier) or a percent (trailing_pct)

Combinators

5 conditions

all_of

Logical AND -- all child conditions must be true.

always_true

Always true -- fires on every bar. Use as a no-op placeholder or unconditional trigger.

any_of

Logical OR -- at least one child condition must be true.

not

Logical NOT -- inverts the inner condition.

sequence

Ordered sequence -- steps must fire in order, each optionally within N bars.

Custom Structures

1 condition

condition_ref

Owned reference to a saved definition: {kind: condition_ref, definition_id: ...}. Use it as an ordinary child in composition. It binds before compilation; the target must belong to this strategy, exist, and satisfy its placement context.

Value refs

30 value refs

Typed references that resolve to a number at evaluation time.

anchor

A field of a named anchor — a single bar captured earlier and then held. The anchor is declared in the strategy's ``anchors`` (captured by timestamp, bar index, or the first false-to-true flip of a condition); referencing an ``anchor_id`` that is not declared fails at compile time. Until the anchor actually fires the value is typed absence. A comparison over that absent operand is UNKNOWN; the action boundary takes no action. ``mid`` and ``range`` are derived from the captured bar's high and low. Does not accept ``resolution``.

binary_expr

Binary expression over two ValueRef operands. Provided alongside UnaryExprValueRef so tests / flat-Condition authors can build composite expressions like ``abs(close - 100)``. Compiles to a binary IRExpression.

constant

A fixed numeric literal, usable anywhere a value ref is accepted. The one ref that is NOT a ``ValueRefBaseModel``: it has no ``symbol`` or ``resolution`` qualifier. A bare int/float written into ``binary_expr``/ ``unary_expr`` operands or ``compare.right`` is coerced to this type automatically, so writing it out explicitly is rarely necessary.

entry_bar

Reference to a field of the signal bar for the currently-open position. Auto-captured by the engine when a position opens. Returns NaN when no position is open. Clears on position close. Use for ORB-style "stop out below the signal-bar low" without AnchorDefinition's silent-latching bug. Fields: - open / high / low / close: signal-bar OHLC - range: high - low - body_high: max(open, close) - body_low: min(open, close)

equity

The strategy's running equity-curve value. ``field`` selects: ``current`` (equity right now), ``peak`` (the running high-water mark), or ``drawdown_pct`` (percent below that peak — 0 at a new high, positive while underwater). Use ``drawdown_pct`` directly for a circuit-breaker gate rather than deriving it from ``current``/``peak``. VIB-1370 / VIB-1319: the sub-metric selector is named ``field`` across every ValueRef-style type. The legacy name ``equity_metric`` was removed.

event_distance

Distance from the current bar to an event type's next or previous occurrence. ``direction="previous"`` counts back to the latest occurrence at or before the bar: 0 on the bar the occurrence is assigned to. ``direction="next"`` counts forward to the earliest occurrence strictly after the bar, so it is never 0 in minutes. ``unit`` is wall-clock minutes or bars. When no such occurrence is known the value is infinity (present, not absent), so ``distance <= N`` is false and ``not (distance <= N)`` is true: that is how a "stay away from events" gate is written. A ``next`` distance needs the event's date to be known in advance. Among system events only those with a forward release calendar (macro.cpi, macro.nonfarm_payrolls, macro.unemployment) qualify; any other system event is refused with ``direction="next"``, because the platform cannot anticipate it. Custom events are unrestricted. Use ``direction="previous"`` to react after a system event. Example, within 5 bars after an event: {"kind": "event_distance", "event_type_id": "my-signal", "direction": "previous", "unit": "bars"}

event_field

Field from latest event payload. Authoring flow: 1. Call list_event_types(). 2. Pick event_type_id from a returned event type. 3. Pick event_field from payload_schema.fields. Example: {"kind": "event_field", "event_type_id": "macro.cpi", "event_field": "value"} To compare a release against a previous one, set occurrences_back on a second ref and subtract: {"kind": "binary_expr", "op": "-", "left": {"kind": "event_field", "event_type_id": "macro.cpi", "event_field": "value"}, "right": {"kind": "event_field", "event_type_id": "macro.cpi", "event_field": "value", "occurrences_back": 1}}

indicator

Indicator output — RSI, CCI, EMA/SMA, ATR, ADX, ROC (decimal: 0.05=5%), oscillators (rsi, srsi_k/d, stochastic_k/d, mfi) are 0-100 NOT 0-1 — oversold is `<= 5`, not `<= 0.05`. MACD/signal/histogram, stochastic_k/d, Bollinger bands, volume_sma, pivot levels. Use schema.variants.shape_refs to find the canonical shape ref for your authored indicator, then fetch it with builder_discover(action='get', ref=<returned ref>).

live_position

A metric of the CURRENTLY OPEN position, read live every bar (not a frozen snapshot from entry — contrast ``entry_bar``/``sequence_step``, which capture a value once and hold it). ``field`` selects: ``entry_price``, ``bars_in_position``, ``unrealized_pnl_pct`` / ``unrealized_pnl_usd``, or ``max_excursion_pct`` / ``min_excursion_pct`` (the best/worst unrealized PnL% reached since entry — MAE/MFE). All are NaN while flat. ``bars_in_position`` counts the bars the position has been open in, INCLUDING the bar it filled in: it is 1 at the close of the fill bar, not 0. An exit on ``bars_in_position >= N`` therefore decides at the close of the Nth held bar and fills at the next bar's open, so the trade's ``exit_bar - entry_bar`` is exactly N. VIB-1398 / VIB-1370 / VIB-1319: the sub-metric selector is named ``field`` across every ValueRef-style type. The legacy name ``position_metric`` was removed (mirrors the IR-side ``LivePositionRef.metric → field`` rename that VIB-1394 shipped).

named_zone

A boundary of a named strategy-level zone: its `upper`, `lower`, or derived `mid`. ``mid`` is computed as ``(upper + lower) / 2`` at read time and is not a stored field. Zone boundaries may themselves be anchor refs, in which case the whole zone reads NaN until that anchor fires. Referencing an undeclared ``zone_id`` fails at compile time. Does not accept ``resolution``.

percentile

Percentile RANK of the current bar's `field` (or of any `source` value) within the trailing `lookback_bars` window. Returns ``100 * (values strictly below the current one) / (lookback_bars - 1)`` over a window that **includes the current bar**: a new window high reads 100, a new window low reads 0. Ties are not counted, so a perfectly flat window reads 0. **This is the inverse of** ``rolling_stats(stat="percentile")``, which returns the *value* sitting at a given percentile level. Use this ref to ask "how extreme is price right now", and ``rolling_stats`` to ask "what price is the 90th percentile". NaN propagates: any missing value in the window returns NaN. ``source`` ranks any value ref rather than a price field, so "is the volume unusually high" or "is the band width unusually narrow" is one operand: ``lookback_bars`` (2 to 500) is the window the current value is ranked in. Every bar in the window is evaluated, so a long window over a nested expression costs more than a price field does. Example, the percentile of the Bollinger band width over 100 bars: {"kind": "percentile", "lookback_bars": 100, "source": {"kind": "binary_expr", "op": "-", "left": {"kind": "indicator", "indicator": "bollinger", "output": "upper"}, "right": {"kind": "indicator", "indicator": "bollinger", "output": "lower"}}}

price

A single OHLC field of the current bar, or of a bar `offset` bars back. ``offset=0`` (the default) is the bar being evaluated. Reading past the start of loaded history returns NaN rather than clamping to the first bar, and a NaN operand makes the enclosing compare false.

rank

Cross-sectional rank of ``source`` among the universe's symbols on the current bar, 0 to 1. The lowest symbol reads 0, the highest 1 (mid-rank for ties). With fewer than 2 symbols holding a value there is no rank: it is absent, so a comparison over it is unknown (not 0.5). ``source`` is evaluated once per symbol; it cannot carry a ``symbol`` and cannot contain another cross-sectional operand. Requires a universe or portfolio strategy with two or more symbols. Example, the top tercile of the universe by 20-bar rate of change: {"kind": "rank", "source": {"kind": "indicator", "indicator": "roc", "period": 20}} compared with ``> 0.66``.

rolling_max

Highest value of `source` over the prior `lookback_bars` — **excludes the current bar**. ``source`` accepts ANY value ref, not just a price field: an indicator, a spread, or a nested expression. That is what makes normalisations composable — e.g. a stochastic of the MACD line is ``(macd - rolling_min(macd)) / (rolling_max(macd) - rolling_min(macd))`` built with ``binary_expr``, with no dedicated indicator type. Two behaviours to design around, both deliberate: - **The current bar is excluded** (same convention as ``donchian``), so a close-exceeds-max breakout is meaningful — the current bar cannot contaminate its own threshold. For a stochastic you want an INCLUSIVE window, so rebuild one with ``binary_expr``: ``{"kind": "binary_expr", "op": "max", "left": <source>, "right": {"kind": "rolling_max", "source": <source>, "lookback_bars": N - 1}}`` - **NaN propagates**: one missing value anywhere in the window returns NaN (no silent zero-substitution while `source` is still warming up), and a NaN operand makes the enclosing compare false. Indicators with their own NaN-compacting buffers — ``srsi_k``, ``stochastic_k`` — do NOT behave this way, which is why they are not redundant with this ref.

rolling_min

Lowest value of `source` over the prior `lookback_bars` — **excludes the current bar**. The mirror of ``rolling_max``; see that class for the composition pattern, the inclusive-window workaround via ``binary_expr`` ``min``, and the NaN-propagation rule. ``source`` accepts any value ref, not just a price field.

rolling_stats

A rolling statistic of `source` over `lookback_bars` — mean, std, zscore, sum, count, rank, percentile or ema. ``source`` accepts ANY value ref, including a nested ``binary_expr``, so this is the general smoothing and normalisation primitive: an SMA of an arbitrary expression is ``stat="mean"``, and a rolling z-score of a spread is ``stat="zscore"``. Combined with ``rolling_max``/``rolling_min`` it expresses whole indicator families that have no dedicated type — the %K of a stochastic over any series is a 3-bar ``"mean"`` of the normalised ratio. **NaN propagates**: one missing value in the window returns NaN, and a NaN operand makes the enclosing compare false. Purpose-built indicators that compact their buffers to finite samples (``srsi_k``, ``stochastic_k``) survive undefined stretches that this ref does not, so they are not redundant with it. ``percentile_level`` is required when ``stat="percentile"`` and must be omitted otherwise.

sequence_step

Reference to a field of the bar that matched a named sequence step. Address the bar that satisfied a specific step inside a specific SequenceCondition. Useful for "stop at the retest bar's low" in break-retest setups. Lifecycle mirrors EntryBarValueRef: the snapshot is captured at step fire, preserved for the lifetime of the open position, cleared on position close. NaN when no position is open or the step has not yet fired on the current match. Fields: - open / high / low / close: step-bar OHLC - range: high - low - body_high: max(open, close) - body_low: min(open, close)

session

Session-level value reference. Day-scoped mode (default): resolves against the full trading day in the session timezone. field in {open, high, low, close, prior_close, bars_into_session, range, mid}. Intraday window mode: set ``window_start`` (HH:MM wall-clock in the session timezone) and ``window_duration_minutes`` to aggregate OHLC across a fixed intraday slot (e.g., Asian session 00:00+480, ORB 09:30+30). Before the window opens each day: NaN. During the window: evolving aggregate. After close: frozen aggregate for the rest of the day; resets at the next day's window_start. Fields prior_close and bars_into_session are day-scope only (not valid with a window).

shared_signal

Reference to a portfolio-level shared signal by name (VIB-2102). Resolves only inside a multi-member portfolio that declares a matching ``shared_signals`` entry; bound to a member-local metric at portfolio compile time. Illegal in a standalone strategy.

sibling

The value of ``source`` on another symbol of the universe, on the current bar. ``symbol`` must be a member of the strategy's universe; one outside it never has a value, so such a strategy is refused when it is compiled. ``source`` is evaluated on that symbol's own data, not this one's; it cannot carry a ``symbol`` and cannot contain another cross-sectional operand. Requires a universe or portfolio strategy with two or more symbols. Example, QQQ's close, to compare this symbol's close with: {"kind": "sibling", "symbol": "QQQ", "source": {"kind": "price", "field": "close"}}

swing

Price of a confirmed swing high/low — a bar whose extreme beats `strength` bars each side. Confirmation is **lagging by design**: a swing at bar N is not visible until bar ``N + strength``, because the bars to its right have to print first. That is what makes it lookahead-free, and it means the newest readable swing is always at least ``strength`` bars old. The comparison is strict, so a level matched exactly by a neighbouring bar never forms a swing. ``offset`` counts back through confirmed swings (0 = most recent); typed absence if that many have not been confirmed yet. A comparison over that absent operand is UNKNOWN; the action boundary takes no action.

time

Reference to the current bar's time field. VIB-1370 / VIB-1319: the sub-metric selector is named ``field`` across every ValueRef-style type. The legacy name ``component`` was removed. Calendar/intraday fields: ``hour``, ``minute``, ``day_of_week`` (0=Mon), ``day_of_month``, ``month`` (1=Jan), ``minutes_since_midnight``. Session-aware fields (use the strategy's session metadata): ``minutes_to_close``, ``minutes_since_open``. Have no value for crypto (24h) and pre/post-market bars. A comparison over a missing value is unknown and takes no action, negated or not: ``not(minutes_to_close <= 5)`` does not fire outside the session.

tracked

Running highest or lowest value of ``source`` since the start of the run or since entry. ``extreme`` chooses the maximum or the minimum and ``since`` the starting point. With ``since: "start"`` (the default) it updates at the end of every bar, warm-up included, so a rule deciding at the close of bar t sees the extreme through bar t-1; a scheduled rule sees its frame bar included. With ``since: "entry"`` it is unset while flat, resets when a position opens from flat (not on a scale-in or a partial exit; a reversal opens from flat) and updates before decisions on each bar while invested, so a rule sees the extreme through the current bar. Absent values of ``source`` are skipped, and an unset value makes a comparison over it unknown. It keeps its state across a paper session's restarts. ``since: "entry"`` is refused in a signal scan, as every operation on the open position is. Known gaps it inherits: a raw trailing ratchet built from it does not reset after it fires, ``since: "entry"`` folds in the whole bar of a mid-bar scheduled fill, and the reset runs only for the entry rule that filled. A ``since: "entry"`` value is refused anywhere inside a gate: a gate is evaluated while flat as well as invested, so a value that resets at entry cannot be kept correct there. Use ``since: "start"``, or put the condition on an exit. It returns the unit of ``source``. Example, the highest high since entry, to place a trailing exit under: {"kind": "tracked", "source": {"kind": "price", "field": "high"}, "extreme": "max", "since": "entry"} compared with ``close`` using ``<``.

trade_history

A statistic computed from the strategy's own closed-trade history. ``field`` selects the metric: ``trade_count`` (closed trades so far), ``consecutive_wins`` / ``consecutive_losses`` (current streak length), ``last_pnl`` / ``last_pnl_pct`` (the most recently closed trade's PnL), ``rolling_win_rate`` / ``rolling_avg_pnl_pct`` (win rate / average PnL% over the last ``lookback_bars`` closed trades — ``lookback_bars`` is REQUIRED for these two and forbidden for every other field, since it counts TRADES, not bars), or ``bars_since_last_exit``. Before the first trade closes: ``trade_count``, ``consecutive_wins`` and ``consecutive_losses`` are all-time counters and read ``0``. The other five have no value yet -- a typed absence (``no_position``), not a number -- so a condition reading one is UNKNOWN and takes no action (neither true nor false), and a ``formula`` sizing over one is refused at compile because it could never size the first entry. VIB-1367 phase 4 / VIB-1319: the sub-metric selector is named ``field`` across every ValueRef-style type. The legacy name ``trade_metric`` was removed.

triggering_zone

Reference to the zone that fired the entry's ZoneCondition (VIB-591). Resolves to a level of the *triggering* zone — the zone selected by the entry's ZoneCondition on the signal bar. An immutable snapshot is captured into ``TradeContext`` so post-entry references (e.g. a standing stop-loss bound to the FVG's lower wick) keep resolving to the same zone for the trade's lifetime. The id is retained for persisted-state compatibility. Returns NaN when no triggering zone is bound (no entry condition with a required ZoneCondition fired) and no compatibility lookup is available.

unary_expr

Unary expression over another ValueRef. Wraps a single operand with an op from {abs, neg, log, log10, sqrt, pct_change}. Compiles to a unary IRExpression.

ValueRef

The union of all value references usable as a signal.

volume

Traded volume of the current bar, or of a bar `offset` bars back. Volume is in **base-asset units** (shares, or coins for crypto) unless the run is configured for quote units, in which case it is multiplied by that bar's close. Reading past the start of loaded history returns NaN.

xs_dispersion

Spread of ``source`` across the WHOLE universe on the current bar. Unlike ``rank`` and ``xs_zscore`` it does not say where this symbol sits; every symbol reads the same number, so it does not degrade while this symbol's own value is still warming up. ``stat`` chooses the standard deviation or the range. ``source`` is evaluated once per symbol; it cannot carry a ``symbol`` and cannot contain another cross-sectional operand. Requires a universe or portfolio strategy with two or more symbols. Example, how widely 20-bar returns are spread across the universe: {"kind": "xs_dispersion", "stat": "stdev", "source": {"kind": "indicator", "indicator": "roc", "period": 20}}

xs_zscore

Cross-sectional z-score of ``source`` among the universe's symbols on the current bar. How many sample standard deviations this symbol's value sits from the universe mean. With fewer than 2 values, or when every symbol sits on the mean, there is no z-score: it is absent (not 0). ``source`` is evaluated once per symbol; it cannot carry a ``symbol`` and cannot contain another cross-sectional operand. Requires a universe or portfolio strategy with two or more symbols. Example, how far this symbol's RSI is from the universe average: {"kind": "xs_zscore", "source": {"kind": "indicator", "indicator": "rsi", "period": 14}}

Enums

34 enums

Bounded option sets referenced by condition and value-ref fields.

Anchor

2 values: close, open

Anchor Field

6 values: close, high, low, mid, open, range

Calc Type

4 values: difference, log_ratio, ratio, zscore

CompareOp

6 values: !=, <, <=, ==, >, >=

3 values: down, same, up

3 values: both, high, low

2 values: long, short

2 values: next, previous

EntryBarField

7 values: body_high, body_low, close, high, low, open, range

enum_bars_minutes

2 values: bars, minutes

enum_entry_start

2 values: entry, start

Every

5 values: 1d, 1m, 1w, 2w, 3m

Extreme

2 values: max, min

6 values: bars_in_position, entry_price, max_excursion_pct, min_excursion_pct, unrealized_pnl_pct, unrealized_pnl_usd

8 values: day_of_month, day_of_week, hour, minute, minutes_since_midnight, minutes_since_open, minutes_to_close, month

8 values: bars_since_last_exit, consecutive_losses, consecutive_wins, last_pnl, last_pnl_pct, rolling_avg_pnl_pct, rolling_win_rate, trade_count