@reefclaw/connect 0.1.10 → 0.1.12

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

@@ -1,1324 +0,0 @@
-// ⚠️ 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
-    condCtx.sweepLevel = sweepLevel;
-    condCtx.recentLow = recentLow;
-    condCtx.recentHigh = recentHigh;
-    condCtx.sweptDirection = sweptLow ? 'LONG' : sweptHigh ? 'SHORT' : null;
-    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,
-    };
-});