@tradejs/strategy-trend-follow 3.0.0

package/dist/index.cjs

@@ -0,0 +1,1299 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TrendFollowStrategyDefinition: () => TrendFollowStrategyDefinition,
+  default: () => index_default,
+  getBuiltInStrategyDefaultConfig: () => getBuiltInStrategyDefaultConfig,
+  strategyEntries: () => strategyEntries,
+  trendFollowAiAdapter: () => trendFollowAiAdapter,
+  trendFollowDefaultConfig: () => config,
+  trendFollowManifest: () => trendFollowManifest
+});
+module.exports = __toCommonJS(index_exports);
+var import_config4 = require("@tradejs/core/config");
+
+// src/TrendFollow/config.ts
+var import_constants = require("@tradejs/core/constants");
+var config = {
+  ENV: "BACKTEST",
+  INTERVAL: "15",
+  MAKE_ORDERS: true,
+  CLOSE_OPPOSITE_POSITIONS: false,
+  BACKTEST_PRICE_MODE: "open",
+  AI_ENABLED: false,
+  AI_MODE: "llm",
+  ML_ENABLED: false,
+  ML_THRESHOLD: 0.1,
+  MIN_AI_QUALITY: 3,
+  FEE_PERCENT: import_constants.FEE_PERCENT,
+  MAX_LOSS_VALUE: 10,
+  MA_FAST: 14,
+  MA_MEDIUM: 49,
+  MA_SLOW: 50,
+  OBV_SMA: 10,
+  ATR: 14,
+  ATR_PCT_SHORT: 7,
+  ATR_PCT_LONG: 30,
+  BB: 20,
+  BB_STD: 2,
+  MACD_FAST: 12,
+  MACD_SLOW: 26,
+  MACD_SIGNAL: 9,
+  TRENDFOLLOW_PIVOT_LENGTH: 10,
+  TRENDFOLLOW_MIN_BARS_BETWEEN_SIGNALS: 0,
+  TRENDFOLLOW_ATR_LENGTH: 14,
+  TRENDFOLLOW_ATR_MULT: 4,
+  TRENDFOLLOW_SIGNAL_OFFSET_ATR: 0.35,
+  TRENDFOLLOW_REQUIRE_STRUCTURE_BREAKOUT: false,
+  TRENDFOLLOW_REQUIRE_TREND_ALIGNMENT: false,
+  TRENDFOLLOW_REQUIRE_BENCHMARK_ALIGNMENT: false,
+  TRENDFOLLOW_MIN_VOLUME_REL20: 0,
+  TRENDFOLLOW_MIN_STRUCTURE_ACCEPTANCE_CLOSES: 0,
+  TRENDFOLLOW_MIN_BREAKOUT_BODY_ATR: 0,
+  TRENDFOLLOW_MIN_TREND_PERSISTENCE: 0,
+  TRENDFOLLOW_MIN_TREND_PERSISTENCE_LONG: 0.5,
+  TRENDFOLLOW_MIN_TREND_PERSISTENCE_SHORT: 0.5,
+  TRENDFOLLOW_MAX_RSI: 0,
+  TRENDFOLLOW_MAX_RSI_LONG: 75,
+  TRENDFOLLOW_MAX_RSI_SHORT: 0,
+  TRENDFOLLOW_MAX_BB_WIDTH_PCT: 0,
+  TRENDFOLLOW_MAX_BB_WIDTH_PCT_LONG: 0,
+  TRENDFOLLOW_MAX_BB_WIDTH_PCT_SHORT: 8,
+  TRENDFOLLOW_MIN_BREAKOUT_DISTANCE_PCT: 0,
+  TRENDFOLLOW_MIN_BREAKOUT_DISTANCE_PCT_LONG: 3,
+  TRENDFOLLOW_MIN_BREAKOUT_DISTANCE_PCT_SHORT: 2,
+  TRENDFOLLOW_MAX_BREAKOUT_DISTANCE_PCT: 0,
+  TRENDFOLLOW_TARGET_R_MULT: 2,
+  TRENDFOLLOW_TARGET_R_MULT_LONG: 1.4,
+  TRENDFOLLOW_TARGET_R_MULT_SHORT: 1.2,
+  TRENDFOLLOW_EXIT_ON_TRAIL_STOP: true,
+  TRENDFOLLOW_EXIT_ON_OPPOSITE_SIGNAL: true,
+  TRENDFOLLOW_MAX_FIGURE_POINTS: 180,
+  LONG: {
+    enable: true,
+    direction: "LONG",
+    minRiskRatio: 0.8
+  },
+  SHORT: {
+    enable: true,
+    direction: "SHORT",
+    minRiskRatio: 0.8
+  }
+};
+
+// src/TrendFollow/core.ts
+var import_math = require("@tradejs/core/math");
+
+// src/TrendFollow/engine.ts
+var asFiniteNumber = (value) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+var clampPositive = (value, fallback) => Number.isFinite(value) && value > 0 ? value : fallback;
+var calculateTrueRange = (candle, prevClose) => {
+  const high = asFiniteNumber(candle.high);
+  const low = asFiniteNumber(candle.low);
+  const close = asFiniteNumber(candle.close);
+  if (high == null || low == null || close == null) {
+    return 0;
+  }
+  if (prevClose == null || !Number.isFinite(prevClose)) {
+    return Math.max(high - low, 0);
+  }
+  return Math.max(
+    high - low,
+    Math.abs(high - prevClose),
+    Math.abs(low - prevClose)
+  );
+};
+var updateAtrState = ({
+  atrState,
+  tr,
+  period
+}) => {
+  const safeTr = Number.isFinite(tr) ? Math.max(tr, 0) : 0;
+  const safePeriod = Math.max(1, Math.floor(period));
+  if (atrState.value == null) {
+    return { value: safeTr, count: 1 };
+  }
+  if (atrState.count < safePeriod) {
+    const nextCount = atrState.count + 1;
+    return {
+      value: (atrState.value * atrState.count + safeTr) / nextCount,
+      count: nextCount
+    };
+  }
+  return {
+    value: (atrState.value * (safePeriod - 1) + safeTr) / safePeriod,
+    count: atrState.count + 1
+  };
+};
+var pushBoundedPoint = (series, point, maxPoints) => {
+  series.push(point);
+  if (series.length > maxPoints) {
+    series.splice(0, series.length - maxPoints);
+  }
+};
+var pushBoundedCandle = (state, candle, maxCandles) => {
+  state.currentIndex += 1;
+  state.candles.push(candle);
+  if (state.candles.length > maxCandles) {
+    const overflow = state.candles.length - maxCandles;
+    state.candles.splice(0, overflow);
+    state.candleStartIndex += overflow;
+  }
+  return state.currentIndex;
+};
+var getBufferedCandle = (state, absoluteIndex) => state.candles[absoluteIndex - state.candleStartIndex] ?? null;
+var getConfigNumbers = (config2) => ({
+  pivotLength: Math.max(2, Math.floor(config2.TRENDFOLLOW_PIVOT_LENGTH ?? 10)),
+  minBarsBetween: Math.max(
+    0,
+    Math.floor(config2.TRENDFOLLOW_MIN_BARS_BETWEEN_SIGNALS ?? 0)
+  ),
+  atrLength: Math.max(1, Math.floor(config2.TRENDFOLLOW_ATR_LENGTH ?? 14)),
+  atrMult: clampPositive(config2.TRENDFOLLOW_ATR_MULT, 4),
+  signalOffsetAtr: Math.max(
+    0,
+    Number(config2.TRENDFOLLOW_SIGNAL_OFFSET_ATR ?? 0)
+  ),
+  maxFigurePoints: Math.max(
+    20,
+    Math.floor(config2.TRENDFOLLOW_MAX_FIGURE_POINTS ?? 180)
+  )
+});
+var getWindow = (state, candidateIndex, lookback) => {
+  const window = [];
+  for (let index = candidateIndex - lookback; index <= candidateIndex + lookback; index += 1) {
+    const candle = getBufferedCandle(state, index);
+    if (!candle) {
+      return [];
+    }
+    window.push(candle);
+  }
+  return window;
+};
+var isPivotHigh = (state, candidateIndex, lookback) => {
+  const candidate = getBufferedCandle(state, candidateIndex);
+  const candidateHigh = asFiniteNumber(candidate?.high);
+  if (candidateHigh == null) {
+    return false;
+  }
+  const window = getWindow(state, candidateIndex, lookback);
+  return window.length === lookback * 2 + 1 && window.every((candle) => candidateHigh >= Number(candle.high));
+};
+var isPivotLow = (state, candidateIndex, lookback) => {
+  const candidate = getBufferedCandle(state, candidateIndex);
+  const candidateLow = asFiniteNumber(candidate?.low);
+  if (candidateLow == null) {
+    return false;
+  }
+  const window = getWindow(state, candidateIndex, lookback);
+  return window.length === lookback * 2 + 1 && window.every((candle) => candidateLow <= Number(candle.low));
+};
+var buildTrendFollowSignalContext = (signal) => ({
+  signalDirection: signal.direction,
+  entryLevel: signal.entryLevel,
+  trailStop: signal.trailStop,
+  atr: signal.atr,
+  pivotKind: signal.pivot.kind,
+  pivotTimestamp: signal.pivot.timestamp,
+  pivotValue: signal.pivot.value,
+  barsSinceSignal: signal.barsSinceSignal,
+  breakoutDistancePct: signal.breakoutDistancePct,
+  distanceToStopPct: signal.distanceToStopPct,
+  currentPrice: signal.close
+});
+var createTrendFollowEngine = ({
+  config: config2,
+  initialCandles = []
+}) => {
+  const {
+    pivotLength,
+    minBarsBetween,
+    atrLength,
+    atrMult,
+    signalOffsetAtr,
+    maxFigurePoints
+  } = getConfigNumbers(config2);
+  const maxCandles = pivotLength * 2 + 1;
+  const state = {
+    candles: [],
+    candleStartIndex: 0,
+    currentIndex: -1,
+    atrState: { value: null, count: 0 },
+    prevClose: null,
+    trendState: 0,
+    lastPivotHigh: null,
+    lastPivotLow: null,
+    lastSignalIndex: null,
+    trailStop: null,
+    entryLevel: null,
+    signal: null,
+    snapshot: null,
+    series: { trailStop: [] }
+  };
+  const apply = (candle) => {
+    state.signal = null;
+    const prevClose = state.prevClose;
+    const close = Number(candle.close);
+    const tr = calculateTrueRange(candle, prevClose);
+    state.atrState = updateAtrState({
+      atrState: state.atrState,
+      tr,
+      period: atrLength
+    });
+    const atr = state.atrState.value ?? 0;
+    const currentIndex = pushBoundedCandle(state, candle, maxCandles);
+    const candidateIndex = currentIndex - pivotLength;
+    const candidate = candidateIndex >= pivotLength ? getBufferedCandle(state, candidateIndex) : null;
+    if (candidate && isPivotHigh(state, candidateIndex, pivotLength)) {
+      state.lastPivotHigh = {
+        timestamp: candidate.timestamp,
+        index: candidateIndex,
+        value: Number(candidate.high),
+        kind: "high"
+      };
+    }
+    if (candidate && isPivotLow(state, candidateIndex, pivotLength)) {
+      state.lastPivotLow = {
+        timestamp: candidate.timestamp,
+        index: candidateIndex,
+        value: Number(candidate.low),
+        kind: "low"
+      };
+    }
+    const barsSinceLastSignal = state.lastSignalIndex == null ? 999999 : currentIndex - state.lastSignalIndex;
+    const filterPass = minBarsBetween === 0 || barsSinceLastSignal >= minBarsBetween;
+    const bullConfirmationLevel = state.lastPivotHigh != null ? state.lastPivotHigh.value + atr * signalOffsetAtr : null;
+    const bearConfirmationLevel = state.lastPivotLow != null ? state.lastPivotLow.value - atr * signalOffsetAtr : null;
+    const bullCross = state.lastPivotHigh != null && bullConfirmationLevel != null && prevClose != null && prevClose <= bullConfirmationLevel && close > bullConfirmationLevel && state.trendState !== 1 && filterPass;
+    const bearCross = state.lastPivotLow != null && bearConfirmationLevel != null && prevClose != null && prevClose >= bearConfirmationLevel && close < bearConfirmationLevel && state.trendState !== -1 && filterPass;
+    if (bullCross && state.lastPivotHigh) {
+      state.trendState = 1;
+      state.entryLevel = state.lastPivotHigh.value;
+      state.trailStop = close - atr * atrMult;
+      state.lastSignalIndex = currentIndex;
+      state.signal = {
+        direction: "LONG",
+        entryLevel: state.entryLevel,
+        trailStop: state.trailStop,
+        atr,
+        pivot: state.lastPivotHigh,
+        barsSinceSignal: 0,
+        breakoutDistancePct: state.entryLevel !== 0 ? (close - state.entryLevel) / Math.abs(state.entryLevel) * 100 : 0,
+        distanceToStopPct: close !== 0 ? Math.abs(close - state.trailStop) / close * 100 : 0,
+        timestamp: candle.timestamp,
+        close
+      };
+    } else if (bearCross && state.lastPivotLow) {
+      state.trendState = -1;
+      state.entryLevel = state.lastPivotLow.value;
+      state.trailStop = close + atr * atrMult;
+      state.lastSignalIndex = currentIndex;
+      state.signal = {
+        direction: "SHORT",
+        entryLevel: state.entryLevel,
+        trailStop: state.trailStop,
+        atr,
+        pivot: state.lastPivotLow,
+        barsSinceSignal: 0,
+        breakoutDistancePct: state.entryLevel !== 0 ? (state.entryLevel - close) / Math.abs(state.entryLevel) * 100 : 0,
+        distanceToStopPct: close !== 0 ? Math.abs(close - state.trailStop) / close * 100 : 0,
+        timestamp: candle.timestamp,
+        close
+      };
+    } else if (state.trendState === 1) {
+      const newStop = close - atr * atrMult;
+      state.trailStop = state.trailStop == null ? newStop : Math.max(state.trailStop, newStop);
+    } else if (state.trendState === -1) {
+      const newStop = close + atr * atrMult;
+      state.trailStop = state.trailStop == null ? newStop : Math.min(state.trailStop, newStop);
+    }
+    const barsSinceSignal = state.lastSignalIndex == null ? null : currentIndex - state.lastSignalIndex;
+    const distanceToStopPct = state.trailStop != null && close !== 0 ? Math.abs(close - state.trailStop) / close * 100 : null;
+    const breakoutDistancePct = state.entryLevel != null && state.entryLevel !== 0 ? state.trendState === 1 ? (close - state.entryLevel) / Math.abs(state.entryLevel) * 100 : state.trendState === -1 ? (state.entryLevel - close) / Math.abs(state.entryLevel) * 100 : null : null;
+    if (state.trailStop != null && state.trendState !== 0) {
+      pushBoundedPoint(
+        state.series.trailStop,
+        { timestamp: candle.timestamp, value: state.trailStop },
+        maxFigurePoints
+      );
+    }
+    state.snapshot = {
+      trendState: state.trendState,
+      signalDirection: state.signal?.direction ?? null,
+      bullCross,
+      bearCross,
+      entryLevel: state.entryLevel,
+      trailStop: state.trailStop,
+      atr,
+      barsSinceSignal,
+      lastPivotHigh: state.lastPivotHigh,
+      lastPivotLow: state.lastPivotLow,
+      distanceToStopPct,
+      breakoutDistancePct,
+      timestamp: candle.timestamp,
+      close
+    };
+    state.prevClose = close;
+    return {
+      signal: state.signal,
+      snapshot: state.snapshot,
+      series: state.series
+    };
+  };
+  for (const candle of initialCandles) {
+    apply(candle);
+  }
+  return {
+    next: apply,
+    getState: () => ({
+      signal: state.signal,
+      snapshot: state.snapshot,
+      series: state.series
+    })
+  };
+};
+
+// src/TrendFollow/figures.ts
+var buildTrendFollowFigures = ({
+  signal,
+  series,
+  entryTimestamp,
+  entryPrice,
+  stopLossPrice,
+  takeProfitPrice
+}) => {
+  const color = signal.direction === "LONG" ? "#00c853" : "#ef5350";
+  const lines = [
+    {
+      id: `trendfollow-trail-${entryTimestamp}`,
+      kind: "trendfollow_trailing_stop",
+      points: series.trailStop.slice(),
+      color,
+      width: 2,
+      style: "solid"
+    },
+    {
+      id: `trendfollow-entry-level-${entryTimestamp}`,
+      kind: "trendfollow_entry_level",
+      points: [
+        { timestamp: signal.pivot.timestamp, value: signal.entryLevel },
+        { timestamp: entryTimestamp, value: signal.entryLevel }
+      ],
+      color: "#f59e0b",
+      width: 2,
+      style: "dashed"
+    },
+    {
+      id: `trendfollow-target-${entryTimestamp}`,
+      kind: "trendfollow_target",
+      points: [
+        { timestamp: signal.pivot.timestamp, value: takeProfitPrice },
+        { timestamp: entryTimestamp, value: takeProfitPrice }
+      ],
+      color: "#22c55e",
+      width: 1,
+      style: "dashed"
+    },
+    {
+      id: `trendfollow-stop-${entryTimestamp}`,
+      kind: "trendfollow_stop",
+      points: [
+        { timestamp: signal.pivot.timestamp, value: stopLossPrice },
+        { timestamp: entryTimestamp, value: stopLossPrice }
+      ],
+      color: "#ef4444",
+      width: 1,
+      style: "dashed"
+    }
+  ].filter((line) => line.points.length > 0);
+  const points = [
+    {
+      id: `trendfollow-pivot-${entryTimestamp}`,
+      kind: `trendfollow_${signal.pivot.kind}_pivot`,
+      points: [
+        { timestamp: signal.pivot.timestamp, value: signal.pivot.value }
+      ],
+      color: "#f59e0b",
+      radius: 4
+    },
+    {
+      id: `trendfollow-entry-${entryTimestamp}`,
+      kind: "trendfollow_entry",
+      points: [{ timestamp: entryTimestamp, value: entryPrice }],
+      color,
+      radius: 5
+    }
+  ];
+  return { lines, points };
+};
+
+// src/TrendFollow/filters.ts
+var import_config = require("@tradejs/strategy-kit/config");
+var asPositiveThreshold = (value) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+};
+var isDirectionAligned = ({
+  direction,
+  bullishValue,
+  bearishValue,
+  value
+}) => direction === "LONG" ? value === bullishValue : value === bearishValue;
+var getTrendFollowCoreFilterSkipCode = ({
+  signal,
+  config: config2,
+  baseContext
+}) => {
+  const minBreakoutDistancePct = asPositiveThreshold(
+    (0, import_config.resolveDirectionalConfigNumber)({
+      config: config2,
+      key: "TRENDFOLLOW_MIN_BREAKOUT_DISTANCE_PCT",
+      direction: signal.direction,
+      fallback: 0
+    })
+  );
+  if (minBreakoutDistancePct != null && signal.breakoutDistancePct < minBreakoutDistancePct) {
+    return "TRENDFOLLOW_BREAKOUT_DISTANCE_TOO_SMALL";
+  }
+  const maxBreakoutDistancePct = asPositiveThreshold(
+    config2.TRENDFOLLOW_MAX_BREAKOUT_DISTANCE_PCT
+  );
+  if (maxBreakoutDistancePct != null && signal.breakoutDistancePct > maxBreakoutDistancePct) {
+    return "TRENDFOLLOW_BREAKOUT_DISTANCE_TOO_EXTENDED";
+  }
+  const breakoutState = baseContext?.structure?.localRange?.breakoutState;
+  if (config2.TRENDFOLLOW_REQUIRE_STRUCTURE_BREAKOUT && !isDirectionAligned({
+    direction: signal.direction,
+    bullishValue: "above_high_level",
+    bearishValue: "below_low_level",
+    value: breakoutState
+  })) {
+    return "TRENDFOLLOW_STRUCTURE_BREAKOUT_NOT_CONFIRMED";
+  }
+  const trendBias = baseContext?.regime?.trend?.bias;
+  if (config2.TRENDFOLLOW_REQUIRE_TREND_ALIGNMENT && !isDirectionAligned({
+    direction: signal.direction,
+    bullishValue: "bull",
+    bearishValue: "bear",
+    value: trendBias
+  })) {
+    return "TRENDFOLLOW_TREND_NOT_ALIGNED";
+  }
+  const benchmarkAlignment = baseContext?.relative?.benchmark?.trendAlignment;
+  if (config2.TRENDFOLLOW_REQUIRE_BENCHMARK_ALIGNMENT && !isDirectionAligned({
+    direction: signal.direction,
+    bullishValue: "aligned_bull",
+    bearishValue: "aligned_bear",
+    value: benchmarkAlignment
+  })) {
+    return "TRENDFOLLOW_BENCHMARK_NOT_ALIGNED";
+  }
+  const minVolumeRel20 = asPositiveThreshold(
+    config2.TRENDFOLLOW_MIN_VOLUME_REL20
+  );
+  if (minVolumeRel20 != null) {
+    const volumeRel20 = Number(baseContext?.participation?.volume?.volumeRel20);
+    if (!Number.isFinite(volumeRel20) || volumeRel20 < minVolumeRel20) {
+      return "TRENDFOLLOW_VOLUME_TOO_THIN";
+    }
+  }
+  const minAcceptanceCloses = asPositiveThreshold(
+    config2.TRENDFOLLOW_MIN_STRUCTURE_ACCEPTANCE_CLOSES
+  );
+  if (minAcceptanceCloses != null) {
+    const acceptance = baseContext?.structure?.acceptance;
+    const continuationCloses = Number(
+      signal.direction === "LONG" ? acceptance?.closesAboveHighLevel3 : acceptance?.closesBelowLowLevel3
+    );
+    if (!Number.isFinite(continuationCloses) || continuationCloses < minAcceptanceCloses) {
+      return "TRENDFOLLOW_CLOSE_ACCEPTANCE_TOO_WEAK";
+    }
+  }
+  const minBreakoutBodyAtr = asPositiveThreshold(
+    config2.TRENDFOLLOW_MIN_BREAKOUT_BODY_ATR
+  );
+  if (minBreakoutBodyAtr != null) {
+    const breakoutBodyAtr = Number(
+      baseContext?.structure?.acceptance?.breakoutBodyAtr
+    );
+    if (!Number.isFinite(breakoutBodyAtr) || breakoutBodyAtr < minBreakoutBodyAtr) {
+      return "TRENDFOLLOW_BREAKOUT_BODY_TOO_SMALL";
+    }
+  }
+  const minTrendPersistence = asPositiveThreshold(
+    (0, import_config.resolveDirectionalConfigNumber)({
+      config: config2,
+      key: "TRENDFOLLOW_MIN_TREND_PERSISTENCE",
+      direction: signal.direction,
+      fallback: 0
+    })
+  );
+  if (minTrendPersistence != null) {
+    const persistence = Number(baseContext?.regime?.trend?.persistence);
+    if (!Number.isFinite(persistence) || persistence < minTrendPersistence) {
+      return "TRENDFOLLOW_TREND_PERSISTENCE_TOO_LOW";
+    }
+  }
+  const maxRsi = asPositiveThreshold(
+    (0, import_config.resolveDirectionalConfigNumber)({
+      config: config2,
+      key: "TRENDFOLLOW_MAX_RSI",
+      direction: signal.direction,
+      fallback: 0
+    })
+  );
+  if (maxRsi != null) {
+    const rsi = Number(baseContext?.regime?.momentum?.rsi);
+    if (!Number.isFinite(rsi) || rsi > maxRsi) {
+      return "TRENDFOLLOW_RSI_TOO_EXTENDED";
+    }
+  }
+  const maxBbWidthPct = asPositiveThreshold(
+    (0, import_config.resolveDirectionalConfigNumber)({
+      config: config2,
+      key: "TRENDFOLLOW_MAX_BB_WIDTH_PCT",
+      direction: signal.direction,
+      fallback: 0
+    })
+  );
+  if (maxBbWidthPct != null) {
+    const bbWidthPct = Number(baseContext?.raw?.volatility?.bbWidthPct);
+    if (!Number.isFinite(bbWidthPct) || bbWidthPct > maxBbWidthPct) {
+      return "TRENDFOLLOW_VOLATILITY_TOO_WIDE";
+    }
+  }
+  return null;
+};
+
+// src/TrendFollow/core.ts
+var import_risk = require("@tradejs/strategy-kit/risk");
+var import_config2 = require("@tradejs/strategy-kit/config");
+var isOpenPosition = (position) => Boolean(
+  position && typeof position.price === "number" && Number.isFinite(position.price) && typeof position.qty === "number" && Number.isFinite(position.qty) && position.qty > 0 && (position.direction === "LONG" || position.direction === "SHORT")
+);
+var buildTrendFollowStateKey = (config2) => JSON.stringify({
+  pivotLength: config2.TRENDFOLLOW_PIVOT_LENGTH,
+  minBarsBetween: config2.TRENDFOLLOW_MIN_BARS_BETWEEN_SIGNALS,
+  atrLength: config2.TRENDFOLLOW_ATR_LENGTH,
+  atrMult: config2.TRENDFOLLOW_ATR_MULT,
+  signalOffsetAtr: config2.TRENDFOLLOW_SIGNAL_OFFSET_ATR,
+  maxFigurePoints: config2.TRENDFOLLOW_MAX_FIGURE_POINTS
+});
+var createTrendFollowCore = async ({ config: config2, data: initialData, strategyApi, indicatorsState }) => {
+  const detectorState = strategyApi.createStateController(
+    "TrendFollow",
+    () => ({
+      engine: createTrendFollowEngine({
+        config: config2,
+        initialCandles: initialData
+      })
+    }),
+    {
+      configKey: buildTrendFollowStateKey(config2),
+      snapshot: (state) => state.engine.getState()
+    }
+  );
+  const lastTradeController = strategyApi.createLastTradeController({
+    enabled: true
+  });
+  const nextDetectorState = (candle) => detectorState.oncePerTimestamp(
+    candle.timestamp,
+    (state) => state.engine.next(candle)
+  );
+  return async (candle) => {
+    const runtimeState = nextDetectorState(candle);
+    const signal = runtimeState.signal;
+    const snapshot = runtimeState.snapshot;
+    const position = await strategyApi.getCurrentPosition();
+    if (isOpenPosition(position)) {
+      const trailStop = snapshot?.trailStop;
+      const close = Number(candle.close);
+      const trailStopHit = trailStop != null && (position.direction === "LONG" && close <= trailStop || position.direction === "SHORT" && close >= trailStop);
+      const oppositeSignal = signal != null && (position.direction === "LONG" ? signal.direction === "SHORT" : signal.direction === "LONG");
+      if (Boolean(config2.TRENDFOLLOW_EXIT_ON_TRAIL_STOP) && trailStopHit) {
+        return strategyApi.exit({
+          code: "TRENDFOLLOW_TRAIL_STOP_EXIT",
+          direction: position.direction
+        });
+      }
+      if (Boolean(config2.TRENDFOLLOW_EXIT_ON_OPPOSITE_SIGNAL) && oppositeSignal) {
+        return strategyApi.exit({
+          code: "TRENDFOLLOW_OPPOSITE_SIGNAL_EXIT",
+          direction: position.direction
+        });
+      }
+      return strategyApi.skip("POSITION_EXISTS");
+    }
+    if (!signal) {
+      return strategyApi.skip("NO_TREND_FOLLOW_SIGNAL");
+    }
+    if (lastTradeController.isInCooldown(candle.timestamp)) {
+      return strategyApi.skip("DEV_TRADE_COOLDOWN");
+    }
+    const modeConfig = signal.direction === "LONG" ? config2.LONG : config2.SHORT;
+    if (!modeConfig.enable) {
+      return strategyApi.skip("STRATEGY_DISABLED");
+    }
+    const baseContext = strategyApi.getBaseContext();
+    const coreFilterSkipCode = getTrendFollowCoreFilterSkipCode({
+      signal,
+      config: config2,
+      baseContext
+    });
+    if (coreFilterSkipCode) {
+      return strategyApi.skip(coreFilterSkipCode);
+    }
+    const { timestamp, currentPrice } = await strategyApi.getDecisionPriceContext();
+    const stopLossPrice = signal.trailStop;
+    if (!(0, import_risk.isStopLossOnCorrectSide)({
+      direction: signal.direction,
+      currentPrice,
+      stopLossPrice
+    })) {
+      return strategyApi.skip("INVALID_STOP");
+    }
+    const { takeProfitPrice, riskRatio, qty } = (0, import_risk.buildStructureRiskPlan)({
+      currentPrice,
+      direction: signal.direction,
+      stopLossPrice,
+      targetR: (0, import_config2.resolveDirectionalConfigNumber)({
+        config: config2,
+        key: "TRENDFOLLOW_TARGET_R_MULT",
+        direction: signal.direction,
+        fallback: 2
+      }),
+      maxLossValue: config2.MAX_LOSS_VALUE,
+      feeRate: Number(config2.FEE_PERCENT ?? 0),
+      slippageBps: Number(config2.SLIPPAGE_BASE_BPS ?? 0) + Number(config2.SLIPPAGE_MARKET_IMPACT_BPS ?? 0)
+    });
+    if (!qty || !Number.isFinite(qty) || qty <= 0) {
+      return strategyApi.skip("INVALID_QTY");
+    }
+    if (riskRatio <= modeConfig.minRiskRatio) {
+      return strategyApi.skip(`RISK_RATIO:${(0, import_math.round)(riskRatio)}`);
+    }
+    const indicators = indicatorsState.snapshot();
+    lastTradeController.markTrade(timestamp);
+    return strategyApi.entry({
+      code: signal.direction === "LONG" ? "TRENDFOLLOW_BULL_TREND" : "TRENDFOLLOW_BEAR_TREND",
+      direction: modeConfig.direction,
+      indicators,
+      additionalIndicators: {
+        trendFollowContext: buildTrendFollowSignalContext({
+          ...signal,
+          close: currentPrice
+        })
+      },
+      figures: buildTrendFollowFigures({
+        signal,
+        series: runtimeState.series,
+        entryTimestamp: timestamp,
+        entryPrice: currentPrice,
+        stopLossPrice,
+        takeProfitPrice
+      }),
+      orderPlan: {
+        qty,
+        stopLossPrice,
+        takeProfits: [{ rate: 1, price: takeProfitPrice }]
+      }
+    });
+  };
+};
+
+// src/TrendFollow/adapters/ai.ts
+var import_strategies = require("@tradejs/core/strategies");
+
+// src/TrendFollow/guardrails.ts
+var TREND_FOLLOW_SHORT_FLUSH_OI_MIN_CHANGE_24H = 2.1;
+var TREND_FOLLOW_SHORT_FLUSH_OI_MIN_LIQ_LONG = 12;
+var TREND_FOLLOW_SHORT_FLUSH_OI_MAX_LIQ_IMBALANCE = -0.75;
+var TREND_FOLLOW_SHORT_MARKET_MAX_BTC_TURNOVER_SHARE_24H = 0.416874;
+var TREND_FOLLOW_SHORT_MARKET_MIN_ALT_BASKET_RETURN_24H = -0.020269;
+var TREND_FOLLOW_SHORT_MARKET_MAX_ALT_BASKET_RETURN_24H = 0.052359;
+var TREND_FOLLOW_SHORT_MIN_TARGET_BTC_BETA_20 = 0.627393;
+var TREND_FOLLOW_SHORT_MAX_SHARED_PARTICIPATION_SCORE = 86;
+var TREND_FOLLOW_REF_HIGH_XRP_OI_MIN = 273e6;
+var TREND_FOLLOW_REF_HIGH_SOL_OI_MIN = 103e5;
+var TREND_FOLLOW_REF_BNB_OI_CHANGE_24H_MAX = -2.7;
+var TREND_FOLLOW_REF_XRP_OI_CHANGE_24H_MIN = 3.8;
+var TREND_FOLLOW_REF_TRX_FUNDING_RATE_MAX = -0.025;
+var TREND_FOLLOW_REF_SOL_FLUSH_OI_MIN = 99e5;
+var TREND_FOLLOW_REF_SOL_OI_CHANGE_4H_MIN = 1.31;
+var TREND_FOLLOW_REF_LOSS_XRP_OI_MIN = 272e6;
+var TREND_FOLLOW_REF_LOSS_ETH_CROWDING_MIN = 90;
+var TREND_FOLLOW_REF_LOSS_SOL_FUNDING_Z_MAX = -1.6;
+var TREND_FOLLOW_OPENING_SESSION_MAX_MINUTES_FROM_OPEN = 75;
+var TREND_FOLLOW_OPENING_REF_XRP_OI_MAX = 324e6;
+var TREND_FOLLOW_OPENING_REF_XRP_OI_CHANGE_1H_MIN = 0.4;
+var TREND_FOLLOW_OPENING_REF_BNB_OI_MIN = 56e4;
+var TREND_FOLLOW_ALLOWED_VOLATILITY_STATE = "normal";
+var asFiniteNumber2 = (value) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+var asStringArray = (value) => Array.isArray(value) ? value.filter(
+  (entry) => typeof entry === "string" && entry.trim().length > 0
+) : [];
+var getReferenceInterval = (baseContext, symbol, interval) => baseContext?.derivatives?.referenceContexts?.[symbol]?.intervals?.[interval];
+var getReferenceSummary = (baseContext, symbol) => baseContext?.derivatives?.referenceContexts?.[symbol]?.summary;
+var isDirectionAligned2 = ({
+  direction,
+  bullishValue,
+  bearishValue,
+  value
+}) => direction === "LONG" ? value === bullishValue : direction === "SHORT" ? value === bearishValue : false;
+var calculateDistanceAtr = ({
+  atr,
+  currentPrice,
+  targetPrice,
+  direction,
+  longDistance
+}) => {
+  if (atr == null || atr <= 0 || currentPrice == null || targetPrice == null || direction !== "LONG" && direction !== "SHORT") {
+    return null;
+  }
+  const distance = direction === "LONG" ? longDistance === "target_above" ? targetPrice - currentPrice : currentPrice - targetPrice : longDistance === "target_above" ? currentPrice - targetPrice : targetPrice - currentPrice;
+  return Number.isFinite(distance) ? distance / atr : null;
+};
+var toTrendFollowContinuationAlignment = ({
+  direction,
+  bullishValue,
+  bearishValue,
+  value
+}) => {
+  if (value == null || direction !== "LONG" && direction !== "SHORT") {
+    return null;
+  }
+  return direction === "LONG" ? value === bullishValue : value === bearishValue;
+};
+var buildTrendFollowGateFeatures = ({
+  signalContext,
+  baseContext,
+  prices,
+  volumeStructureDirectionAligned,
+  flushSupport,
+  directionalCrowding
+}) => {
+  const direction = signalContext.signalDirection;
+  const atr = asFiniteNumber2(baseContext?.raw?.volatility?.atr) ?? asFiniteNumber2(signalContext.atr);
+  const currentPrice = asFiniteNumber2(prices?.currentPrice) ?? asFiniteNumber2(signalContext.currentPrice);
+  const setupStopDistanceAtr = calculateDistanceAtr({
+    atr,
+    currentPrice,
+    targetPrice: asFiniteNumber2(prices?.stopLossPrice) ?? asFiniteNumber2(signalContext.trailStop),
+    direction,
+    longDistance: "target_below"
+  }) ?? asFiniteNumber2(baseContext?.gateFeatures?.setup?.stopDistanceAtr);
+  const setupTpDistanceAtr = calculateDistanceAtr({
+    atr,
+    currentPrice,
+    targetPrice: asFiniteNumber2(prices?.takeProfitPrice),
+    direction,
+    longDistance: "target_above"
+  }) ?? asFiniteNumber2(baseContext?.gateFeatures?.setup?.tpDistanceAtr);
+  const setupRewardToVolatility = setupTpDistanceAtr ?? asFiniteNumber2(baseContext?.gateFeatures?.setup?.rewardToVolatility);
+  const setupRiskShape = setupStopDistanceAtr == null ? "unknown" : setupStopDistanceAtr < 0.8 ? "too_tight" : setupStopDistanceAtr < 1.15 ? "tight" : setupStopDistanceAtr <= 3.5 ? "balanced" : "wide";
+  const breakoutBodyAtr = asFiniteNumber2(
+    baseContext?.structure?.acceptance?.breakoutBodyAtr
+  );
+  const closesAboveHighLevel3 = asFiniteNumber2(
+    baseContext?.structure?.acceptance?.closesAboveHighLevel3
+  );
+  const closesBelowLowLevel3 = asFiniteNumber2(
+    baseContext?.structure?.acceptance?.closesBelowLowLevel3
+  );
+  const continuationCloses = direction === "LONG" ? closesAboveHighLevel3 : direction === "SHORT" ? closesBelowLowLevel3 : null;
+  const breakoutAcceptance = continuationCloses == null ? "unknown" : continuationCloses >= 2 ? "confirmed" : continuationCloses >= 1 ? "single_close" : "failed_acceptance";
+  const breakoutState = baseContext?.structure?.localRange?.breakoutState ?? null;
+  const breakoutWithDirection = toTrendFollowContinuationAlignment({
+    direction,
+    bullishValue: "above_high_level",
+    bearishValue: "below_low_level",
+    value: breakoutState
+  });
+  const failedBreakoutForDirection = toTrendFollowContinuationAlignment({
+    direction,
+    bullishValue: "failed_low_breakout",
+    bearishValue: "failed_high_breakout",
+    value: breakoutState
+  });
+  const continuationState = breakoutWithDirection === true ? "breakout_confirmed" : failedBreakoutForDirection === true ? "failed_breakout" : breakoutState === "inside_range" ? "inside_range" : "unknown";
+  const volumeRel20 = asFiniteNumber2(
+    baseContext?.participation?.volume?.volumeRel20
+  );
+  const participationState = volumeRel20 == null ? "unknown" : volumeRel20 < 0.8 ? "thin" : volumeRel20 < 1.5 ? "weak" : "confirmed";
+  const derivativesDirectionAligned = typeof baseContext?.derivatives?.summary?.directionAligned === "boolean" ? baseContext.derivatives.summary.directionAligned : null;
+  const derivativesContinuation = flushSupport ? "flush_support" : derivativesDirectionAligned === true ? "aligned" : derivativesDirectionAligned === false ? "conflict" : directionalCrowding ? "crowded" : baseContext?.derivatives?.summary == null ? "unknown" : "neutral";
+  const benchmarkTrendAlignment = baseContext?.relative?.benchmark?.trendAlignment ?? null;
+  const benchmarkAligned = benchmarkTrendAlignment === "against_benchmark" ? false : toTrendFollowContinuationAlignment({
+    direction,
+    bullishValue: "aligned_bull",
+    bearishValue: "aligned_bear",
+    value: benchmarkTrendAlignment
+  });
+  const relativeContinuation = benchmarkAligned === true ? "aligned" : benchmarkAligned === false ? "against" : benchmarkTrendAlignment == null ? "unknown" : "neutral";
+  const marketBreadth = baseContext?.relative?.marketBreadth;
+  const marketBreadthReturn = asFiniteNumber2(
+    marketBreadth?.equalWeightedReturn
+  );
+  const marketBreadthAligned = marketBreadthReturn == null || marketBreadth?.stale ? null : direction === "LONG" ? marketBreadthReturn >= 0 : direction === "SHORT" ? marketBreadthReturn <= 0 : null;
+  const marketBreadthContinuation = marketBreadth?.stale === true ? "stale" : marketBreadthAligned === true ? "aligned" : marketBreadthAligned === false ? "against" : "unknown";
+  const marketVolatilityState = typeof baseContext?.regime?.volatility?.state === "string" ? baseContext.regime.volatility.state : null;
+  const targetVsBtcBeta20 = asFiniteNumber2(
+    baseContext?.relative?.targetVsBtc?.betaToBtc20
+  );
+  const sharedParticipationScore = asFiniteNumber2(
+    baseContext?.gateFeatures?.scores?.participation
+  );
+  const btcAltRegime = baseContext?.relative?.btcAltRegime;
+  const btcAltRegimeBtcTurnoverShare24h = asFiniteNumber2(
+    btcAltRegime?.btcTurnoverShare24h
+  );
+  const btcAltRegimeAltBasketReturn24h = asFiniteNumber2(
+    btcAltRegime?.altBasketReturn24h
+  );
+  const derivatives1h = baseContext?.derivatives?.intervals?.["1h"];
+  const derivatives1hOiChangePct24h = asFiniteNumber2(
+    derivatives1h?.oiChangePct24h
+  );
+  const derivatives1hLiqLong = asFiniteNumber2(derivatives1h?.liqLong);
+  const derivatives1hLiqImbalance = asFiniteNumber2(derivatives1h?.liqImbalance);
+  const xrp15m = getReferenceInterval(baseContext, "XRPUSDT", "15m");
+  const xrp1h = getReferenceInterval(baseContext, "XRPUSDT", "1h");
+  const sol15m = getReferenceInterval(baseContext, "SOLUSDT", "15m");
+  const bnb15m = getReferenceInterval(baseContext, "BNBUSDT", "15m");
+  const trx15m = getReferenceInterval(baseContext, "TRXUSDT", "15m");
+  const ethSummary = getReferenceSummary(baseContext, "ETHUSDT");
+  const minutesFromSessionOpen = asFiniteNumber2(
+    baseContext?.regime?.session?.minutesFromSessionOpen
+  );
+  const referenceXrp15mOpenInterest = asFiniteNumber2(xrp15m?.openInterest);
+  const referenceXrp15mOiChangePct24h = asFiniteNumber2(xrp15m?.oiChangePct24h);
+  const referenceXrp1hOiChangePct1h = asFiniteNumber2(xrp1h?.oiChangePct1h);
+  const referenceSol15mOpenInterest = asFiniteNumber2(sol15m?.openInterest);
+  const referenceSol15mOiChangePct4h = asFiniteNumber2(sol15m?.oiChangePct4h);
+  const referenceSol15mFundingZScore = asFiniteNumber2(sol15m?.fundingZScore);
+  const referenceBnb15mOpenInterest = asFiniteNumber2(bnb15m?.openInterest);
+  const referenceBnb15mOiChangePct24h = asFiniteNumber2(bnb15m?.oiChangePct24h);
+  const referenceTrx15mFundingRate = asFiniteNumber2(trx15m?.fundingRate);
+  const referenceEthCrowdingPersistenceBars = asFiniteNumber2(
+    ethSummary?.crowdingPersistenceBars
+  );
+  const derivativesShortFlushOiPocket = direction === "SHORT" && derivatives1hOiChangePct24h != null && derivatives1hOiChangePct24h >= TREND_FOLLOW_SHORT_FLUSH_OI_MIN_CHANGE_24H && derivatives1hLiqLong != null && derivatives1hLiqLong >= TREND_FOLLOW_SHORT_FLUSH_OI_MIN_LIQ_LONG && derivatives1hLiqImbalance != null && derivatives1hLiqImbalance <= TREND_FOLLOW_SHORT_FLUSH_OI_MAX_LIQ_IMBALANCE;
+  const marketRegimeCadencePocket = btcAltRegimeBtcTurnoverShare24h != null && btcAltRegimeBtcTurnoverShare24h < TREND_FOLLOW_SHORT_MARKET_MAX_BTC_TURNOVER_SHARE_24H && btcAltRegimeAltBasketReturn24h != null && btcAltRegimeAltBasketReturn24h >= TREND_FOLLOW_SHORT_MARKET_MIN_ALT_BASKET_RETURN_24H && btcAltRegimeAltBasketReturn24h < TREND_FOLLOW_SHORT_MARKET_MAX_ALT_BASKET_RETURN_24H;
+  const relativeCadencePocket = targetVsBtcBeta20 != null && targetVsBtcBeta20 > TREND_FOLLOW_SHORT_MIN_TARGET_BTC_BETA_20;
+  const participationCadencePocket = sharedParticipationScore != null && sharedParticipationScore <= TREND_FOLLOW_SHORT_MAX_SHARED_PARTICIPATION_SCORE;
+  const legacyCadencePocket = derivativesShortFlushOiPocket && marketRegimeCadencePocket && relativeCadencePocket && participationCadencePocket;
+  const referenceDerivativesOiCompressionPocket = direction === "SHORT" && referenceXrp15mOpenInterest != null && referenceXrp15mOpenInterest >= TREND_FOLLOW_REF_HIGH_XRP_OI_MIN && referenceSol15mOpenInterest != null && referenceSol15mOpenInterest >= TREND_FOLLOW_REF_HIGH_SOL_OI_MIN && referenceBnb15mOiChangePct24h != null && referenceBnb15mOiChangePct24h <= TREND_FOLLOW_REF_BNB_OI_CHANGE_24H_MAX;
+  const referenceDerivativesXrpFundingPocket = direction === "SHORT" && referenceXrp15mOpenInterest != null && referenceXrp15mOpenInterest >= TREND_FOLLOW_REF_HIGH_XRP_OI_MIN && referenceXrp15mOiChangePct24h != null && referenceXrp15mOiChangePct24h >= TREND_FOLLOW_REF_XRP_OI_CHANGE_24H_MIN && referenceTrx15mFundingRate != null && referenceTrx15mFundingRate <= TREND_FOLLOW_REF_TRX_FUNDING_RATE_MAX;
+  const referenceDerivativesSolFlushPocket = direction === "SHORT" && referenceSol15mOpenInterest != null && referenceSol15mOpenInterest >= TREND_FOLLOW_REF_SOL_FLUSH_OI_MIN && derivativesShortFlushOiPocket && referenceSol15mOiChangePct4h != null && referenceSol15mOiChangePct4h >= TREND_FOLLOW_REF_SOL_OI_CHANGE_4H_MIN;
+  const referenceDerivativesLossBlock = direction === "SHORT" && referenceXrp15mOpenInterest != null && referenceXrp15mOpenInterest >= TREND_FOLLOW_REF_LOSS_XRP_OI_MIN && referenceEthCrowdingPersistenceBars != null && referenceEthCrowdingPersistenceBars >= TREND_FOLLOW_REF_LOSS_ETH_CROWDING_MIN && referenceSol15mFundingZScore != null && referenceSol15mFundingZScore <= TREND_FOLLOW_REF_LOSS_SOL_FUNDING_Z_MAX;
+  const referenceDerivativesCadencePocket = !referenceDerivativesLossBlock && (legacyCadencePocket || referenceDerivativesOiCompressionPocket || referenceDerivativesXrpFundingPocket || referenceDerivativesSolFlushPocket);
+  const referenceDerivativesOpeningPocket = direction === "SHORT" && minutesFromSessionOpen != null && minutesFromSessionOpen <= TREND_FOLLOW_OPENING_SESSION_MAX_MINUTES_FROM_OPEN && referenceXrp15mOpenInterest != null && referenceXrp15mOpenInterest <= TREND_FOLLOW_OPENING_REF_XRP_OI_MAX && referenceXrp1hOiChangePct1h != null && referenceXrp1hOiChangePct1h >= TREND_FOLLOW_OPENING_REF_XRP_OI_CHANGE_1H_MIN && referenceBnb15mOpenInterest != null && referenceBnb15mOpenInterest >= TREND_FOLLOW_OPENING_REF_BNB_OI_MIN;
+  const referenceDerivativesCleanCadencePocket = referenceDerivativesCadencePocket && !derivativesShortFlushOiPocket;
+  const normalVolatilityCadencePocket = marketVolatilityState === TREND_FOLLOW_ALLOWED_VOLATILITY_STATE;
+  return {
+    setupStopDistanceAtr,
+    setupTpDistanceAtr,
+    setupRewardToVolatility,
+    setupRiskShape,
+    breakoutBodyAtr,
+    breakoutAcceptance,
+    continuationState,
+    participationState,
+    directionalVolumeAligned: volumeStructureDirectionAligned,
+    derivativesContinuation,
+    relativeContinuation,
+    marketBreadthContinuation,
+    marketBreadthDispersion: asFiniteNumber2(marketBreadth?.dispersion),
+    marketVolatilityState,
+    targetVsBtcBeta20,
+    btcAltRegimeBtcTurnoverShare24h,
+    btcAltRegimeAltBasketReturn24h,
+    derivatives1hOiChangePct24h,
+    derivatives1hLiqLong,
+    derivatives1hLiqImbalance,
+    sharedParticipationScore,
+    minutesFromSessionOpen,
+    referenceXrp15mOpenInterest,
+    referenceXrp15mOiChangePct24h,
+    referenceXrp1hOiChangePct1h,
+    referenceSol15mOpenInterest,
+    referenceSol15mOiChangePct4h,
+    referenceSol15mFundingZScore,
+    referenceBnb15mOpenInterest,
+    referenceBnb15mOiChangePct24h,
+    referenceTrx15mFundingRate,
+    referenceEthCrowdingPersistenceBars,
+    derivativesShortFlushOiPocket,
+    marketRegimeCadencePocket,
+    participationCadencePocket,
+    referenceDerivativesOiCompressionPocket,
+    referenceDerivativesXrpFundingPocket,
+    referenceDerivativesSolFlushPocket,
+    referenceDerivativesLossBlock,
+    referenceDerivativesCadencePocket,
+    referenceDerivativesCleanCadencePocket,
+    referenceDerivativesOpeningPocket,
+    normalVolatilityCadencePocket,
+    highQualityCadencePocket: normalVolatilityCadencePocket && referenceDerivativesCleanCadencePocket
+  };
+};
+var buildTrendFollowGuardrailContext = ({
+  signalContext,
+  baseContext,
+  prices
+}) => {
+  const derivativesSummary = baseContext?.derivatives?.summary ?? null;
+  const primarySession = baseContext?.regime?.session?.sessionPhase ?? null;
+  const trendBias = baseContext?.regime?.trend?.bias ?? null;
+  const trendFollowState = signalContext.signalDirection === "LONG" ? "bull" : signalContext.signalDirection === "SHORT" ? "bear" : null;
+  const breakoutState = baseContext?.structure?.localRange?.breakoutState ?? null;
+  const momentumRsi = asFiniteNumber2(baseContext?.regime?.momentum?.rsi);
+  const volumeRel20 = asFiniteNumber2(
+    baseContext?.participation?.volume?.volumeRel20
+  );
+  const deltaDivergenceVsPrice = baseContext?.participation?.delta?.deltaDivergenceVsPrice ?? null;
+  const totalUpVolumeShare = asFiniteNumber2(
+    baseContext?.participation?.volumeStructure?.totalUpVolumeShare
+  );
+  const totalDownVolumeShare = asFiniteNumber2(
+    baseContext?.participation?.volumeStructure?.totalDownVolumeShare
+  );
+  const benchmarkTrendAlignment = baseContext?.relative?.benchmark?.trendAlignment ?? null;
+  const derivativesPressure = typeof derivativesSummary?.pressure === "string" ? derivativesSummary.pressure : null;
+  const derivativesDirectionAligned = typeof derivativesSummary?.directionAligned === "boolean" ? derivativesSummary.directionAligned : null;
+  const derivativesRiskFlags = asStringArray(derivativesSummary?.riskFlags);
+  const hardBlockReasons = [];
+  const softBlockReasons = [];
+  if (signalContext.signalDirection !== "LONG" && signalContext.signalDirection !== "SHORT") {
+    hardBlockReasons.push("missing_direction");
+  }
+  if ((signalContext.atr ?? 0) <= 0 || signalContext.trailStop == null) {
+    hardBlockReasons.push("missing_trailing_stop");
+  }
+  if ((signalContext.breakoutDistancePct ?? 0) <= 0) {
+    hardBlockReasons.push("missing_breakout");
+  }
+  if ((signalContext.distanceToStopPct ?? 0) <= 0) {
+    hardBlockReasons.push("invalid_stop_distance");
+  }
+  const direction = signalContext.signalDirection;
+  const trendAligned = isDirectionAligned2({
+    direction,
+    bullishValue: "bull",
+    bearishValue: "bear",
+    value: trendBias
+  });
+  const benchmarkAligned = isDirectionAligned2({
+    direction,
+    bullishValue: "aligned_bull",
+    bearishValue: "aligned_bear",
+    value: benchmarkTrendAlignment
+  });
+  const breakoutAligned = isDirectionAligned2({
+    direction,
+    bullishValue: "above_high_level",
+    bearishValue: "below_low_level",
+    value: breakoutState
+  });
+  const strategyTrendFollowAligned = isDirectionAligned2({
+    direction,
+    bullishValue: "bull",
+    bearishValue: "bear",
+    value: trendFollowState
+  });
+  const flushSupport = direction === "LONG" ? derivativesRiskFlags.includes("short_liquidation_spike") || derivativesPressure === "short_flush" : direction === "SHORT" ? derivativesRiskFlags.includes("long_liquidation_spike") || derivativesPressure === "long_flush" : false;
+  const directionalCrowding = direction === "LONG" ? derivativesRiskFlags.includes("crowded_long") : direction === "SHORT" ? derivativesRiskFlags.includes("crowded_short") : false;
+  const adverseDeltaDivergence = direction === "LONG" ? deltaDivergenceVsPrice === "bearish" : direction === "SHORT" ? deltaDivergenceVsPrice === "bullish" : false;
+  const volumeStructureDirectionalShare = direction === "LONG" ? totalUpVolumeShare : direction === "SHORT" ? totalDownVolumeShare : null;
+  const volumeStructureDirectionAligned = volumeStructureDirectionalShare == null ? null : volumeStructureDirectionalShare >= 0.48;
+  const breakoutDistancePct = signalContext.breakoutDistancePct ?? 0;
+  const distanceToStopPct = signalContext.distanceToStopPct ?? 0;
+  const highConvictionApprovalPocket = direction === "SHORT" && (primarySession === "off_hours" || primarySession === "asia") && breakoutDistancePct >= 0.5 && breakoutDistancePct <= 2 && distanceToStopPct >= 0.5 && distanceToStopPct <= 3;
+  const trendFollowGateFeatures = buildTrendFollowGateFeatures({
+    signalContext,
+    baseContext,
+    prices,
+    volumeStructureDirectionAligned,
+    flushSupport,
+    directionalCrowding
+  });
+  if (volumeRel20 != null && volumeRel20 < 0.8) {
+    softBlockReasons.push("thin_participation");
+  } else if (volumeRel20 != null && volumeRel20 < 1.5) {
+    softBlockReasons.push("weak_relative_volume");
+  }
+  if (trendFollowGateFeatures.setupRiskShape === "unknown") {
+    softBlockReasons.push("missing_setup_stop_distance_atr");
+  } else if (trendFollowGateFeatures.setupStopDistanceAtr != null && trendFollowGateFeatures.setupStopDistanceAtr < 1.15) {
+    softBlockReasons.push("tight_setup_stop_distance_atr");
+  }
+  if (trendFollowGateFeatures.setupTpDistanceAtr != null && trendFollowGateFeatures.setupTpDistanceAtr < 1.5) {
+    softBlockReasons.push("weak_setup_tp_distance_atr");
+  }
+  if (direction === "SHORT" && momentumRsi != null && momentumRsi > 36.35) {
+    softBlockReasons.push("weak_downside_momentum");
+  }
+  if (directionalCrowding && !flushSupport) {
+    softBlockReasons.push("directional_crowding");
+  }
+  if (derivativesDirectionAligned === false && !flushSupport) {
+    softBlockReasons.push("derivatives_not_aligned");
+  }
+  if (breakoutState === "inside_range") {
+    softBlockReasons.push("inside_range_breakout");
+  }
+  if (adverseDeltaDivergence) {
+    softBlockReasons.push("adverse_delta_divergence");
+  }
+  if (volumeStructureDirectionAligned === false) {
+    softBlockReasons.push("weak_volume_structure");
+  }
+  if (!trendFollowGateFeatures.highQualityCadencePocket) {
+    softBlockReasons.push("outside_high_conviction_cadence_pocket");
+  }
+  let deterministicQuality = 3;
+  if (hardBlockReasons.length > 0) {
+    deterministicQuality = 1;
+  } else if (breakoutDistancePct >= 0.25 && breakoutDistancePct <= 2.5 && distanceToStopPct >= 0.25 && (trendAligned || strategyTrendFollowAligned || benchmarkAligned || breakoutAligned || flushSupport)) {
+    deterministicQuality = flushSupport || breakoutAligned || strategyTrendFollowAligned ? 5 : 4;
+  } else if (breakoutDistancePct > 0 && distanceToStopPct > 0) {
+    deterministicQuality = 4;
+  }
+  if (deterministicQuality >= 5 && softBlockReasons.length > 0) {
+    deterministicQuality = 4;
+  }
+  return {
+    ...signalContext,
+    baseContextAvailable: Boolean(baseContext),
+    primarySession,
+    trendBias,
+    trendFollowState,
+    breakoutState,
+    momentumRsi,
+    volumeRel20,
+    deltaDivergenceVsPrice,
+    volumeStructureDirectionalShare,
+    volumeStructureDirectionAligned,
+    highConvictionApprovalPocket,
+    benchmarkTrendAlignment,
+    derivativesPressure,
+    derivativesDirectionAligned,
+    derivativesRiskFlags,
+    trendFollowGateFeatures,
+    hardBlockReasons,
+    softBlockReasons,
+    deterministicQuality,
+    approvalAllowedNow: deterministicQuality >= 4 && hardBlockReasons.length === 0 && trendFollowGateFeatures.highQualityCadencePocket
+  };
+};
+
+// src/TrendFollow/adapters/ai.ts
+var import_ai_gate = require("@tradejs/strategy-kit/ai-gate");
+var asRecord = (value) => typeof value === "object" && value != null && !Array.isArray(value) ? value : null;
+var getTrendFollowContext = (payload) => {
+  const additional = asRecord(payload.additionalIndicators);
+  const signalContext = (additional?.trendFollowContext ?? {}) || {};
+  const baseContext = additional?.baseContext ?? null;
+  return buildTrendFollowGuardrailContext({
+    signalContext,
+    baseContext,
+    prices: payload.signal?.prices
+  });
+};
+var trendFollowBaseAiAdapter = {
+  buildPayload: ({ signal, basePayload }) => {
+    const payload = {
+      ...basePayload,
+      additionalIndicators: {
+        ...basePayload.additionalIndicators,
+        trendFollowContext: signal.additionalIndicators?.trendFollowContext
+      }
+    };
+    return {
+      ...payload,
+      additionalIndicators: {
+        ...payload.additionalIndicators,
+        trendFollowContext: getTrendFollowContext(payload)
+      }
+    };
+  },
+  postProcessAnalysis: ({ payload, analysis }) => {
+    const context = getTrendFollowContext(payload);
+    const requestedDirection = analysis.direction === "LONG" || analysis.direction === "SHORT" ? analysis.direction : context.signalDirection;
+    const approved = context.approvalAllowedNow === true && requestedDirection != null;
+    return {
+      ...analysis,
+      direction: approved ? requestedDirection : null,
+      quality: context.deterministicQuality,
+      approved,
+      rejectReason: approved ? void 0 : [...context.hardBlockReasons, ...context.softBlockReasons].join(
+        "; "
+      ) || "Trend Follow breakout lacks confirmation."
+    };
+  },
+  buildHumanPromptAddon: ({ payload }) => {
+    const context = getTrendFollowContext(payload);
+    return `
+Additional TrendFollow context:
+- signalDirection=${context.signalDirection ?? "n/a"}
+- entryLevel=${String(context.entryLevel ?? "n/a")}
+- trailStop=${String(context.trailStop ?? "n/a")}
+- atr=${String(context.atr ?? "n/a")}
+- pivotKind=${context.pivotKind ?? "n/a"}
+- pivotTimestamp=${String(context.pivotTimestamp ?? "n/a")}
+- pivotValue=${String(context.pivotValue ?? "n/a")}
+- barsSinceSignal=${String(context.barsSinceSignal ?? "n/a")}
+- breakoutDistancePct=${String(context.breakoutDistancePct ?? "n/a")}
+- distanceToStopPct=${String(context.distanceToStopPct ?? "n/a")}
+- currentPrice=${String(context.currentPrice ?? "n/a")}
+- primarySession=${context.primarySession ?? "n/a"}
+- trendBias=${context.trendBias ?? "n/a"}
+- breakoutState=${context.breakoutState ?? "n/a"}
+- momentumRsi=${String(context.momentumRsi ?? "n/a")}
+- volumeRel20=${String(context.volumeRel20 ?? "n/a")}
+- deltaDivergenceVsPrice=${context.deltaDivergenceVsPrice ?? "n/a"}
+- volumeStructureDirectionalShare=${String(context.volumeStructureDirectionalShare ?? "n/a")}
+- volumeStructureDirectionAligned=${String(context.volumeStructureDirectionAligned ?? "n/a")}
+- highConvictionApprovalPocket=${String(context.highConvictionApprovalPocket)}
+- trendFollowGateSetupStopDistanceAtr=${String(context.trendFollowGateFeatures.setupStopDistanceAtr ?? "n/a")}
+- trendFollowGateSetupTpDistanceAtr=${String(context.trendFollowGateFeatures.setupTpDistanceAtr ?? "n/a")}
+- trendFollowGateSetupRewardToVolatility=${String(context.trendFollowGateFeatures.setupRewardToVolatility ?? "n/a")}
+- trendFollowGateSetupRiskShape=${context.trendFollowGateFeatures.setupRiskShape}
+- trendFollowGateBreakoutBodyAtr=${String(context.trendFollowGateFeatures.breakoutBodyAtr ?? "n/a")}
+- trendFollowGateBreakoutAcceptance=${context.trendFollowGateFeatures.breakoutAcceptance}
+- trendFollowGateContinuationState=${context.trendFollowGateFeatures.continuationState}
+- trendFollowGateParticipationState=${context.trendFollowGateFeatures.participationState}
+- trendFollowGateDirectionalVolumeAligned=${String(context.trendFollowGateFeatures.directionalVolumeAligned ?? "n/a")}
+- trendFollowGateDerivativesContinuation=${context.trendFollowGateFeatures.derivativesContinuation}
+- trendFollowGateRelativeContinuation=${context.trendFollowGateFeatures.relativeContinuation}
+- trendFollowGateMarketBreadthContinuation=${context.trendFollowGateFeatures.marketBreadthContinuation}
+- trendFollowGateMarketBreadthDispersion=${String(context.trendFollowGateFeatures.marketBreadthDispersion ?? "n/a")}
+- trendFollowGateMarketVolatilityState=${String(context.trendFollowGateFeatures.marketVolatilityState ?? "n/a")}
+- trendFollowGateTargetVsBtcBeta20=${String(context.trendFollowGateFeatures.targetVsBtcBeta20 ?? "n/a")}
+- trendFollowGateBtcAltRegimeBtcTurnoverShare24h=${String(context.trendFollowGateFeatures.btcAltRegimeBtcTurnoverShare24h ?? "n/a")}
+- trendFollowGateBtcAltRegimeAltBasketReturn24h=${String(context.trendFollowGateFeatures.btcAltRegimeAltBasketReturn24h ?? "n/a")}
+- trendFollowGateDerivatives1hOiChangePct24h=${String(context.trendFollowGateFeatures.derivatives1hOiChangePct24h ?? "n/a")}
+- trendFollowGateDerivatives1hLiqLong=${String(context.trendFollowGateFeatures.derivatives1hLiqLong ?? "n/a")}
+- trendFollowGateDerivatives1hLiqImbalance=${String(context.trendFollowGateFeatures.derivatives1hLiqImbalance ?? "n/a")}
+- trendFollowGateSharedParticipationScore=${String(context.trendFollowGateFeatures.sharedParticipationScore ?? "n/a")}
+- trendFollowGateMinutesFromSessionOpen=${String(context.trendFollowGateFeatures.minutesFromSessionOpen ?? "n/a")}
+- trendFollowGateReferenceXrp15mOpenInterest=${String(context.trendFollowGateFeatures.referenceXrp15mOpenInterest ?? "n/a")}
+- trendFollowGateReferenceXrp15mOiChangePct24h=${String(context.trendFollowGateFeatures.referenceXrp15mOiChangePct24h ?? "n/a")}
+- trendFollowGateReferenceXrp1hOiChangePct1h=${String(context.trendFollowGateFeatures.referenceXrp1hOiChangePct1h ?? "n/a")}
+- trendFollowGateReferenceSol15mOpenInterest=${String(context.trendFollowGateFeatures.referenceSol15mOpenInterest ?? "n/a")}
+- trendFollowGateReferenceSol15mOiChangePct4h=${String(context.trendFollowGateFeatures.referenceSol15mOiChangePct4h ?? "n/a")}
+- trendFollowGateReferenceSol15mFundingZScore=${String(context.trendFollowGateFeatures.referenceSol15mFundingZScore ?? "n/a")}
+- trendFollowGateReferenceBnb15mOpenInterest=${String(context.trendFollowGateFeatures.referenceBnb15mOpenInterest ?? "n/a")}
+- trendFollowGateReferenceBnb15mOiChangePct24h=${String(context.trendFollowGateFeatures.referenceBnb15mOiChangePct24h ?? "n/a")}
+- trendFollowGateReferenceTrx15mFundingRate=${String(context.trendFollowGateFeatures.referenceTrx15mFundingRate ?? "n/a")}
+- trendFollowGateReferenceEthCrowdingPersistenceBars=${String(context.trendFollowGateFeatures.referenceEthCrowdingPersistenceBars ?? "n/a")}
+- trendFollowGateDerivativesShortFlushOiPocket=${String(context.trendFollowGateFeatures.derivativesShortFlushOiPocket)}
+- trendFollowGateMarketRegimeCadencePocket=${String(context.trendFollowGateFeatures.marketRegimeCadencePocket)}
+- trendFollowGateParticipationCadencePocket=${String(context.trendFollowGateFeatures.participationCadencePocket)}
+- trendFollowGateReferenceDerivativesOiCompressionPocket=${String(context.trendFollowGateFeatures.referenceDerivativesOiCompressionPocket)}
+- trendFollowGateReferenceDerivativesXrpFundingPocket=${String(context.trendFollowGateFeatures.referenceDerivativesXrpFundingPocket)}
+- trendFollowGateReferenceDerivativesSolFlushPocket=${String(context.trendFollowGateFeatures.referenceDerivativesSolFlushPocket)}
+- trendFollowGateReferenceDerivativesLossBlock=${String(context.trendFollowGateFeatures.referenceDerivativesLossBlock)}
+- trendFollowGateReferenceDerivativesCadencePocket=${String(context.trendFollowGateFeatures.referenceDerivativesCadencePocket)}
+- trendFollowGateReferenceDerivativesCleanCadencePocket=${String(context.trendFollowGateFeatures.referenceDerivativesCleanCadencePocket)}
+- trendFollowGateReferenceDerivativesOpeningPocket=${String(context.trendFollowGateFeatures.referenceDerivativesOpeningPocket)}
+- trendFollowGateNormalVolatilityCadencePocket=${String(context.trendFollowGateFeatures.normalVolatilityCadencePocket)}
+- trendFollowGateHighQualityCadencePocket=${String(context.trendFollowGateFeatures.highQualityCadencePocket)}
+- benchmarkTrendAlignment=${context.benchmarkTrendAlignment ?? "n/a"}
+- derivativesPressure=${context.derivativesPressure ?? "n/a"}
+- derivativesDirectionAligned=${String(context.derivativesDirectionAligned ?? "n/a")}
+- derivativesRiskFlags=${JSON.stringify(context.derivativesRiskFlags)}
+- deterministicQuality=${context.deterministicQuality}
+- approvalAllowedNow=${String(context.approvalAllowedNow)}
+- hardBlockReasons=${JSON.stringify(context.hardBlockReasons)}
+- softBlockReasons=${JSON.stringify(context.softBlockReasons)}
+
+Interpretation rules for TrendFollow:
+- This is a market-structure trend-following strategy, not a mean-reversion setup.
+- LONG appears when close crosses above the latest confirmed pivot high.
+- SHORT appears when close crosses below the latest confirmed pivot low.
+- The ATR trailing stop is the structural invalidation line and also updates while a position is open.
+- Prefer breakouts aligned with shared market context and backed by participation.
+- Late, thin, crowded, inside-range, adverse-delta, weak-momentum, or weak-volume-structure breakouts should be downgraded even if the pivot cross is valid.
+- Live approval is reserved for calibrated SHORT extra-reference derivatives pockets in normal volatility when the BTC benchmark short-flush/OI pocket is not active; legacy BTC benchmark flush and opening-session recovery remain watch mode.
+- Treat deterministicQuality and approvalAllowedNow as the local normalized gate result.
+`.trim();
+  },
+  mapEntryRuntimeFromConfig: (config2) => (0, import_strategies.mapAiRuntimeFromConfig)(
+    config2
+  )
+};
+var trendFollowAiAdapter = (0, import_ai_gate.withStrategyLocalAiGate)(
+  trendFollowBaseAiAdapter,
+  {
+    id: "trend_follow_short_breadth_2026_08_12",
+    approves: ({ signal, payload }) => {
+      const advancers = (0, import_ai_gate.getAiPayloadNumber)(
+        payload,
+        "additionalIndicators.baseContext.relative.marketBreadth.advancers"
+      );
+      const top5Unchanged = (0, import_ai_gate.getAiPayloadNumber)(
+        payload,
+        "additionalIndicators.baseContext.relative.marketBreadths.top5.unchanged"
+      );
+      return signal.direction === "SHORT" && advancers != null && advancers >= 2 && top5Unchanged != null && top5Unchanged <= 0;
+    }
+  }
+);
+
+// src/TrendFollow/manifest.ts
+var trendFollowManifest = {
+  name: "TrendFollow",
+  aiAdapter: trendFollowAiAdapter
+};
+
+// src/TrendFollow/strategy.ts
+var TrendFollowStrategyDefinition = {
+  defaults: config,
+  createCore: createTrendFollowCore,
+  manifest: trendFollowManifest
+};
+
+// src/index.ts
+var strategyEntries = [
+  TrendFollowStrategyDefinition
+];
+var defaultConfigs = {
+  TrendFollow: config
+};
+var getBuiltInStrategyDefaultConfig = (strategyName) => defaultConfigs[strategyName];
+var index_default = (0, import_config4.defineStrategyPlugin)({ strategyEntries });
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TrendFollowStrategyDefinition,
+  getBuiltInStrategyDefaultConfig,
+  strategyEntries,
+  trendFollowAiAdapter,
+  trendFollowDefaultConfig,
+  trendFollowManifest
+});