@reefclaw/connect 0.1.12 → 0.1.14

package/assets/plugin/signals/conditions/registry.js

@@ -0,0 +1,1333 @@
+// ⚠️ GENERATED FILE — DO NOT EDIT.
+// Canonical source of truth: shared/src/signals/conditions/registry.ts
+// Regenerate: node scripts/sync-shared-code.mjs  (enforced by shared-code-sync.test.ts)
+//
+// This copy exists because this package builds with tsc and deploys as a
+// self-contained tree that strips workspace deps, so it cannot import
+// @reefclaw/shared runtime code across the deploy boundary.
+// Condition registry — all reusable condition functions for declarative strategies.
+// Each condition is a pure function: (ctx, params, direction, condCtx) => ConditionResult.
+import { computeEMA, computeRSI, linearSlope, findSwingPoints, mean } from '../../shared/indicators.js';
+import { computeMACD, computeBollingerBands, computeVWAP, computeStochRSI, computeADX, computeIchimoku, computeSupertrend, } from '../../shared/indicators-extended.js';
+// ─── Condition Registry ────────────────────────────────────────────────
+const REGISTRY = new Map();
+function register(type, fn) {
+    REGISTRY.set(type, fn);
+}
+export function getConditionFn(type) {
+    return REGISTRY.get(type);
+}
+export function hasCondition(type) {
+    return REGISTRY.has(type);
+}
+export function listConditionTypes() {
+    return Array.from(REGISTRY.keys());
+}
+/** Evaluate an array of condition configs. Returns SignalCondition[] + shared context. */
+export function evaluateConditions(configs, ctx, direction) {
+    const condCtx = {};
+    const conditions = configs.map(cfg => {
+        const fn = REGISTRY.get(cfg.type);
+        if (!fn) {
+            return { name: cfg.type, met: false, currentValue: 0, threshold: 0, description: `Unknown condition: ${cfg.type}` };
+        }
+        const result = fn(ctx, cfg.params, direction, condCtx);
+        return { name: cfg.type, met: result.met, currentValue: result.value, threshold: result.threshold, description: result.description };
+    });
+    return { conditions, condCtx };
+}
+// ─── 1. ema_proximity ──────────────────────────────────────────────────
+// Price within X% of EMA(N)
+register('ema_proximity', (ctx, params, _dir, condCtx) => {
+    const period = params.period ?? 21;
+    const maxDistPct = params.maxDistPct ?? 0.003;
+    const closes = ctx.ohlcv1h.map(b => b.close);
+    const ema = computeEMA(closes, period);
+    const dist = Math.abs(ctx.currentPrice - ema) / ema;
+    const met = dist <= maxDistPct;
+    // Store EMA for entry rule
+    condCtx.ema21 = period === 21 ? ema : condCtx.ema21;
+    return {
+        met,
+        value: Math.round(dist * 10000) / 100,
+        threshold: maxDistPct * 100,
+        description: met
+            ? `Price within ${(dist * 100).toFixed(2)}% of EMA(${period})`
+            : `Price ${(dist * 100).toFixed(2)}% from EMA(${period}) (need ≤${maxDistPct * 100}%)`,
+    };
+});
+// ─── 2. orderbook_imbalance ────────────────────────────────────────────
+// OB imbalance favors direction; auto-passes in backtest mode
+register('orderbook_imbalance', (ctx, params, direction) => {
+    const threshold = params.threshold ?? 0.6;
+    if (ctx.backtestMode) {
+        return { met: true, value: 50, threshold: threshold * 100, description: 'Skipped (no historical orderbook)' };
+    }
+    const met = direction === 'LONG'
+        ? ctx.obImbalance > threshold
+        : direction === 'SHORT'
+            ? ctx.obImbalance < 1 - threshold
+            : Math.abs(ctx.obImbalance - 0.5) > (threshold - 0.5);
+    return {
+        met,
+        value: Math.round(ctx.obImbalance * 100),
+        threshold: threshold * 100,
+        description: met
+            ? `Orderbook ${direction === 'LONG' ? 'bid' : 'ask'} imbalance ${(ctx.obImbalance * 100).toFixed(0)}%`
+            : `Orderbook imbalance ${(ctx.obImbalance * 100).toFixed(0)}% (need ${direction === 'LONG' ? '>' : '<'}${threshold * 100}%)`,
+    };
+});
+// ─── 3. funding_not_crowded ────────────────────────────────────────────
+// Funding z-score within bounds (not overcrowded)
+register('funding_not_crowded', (ctx, params) => {
+    const maxZScore = params.maxZScore ?? 2;
+    const zScore = ctx.fundingStd > 0
+        ? Math.abs((ctx.fundingRates[0] ?? 0) - ctx.fundingMean) / ctx.fundingStd
+        : 0;
+    const met = zScore < maxZScore;
+    return {
+        met,
+        value: Math.round(zScore * 100) / 100,
+        threshold: maxZScore,
+        description: met
+            ? `Funding z-score ${zScore.toFixed(2)} (not crowded)`
+            : `Funding z-score ${zScore.toFixed(2)} (crowded, need <${maxZScore}σ)`,
+    };
+});
+// ─── 4. oi_slope ───────────────────────────────────────────────────────
+// OI slope over N slots is >= minSlope (steady or rising)
+register('oi_slope', (ctx, params) => {
+    const lookbackSlots = params.lookbackSlots ?? 16;
+    const minSlope = params.minSlope ?? 0;
+    const oiRecent = ctx.oiValues.slice(0, lookbackSlots).reverse();
+    const slope = oiRecent.length >= 4 ? linearSlope(oiRecent) : 0;
+    const met = slope >= minSlope;
+    return {
+        met,
+        value: Math.round(slope * 100) / 100,
+        threshold: minSlope,
+        description: met
+            ? `OI slope ${slope >= 0 ? '+' : ''}${slope.toFixed(2)} (steady/rising)`
+            : `OI slope ${slope.toFixed(2)} (declining)`,
+    };
+});
+// ─── 5. no_liquidation_cluster ─────────────────────────────────────────
+// No major liq cluster near entry; auto-passes in backtest mode
+register('no_liquidation_cluster', (ctx, params) => {
+    const maxUsd = params.maxUsd ?? 500_000;
+    if (ctx.backtestMode) {
+        return { met: true, value: 0, threshold: maxUsd, description: 'Skipped (no historical liquidation data)' };
+    }
+    const met = ctx.liqNearEntry < maxUsd;
+    return {
+        met,
+        value: Math.round(ctx.liqNearEntry),
+        threshold: maxUsd,
+        description: met
+            ? `Liquidations near entry $${(ctx.liqNearEntry / 1000).toFixed(0)}k (below threshold)`
+            : `Liquidation cluster $${(ctx.liqNearEntry / 1000).toFixed(0)}k near entry (threshold $${(maxUsd / 1000).toFixed(0)}k)`,
+    };
+});
+// ─── 6. price_sweep ────────────────────────────────────────────────────
+// Price swept a swing high/low on 5m, then reversed
+register('price_sweep', (ctx, params, _dir, condCtx) => {
+    const swingLookback = params.swingLookback ?? 5;
+    const recentBarCount = params.recentBars ?? 10;
+    const bars5m = ctx.ohlcv5m;
+    if (bars5m.length < 50) {
+        return { met: false, value: 0, threshold: 0, description: 'Insufficient 5m data' };
+    }
+    const lookbackBars = bars5m.slice(0, -recentBarCount);
+    const recentBars = bars5m.slice(-recentBarCount);
+    const swings = findSwingPoints(lookbackBars, swingLookback);
+    const latestClose = recentBars[recentBars.length - 1].close;
+    const recentLow = Math.min(...recentBars.map(b => b.low));
+    const recentHigh = Math.max(...recentBars.map(b => b.high));
+    let sweptLow = false;
+    let sweptHigh = false;
+    let sweepLevel = 0;
+    if (swings.lows.length > 0) {
+        const nearestLow = Math.min(...swings.lows.slice(-5));
+        if (recentLow < nearestLow && latestClose > nearestLow) {
+            sweptLow = true;
+            sweepLevel = nearestLow;
+        }
+    }
+    if (!sweptLow && swings.highs.length > 0) {
+        const nearestHigh = Math.max(...swings.highs.slice(-5));
+        if (recentHigh > nearestHigh && latestClose < nearestHigh) {
+            sweptHigh = true;
+            sweepLevel = nearestHigh;
+        }
+    }
+    // Store in shared context for entry/stop rules and direction.
+    // sweptDirection is written non-destructively, like the funding_extreme /
+    // cvd_divergence setters: only when a sweep actually resolved a side. An
+    // unconditional write (including null on a no-sweep bar) clobbered a
+    // direction set by an earlier condition in the same evaluation, so a
+    // from_sweep/from_funding strategy listing price_sweep AFTER another
+    // setter could never fire.
+    condCtx.sweepLevel = sweepLevel;
+    condCtx.recentLow = recentLow;
+    condCtx.recentHigh = recentHigh;
+    if (sweptLow)
+        condCtx.sweptDirection = 'LONG';
+    else if (sweptHigh)
+        condCtx.sweptDirection = 'SHORT';
+    const met = sweptLow || sweptHigh;
+    return {
+        met,
+        value: sweepLevel,
+        threshold: 0,
+        description: sweptLow
+            ? `Swept swing low at ${sweepLevel.toFixed(2)}, reversed above`
+            : sweptHigh
+                ? `Swept swing high at ${sweepLevel.toFixed(2)}, reversed below`
+                : 'No sweep detected',
+    };
+});
+// ─── 7. liquidations_at_sweep ──────────────────────────────────────────
+// Liquidation volume at sweep level above minimum; auto-passes in backtest
+register('liquidations_at_sweep', (ctx, params) => {
+    const minUsd = params.minUsd ?? 200_000;
+    if (ctx.backtestMode) {
+        return { met: true, value: 0, threshold: minUsd, description: 'Skipped (no historical liquidation data)' };
+    }
+    const liq = ctx.liqNearEntry;
+    const met = liq > minUsd;
+    return {
+        met,
+        value: Math.round(liq),
+        threshold: minUsd,
+        description: met
+            ? `$${(liq / 1000).toFixed(0)}k liquidations at sweep level`
+            : `Only $${(liq / 1000).toFixed(0)}k liquidations (need >${(minUsd / 1000).toFixed(0)}k)`,
+    };
+});
+// ─── 8. order_flow_absorption ──────────────────────────────────────────
+// High volume but small net delta = absorption
+register('order_flow_absorption', (ctx, params) => {
+    const maxRatio = params.maxRatio ?? 0.3;
+    const totalBuy = ctx.tradeFlow.reduce((s, b) => s + b.buyVolume, 0);
+    const totalSell = ctx.tradeFlow.reduce((s, b) => s + b.sellVolume, 0);
+    const totalVolume = totalBuy + totalSell;
+    const netDelta = Math.abs(totalBuy - totalSell);
+    const ratio = totalVolume > 0 ? netDelta / totalVolume : 1;
+    const met = ratio < maxRatio;
+    return {
+        met,
+        value: Math.round(ratio * 100),
+        threshold: maxRatio * 100,
+        description: met
+            ? `Absorption detected: delta/volume ratio ${(ratio * 100).toFixed(0)}%`
+            : `No absorption: delta/volume ratio ${(ratio * 100).toFixed(0)}% (need <${(maxRatio * 100).toFixed(0)}%)`,
+    };
+});
+// ─── 9. funding_contrarian ─────────────────────────────────────────────
+// Funding not extreme in the direction of trade (direction-aware)
+register('funding_contrarian', (ctx, params, direction) => {
+    const maxZScore = params.maxZScore ?? 1.5;
+    const currentFunding = ctx.fundingRates[0] ?? 0;
+    const zScore = ctx.fundingStd > 0 ? (currentFunding - ctx.fundingMean) / ctx.fundingStd : 0;
+    const met = direction === 'LONG'
+        ? zScore > -maxZScore
+        : direction === 'SHORT'
+            ? zScore < maxZScore
+            : Math.abs(zScore) < maxZScore;
+    return {
+        met,
+        value: Math.round(zScore * 100) / 100,
+        threshold: maxZScore,
+        description: met
+            ? `Funding z-score ${zScore.toFixed(2)} (neutral/contrarian)`
+            : `Funding z-score ${zScore.toFixed(2)} (aligned with crowd)`,
+    };
+});
+// ─── 10. funding_extreme ───────────────────────────────────────────────
+// Funding > Nσ or < -Nσ from mean (for mean reversion setups)
+// Also determines direction: extreme positive → SHORT, extreme negative → LONG
+register('funding_extreme', (ctx, params, _dir, condCtx) => {
+    const minZScore = params.minZScore ?? 3;
+    const currentFunding = ctx.fundingRates[0] ?? 0;
+    const zScore = ctx.fundingStd > 0 ? (currentFunding - ctx.fundingMean) / ctx.fundingStd : 0;
+    const isExtremePositive = zScore > minZScore;
+    const isExtremeNegative = zScore < -minZScore;
+    const met = isExtremePositive || isExtremeNegative;
+    // Store direction for from_funding rule
+    if (isExtremePositive)
+        condCtx.sweptDirection = 'SHORT';
+    else if (isExtremeNegative)
+        condCtx.sweptDirection = 'LONG';
+    return {
+        met,
+        value: Math.round(zScore * 100) / 100,
+        threshold: minZScore,
+        description: met
+            ? `Funding z-score ${zScore.toFixed(2)} (extreme ${isExtremePositive ? 'positive' : 'negative'})`
+            : `Funding z-score ${zScore.toFixed(2)} (need >${minZScore}σ or <-${minZScore}σ)`,
+    };
+});
+// ─── 11. oi_elevated ───────────────────────────────────────────────────
+// OI above N× its average (elevated positioning)
+register('oi_elevated', (ctx, params) => {
+    const elevationRatio = params.elevationRatio ?? 1.1;
+    const oiCurrent = ctx.oiValues[0] ?? 0;
+    const oiAvg = ctx.oiValues.length > 10 ? mean(ctx.oiValues) : oiCurrent;
+    const ratio = oiAvg > 0 ? oiCurrent / oiAvg : 1;
+    const met = ratio > elevationRatio;
+    return {
+        met,
+        value: Math.round(ratio * 100) / 100,
+        threshold: elevationRatio,
+        description: met
+            ? `OI ${((ratio - 1) * 100).toFixed(0)}% above average (crowded positioning)`
+            : `OI only ${((ratio - 1) * 100).toFixed(0)}% vs average (need >${((elevationRatio - 1) * 100).toFixed(0)}%)`,
+    };
+});
+// ─── 12. price_at_level ────────────────────────────────────────────────
+// Price near a technically significant level (EMA50, EMA200, or swing)
+register('price_at_level', (ctx, params) => {
+    const maxDistPct = params.maxDistPct ?? 0.005;
+    const closes = ctx.ohlcv1h.map(b => b.close);
+    const ema50 = computeEMA(closes, params.emaPeriod1 ?? 50);
+    const ema200 = computeEMA(closes, params.emaPeriod2 ?? 200);
+    const swingLookbackBars = params.swingLookbackBars ?? 48;
+    const swingLookback = params.swingLookback ?? 3;
+    const swings = findSwingPoints(ctx.ohlcv1h.slice(-swingLookbackBars), swingLookback);
+    const distToEma50 = Math.abs(ctx.currentPrice - ema50) / ema50;
+    const distToEma200 = Math.abs(ctx.currentPrice - ema200) / ema200;
+    const distToSwing = Math.min(...swings.highs.slice(-5).map(h => Math.abs(ctx.currentPrice - h) / ctx.currentPrice), ...swings.lows.slice(-5).map(l => Math.abs(ctx.currentPrice - l) / ctx.currentPrice), 1);
+    const closestDist = Math.min(distToEma50, distToEma200, distToSwing);
+    const met = closestDist < maxDistPct;
+    return {
+        met,
+        value: Math.round(closestDist * 10000) / 100,
+        threshold: maxDistPct * 10000 / 100,
+        description: met
+            ? `Price within ${(closestDist * 100).toFixed(2)}% of significant level`
+            : `Price ${(closestDist * 100).toFixed(2)}% from nearest level (need ≤${(maxDistPct * 100).toFixed(1)}%)`,
+    };
+});
+// ─── 13. macd_crossover ──────────────────────────────────────────────────
+// MACD line crossed signal in trade direction
+register('macd_crossover', (ctx, params, direction) => {
+    const closes = ctx.ohlcv1h.map(b => b.close);
+    const macd = computeMACD(closes, params.fast ?? 12, params.slow ?? 26, params.signal ?? 9);
+    const met = direction === 'LONG'
+        ? macd.crossover === 'bullish'
+        : direction === 'SHORT'
+            ? macd.crossover === 'bearish'
+            : macd.crossover !== 'none';
+    return {
+        met,
+        value: Math.round(macd.histogram * 100) / 100,
+        threshold: 0,
+        description: met
+            ? `MACD ${macd.crossover} crossover (histogram ${macd.histogram.toFixed(2)})`
+            : `No MACD crossover in trade direction (histogram ${macd.histogram.toFixed(2)})`,
+    };
+});
+// ─── 14. macd_divergence ─────────────────────────────────────────────────
+// Price vs MACD divergence (trend weakening)
+register('macd_divergence', (ctx) => {
+    const closes = ctx.ohlcv1h.map(b => b.close);
+    const macd = computeMACD(closes, 12, 26, 9);
+    if (closes.length < 20) {
+        return { met: false, value: 0, threshold: 0, description: 'Insufficient data for divergence' };
+    }
+    const recent = closes.slice(-20);
+    const priceUp = recent[recent.length - 1] > recent[0];
+    const histDown = macd.histogram < 0;
+    const priceDown = recent[recent.length - 1] < recent[0];
+    const histUp = macd.histogram > 0;
+    const met = (priceUp && histDown) || (priceDown && histUp);
+    return {
+        met,
+        value: Math.round(macd.histogram * 100) / 100,
+        threshold: 0,
+        description: met
+            ? `MACD divergence: price ${priceUp ? 'rising' : 'falling'} vs histogram ${histUp ? 'positive' : 'negative'}`
+            : 'No MACD divergence detected',
+    };
+});
+// ─── 15. bollinger_squeeze ───────────────────────────────────────────────
+// Bollinger bandwidth below threshold (compression)
+register('bollinger_squeeze', (ctx, params) => {
+    const closes = ctx.ohlcv1h.map(b => b.close);
+    const bb = computeBollingerBands(closes, params.period ?? 20, params.stdDev ?? 2);
+    const maxBandwidth = params.maxBandwidth ?? 3.0;
+    const met = bb.bandwidth < maxBandwidth;
+    return {
+        met,
+        value: Math.round(bb.bandwidth * 100) / 100,
+        threshold: maxBandwidth,
+        description: met
+            ? `Bollinger squeeze: bandwidth ${bb.bandwidth.toFixed(2)}% (compressed)`
+            : `Bollinger bandwidth ${bb.bandwidth.toFixed(2)}% (need <${maxBandwidth}%)`,
+    };
+});
+// ─── 16. bollinger_breakout ──────────────────────────────────────────────
+// Price closes outside Bollinger band
+register('bollinger_breakout', (ctx, params, direction) => {
+    const closes = ctx.ohlcv1h.map(b => b.close);
+    const bb = computeBollingerBands(closes, params.period ?? 20, params.stdDev ?? 2);
+    const met = direction === 'LONG'
+        ? bb.percentB > 1
+        : direction === 'SHORT'
+            ? bb.percentB < 0
+            : bb.percentB > 1 || bb.percentB < 0;
+    return {
+        met,
+        value: Math.round(bb.percentB * 100) / 100,
+        threshold: direction === 'SHORT' ? 0 : 1,
+        description: met
+            ? `Bollinger breakout: %B=${bb.percentB.toFixed(2)} (outside band)`
+            : `Price inside Bollinger bands: %B=${bb.percentB.toFixed(2)}`,
+    };
+});
+// ─── 17. vwap_position ───────────────────────────────────────────────────
+// Price above/below VWAP aligns with direction
+register('vwap_position', (ctx, params, direction) => {
+    const bars = ctx.ohlcv1h.slice(-24).map(b => ({
+        open: b.open, high: b.high, low: b.low, close: b.close, volume: b.volume,
+    }));
+    const vwap = computeVWAP(bars);
+    const above = ctx.currentPrice > vwap;
+    const met = direction === 'LONG' ? above : direction === 'SHORT' ? !above : true;
+    const distPct = vwap > 0 ? ((ctx.currentPrice - vwap) / vwap) * 100 : 0;
+    return {
+        met,
+        value: Math.round(distPct * 100) / 100,
+        threshold: 0,
+        description: met
+            ? `Price ${above ? 'above' : 'below'} VWAP (${distPct.toFixed(2)}%)`
+            : `Price on wrong side of VWAP for ${direction} (${distPct.toFixed(2)}%)`,
+    };
+});
+// ─── 18. stoch_rsi_extreme ───────────────────────────────────────────────
+// StochRSI in extreme zone
+register('stoch_rsi_extreme', (ctx, params, direction) => {
+    const closes = ctx.ohlcv1h.map(b => b.close);
+    const sr = computeStochRSI(closes, 14, 14, 3, 3);
+    const oversoldThreshold = params.oversold ?? 20;
+    const overboughtThreshold = params.overbought ?? 80;
+    const met = direction === 'LONG'
+        ? sr.k < oversoldThreshold
+        : direction === 'SHORT'
+            ? sr.k > overboughtThreshold
+            : sr.k < oversoldThreshold || sr.k > overboughtThreshold;
+    return {
+        met,
+        value: sr.k,
+        threshold: direction === 'SHORT' ? overboughtThreshold : oversoldThreshold,
+        description: met
+            ? `StochRSI extreme: K=${sr.k} (${sr.k < 50 ? 'oversold' : 'overbought'})`
+            : `StochRSI K=${sr.k} (not extreme)`,
+    };
+});
+// ─── 19. adx_trending ────────────────────────────────────────────────────
+// ADX above threshold (trending market)
+register('adx_trending', (ctx, params) => {
+    const closes = ctx.ohlcv1h.map(b => b.close);
+    const highs = ctx.ohlcv1h.map(b => b.high);
+    const lows = ctx.ohlcv1h.map(b => b.low);
+    const adx = computeADX(highs, lows, closes, params.period ?? 14);
+    const minAdx = params.minAdx ?? 25;
+    const met = adx.adx > minAdx;
+    return {
+        met,
+        value: adx.adx,
+        threshold: minAdx,
+        description: met
+            ? `ADX ${adx.adx} (trending, +DI=${adx.plusDI} -DI=${adx.minusDI})`
+            : `ADX ${adx.adx} (not trending, need >${minAdx})`,
+    };
+});
+// ─── 20. adx_ranging ─────────────────────────────────────────────────────
+// ADX below threshold (ranging market)
+register('adx_ranging', (ctx, params) => {
+    const closes = ctx.ohlcv1h.map(b => b.close);
+    const highs = ctx.ohlcv1h.map(b => b.high);
+    const lows = ctx.ohlcv1h.map(b => b.low);
+    const adx = computeADX(highs, lows, closes, params.period ?? 14);
+    const maxAdx = params.maxAdx ?? 20;
+    const met = adx.adx < maxAdx;
+    return {
+        met,
+        value: adx.adx,
+        threshold: maxAdx,
+        description: met
+            ? `ADX ${adx.adx} (ranging, choppy market)`
+            : `ADX ${adx.adx} (too strong for range, need <${maxAdx})`,
+    };
+});
+// ─── 21. ichimoku_cloud ──────────────────────────────────────────────────
+// Price position relative to Ichimoku cloud + TK cross
+register('ichimoku_cloud', (ctx, params, direction) => {
+    const closes = ctx.ohlcv1h.map(b => b.close);
+    const highs = ctx.ohlcv1h.map(b => b.high);
+    const lows = ctx.ohlcv1h.map(b => b.low);
+    const ichi = computeIchimoku(highs, lows, closes, 9, 26, 52);
+    const bullish = ichi.cloudPosition === 'above' && ichi.tenkan > ichi.kijun;
+    const bearish = ichi.cloudPosition === 'below' && ichi.tenkan < ichi.kijun;
+    const met = direction === 'LONG' ? bullish : direction === 'SHORT' ? bearish : bullish || bearish;
+    return {
+        met,
+        value: ichi.cloudPosition === 'above' ? 1 : ichi.cloudPosition === 'below' ? -1 : 0,
+        threshold: 0,
+        description: met
+            ? `Ichimoku ${bullish ? 'bullish' : 'bearish'}: ${ichi.cloudPosition} cloud, TK ${ichi.tenkan > ichi.kijun ? 'bull' : 'bear'} cross`
+            : `Ichimoku neutral: ${ichi.cloudPosition} cloud`,
+    };
+});
+// ─── 22. obv_divergence ──────────────────────────────────────────────────
+// OBV diverges from price
+register('obv_divergence', (ctx, params, direction) => {
+    const closes = ctx.ohlcv1h.map(b => b.close);
+    const volumes = ctx.ohlcv1h.map(b => b.volume);
+    if (closes.length < 20) {
+        return { met: false, value: 0, threshold: 0, description: 'Insufficient data' };
+    }
+    const recentCloses = closes.slice(-20);
+    const recentVolumes = volumes.slice(-20);
+    let obv = 0;
+    const obvSeries = [0];
+    for (let i = 1; i < recentCloses.length; i++) {
+        if (recentCloses[i] > recentCloses[i - 1])
+            obv += recentVolumes[i];
+        else if (recentCloses[i] < recentCloses[i - 1])
+            obv -= recentVolumes[i];
+        obvSeries.push(obv);
+    }
+    const priceSlope = linearSlope(recentCloses);
+    const obvSlope = linearSlope(obvSeries);
+    const bullishDiv = priceSlope < 0 && obvSlope > 0;
+    const bearishDiv = priceSlope > 0 && obvSlope < 0;
+    const met = direction === 'LONG' ? bullishDiv : direction === 'SHORT' ? bearishDiv : bullishDiv || bearishDiv;
+    return {
+        met,
+        value: Math.round(obvSlope * 100) / 100,
+        threshold: 0,
+        description: met
+            ? `OBV ${bullishDiv ? 'bullish' : 'bearish'} divergence (accumulation/distribution)`
+            : 'No OBV divergence detected',
+    };
+});
+// ─── 24. cvd_divergence_bullish ──────────────────────────────────────────
+// CVD bullish divergence detected (price lower low + CVD higher low)
+register('cvd_divergence_bullish', (ctx, _params, _dir, condCtx) => {
+    if (!ctx.cvd) {
+        if (ctx.backtestMode)
+            return { met: true, value: 0, threshold: 0, description: 'Skipped (no CVD data in backtest)' };
+        return { met: false, value: 0, threshold: 0, description: 'No CVD data available' };
+    }
+    const met = ctx.cvd.cvdDivergence === 'bullish';
+    if (met)
+        condCtx.sweptDirection = condCtx.sweptDirection ?? 'LONG';
+    return {
+        met,
+        value: Math.round(ctx.cvd.cvdDivergenceStrength * 100),
+        threshold: 0,
+        description: met
+            ? `CVD bullish divergence (strength ${(ctx.cvd.cvdDivergenceStrength * 100).toFixed(0)}%)`
+            : 'No CVD bullish divergence',
+    };
+});
+// ─── 25. cvd_divergence_bearish ─────────────────────────────────────────
+// CVD bearish divergence detected (price higher high + CVD lower high)
+register('cvd_divergence_bearish', (ctx, _params, _dir, condCtx) => {
+    if (!ctx.cvd) {
+        if (ctx.backtestMode)
+            return { met: true, value: 0, threshold: 0, description: 'Skipped (no CVD data in backtest)' };
+        return { met: false, value: 0, threshold: 0, description: 'No CVD data available' };
+    }
+    const met = ctx.cvd.cvdDivergence === 'bearish';
+    if (met)
+        condCtx.sweptDirection = condCtx.sweptDirection ?? 'SHORT';
+    return {
+        met,
+        value: Math.round(ctx.cvd.cvdDivergenceStrength * 100),
+        threshold: 0,
+        description: met
+            ? `CVD bearish divergence (strength ${(ctx.cvd.cvdDivergenceStrength * 100).toFixed(0)}%)`
+            : 'No CVD bearish divergence',
+    };
+});
+// ─── 26. cvd_positive_slope ─────────────────────────────────────────────
+// CVD slope is positive (buying pressure increasing)
+register('cvd_positive_slope', (ctx, params) => {
+    if (!ctx.cvd) {
+        if (ctx.backtestMode)
+            return { met: true, value: 0, threshold: 0, description: 'Skipped (no CVD data in backtest)' };
+        return { met: false, value: 0, threshold: 0, description: 'No CVD data available' };
+    }
+    const minSlope = params.minSlope ?? 0;
+    const met = ctx.cvd.cvdSlope1h > minSlope;
+    return {
+        met,
+        value: Math.round(ctx.cvd.cvdSlope1h * 100) / 100,
+        threshold: minSlope,
+        description: met
+            ? `CVD slope positive: ${ctx.cvd.cvdSlope1h.toFixed(2)} (buying pressure increasing)`
+            : `CVD slope ${ctx.cvd.cvdSlope1h.toFixed(2)} (buying pressure weak)`,
+    };
+});
+// ─── 27. cvd_negative_slope ─────────────────────────────────────────────
+// CVD slope is negative (selling pressure increasing)
+register('cvd_negative_slope', (ctx, params) => {
+    if (!ctx.cvd) {
+        if (ctx.backtestMode)
+            return { met: true, value: 0, threshold: 0, description: 'Skipped (no CVD data in backtest)' };
+        return { met: false, value: 0, threshold: 0, description: 'No CVD data available' };
+    }
+    const maxSlope = params.maxSlope ?? 0;
+    const met = ctx.cvd.cvdSlope1h < maxSlope;
+    return {
+        met,
+        value: Math.round(ctx.cvd.cvdSlope1h * 100) / 100,
+        threshold: maxSlope,
+        description: met
+            ? `CVD slope negative: ${ctx.cvd.cvdSlope1h.toFixed(2)} (selling pressure increasing)`
+            : `CVD slope ${ctx.cvd.cvdSlope1h.toFixed(2)} (selling pressure weak)`,
+    };
+});
+// ─── 28. cvd_extreme ────────────────────────────────────────────────────
+// CVD z-score at extreme (>2σ = exhaustion signal)
+register('cvd_extreme', (ctx, params) => {
+    if (!ctx.cvd) {
+        if (ctx.backtestMode)
+            return { met: true, value: 0, threshold: 0, description: 'Skipped (no CVD data in backtest)' };
+        return { met: false, value: 0, threshold: 0, description: 'No CVD data available' };
+    }
+    const minZScore = params.minZScore ?? 2;
+    const absZ = Math.abs(ctx.cvd.cvdZScore);
+    const met = absZ > minZScore;
+    return {
+        met,
+        value: Math.round(ctx.cvd.cvdZScore * 100) / 100,
+        threshold: minZScore,
+        description: met
+            ? `CVD extreme: z-score ${ctx.cvd.cvdZScore.toFixed(2)} (${ctx.cvd.cvdZScore > 0 ? 'buying' : 'selling'} exhaustion)`
+            : `CVD z-score ${ctx.cvd.cvdZScore.toFixed(2)} (not extreme, need >${minZScore}σ)`,
+    };
+});
+// ─── 23. supertrend_direction ────────────────────────────────────────────
+// Supertrend indicator direction matches trade direction
+register('supertrend_direction', (ctx, params, direction) => {
+    const closes = ctx.ohlcv1h.map(b => b.close);
+    const highs = ctx.ohlcv1h.map(b => b.high);
+    const lows = ctx.ohlcv1h.map(b => b.low);
+    const st = computeSupertrend(highs, lows, closes, params.period ?? 10, params.multiplier ?? 3);
+    const met = direction === 'LONG'
+        ? st.direction === 'bullish'
+        : direction === 'SHORT'
+            ? st.direction === 'bearish'
+            : true;
+    return {
+        met,
+        value: st.direction === 'bullish' ? 1 : -1,
+        threshold: 0,
+        description: met
+            ? `Supertrend ${st.direction} (value ${st.value.toFixed(2)})`
+            : `Supertrend ${st.direction} conflicts with ${direction} direction`,
+    };
+});
+// ─── Helpers for higher-timeframe pattern conditions (Path B) ─────────
+// All conditions below honour params.tfHours: 1 (default, ohlcv1h),
+// 4 (ohlcv4h), or 24 (ohlcv1d). When the requested higher timeframe is
+// unavailable on this MarketContext, they fall back to ohlcv1h so unit
+// tests and legacy contexts still work.
+function pickBars(ctx, tfHours) {
+    if (tfHours >= 24)
+        return ctx.ohlcv1d ?? ctx.ohlcv1h;
+    if (tfHours >= 4)
+        return ctx.ohlcv4h ?? ctx.ohlcv1h;
+    return ctx.ohlcv1h;
+}
+/** Pivot finder that returns indices alongside prices. We can't reuse
+ *  `findSwingPoints` from shared/indicators because it discards indices,
+ *  and trendline-fit + multi-pivot divergence both need them. */
+function findPivotsIdx(bars, lookback) {
+    const highs = [];
+    const lows = [];
+    for (let i = lookback; i < bars.length - lookback; i++) {
+        let isHigh = true;
+        let isLow = true;
+        for (let j = i - lookback; j <= i + lookback; j++) {
+            if (j === i)
+                continue;
+            if (bars[j].high >= bars[i].high)
+                isHigh = false;
+            if (bars[j].low <= bars[i].low)
+                isLow = false;
+        }
+        if (isHigh)
+            highs.push({ idx: i, price: bars[i].high });
+        if (isLow)
+            lows.push({ idx: i, price: bars[i].low });
+    }
+    return { highs, lows };
+}
+// ─── 30. ema_slope ───────────────────────────────────────────────────
+// EMA(N) is sloping in the trade direction at >= minSlopePct per bar
+// (slope normalised by current EMA value, so it's a percent change rate).
+// params: period, lookback, minSlopePct, dirSign (1=up,-1=down,0=use trade direction), tfHours
+register('ema_slope', (ctx, params, direction) => {
+    const period = Math.floor(params.period ?? 21);
+    const lookback = Math.floor(params.lookback ?? 5);
+    const minSlopePct = params.minSlopePct ?? 0;
+    const dirSign = params.dirSign ?? 0;
+    const tfHours = params.tfHours ?? 1;
+    const bars = pickBars(ctx, tfHours);
+    if (bars.length < period + lookback + 5) {
+        return { met: false, value: 0, threshold: minSlopePct * 100, description: `Insufficient ${tfHours}h bars for ema_slope` };
+    }
+    const closes = bars.map((b) => b.close);
+    const emaSeries = [];
+    for (let i = closes.length - lookback - 1; i < closes.length; i++) {
+        emaSeries.push(computeEMA(closes.slice(0, i + 1), period));
+    }
+    const slope = linearSlope(emaSeries);
+    const lastEma = emaSeries[emaSeries.length - 1];
+    const slopePct = lastEma > 0 ? slope / lastEma : 0;
+    const requiredSign = dirSign !== 0
+        ? Math.sign(dirSign)
+        : direction === 'LONG' ? 1 : direction === 'SHORT' ? -1 : 0;
+    const met = requiredSign === 0
+        ? Math.abs(slopePct) >= minSlopePct
+        : (slopePct * requiredSign) >= minSlopePct;
+    return {
+        met,
+        value: Math.round(slopePct * 1_000_000) / 10_000,
+        threshold: minSlopePct * 100,
+        description: met
+            ? `EMA(${period}) slope ${(slopePct * 100).toFixed(3)}%/bar over ${lookback} ${tfHours}h bars (${slopePct > 0 ? 'rising' : slopePct < 0 ? 'falling' : 'flat'})`
+            : `EMA(${period}) slope ${(slopePct * 100).toFixed(3)}%/bar fails ${requiredSign > 0 ? '≥+' : requiredSign < 0 ? '≤−' : '|·|≥'}${(minSlopePct * 100).toFixed(3)}%`,
+    };
+});
+// ─── 31. volume_vs_sma ───────────────────────────────────────────────
+// Latest bar volume >= multiplier × N-bar SMA of prior volumes.
+// params: period, minMultiplier, tfHours
+register('volume_vs_sma', (ctx, params) => {
+    const period = Math.floor(params.period ?? 20);
+    const minMultiplier = params.minMultiplier ?? 1.5;
+    const tfHours = params.tfHours ?? 1;
+    const bars = pickBars(ctx, tfHours);
+    if (bars.length < period + 1) {
+        return { met: false, value: 0, threshold: minMultiplier, description: `Insufficient ${tfHours}h bars for volume_vs_sma` };
+    }
+    const currentVol = bars[bars.length - 1].volume;
+    const prevVols = bars.slice(-period - 1, -1).map((b) => b.volume);
+    const sma = mean(prevVols);
+    const ratio = sma > 0 ? currentVol / sma : 0;
+    const met = ratio >= minMultiplier;
+    return {
+        met,
+        value: Math.round(ratio * 100) / 100,
+        threshold: minMultiplier,
+        description: met
+            ? `Volume ${ratio.toFixed(2)}× ${period}-bar SMA on ${tfHours}h`
+            : `Volume only ${ratio.toFixed(2)}× ${period}-bar SMA (need ≥${minMultiplier}×)`,
+    };
+});
+// Direction-aware return momentum over a fixed lookback.
+//
+// params:
+//   lookback: bars back from the latest close
+//   minReturnPct: decimal return threshold, e.g. 0.02 = 2%
+//   maxAbsReturnPct: optional decimal cap to avoid chasing blow-off moves
+//   mode: 1 = momentum with direction, -1 = counter-move into direction,
+//         0 = absolute move either way
+//   dirSign: 1 long/up, -1 short/down, 0 use resolved trade direction
+//   tfHours: 1, 4, or 24
+register('return_momentum', (ctx, params, direction) => {
+    const lookback = Math.max(1, Math.floor(params.lookback ?? 12));
+    const minReturnPct = params.minReturnPct ?? 0.01;
+    const maxAbsReturnPct = params.maxAbsReturnPct ?? 0;
+    const mode = params.mode === 0 ? 0 : params.mode && params.mode < 0 ? -1 : 1;
+    const dirSign = params.dirSign ?? 0;
+    const tfHours = params.tfHours ?? 1;
+    const bars = pickBars(ctx, tfHours);
+    if (bars.length <= lookback) {
+        return {
+            met: false,
+            value: 0,
+            threshold: minReturnPct * 100,
+            description: `Insufficient ${tfHours}h bars for return_momentum`,
+        };
+    }
+    const currentClose = bars[bars.length - 1].close;
+    const priorClose = bars[bars.length - 1 - lookback].close;
+    const ret = priorClose > 0 ? (currentClose - priorClose) / priorClose : 0;
+    const absRet = Math.abs(ret);
+    const baseSign = dirSign !== 0
+        ? Math.sign(dirSign)
+        : direction === 'LONG' ? 1 : direction === 'SHORT' ? -1 : 0;
+    const targetSign = mode === 0 || baseSign === 0 ? 0 : baseSign * mode;
+    const directionOk = targetSign > 0
+        ? ret >= minReturnPct
+        : targetSign < 0
+            ? ret <= -minReturnPct
+            : absRet >= minReturnPct;
+    const extensionOk = maxAbsReturnPct <= 0 || absRet <= maxAbsReturnPct;
+    const met = directionOk && extensionOk;
+    const label = targetSign > 0
+        ? 'upside momentum'
+        : targetSign < 0
+            ? 'downside momentum'
+            : 'absolute momentum';
+    const capText = maxAbsReturnPct > 0 ? `, cap ${(maxAbsReturnPct * 100).toFixed(1)}%` : '';
+    return {
+        met,
+        value: Math.round(ret * 10000) / 100,
+        threshold: minReturnPct * 100,
+        description: met
+            ? `${lookback}-bar ${tfHours}h return ${(ret * 100).toFixed(2)}% confirms ${label}`
+            : `${lookback}-bar ${tfHours}h return ${(ret * 100).toFixed(2)}% fails ${label} threshold ${(minReturnPct * 100).toFixed(1)}%${capText}`,
+    };
+});
+// Strict return-momentum episode transition. Unlike return_momentum, this is
+// an event rather than a level: it fires once when the lookback return crosses
+// zero (or an explicit threshold), then remains false until the sign resets.
+// That makes stop-outs and capacity-rejected entries naturally lock out for
+// the rest of the same momentum episode.
+register('return_momentum_zero_cross', (ctx, params, direction) => {
+    const lookback = Math.max(1, Math.floor(params.lookback ?? 28));
+    const thresholdPct = Math.max(0, params.thresholdPct ?? 0);
+    const dirSign = params.dirSign ?? 0;
+    const tfHours = params.tfHours ?? 24;
+    const bars = pickBars(ctx, tfHours);
+    if (bars.length <= lookback + 1) {
+        return {
+            met: false,
+            value: 0,
+            threshold: thresholdPct * 100,
+            description: `Insufficient ${tfHours}h bars for return_momentum_zero_cross`,
+        };
+    }
+    const currentClose = bars[bars.length - 1].close;
+    const currentPrior = bars[bars.length - 1 - lookback].close;
+    const previousClose = bars[bars.length - 2].close;
+    const previousPrior = bars[bars.length - 2 - lookback].close;
+    const currentReturn = currentPrior > 0
+        ? (currentClose - currentPrior) / currentPrior
+        : Number.NaN;
+    const previousReturn = previousPrior > 0
+        ? (previousClose - previousPrior) / previousPrior
+        : Number.NaN;
+    const sign = dirSign !== 0
+        ? Math.sign(dirSign)
+        : direction === 'LONG' ? 1 : direction === 'SHORT' ? -1 : 0;
+    const met = Number.isFinite(currentReturn)
+        && Number.isFinite(previousReturn)
+        && (sign > 0
+            ? previousReturn <= thresholdPct && currentReturn > thresholdPct
+            : sign < 0
+                ? previousReturn >= -thresholdPct && currentReturn < -thresholdPct
+                : false);
+    return {
+        met,
+        value: Number.isFinite(currentReturn)
+            ? Math.round(currentReturn * 10000) / 100
+            : 0,
+        threshold: thresholdPct * 100,
+        description: Number.isFinite(currentReturn) && Number.isFinite(previousReturn)
+            ? `${lookback}-bar ${tfHours}h return moved from ${(previousReturn * 100).toFixed(2)}% to ${(currentReturn * 100).toFixed(2)}%`
+            : `Invalid ${tfHours}h prices for return_momentum_zero_cross`,
+    };
+});
+// ─── 32. rsi_multi_pivot_divergence ──────────────────────────────────
+// Strict N-pivot RSI divergence: price makes successively lower lows (or
+// higher highs) while RSI makes the opposite, with optional volume dry-up
+// at the final pivot.
+// params: pivots, swingLookback, rsiPeriod, volumeDryUp (0=disabled,
+// 0..1=ratio cap of last/first vol), direction (1=bullish, -1=bearish), tfHours
+register('rsi_multi_pivot_divergence', (ctx, params) => {
+    const pivotsN = Math.max(2, Math.floor(params.pivots ?? 3));
+    const swingLookback = Math.floor(params.swingLookback ?? 5);
+    const rsiPeriod = Math.floor(params.rsiPeriod ?? 14);
+    const volumeDryUp = params.volumeDryUp ?? 0;
+    const dirParam = params.direction ?? 1;
+    const isBullish = dirParam >= 0;
+    const tfHours = params.tfHours ?? 1;
+    const bars = pickBars(ctx, tfHours);
+    if (bars.length < rsiPeriod + swingLookback * 2 + 10) {
+        return { met: false, value: 0, threshold: pivotsN, description: `Insufficient ${tfHours}h bars for rsi_multi_pivot_divergence` };
+    }
+    const found = findPivotsIdx(bars, swingLookback);
+    const piv = isBullish ? found.lows : found.highs;
+    if (piv.length < pivotsN) {
+        return {
+            met: false,
+            value: piv.length,
+            threshold: pivotsN,
+            description: `Only ${piv.length} pivot ${isBullish ? 'lows' : 'highs'} on ${tfHours}h (need ${pivotsN})`,
+        };
+    }
+    const last = piv.slice(-pivotsN);
+    // Price sequence check
+    let priceSeqOk = true;
+    for (let i = 1; i < last.length; i++) {
+        if (isBullish && !(last[i].price < last[i - 1].price))
+            priceSeqOk = false;
+        if (!isBullish && !(last[i].price > last[i - 1].price))
+            priceSeqOk = false;
+    }
+    if (!priceSeqOk) {
+        return {
+            met: false,
+            value: 0,
+            threshold: pivotsN,
+            description: `${isBullish ? 'Price lows' : 'Price highs'} not in ${isBullish ? 'descending' : 'ascending'} sequence: ${last.map((p) => p.price.toFixed(2)).join('→')}`,
+        };
+    }
+    // RSI at each pivot index
+    const closes = bars.map((b) => b.close);
+    const rsiAt = last.map((p) => computeRSI(closes.slice(0, p.idx + 1), rsiPeriod));
+    let rsiSeqOk = true;
+    for (let i = 1; i < rsiAt.length; i++) {
+        if (isBullish && !(rsiAt[i] > rsiAt[i - 1]))
+            rsiSeqOk = false;
+        if (!isBullish && !(rsiAt[i] < rsiAt[i - 1]))
+            rsiSeqOk = false;
+    }
+    if (!rsiSeqOk) {
+        return {
+            met: false,
+            value: rsiAt[rsiAt.length - 1] - rsiAt[0],
+            threshold: 0,
+            description: `RSI not diverging: ${rsiAt.map((r) => r.toFixed(0)).join('→')}`,
+        };
+    }
+    if (volumeDryUp > 0) {
+        const v0 = bars[last[0].idx].volume;
+        const vN = bars[last[last.length - 1].idx].volume;
+        const ratio = v0 > 0 ? vN / v0 : 1;
+        if (ratio > volumeDryUp) {
+            return {
+                met: false,
+                value: Math.round(ratio * 100) / 100,
+                threshold: volumeDryUp,
+                description: `No volume dry-up: last pivot vol ${(ratio * 100).toFixed(0)}% of first (need ≤${(volumeDryUp * 100).toFixed(0)}%)`,
+            };
+        }
+    }
+    return {
+        met: true,
+        value: Math.round((rsiAt[rsiAt.length - 1] - rsiAt[0]) * 100) / 100,
+        threshold: 0,
+        description: `${pivotsN}-pivot ${isBullish ? 'bullish' : 'bearish'} divergence on ${tfHours}h: price ${last.map((p) => p.price.toFixed(2)).join('→')}, RSI ${rsiAt.map((r) => r.toFixed(0)).join('→')}`,
+    };
+});
+// ─── 33. trendline_break ─────────────────────────────────────────────
+// Linear-fit a trendline through the last N pivot lows (or highs) and
+// check whether the latest close has broken through it in the requested
+// direction. Slope sign is also constrained to match the expected pattern
+// (descending trendline for bullish break above, ascending for bearish
+// break below).
+// params: pivots, swingLookback, useHighs (0=lows, 1=highs), breakDir
+// (1=above, -1=below), requireSlopeSign (1=ascending, -1=descending,
+// default flips with useHighs), tfHours
+register('trendline_break', (ctx, params) => {
+    const pivotsN = Math.max(2, Math.floor(params.pivots ?? 3));
+    const swingLookback = Math.floor(params.swingLookback ?? 5);
+    const useHighs = (params.useHighs ?? 0) > 0;
+    const breakDir = (params.breakDir ?? 1) >= 0 ? 1 : -1;
+    const defaultSlope = useHighs ? 1 : -1;
+    const requireSlope = (params.requireSlopeSign ?? defaultSlope) >= 0 ? 1 : -1;
+    const tfHours = params.tfHours ?? 1;
+    const bars = pickBars(ctx, tfHours);
+    if (bars.length < swingLookback * 2 + pivotsN + 5) {
+        return { met: false, value: 0, threshold: 0, description: `Insufficient ${tfHours}h bars for trendline_break` };
+    }
+    const found = findPivotsIdx(bars, swingLookback);
+    const piv = useHighs ? found.highs : found.lows;
+    if (piv.length < pivotsN) {
+        return {
+            met: false,
+            value: piv.length,
+            threshold: pivotsN,
+            description: `Only ${piv.length} pivot ${useHighs ? 'highs' : 'lows'} on ${tfHours}h (need ${pivotsN})`,
+        };
+    }
+    const lastPivots = piv.slice(-pivotsN);
+    const xs = lastPivots.map((p) => p.idx);
+    const ys = lastPivots.map((p) => p.price);
+    const slope = linearSlope(ys, xs);
+    const intercept = mean(ys) - slope * mean(xs);
+    if ((requireSlope > 0 && slope <= 0) || (requireSlope < 0 && slope >= 0)) {
+        return {
+            met: false,
+            value: Math.round(slope * 10000) / 10000,
+            threshold: 0,
+            description: `Trendline slope ${slope.toExponential(2)} wrong sign (need ${requireSlope > 0 ? '>0' : '<0'})`,
+        };
+    }
+    const lastIdx = bars.length - 1;
+    const lastClose = bars[lastIdx].close;
+    const lineAtLast = slope * lastIdx + intercept;
+    const broken = breakDir > 0 ? lastClose > lineAtLast : lastClose < lineAtLast;
+    return {
+        met: broken,
+        value: Math.round((lastClose - lineAtLast) * 100) / 100,
+        threshold: 0,
+        description: broken
+            ? `${pivotsN}-pivot ${useHighs ? 'highs' : 'lows'} trendline broken ${breakDir > 0 ? 'above' : 'below'}: close ${lastClose.toFixed(2)} vs line ${lineAtLast.toFixed(2)}`
+            : `Close ${lastClose.toFixed(2)} ${breakDir > 0 ? 'still below' : 'still above'} trendline ${lineAtLast.toFixed(2)}`,
+    };
+});
+// ─── 34. wedge_breakout ──────────────────────────────────────────────
+// Detect a falling wedge in the last N bars and confirm a breakout above
+// the upper trendline with volume confirmation. Falling wedge = both
+// trendlines sloping down with the upper line falling faster (converging).
+// params: minBars, swingLookback, minVolMultiplier, tfHours
+// (Currently implements falling wedge only — the bullish-break variant
+// the operator's strategies need. Rising wedge can be added later.)
+register('wedge_breakout', (ctx, params) => {
+    const minBars = Math.floor(params.minBars ?? 40);
+    const swingLookback = Math.floor(params.swingLookback ?? 5);
+    const minVolMultiplier = params.minVolMultiplier ?? 1.5;
+    const tfHours = params.tfHours ?? 1;
+    const bars = pickBars(ctx, tfHours);
+    if (bars.length < minBars + 5) {
+        return { met: false, value: 0, threshold: 0, description: `Insufficient ${tfHours}h bars for wedge_breakout` };
+    }
+    const window = bars.slice(-minBars);
+    const found = findPivotsIdx(window, swingLookback);
+    if (found.highs.length < 3 || found.lows.length < 3) {
+        return {
+            met: false,
+            value: 0,
+            threshold: 0,
+            description: `Need ≥3 highs+lows in ${minBars}-bar ${tfHours}h window (have ${found.highs.length}/${found.lows.length})`,
+        };
+    }
+    const xsH = found.highs.map((h) => h.idx);
+    const ysH = found.highs.map((h) => h.price);
+    const xsL = found.lows.map((l) => l.idx);
+    const ysL = found.lows.map((l) => l.price);
+    const slopeH = linearSlope(ysH, xsH);
+    const slopeL = linearSlope(ysL, xsL);
+    const interceptH = mean(ysH) - slopeH * mean(xsH);
+    const isFallingWedge = slopeH < 0 && slopeL < 0 && Math.abs(slopeH) > Math.abs(slopeL);
+    if (!isFallingWedge) {
+        return {
+            met: false,
+            value: 0,
+            threshold: 0,
+            description: `Not a falling wedge: upper slope ${slopeH.toExponential(2)}, lower ${slopeL.toExponential(2)}`,
+        };
+    }
+    const lastIdx = window.length - 1;
+    const upperAtLast = slopeH * lastIdx + interceptH;
+    const lastClose = window[lastIdx].close;
+    if (lastClose <= upperAtLast) {
+        return {
+            met: false,
+            value: Math.round((lastClose - upperAtLast) * 100) / 100,
+            threshold: 0,
+            description: `Wedge intact: close ${lastClose.toFixed(2)} ≤ upper line ${upperAtLast.toFixed(2)}`,
+        };
+    }
+    const lastVol = window[lastIdx].volume;
+    const volSma = mean(window.slice(-21, -1).map((b) => b.volume));
+    const volRatio = volSma > 0 ? lastVol / volSma : 0;
+    if (volRatio < minVolMultiplier) {
+        return {
+            met: false,
+            value: Math.round(volRatio * 100) / 100,
+            threshold: minVolMultiplier,
+            description: `Wedge break but volume ${volRatio.toFixed(2)}× SMA (need ≥${minVolMultiplier}×)`,
+        };
+    }
+    return {
+        met: true,
+        value: Math.round((lastClose - upperAtLast) * 100) / 100,
+        threshold: 0,
+        description: `Falling wedge break on ${tfHours}h: close ${lastClose.toFixed(2)} > upper ${upperAtLast.toFixed(2)}, vol ${volRatio.toFixed(1)}× SMA`,
+    };
+});
+// ─── 35. distance_to_resistance_R ────────────────────────────────────
+// Measures the distance from current price to the nearest swing high
+// (LONG) / swing low (SHORT) in units of ATR(14). Used to ensure a setup
+// has at least N R of headroom before hitting structural resistance.
+// params: minR, swingLookback, lookbackBars, tfHours
+register('distance_to_resistance_R', (ctx, params, direction) => {
+    const minR = params.minR ?? 1.5;
+    const swingLookback = Math.floor(params.swingLookback ?? 5);
+    const lookbackBars = Math.floor(params.lookbackBars ?? 100);
+    const tfHours = params.tfHours ?? 1;
+    const bars = pickBars(ctx, tfHours);
+    if (bars.length < lookbackBars) {
+        return { met: false, value: 0, threshold: minR, description: `Insufficient ${tfHours}h bars for distance_to_resistance_R` };
+    }
+    if (ctx.atr14 <= 0) {
+        return { met: false, value: 0, threshold: minR, description: 'ATR(14) is zero — cannot compute R distance' };
+    }
+    const window = bars.slice(-lookbackBars);
+    const found = findPivotsIdx(window, swingLookback);
+    const isLong = direction === 'LONG' || direction === null;
+    const candidates = isLong
+        ? found.highs.map((h) => h.price).filter((p) => p > ctx.currentPrice)
+        : found.lows.map((l) => l.price).filter((p) => p < ctx.currentPrice);
+    if (candidates.length === 0) {
+        return {
+            met: true,
+            value: 999,
+            threshold: minR,
+            description: `No ${isLong ? 'overhead resistance' : 'support below'} in last ${lookbackBars} ${tfHours}h bars`,
+        };
+    }
+    const nearest = isLong ? Math.min(...candidates) : Math.max(...candidates);
+    const distance = Math.abs(nearest - ctx.currentPrice);
+    const distanceR = distance / ctx.atr14;
+    const met = distanceR >= minR;
+    return {
+        met,
+        value: Math.round(distanceR * 100) / 100,
+        threshold: minR,
+        description: met
+            ? `${distanceR.toFixed(2)}R clear to nearest ${isLong ? 'resistance' : 'support'} at ${nearest.toFixed(2)}`
+            : `Only ${distanceR.toFixed(2)}R to nearest ${isLong ? 'resistance' : 'support'} at ${nearest.toFixed(2)} (need ≥${minR}R)`,
+    };
+});
+// ─── 36. btc_rsi_overbought (skipIf helper) ──────────────────────────
+// Reads the global market context (BTC daily RSI) and returns met=true
+// when BTC RSI exceeds the threshold. Designed to be used in StrategyConfig.skipIf
+// to block longs when BTC daily RSI is overbought. Fail-open: if global
+// context is missing the condition returns met=false (do not skip).
+// params: maxRsi (default 70)
+register('btc_rsi_overbought', (ctx, params) => {
+    const maxRsi = params.maxRsi ?? 70;
+    const btcRsi = ctx.globalContext?.btcRsi14_1d;
+    if (btcRsi === undefined) {
+        return {
+            met: false,
+            value: 0,
+            threshold: maxRsi,
+            description: 'BTC 1d RSI unavailable in global context (fail-open)',
+        };
+    }
+    const met = btcRsi > maxRsi;
+    return {
+        met,
+        value: Math.round(btcRsi * 100) / 100,
+        threshold: maxRsi,
+        description: met
+            ? `BTC 1d RSI ${btcRsi.toFixed(1)} > ${maxRsi} (overbought — skip longs)`
+            : `BTC 1d RSI ${btcRsi.toFixed(1)} ≤ ${maxRsi}`,
+    };
+});
+// ─── cascade_pulse_safety ──────────────────────────────────────────────
+// `met=true` when an `active_cascade` is in progress on the majors group
+// AND the dominant side opposes the trade direction — i.e. liquidations
+// are running INTO our entry. Use as skipIf to keep the agent out of
+// liquidation cascades that typically continue for 60-180 seconds.
+//
+// Params (ConditionConfig schema is `Record<string, number>` so flags are
+// numeric):
+//   scope: 0 = majors (default), 1 = symbol
+//   minSeverity: 1 = elevated, 2 = active_cascade (default)
+//
+// Fail-open semantics: returns met=false when the microstructure flag is
+// off (fields undefined) or events=0 in window (dominantSide=balanced).
+// This keeps the condition safe to add to a strategy before Phase 1 is on.
+register('cascade_pulse_safety', (ctx, params, direction) => {
+    const useSymbolScope = params.scope === 1;
+    const minSeverity = params.minSeverity === 1 ? 1 : 2; // default: active_cascade
+    const classification = useSymbolScope ? ctx.cascadePulse60s : ctx.majorsCascadePulse60s;
+    const dominant = ctx.cascadeDominantSide;
+    const scopeLabel = useSymbolScope ? 'symbol' : 'majors';
+    if (classification === undefined || dominant === undefined) {
+        return {
+            met: false,
+            value: 0,
+            threshold: 0,
+            description: 'Cascade pulse unavailable (feature flag off — fail-open)',
+        };
+    }
+    const severityRank = classification === 'active_cascade' ? 2 : classification === 'elevated' ? 1 : 0;
+    const meetsSeverity = severityRank >= minSeverity;
+    // Direction-aware: a long entry is endangered when LONGS are being
+    // liquidated (cascading SELL pressure). A short entry is endangered when
+    // SHORTS are being liquidated (cascading BUY pressure).
+    const opposing = direction === 'LONG' ? dominant === 'long' :
+        direction === 'SHORT' ? dominant === 'short' :
+            false;
+    const met = meetsSeverity && opposing;
+    return {
+        met,
+        value: severityRank,
+        threshold: minSeverity,
+        description: met
+            ? `${scopeLabel} cascade ${classification} dominant=${dominant} opposing ${direction} — skip`
+            : `${scopeLabel} pulse=${classification}, dominant=${dominant}, dir=${direction} (no skip)`,
+    };
+});
+// ─── resting_band_unfavourable ─────────────────────────────────────────
+// `met=true` when banded resting liquidity in the 0.5%/1% band shows the
+// opposite side has substantially more notional resting against the
+// trade direction — i.e. there's a wall of overhead supply against a
+// long, or a wall of underlying support against a short.
+//
+// Direction-aware:
+//   LONG  : skip if ask-side share of (mid, mid+0.5%] > minMargin (default 0.55)
+//   SHORT : skip if bid-side share of (mid-0.5%, mid] > minMargin
+//
+// Fail-open: returns met=false (no skip) when bandedLiquidity flag is
+// off OR coverage_pct < minCoverage (data unreliable on tight books like
+// BTCUSDT where depth-20 reaches < 0.01%). Strategies on those symbols
+// effectively bypass this filter.
+//
+// Numeric params (ConditionConfig schema is Record<string, number>):
+//   band:        5 = 0.5% (default), 10 = 1.0%
+//   minMargin:   0.55 default — minimum share against direction to trigger
+//   minCoverage: 0.5 default (% units) — coverage_pct floor for reliability
+register('resting_band_unfavourable', (ctx, params, direction) => {
+    const useBand10 = params.band === 10;
+    const minMargin = params.minMargin ?? 0.55;
+    const minCoverage = params.minCoverage ?? 0.5;
+    const imbalance = useBand10 ? ctx.restingBandImbalance10 : ctx.restingBandImbalance05;
+    const coverage = ctx.restingCoveragePct;
+    const bandLabel = useBand10 ? '1.0%' : '0.5%';
+    if (imbalance === undefined || coverage === undefined) {
+        return {
+            met: false,
+            value: 0,
+            threshold: minMargin,
+            description: 'Resting bands unavailable (feature flag off — fail-open)',
+        };
+    }
+    if (coverage < minCoverage) {
+        return {
+            met: false,
+            value: imbalance,
+            threshold: minMargin,
+            description: `Coverage ${coverage.toFixed(3)}% < ${minCoverage}% — depth-20 too tight, fail-open`,
+        };
+    }
+    // imbalance is bid-share. ask-share = 1 - imbalance.
+    // For LONG, "unfavourable" = ask-share dominant = imbalance < 1 - minMargin.
+    // For SHORT, "unfavourable" = bid-share dominant = imbalance > minMargin.
+    let unfavourable = false;
+    let actualShare = 0;
+    if (direction === 'LONG') {
+        actualShare = 1 - imbalance; // ask side
+        unfavourable = actualShare > minMargin;
+    }
+    else if (direction === 'SHORT') {
+        actualShare = imbalance; // bid side
+        unfavourable = actualShare > minMargin;
+    }
+    return {
+        met: unfavourable,
+        value: Math.round(actualShare * 1000) / 1000,
+        threshold: minMargin,
+        description: unfavourable
+            ? `${bandLabel} band ${direction === 'LONG' ? 'ask' : 'bid'}-share ${(actualShare * 100).toFixed(1)}% > ${(minMargin * 100).toFixed(0)}% — wall against ${direction} entry, skip`
+            : `${bandLabel} band ${direction === 'LONG' ? 'ask' : 'bid'}-share ${(actualShare * 100).toFixed(1)}%, coverage ${coverage.toFixed(2)}% (no skip)`,
+    };
+});
+// ─── funding_extreme_skip ──────────────────────────────────────────────
+// `met=true` (skip) when current funding sits in the extreme tail of its
+// 30-day distribution AND the trade direction would be entering INTO that
+// crowded positioning:
+//   - LONG  skipped when percentileRank > upperRank (default 0.90)
+//           — funding is in the top decile = crowded longs, top-tick risk
+//   - SHORT skipped when percentileRank < lowerRank (default 0.10)
+//           — funding is in the bottom decile = crowded shorts, squeeze risk
+//
+// Per-symbol adaptive by construction: the rank is computed against each
+// symbol's own 30d distribution server-side (see funding-percentile-api.ts),
+// so DOT/WIF heavy tails and BTC/BNB tight ranges both get sensible cutoffs.
+//
+// Numeric params:
+//   upperRank: default 0.90 — skip LONG if rank > this
+//   lowerRank: default 0.10 — skip SHORT if rank < this
+//
+// Fail-open: returns met=false when fundingPercentile is undefined
+// (FUNDING_OVERLAY flag off, insufficient sample, or symbol missing data).
+// Direction-aware via pass2 evaluation; in skipIf (direction=null) it
+// effectively no-ops since neither branch matches.
+register('funding_extreme_skip', (ctx, params, direction) => {
+    const upperRank = params.upperRank ?? 0.90;
+    const lowerRank = params.lowerRank ?? 0.10;
+    const fp = ctx.fundingPercentile;
+    if (!fp) {
+        return {
+            met: false,
+            value: 0,
+            threshold: 0,
+            description: 'Funding percentile unavailable (FUNDING_OVERLAY off or no data — fail-open)',
+        };
+    }
+    const rate_bps = fp.current * 10000;
+    let met = false;
+    let why = '';
+    if (direction === 'LONG' && fp.percentileRank > upperRank) {
+        met = true;
+        why = `rank ${(fp.percentileRank * 100).toFixed(0)}th > ${(upperRank * 100).toFixed(0)}th — crowded longs (rate ${rate_bps.toFixed(2)} bps), skip LONG`;
+    }
+    else if (direction === 'SHORT' && fp.percentileRank < lowerRank) {
+        met = true;
+        why = `rank ${(fp.percentileRank * 100).toFixed(0)}th < ${(lowerRank * 100).toFixed(0)}th — crowded shorts (rate ${rate_bps.toFixed(2)} bps), skip SHORT`;
+    }
+    else {
+        why = `rank ${(fp.percentileRank * 100).toFixed(0)}th, dir=${direction ?? 'null'} (no skip)`;
+    }
+    return {
+        met,
+        value: Math.round(fp.percentileRank * 100) / 100,
+        threshold: direction === 'LONG' ? upperRank : direction === 'SHORT' ? lowerRank : 0,
+        description: why,
+    };
+});
+// ─── funding_position_ok ───────────────────────────────────────────────
+// Inverse of `funding_extreme_skip` for use in a strategy's `conditions`
+// list (gate semantics: met=true means "funding is OK to trade in this
+// direction"). Where `funding_extreme_skip` is intended for skipIf in
+// fixed-direction strategies, this variant is what regular conditions
+// pipelines need: pass-2 evaluation re-runs after directionRule resolves,
+// giving the agent direction-aware behaviour without changing the adapter.
+//
+// met=true when the trade is NOT entering INTO crowded positioning:
+//   LONG  acceptable if percentileRank ≤ upperRank (default 0.90)
+//   SHORT acceptable if percentileRank ≥ lowerRank (default 0.10)
+//
+// Same numeric params as funding_extreme_skip. Same fail-open contract:
+// returns met=true when fundingPercentile is undefined (FUNDING_OVERLAY
+// off, no data, or insufficient sample) so the strategy is not blocked
+// by missing data.
+register('funding_position_ok', (ctx, params, direction) => {
+    const upperRank = params.upperRank ?? 0.90;
+    const lowerRank = params.lowerRank ?? 0.10;
+    const fp = ctx.fundingPercentile;
+    if (!fp) {
+        return {
+            met: true,
+            value: 0,
+            threshold: 0,
+            description: 'Funding percentile unavailable (FUNDING_OVERLAY off or no data — fail-open)',
+        };
+    }
+    const rate_bps = fp.current * 10000;
+    let met = true;
+    let why = '';
+    if (direction === 'LONG' && fp.percentileRank > upperRank) {
+        met = false;
+        why = `rank ${(fp.percentileRank * 100).toFixed(0)}th > ${(upperRank * 100).toFixed(0)}th — crowded longs (rate ${rate_bps.toFixed(2)} bps), block LONG`;
+    }
+    else if (direction === 'SHORT' && fp.percentileRank < lowerRank) {
+        met = false;
+        why = `rank ${(fp.percentileRank * 100).toFixed(0)}th < ${(lowerRank * 100).toFixed(0)}th — crowded shorts (rate ${rate_bps.toFixed(2)} bps), block SHORT`;
+    }
+    else {
+        why = `rank ${(fp.percentileRank * 100).toFixed(0)}th, dir=${direction ?? 'null'} (funding OK for this direction)`;
+    }
+    return {
+        met,
+        value: Math.round(fp.percentileRank * 100) / 100,
+        threshold: direction === 'LONG' ? upperRank : direction === 'SHORT' ? lowerRank : 0,
+        description: why,
+    };
+});