Nodes: Logic

The Condition node is the core logic unit of the strategy builder. It evaluates a comparison between a left operand (a value from an indicator, price, pattern, or other source) and a right operand (a fixed value, another indicator, a level, or nothing) using an operator. The output is a boolean (true/false) result that flows to logic gates, signal gates, or directly to entry/exit nodes.

Every condition has three core components: the left side defines what is being compared, the operator defines how it is compared, and the right side defines what it is compared against. The available choices for each component depend on the connected source nodes, creating a context-sensitive inspector that adapts as you wire the graph.

Left Side (input handle: left)

The left operand defines what is being compared. Its type field determines the source and the available downstream options. The left handle is positioned at 35% from the top of the node's left edge.

Left Side Types

Indicator (type="indicator"): When a node with a value or signal handle connects to left. The left side displays the connected node's name and its output value. For indicators, you select which field to use (e.g., sma, rsi, macd). This is the most common left-side type.

Price (type="price"): Auto-set when a level node (fibonacci, pivot_points, price_levels, volume_profile) connects to the right handle. The left side is automatically configured to price, and you select which price field: open, high, low, close, hl2, hlc3, ohlc4. This is the typical pattern for “price crosses level” conditions.

Pattern (type="pattern"): When a pattern node connects. You select the signal name from the pattern's signals_map (e.g., “Bullish”, “Bearish”).

Classifier (type="classifier"): When a classifier node connects. Generates categorical signals: Short, Neutral, or Long.

Regressor (type="regressor"): When a regressor node connects. Outputs a percentage value representing the predicted return or price change.

Strategy (type="strategy"): When a strategy reference node connects. Generates categorical signals based on the referenced strategy's direction_bias.

SMC (type="smc"): When an SMC (Smart Money Concepts) node connects. Per-signal output_types determine behavior: signals can be binary, numeric, or level.

Operator (required)

The comparison operator defines the logical relationship between left and right. The available operators depend on the left side's output_type, which is determined by the connected source node.

Numeric Operators (output_type: numeric)

Most indicators and price sources produce numeric outputs. Available operators:

Zero-Crossing Operators (output_type: zero_crossing)

Used for indicators that oscillate around zero (MACD histogram, momentum indicators). Includes crosses_above (crosses above zero) and crosses_below (crosses below zero), plus select numeric operators.

Binary Operators (output_type: binary)

For sources that produce only true/false signals. Right side is hidden (type=none).

Categorical Operators (output_type: categorical)

For patterns, classifiers, and strategies that produce named signals.

Percentage Operators (output_type: percentage)

For regressor nodes that output predicted return percentages.

Level Operators (output_type: level)

Auto-set when left is price and right is a level node. These operators are designed for price-versus-level interactions.

Right Side (input handle: right)

The right operand defines what the left side is compared against. The right handle is positioned at 65% from the top of the node's left edge. The UI for the right side depends on its type:

Value (type="value"): A free-form numeric input field. Enter any number. Used when comparing an indicator to a fixed threshold (e.g., “RSI > 70”). For percentage output types, the value input includes a % suffix to indicate the unit.

Indicator (type="indicator"): When another indicator node connects to the right handle. You select the indicator and its field. Used for indicator-vs-indicator comparisons (e.g., “SMA(20) crosses_above SMA(50)”). Both left and right can reference the same indicator using different fields (e.g., “MACD line crosses_above MACD signal line”).

Signal Selector (type="signal_selector"): A dropdown listing available signal names from the connected source's signals_map (for patterns) or predefined categories (for classifiers: Short, Neutral, Long; for strategies: based on direction_bias). The dropdown options update dynamically when you connect a new source.

Event Selector (type="event_selector"): Similar to signal selector but for strategy reference nodes. Shows events like “Long Entry”, “Short Entry”, “Long Exit”, “Short Exit” — representing trade signals emitted by the referenced strategy.

Level (type="level"): Display-only field showing the level value from the connected level node (e.g., “0.618”, “R1”, “VAH”). The level value is read from the level node's output: you do not type it manually. When a level connects to right, the left side is auto-set to price type.

None (type="none"): No right side shown. Used for binary operators (is_true, is_false, just_turned_true, just_turned_false) and SMC binary signals that do not need a right operand.

Lookback (integer, optional)

Number of bars to look back for operators like crosses_above, is_rising, and edge-detection operators. The default varies by operator. For cross operators, lookback defines how many bars back to check whether the cross occurred. For example, with lookback=1 and crosses_above: the condition is true if the left value was below the right value on the previous bar and is above it on the current bar. Larger lookback values capture crosses that occurred further in the past.

MTF Override

Visible when the data source's multi-timeframe (MTF) configuration is enabled AND the left type is price. Provides symbol, bar_type, and timeframe fields that propagate from the MTF configuration. When price is selected, the condition can evaluate at a different timeframe than the main strategy. For example, a strategy running on 15m bars can have a condition checking whether daily price crosses above a pivot point.

This section explains the automatic resolution logic that runs when you connect a source node to a condition. Understanding this process helps you predict how the condition inspector will reconfigure itself before you even wire the connection.

The resolveConditionBehavior() Pipeline

When you connect a node handle to a condition's left or right handle, the system runs resolveConditionBehavior() which executes four sequential steps:

1. Determines output_type: Reads the output_types from the source node's registry definition. For indicators, this comes from indicators.json output_types[output]. For patterns: from patterns.json _condition.output_type. For SMC: per-signal from market-structure.json. Falls back to 'numeric' if not specified.
2. Selects operator set: Uses condition.json _operator_sets[output_type] to determine which operators are available in the dropdown. Each output type maps to a curated list of semantically appropriate operators.
3. Configures right side: Based on the operator set, determines whether the right side shows a value input, signal selector, event selector, level display, or nothing (none).
4. Auto-populates handles: When connecting, the system auto-populates the target handle based on the source handle type. It also auto-redirects: value/ signal handles landing on right are redirected to left; level handles landing on left are redirected to right.

Resolution Summary Table

Logic gates combine multiple boolean signals into a single boolean output. They take condition results (or other logic gate outputs) as inputs and produce a composite true/false signal. This is how you express multi-condition entry rules: “Enter long when RSI < 30 and price > SMA 200 and MACD > 0.”

Logic Type (required)

Select AND or OR via tabs or buttons at the top of the inspector. This is the fundamental decision for how the gate combines its inputs.

Input Handles

AND/OR gates have 5 input handles (in-0 through in-4) stacked vertically on the left edge of the node. You can connect between 1 and 5 condition results or other logic outputs. Unconnected handles are ignored during evaluation. Handles are numbered: connections auto-populate the first free slot, filling from top to bottom.

How AND Works

ALL connected inputs must be true for the output to be true. If any connected input is false, the output is false. Use AND when you need multiple conditions to align simultaneously. Example: “RSI < 30 AND price > SMA 200” means both must be true on the same bar for the entry signal to fire.

How OR Works

ANY connected input being true makes the output true. Use OR for alternative entry signals: “MACD crosses above OR RSI crosses above 50” means the strategy enters on whichever signal fires first.

Voting / Threshold

There is no explicit voting threshold in the AND/OR gates. An AND gate requires 100% of connected inputs to be true; an OR gate requires at least 1. For weighted voting (e.g., “at least 3 of 5 conditions must be true”), use a downstream Entry node with combination_mode: 'weighted' or 'majority', which can assign weights and thresholds to individual condition inputs.

Output Handle

out (right edge of the node). Produces a boolean signal that can connect to: Entry nodes (cond-0 through cond-4), Exit nodes (cond-0 through cond-4), other Logic gates (in-0 through in-4), or Signal Gates (in). Logic gates can be nested: an OR gate can feed into an AND gate to create complex boolean expressions.

Alias

A unique, user-defined label shown on the canvas node body. Name it descriptively to document the gate's purpose (e.g., “Oversold Entry”, “Breakout Confirm”). Aliases are displayed on the node in the graph canvas and appear in the node inspector header.

Nested Gate Example: (A AND B) OR (C AND D)

A common real-world pattern using nested gates:

1. Condition A: RSI < 30 (oversold)
2. Condition B: Price > SMA 200 (uptrend)
3. AND Gate 1: Combines A AND B → “Oversold in Uptrend”
4. Condition C: MACD crosses above signal (bullish crossover)
5. Condition D: Volume > 1.5x average (high conviction)
6. AND Gate 2: Combines C AND D → “MACD Cross with Volume”
7. OR Gate: Combines AND Gate 1 OR AND Gate 2 → entry signal

This pattern means: enter long when either (a) the market is oversold in an uptrend, OR (b) MACD gives a bullish crossover with strong volume confirmation.

The NOT gate inverts a single boolean input: output is true when input is false, and output is false when input is true. This is essential for expressing negative conditions (“do NOT enter when overbought”) without needing to invert every condition individually.

Logic Type (required)

Set to NOT. Unlike AND/OR gates, NOT only supports a single input.

Input Handle

Only one input handle: in-0, centered on the left edge of the node. Connect exactly one condition result or logic output. An unconnected NOT gate produces no meaningful output: the system treats an unconnected input as invalid, and the gate outputs no signal (effectively false/inactive).

How NOT Works in Practice

Use NOT to negate a condition or a composite logic result. Common patterns include:

• Inverse entry filter: NOT(RSI > 70) means “do not enter when overbought.” Combined with an AND gate: “MACD crosses above AND NOT(RSI > 70).”
• Exit on condition loss: NOT(bullish pattern active) means “exit when the pattern is no longer valid.”
• Negating composite gates: Connect a NOT gate after an AND gate to express “NOT(A AND B)” — equivalent to “NOT A OR NOT B” (De Morgan's law).
• Ranging market filter: NOT(trend filter) means “only trade when no strong trend is detected” — useful for mean-reversion strategies.

Output Handle

out (right edge). Same connectivity as AND/OR output: connects to Entry cond-*, Exit cond-*, other Logic in-*, or Signal Gate in handles.

The Signal Gate modifies the timing and duration of a boolean signal without changing its value. It answers questions like: “How long should I hold after the signal?”, “Should I wait N bars before acting?”, “How long should I wait before taking another entry?”

Signal Gates do not affect the logical content of a signal — they affect when and for how long the signal remains active. They sit between logic gates and entry/exit nodes, forming the final timing layer before trade execution.

Mode (required)

One of five modes, selected via a dropdown in the inspector:

hold_re — Hold Until Re-Entry

Once the input signal becomes true, the output stays true until a new signal in the opposite direction is received. This is the most common mode for trend-following strategies: hold a long position until a short signal appears. The bars parameter is not used in this mode.

Use case: A moving average crossover strategy that stays long until the crossover reverses. No fixed holding period: the trade duration is determined by when the opposite signal fires.

hold_non_re — Hold, Non-Re-entrant

Once the input signal becomes true, the output stays true for exactly bars N bars, then resets to false. A new true input during the hold period does not restart the timer. This prevents rapid re-entry and ensures each signal results in a single, fixed-duration hold.

Use case: “Enter on signal and hold for exactly 5 bars, ignoring any new signals during that window.”

delay — Delayed Activation

When the input signal becomes true, wait bars N bars before setting the output to true. If the input goes false during the delay period, the delayed output is cancelled and never fires. This is an “armed but cancellable” delay.

Use case: Wait for 2 confirmation bars after a breakout signal before entering. If the breakout fails during those 2 bars (price falls back below the level), the entry is cancelled.

cooldown — Post-Signal Cooldown

After the output becomes true (from any input trigger), enforce a cooldown period of bars N bars where new input triggers are ignored. The output itself follows the input signal (passes through), but after any true output, subsequent inputs are suppressed for N bars.

Use case: Prevent overtrading by enforcing a minimum 10-bar gap between entries. The first signal fires immediately; the next signal is ignored until 10 bars have passed.

pulse — Fixed-Width Pulse

When the input signal becomes true, the output becomes true for exactly bars N bars, then goes false regardless of the input state. Each new true input restarts the pulse, even if already pulsing. This is a “retriggerable monostable” behavior.

Use case: Generate a fixed 3-bar entry window after each signal. If a new signal fires during an active pulse, the window extends for another 3 bars from the new signal.

Bars (integer, required)

The number of bars for the mode's duration. The meaning depends on the selected mode:

Input Handle

in (left edge, single). Connect from a condition result handle or logic gate out handle. Only one input connection is supported: if you need to combine multiple signals before timing control, use a logic gate upstream.

Output Handle

out (right edge). Connects to Entry/Exit cond-* handles or other Logic in-* handles. The output is boolean: true during the active period (hold/pulse active), false otherwise.

Alias

A unique, user-defined label. Name it descriptively for the mode and duration (e.g., “Cooldown 5 bars”, “Delay 3 bars”, “Hold 10 bars”). This appears on the canvas node and helps document the signal timing logic.