@tradejs/strategy-double-tap 3.0.0

package/dist/index.js

@@ -0,0 +1,1653 @@
+// src/index.ts
+import { defineStrategyPlugin } from "@tradejs/core/config";
+
+// src/DoubleTap/config.ts
+import { FEE_PERCENT } from "@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: 4,
+  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,
+  DOUBLETAP_PIVOT_LENGTH: 35,
+  DOUBLETAP_PIVOT_TOLERANCE_PCT: 12,
+  DOUBLETAP_TARGET_FIB_PCT: 180,
+  DOUBLETAP_STOP_FIB_PCT: 0,
+  DOUBLETAP_MIN_PATTERN_HEIGHT_PCT: 0.2,
+  DOUBLETAP_MIN_PATTERN_HEIGHT_ATR: 1,
+  DOUBLETAP_ATR_PERIOD: 14,
+  DOUBLETAP_MIN_TAP_SPACING_BARS: 3,
+  DOUBLETAP_MAX_PATTERN_AGE_BARS: 180,
+  DOUBLETAP_MIN_LEG_SYMMETRY_RATIO: 0.25,
+  DOUBLETAP_MIN_BREAKOUT_DISTANCE_ATR: 0.05,
+  DOUBLETAP_MAX_BREAKOUT_DISTANCE_HEIGHT_RATIO: 0.8,
+  DOUBLETAP_MAX_BREAKOUT_DISTANCE_PCT: 0.8,
+  DOUBLETAP_ENTRY_MODE: "close_acceptance",
+  DOUBLETAP_CONFIRMATION_MAX_BARS: 2,
+  DOUBLETAP_MAX_ENTRY_CONFIRMATION_BARS: 0,
+  DOUBLETAP_MAX_ENTRY_CONFIRMATION_BARS_LONG: 1,
+  DOUBLETAP_MAX_ENTRY_CONFIRMATION_BARS_SHORT: 0,
+  DOUBLETAP_MAX_BB_WIDTH_PCT: 0,
+  DOUBLETAP_MAX_BB_WIDTH_PCT_LONG: 0,
+  DOUBLETAP_MAX_BB_WIDTH_PCT_SHORT: 6,
+  DOUBLETAP_RETEST_MAX_BARS: 4,
+  DOUBLETAP_RETEST_TOLERANCE_ATR: 0.25,
+  DOUBLETAP_EXIT_ON_OPPOSITE_PATTERN: true,
+  LONG: {
+    enable: true,
+    direction: "LONG",
+    minRiskRatio: 0.7
+  },
+  SHORT: {
+    enable: true,
+    direction: "SHORT",
+    minRiskRatio: 0.7
+  }
+};
+
+// src/DoubleTap/core.ts
+import { round } from "@tradejs/core/math";
+
+// src/DoubleTap/engine.ts
+var asNumber = (value) => {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+};
+var clampPositive = (value, fallback) => Number.isFinite(value) && value > 0 ? value : fallback;
+var getConfigNumbers = (config2) => ({
+  pivotLength: Math.max(1, Math.floor(config2.DOUBLETAP_PIVOT_LENGTH ?? 50)),
+  tolerancePct: clampPositive(config2.DOUBLETAP_PIVOT_TOLERANCE_PCT, 15),
+  targetFibPct: Math.max(0, Number(config2.DOUBLETAP_TARGET_FIB_PCT ?? 100)),
+  stopFibPct: Number(config2.DOUBLETAP_STOP_FIB_PCT ?? 0),
+  minPatternHeightPct: Math.max(
+    0,
+    Number(config2.DOUBLETAP_MIN_PATTERN_HEIGHT_PCT ?? 0)
+  ),
+  minPatternHeightAtr: Math.max(
+    0,
+    Number(config2.DOUBLETAP_MIN_PATTERN_HEIGHT_ATR ?? 0)
+  ),
+  atrPeriod: Math.max(2, Math.floor(config2.DOUBLETAP_ATR_PERIOD ?? 14)),
+  minTapSpacingBars: Math.max(
+    1,
+    Math.floor(config2.DOUBLETAP_MIN_TAP_SPACING_BARS ?? 1)
+  ),
+  maxPatternAgeBars: Math.max(
+    1,
+    Math.floor(config2.DOUBLETAP_MAX_PATTERN_AGE_BARS ?? 180)
+  ),
+  minLegSymmetryRatio: Math.min(
+    1,
+    Math.max(0, Number(config2.DOUBLETAP_MIN_LEG_SYMMETRY_RATIO ?? 0))
+  ),
+  minBreakoutDistanceAtr: Math.max(
+    0,
+    Number(config2.DOUBLETAP_MIN_BREAKOUT_DISTANCE_ATR ?? 0)
+  ),
+  maxBreakoutDistanceHeightRatio: Math.max(
+    0,
+    Number(config2.DOUBLETAP_MAX_BREAKOUT_DISTANCE_HEIGHT_RATIO ?? 0)
+  ),
+  maxBreakoutDistancePct: Math.max(
+    0,
+    Number(config2.DOUBLETAP_MAX_BREAKOUT_DISTANCE_PCT ?? 0)
+  ),
+  entryMode: config2.DOUBLETAP_ENTRY_MODE ?? "close_acceptance",
+  confirmationMaxBars: Math.max(
+    1,
+    Math.floor(config2.DOUBLETAP_CONFIRMATION_MAX_BARS ?? 2)
+  ),
+  retestMaxBars: Math.max(1, Math.floor(config2.DOUBLETAP_RETEST_MAX_BARS ?? 4)),
+  retestToleranceAtr: Math.max(
+    0,
+    Number(config2.DOUBLETAP_RETEST_TOLERANCE_ATR ?? 0.25)
+  )
+});
+var highest = (candles) => candles.reduce(
+  (max, candle) => Math.max(max, Number(candle.high)),
+  -Infinity
+);
+var lowest = (candles) => candles.reduce((min, candle) => Math.min(min, Number(candle.low)), Infinity);
+var calculateAtr = (candles, period) => {
+  const relevant = candles.slice(-(period + 1));
+  if (relevant.length < 2) return null;
+  const trueRanges = [];
+  for (let index = 1; index < relevant.length; index += 1) {
+    const candle = relevant[index];
+    const previous = relevant[index - 1];
+    const high = asNumber(candle?.high);
+    const low = asNumber(candle?.low);
+    const previousClose = asNumber(previous?.close);
+    if (high == null || low == null || previousClose == null) continue;
+    trueRanges.push(
+      Math.max(
+        high - low,
+        Math.abs(high - previousClose),
+        Math.abs(low - previousClose)
+      )
+    );
+  }
+  if (trueRanges.length === 0) return null;
+  return trueRanges.reduce((sum, value) => sum + value, 0) / trueRanges.length;
+};
+var pushBoundedCandle = (state, candle, maxCandles) => {
+  state.currentIndex += 1;
+  state.candles.push(candle);
+  if (state.candles.length > maxCandles) {
+    state.candles.splice(0, state.candles.length - maxCandles);
+  }
+  return state.currentIndex;
+};
+var pushPivot = ({
+  pivots,
+  candle,
+  index,
+  kind,
+  value
+}) => {
+  pivots.push({
+    timestamp: candle.timestamp,
+    index,
+    value,
+    kind,
+    traded: false
+  });
+  if (pivots.length > 12) pivots.shift();
+};
+var updateLatestPivot = ({
+  pivots,
+  candle,
+  index,
+  kind,
+  value
+}) => {
+  const latest = pivots[pivots.length - 1];
+  if (!latest || latest.kind !== kind) return;
+  const isMoreExtreme = kind === "high" ? value > latest.value : value < latest.value;
+  if (!isMoreExtreme) return;
+  latest.timestamp = candle.timestamp;
+  latest.index = index;
+  latest.value = value;
+};
+var markTerminal = (state, setup) => {
+  state.consumedSetupIds.add(setup.setupId);
+  const terminalPivot = state.pivots.find(
+    (pivot) => pivot.timestamp === setup.pattern.pivots[3].timestamp
+  );
+  if (terminalPivot) terminalPivot.traded = true;
+};
+var buildBreakoutPattern = ({
+  state,
+  candle,
+  prevClose,
+  atr,
+  multiplier,
+  tolerancePct,
+  targetFibPct,
+  stopFibPct,
+  minPatternHeightPct,
+  minPatternHeightAtr,
+  minTapSpacingBars,
+  maxPatternAgeBars,
+  minLegSymmetryRatio,
+  minBreakoutDistanceAtr,
+  maxBreakoutDistanceHeightRatio,
+  maxBreakoutDistancePct,
+  entryMode
+}) => {
+  const { pivots } = state;
+  if (pivots.length < 5 || prevClose == null) return null;
+  const rows = pivots.length;
+  const p1 = pivots[rows - 5];
+  const p2 = pivots[rows - 4];
+  const p3 = pivots[rows - 3];
+  const p4 = pivots[rows - 2];
+  if (!p1 || !p2 || !p3 || !p4 || p4.traded) return null;
+  const close = asNumber(candle.close);
+  if (close == null) return null;
+  const signedHeight = (p2.value + p4.value) / 2 - p3.value;
+  const height = Math.abs(signedHeight);
+  if (height <= 0) return null;
+  const heightPct = p3.value !== 0 ? height / Math.abs(p3.value) * 100 : 0;
+  const patternHeightAtr = atr != null && atr > 0 ? height / atr : 0;
+  if (heightPct < minPatternHeightPct || patternHeightAtr < minPatternHeightAtr) {
+    return null;
+  }
+  const upper = p2.value + signedHeight * (tolerancePct / 100);
+  const lower = p2.value - signedHeight * (tolerancePct / 100);
+  const crossedNeckline = close * multiplier < p3.value * multiplier && !(prevClose * multiplier < p3.value * multiplier);
+  const pivotsAligned = p1.value * multiplier < p3.value * multiplier && p4.value * multiplier <= upper * multiplier && p4.value * multiplier >= lower * multiplier;
+  if (!crossedNeckline || !pivotsAligned) return null;
+  const tapSpacingBars = p4.index - p2.index;
+  const firstLegBars = p3.index - p2.index;
+  const secondLegBars = p4.index - p3.index;
+  const legDurationSymmetryRatio = Math.max(firstLegBars, secondLegBars) > 0 ? Math.min(firstLegBars, secondLegBars) / Math.max(firstLegBars, secondLegBars) : 0;
+  const patternAgeBars = state.currentIndex - p2.index;
+  if (tapSpacingBars < minTapSpacingBars || patternAgeBars > maxPatternAgeBars || legDurationSymmetryRatio < minLegSymmetryRatio) {
+    return null;
+  }
+  const breakoutDistance = Math.abs(close - p3.value);
+  const breakoutDistancePct = p3.value !== 0 ? breakoutDistance / Math.abs(p3.value) * 100 : 0;
+  const breakoutDistanceAtr = atr != null && atr > 0 ? breakoutDistance / atr : 0;
+  const breakoutDistanceHeightRatio = breakoutDistance / height;
+  if (breakoutDistanceAtr < minBreakoutDistanceAtr || maxBreakoutDistanceHeightRatio > 0 && breakoutDistanceHeightRatio > maxBreakoutDistanceHeightRatio || maxBreakoutDistancePct > 0 && breakoutDistancePct > maxBreakoutDistancePct) {
+    return null;
+  }
+  const kind = multiplier === -1 ? "double_bottom" : "double_top";
+  const setupId = `${kind}:${p2.timestamp}:${p3.timestamp}:${p4.timestamp}`;
+  if (state.consumedSetupIds.has(setupId)) return null;
+  const lowerInvalidation = Math.min(p2.value, p4.value);
+  const upperInvalidation = Math.max(p2.value, p4.value);
+  const stopLossPrice = multiplier === -1 ? lowerInvalidation + height * (stopFibPct / 100) : upperInvalidation - height * (stopFibPct / 100);
+  return {
+    setupId,
+    kind,
+    direction: multiplier === -1 ? "LONG" : "SHORT",
+    entryMode,
+    entryStage: "breakout",
+    pivots: [p1, p2, p3, p4],
+    neckline: p3.value,
+    targetPrice: p3.value - signedHeight * (targetFibPct / 100),
+    stopLossPrice,
+    height,
+    patternHeightAtr,
+    patternAgeBars,
+    tapSpacingBars,
+    legDurationSymmetryRatio,
+    pivotTolerancePct: tolerancePct,
+    breakoutDistancePct,
+    breakoutDistanceAtr,
+    breakoutDistanceHeightRatio,
+    breakoutTimestamp: candle.timestamp,
+    confirmationBars: 0,
+    timestamp: candle.timestamp,
+    close
+  };
+};
+var isBeyondNeckline = (direction, close, neckline, minimumDistance) => direction === "LONG" ? close >= neckline + minimumDistance : close <= neckline - minimumDistance;
+var resolvePending = ({
+  state,
+  candle,
+  atr,
+  confirmationMaxBars,
+  retestMaxBars,
+  retestToleranceAtr,
+  minBreakoutDistanceAtr
+}) => {
+  const pending = state.pending;
+  if (!pending) return null;
+  const confirmationBars = state.currentIndex - pending.breakoutIndex;
+  if (confirmationBars < 1) return null;
+  const close = asNumber(candle.close);
+  const high = asNumber(candle.high);
+  const low = asNumber(candle.low);
+  if (close == null || high == null || low == null) return null;
+  const pattern = pending.pattern;
+  const invalidated = pattern.direction === "LONG" ? low <= pattern.stopLossPrice : high >= pattern.stopLossPrice;
+  const maxBars = pending.mode === "retest" ? retestMaxBars : confirmationMaxBars;
+  if (invalidated || confirmationBars > maxBars) {
+    markTerminal(state, pending);
+    state.pending = null;
+    return null;
+  }
+  const effectiveAtr = atr != null && atr > 0 ? atr : pattern.height;
+  const minimumDistance = effectiveAtr * minBreakoutDistanceAtr;
+  const closeAccepted = isBeyondNeckline(
+    pattern.direction,
+    close,
+    pattern.neckline,
+    minimumDistance
+  );
+  let entryStage = null;
+  if (pending.mode === "close_acceptance") {
+    if (closeAccepted) entryStage = "close_accepted";
+  } else {
+    const tolerance = effectiveAtr * retestToleranceAtr;
+    const touched = pattern.direction === "LONG" ? low <= pattern.neckline + tolerance && low >= pattern.neckline - tolerance : high >= pattern.neckline - tolerance && high <= pattern.neckline + tolerance;
+    if (touched && closeAccepted) entryStage = "retest_held";
+  }
+  if (!entryStage) return null;
+  markTerminal(state, pending);
+  state.pending = null;
+  return {
+    ...pattern,
+    entryStage,
+    confirmationBars,
+    timestamp: candle.timestamp,
+    close
+  };
+};
+var clonePending = (pending) => pending ? {
+  ...pending,
+  pattern: { ...pending.pattern, pivots: [...pending.pattern.pivots] }
+} : null;
+var buildDoubleTapSignalContext = (pattern) => ({
+  setupId: pattern.setupId,
+  patternKind: pattern.kind,
+  signalDirection: pattern.direction,
+  entryMode: pattern.entryMode,
+  entryStage: pattern.entryStage,
+  neckline: pattern.neckline,
+  targetPrice: pattern.targetPrice,
+  stopLossPrice: pattern.stopLossPrice,
+  height: pattern.height,
+  patternHeightAtr: pattern.patternHeightAtr,
+  patternAgeBars: pattern.patternAgeBars,
+  tapSpacingBars: pattern.tapSpacingBars,
+  legDurationSymmetryRatio: pattern.legDurationSymmetryRatio,
+  pivotTolerancePct: pattern.pivotTolerancePct,
+  breakoutDistancePct: pattern.breakoutDistancePct,
+  breakoutDistanceAtr: pattern.breakoutDistanceAtr,
+  breakoutDistanceHeightRatio: pattern.breakoutDistanceHeightRatio,
+  breakoutTimestamp: pattern.breakoutTimestamp,
+  confirmationBars: pattern.confirmationBars,
+  currentPrice: pattern.close,
+  pivots: pattern.pivots.map(({ timestamp, value, kind }) => ({
+    timestamp,
+    value,
+    kind
+  }))
+});
+var createDoubleTapEngine = ({
+  config: config2,
+  initialCandles = []
+}) => {
+  const options = getConfigNumbers(config2);
+  const state = {
+    candles: [],
+    currentIndex: -1,
+    pivots: [],
+    dir: null,
+    pattern: null,
+    pending: null,
+    consumedSetupIds: /* @__PURE__ */ new Set(),
+    lastTimestamp: null
+  };
+  const snapshot = () => ({
+    pattern: state.pattern ? { ...state.pattern, pivots: [...state.pattern.pivots] } : null,
+    pending: clonePending(state.pending),
+    pivots: state.pivots.map((pivot) => ({ ...pivot }))
+  });
+  const apply = (candle) => {
+    if (state.lastTimestamp === candle.timestamp) return snapshot();
+    state.lastTimestamp = candle.timestamp;
+    state.pattern = null;
+    const previous = state.candles[state.candles.length - 1];
+    const prevClose = previous ? asNumber(previous.close) : null;
+    const maxCandles = Math.max(options.pivotLength + 1, options.atrPeriod + 1);
+    const currentIndex = pushBoundedCandle(state, candle, maxCandles);
+    const atr = calculateAtr(state.candles, options.atrPeriod);
+    const pendingPattern = resolvePending({
+      state,
+      candle,
+      atr,
+      confirmationMaxBars: options.confirmationMaxBars,
+      retestMaxBars: options.retestMaxBars,
+      retestToleranceAtr: options.retestToleranceAtr,
+      minBreakoutDistanceAtr: options.minBreakoutDistanceAtr
+    });
+    const window = state.candles.slice(-options.pivotLength);
+    const high = asNumber(candle.high);
+    const low = asNumber(candle.low);
+    const currentIsHigh = high != null && high >= highest(window);
+    const currentIsLow = low != null && low <= lowest(window);
+    const nextDir = currentIsHigh ? 1 : currentIsLow ? 0 : state.dir;
+    const dirChanged = state.dir != null && nextDir !== state.dir;
+    if (dirChanged && nextDir === 1 && high != null) {
+      pushPivot({
+        pivots: state.pivots,
+        candle,
+        index: currentIndex,
+        kind: "high",
+        value: high
+      });
+    }
+    if (dirChanged && nextDir === 0 && low != null) {
+      pushPivot({
+        pivots: state.pivots,
+        candle,
+        index: currentIndex,
+        kind: "low",
+        value: low
+      });
+    }
+    if (!dirChanged && nextDir === 1 && high != null) {
+      updateLatestPivot({
+        pivots: state.pivots,
+        candle,
+        index: currentIndex,
+        kind: "high",
+        value: high
+      });
+    }
+    if (!dirChanged && nextDir === 0 && low != null) {
+      updateLatestPivot({
+        pivots: state.pivots,
+        candle,
+        index: currentIndex,
+        kind: "low",
+        value: low
+      });
+    }
+    state.dir = nextDir;
+    if (pendingPattern) {
+      state.pattern = pendingPattern;
+      return snapshot();
+    }
+    if (state.pending) return snapshot();
+    const common = {
+      state,
+      candle,
+      prevClose,
+      atr,
+      tolerancePct: options.tolerancePct,
+      targetFibPct: options.targetFibPct,
+      stopFibPct: options.stopFibPct,
+      minPatternHeightPct: options.minPatternHeightPct,
+      minPatternHeightAtr: options.minPatternHeightAtr,
+      minTapSpacingBars: options.minTapSpacingBars,
+      maxPatternAgeBars: options.maxPatternAgeBars,
+      minLegSymmetryRatio: options.minLegSymmetryRatio,
+      minBreakoutDistanceAtr: options.minBreakoutDistanceAtr,
+      maxBreakoutDistanceHeightRatio: options.maxBreakoutDistanceHeightRatio,
+      maxBreakoutDistancePct: options.maxBreakoutDistancePct,
+      entryMode: options.entryMode
+    };
+    const breakout = buildBreakoutPattern({ ...common, multiplier: 1 }) ?? buildBreakoutPattern({ ...common, multiplier: -1 });
+    if (!breakout) return snapshot();
+    if (options.entryMode === "breakout") {
+      const terminal = {
+        setupId: breakout.setupId,
+        mode: "close_acceptance",
+        stage: "neckline_crossed",
+        breakoutIndex: currentIndex,
+        pattern: breakout
+      };
+      markTerminal(state, terminal);
+      state.pattern = breakout;
+      return snapshot();
+    }
+    state.pending = {
+      setupId: breakout.setupId,
+      mode: options.entryMode,
+      stage: options.entryMode === "retest" ? "retest_pending" : "neckline_crossed",
+      breakoutIndex: currentIndex,
+      pattern: breakout
+    };
+    return snapshot();
+  };
+  for (const candle of initialCandles) apply(candle);
+  return { next: apply, getState: snapshot };
+};
+
+// src/DoubleTap/figures.ts
+var buildDoubleTapFigures = ({
+  pattern,
+  entryTimestamp,
+  entryPrice
+}) => {
+  const color = pattern.direction === "LONG" ? "#22c55e" : "#ef4444";
+  const [p1, p2, p3, p4] = pattern.pivots;
+  const patternPoints = [
+    { timestamp: p1.timestamp, value: p1.value },
+    { timestamp: p2.timestamp, value: p2.value },
+    { timestamp: p3.timestamp, value: p3.value },
+    { timestamp: p4.timestamp, value: p4.value },
+    { timestamp: entryTimestamp, value: entryPrice }
+  ];
+  const lines = [
+    {
+      id: `doubletap-pattern-${entryTimestamp}`,
+      kind: `doubletap_${pattern.kind}_pattern`,
+      points: patternPoints,
+      color,
+      width: 2,
+      style: "solid"
+    },
+    {
+      id: `doubletap-neckline-${entryTimestamp}`,
+      kind: "doubletap_neckline",
+      points: [
+        { timestamp: p3.timestamp, value: pattern.neckline },
+        { timestamp: entryTimestamp, value: pattern.neckline }
+      ],
+      color: "#f59e0b",
+      width: 2,
+      style: "dashed"
+    },
+    {
+      id: `doubletap-target-${entryTimestamp}`,
+      kind: "doubletap_target",
+      points: [
+        { timestamp: p3.timestamp, value: pattern.targetPrice },
+        { timestamp: entryTimestamp, value: pattern.targetPrice }
+      ],
+      color: "#22c55e",
+      width: 1,
+      style: "dashed"
+    },
+    {
+      id: `doubletap-stop-${entryTimestamp}`,
+      kind: "doubletap_stop",
+      points: [
+        { timestamp: p3.timestamp, value: pattern.stopLossPrice },
+        { timestamp: entryTimestamp, value: pattern.stopLossPrice }
+      ],
+      color: "#ef4444",
+      width: 1,
+      style: "dashed"
+    }
+  ];
+  const points = [
+    {
+      id: `doubletap-pivots-${entryTimestamp}`,
+      kind: `doubletap_${pattern.kind}_pivots`,
+      points: patternPoints.slice(0, 4),
+      color,
+      radius: 4
+    },
+    {
+      id: `doubletap-entry-${entryTimestamp}`,
+      kind: "doubletap_entry",
+      points: [{ timestamp: entryTimestamp, value: entryPrice }],
+      color,
+      radius: 5
+    }
+  ];
+  return { lines, points };
+};
+
+// src/DoubleTap/filters.ts
+import { resolveDirectionalConfigNumber } from "@tradejs/strategy-kit/config";
+var asPositiveThreshold = (value) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+};
+var getDoubleTapCoreFilterSkipCode = ({
+  config: config2,
+  pattern,
+  baseContext
+}) => {
+  const maxConfirmationBars = asPositiveThreshold(
+    resolveDirectionalConfigNumber({
+      config: config2,
+      key: "DOUBLETAP_MAX_ENTRY_CONFIRMATION_BARS",
+      direction: pattern.direction,
+      fallback: 0
+    })
+  );
+  if (maxConfirmationBars != null && pattern.confirmationBars > maxConfirmationBars) {
+    return "DOUBLETAP_CONFIRMATION_TOO_LATE";
+  }
+  const maxBbWidthPct = asPositiveThreshold(
+    resolveDirectionalConfigNumber({
+      config: config2,
+      key: "DOUBLETAP_MAX_BB_WIDTH_PCT",
+      direction: pattern.direction,
+      fallback: 0
+    })
+  );
+  if (maxBbWidthPct != null) {
+    const bbWidthPct = Number(baseContext?.raw?.volatility?.bbWidthPct);
+    if (!Number.isFinite(bbWidthPct) || bbWidthPct > maxBbWidthPct) {
+      return "DOUBLETAP_VOLATILITY_TOO_WIDE";
+    }
+  }
+  return null;
+};
+
+// src/DoubleTap/core.ts
+import {
+  buildTradeEconomics,
+  isStopLossOnCorrectSide
+} from "@tradejs/strategy-kit/risk";
+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 buildDoubleTapStateKey = (config2) => JSON.stringify({
+  pivotLength: config2.DOUBLETAP_PIVOT_LENGTH,
+  pivotTolerancePct: config2.DOUBLETAP_PIVOT_TOLERANCE_PCT,
+  targetFibPct: config2.DOUBLETAP_TARGET_FIB_PCT,
+  stopFibPct: config2.DOUBLETAP_STOP_FIB_PCT,
+  minPatternHeightPct: config2.DOUBLETAP_MIN_PATTERN_HEIGHT_PCT,
+  minPatternHeightAtr: config2.DOUBLETAP_MIN_PATTERN_HEIGHT_ATR,
+  atrPeriod: config2.DOUBLETAP_ATR_PERIOD,
+  minTapSpacingBars: config2.DOUBLETAP_MIN_TAP_SPACING_BARS,
+  maxPatternAgeBars: config2.DOUBLETAP_MAX_PATTERN_AGE_BARS,
+  minLegSymmetryRatio: config2.DOUBLETAP_MIN_LEG_SYMMETRY_RATIO,
+  minBreakoutDistanceAtr: config2.DOUBLETAP_MIN_BREAKOUT_DISTANCE_ATR,
+  maxBreakoutDistanceHeightRatio: config2.DOUBLETAP_MAX_BREAKOUT_DISTANCE_HEIGHT_RATIO,
+  maxBreakoutDistancePct: config2.DOUBLETAP_MAX_BREAKOUT_DISTANCE_PCT,
+  entryMode: config2.DOUBLETAP_ENTRY_MODE,
+  confirmationMaxBars: config2.DOUBLETAP_CONFIRMATION_MAX_BARS,
+  retestMaxBars: config2.DOUBLETAP_RETEST_MAX_BARS,
+  retestToleranceAtr: config2.DOUBLETAP_RETEST_TOLERANCE_ATR
+});
+var createDoubleTapCore = async ({ config: config2, data: initialData, strategyApi, indicatorsState }) => {
+  const detectorState = strategyApi.createStateController(
+    "DoubleTap",
+    () => ({
+      engine: createDoubleTapEngine({
+        config: config2,
+        initialCandles: initialData
+      })
+    }),
+    {
+      configKey: buildDoubleTapStateKey(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 pattern = runtimeState.pattern;
+    if (!pattern) {
+      return strategyApi.skip("NO_PATTERN");
+    }
+    const position = await strategyApi.getCurrentPosition();
+    if (isOpenPosition(position)) {
+      const oppositePattern = position.direction === "LONG" ? pattern.direction === "SHORT" : pattern.direction === "LONG";
+      if (Boolean(config2.DOUBLETAP_EXIT_ON_OPPOSITE_PATTERN) && oppositePattern) {
+        return strategyApi.exit({
+          code: "DOUBLETAP_OPPOSITE_PATTERN_EXIT",
+          direction: position.direction
+        });
+      }
+      return strategyApi.skip("POSITION_EXISTS");
+    }
+    if (lastTradeController.isInCooldown(candle.timestamp)) {
+      return strategyApi.skip("DEV_TRADE_COOLDOWN");
+    }
+    const modeConfig = pattern.direction === "LONG" ? config2.LONG : config2.SHORT;
+    if (!modeConfig.enable) {
+      return strategyApi.skip("STRATEGY_DISABLED");
+    }
+    const coreFilterSkipCode = getDoubleTapCoreFilterSkipCode({
+      config: config2,
+      pattern,
+      baseContext: strategyApi.getBaseContext()
+    });
+    if (coreFilterSkipCode) {
+      return strategyApi.skip(coreFilterSkipCode);
+    }
+    const { timestamp, currentPrice } = await strategyApi.getDecisionPriceContext();
+    if (!isStopLossOnCorrectSide({
+      direction: pattern.direction,
+      currentPrice,
+      stopLossPrice: pattern.stopLossPrice
+    })) {
+      return strategyApi.skip("INVALID_STOP");
+    }
+    const targetIsValid = pattern.direction === "LONG" ? pattern.targetPrice > currentPrice : pattern.targetPrice < currentPrice;
+    if (!targetIsValid) {
+      return strategyApi.skip("TARGET_ALREADY_PASSED");
+    }
+    const economics = buildTradeEconomics({
+      entryPrice: currentPrice,
+      stopLossPrice: pattern.stopLossPrice,
+      takeProfitPrice: pattern.targetPrice,
+      feeRate: Number(config2.FEE_PERCENT ?? 0),
+      slippageBps: Number(config2.SLIPPAGE_BASE_BPS ?? 0) + Number(config2.SLIPPAGE_MARKET_IMPACT_BPS ?? 0)
+    });
+    const qty = economics.lossPerUnit > 0 ? Number(config2.MAX_LOSS_VALUE ?? 0) / economics.lossPerUnit : 0;
+    const riskRatio = economics.netRiskRatio;
+    const signalContext = {
+      ...buildDoubleTapSignalContext({ ...pattern, close: currentPrice }),
+      executionEconomics: {
+        grossRiskRatio: economics.grossRiskRatio,
+        netRiskRatio: economics.netRiskRatio,
+        lossPerUnit: economics.lossPerUnit,
+        rewardPerUnit: economics.rewardPerUnit
+      }
+    };
+    if (!qty || !Number.isFinite(qty) || qty <= 0) {
+      return strategyApi.skip("INVALID_QTY");
+    }
+    if (riskRatio <= modeConfig.minRiskRatio) {
+      return strategyApi.skip(`RISK_RATIO:${round(riskRatio)}`);
+    }
+    const indicators = indicatorsState.snapshot();
+    lastTradeController.markTrade(timestamp);
+    return strategyApi.entry({
+      code: pattern.direction === "LONG" ? `DOUBLETAP_DOUBLE_BOTTOM_${pattern.entryStage.toUpperCase()}` : `DOUBLETAP_DOUBLE_TOP_${pattern.entryStage.toUpperCase()}`,
+      direction: modeConfig.direction,
+      indicators,
+      additionalIndicators: {
+        doubleTapContext: signalContext
+      },
+      figures: buildDoubleTapFigures({
+        pattern,
+        entryTimestamp: timestamp,
+        entryPrice: currentPrice
+      }),
+      orderPlan: {
+        qty,
+        stopLossPrice: pattern.stopLossPrice,
+        takeProfits: [{ rate: 1, price: pattern.targetPrice }]
+      }
+    });
+  };
+};
+
+// src/DoubleTap/adapters/ai.ts
+import { intervalToMs } from "@tradejs/core/data";
+import { mapAiRuntimeFromConfig } from "@tradejs/core/strategies";
+import {
+  getAiPayloadNumber,
+  withStrategyLocalAiGate
+} from "@tradejs/strategy-kit/ai-gate";
+var MIN_EXECUTION_SCORE_FOR_AI_GATE = 35;
+var MIN_LOW_TOUCH_COUNT20_FOR_AI_GATE = 1;
+var HIGH_PRECISION_CMC_ALT_VOLUME_CHANGE_MAX = 0.5;
+var Q4_CMC_BTC_DOMINANCE_CHANGE_MIN = -0.3;
+var Q4_CMC_BTC_DOMINANCE_CHANGE_MAX = -0.05;
+var Q4_ALT_DISPERSION_24H_MAX = 0.06;
+var Q4_DERIVATIVES_BTC_VS_ALT_RETURN_24H_MAX = -9e-3;
+var Q4_DERIVATIVES_ETH_CROWDING_PERSISTENCE_MIN = 140;
+var Q4_DERIVATIVES_SOL_FUNDING_Z_SCORE_15M_MAX = 0.2;
+var Q4_DERIVATIVES_BAD_BTC_VS_ALT_RETURN_24H_MAX = -0.014;
+var Q4_DERIVATIVES_BAD_CMC20_TO_CMC100_CHANGE_24H_MAX = -7e-4;
+var BNB_OI_ROTATION_CHANGE_24H_15M_MIN = 0.65;
+var BNB_OI_ROTATION_CHANGE_1H_1H_MAX = -0.28;
+var XRP_OI_SHORT_NO_HTF_CHANGE_1H_15M_MIN = 0.32;
+var ETH_VOLUME_BREADTH_ETH_VS_BTC_VOLUME_RATIO_MAX = 0.39;
+var ETH_VOLUME_BREADTH_TOP5_DISPERSION_MAX = 7e-4;
+var ETH_VOLUME_BREADTH_ETH_DOMINANCE_CHANGE_MIN = -0.05;
+var APPROVAL_ETH_VS_BTC_VOLUME_RATIO_MIN = 0.34;
+var STRICT_MOMENTUM_ROC1D_MIN = -5.25;
+var PROTECTIVE_RELATIVE_STRENGTH_4H_MAX = 7.77009;
+var PROTECTIVE_CMC_EXCHANGE_LIQUIDITY_CHANGE_24H_MIN = -0.378662;
+var PROTECTIVE_BNB_REFERENCE_PRESSURE_BLOCK = "crowded_long";
+var asRecord = (value) => typeof value === "object" && value != null && !Array.isArray(value) ? value : null;
+var asNumber2 = (value) => {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (typeof value === "string" && value.trim().length > 0) {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? numeric : null;
+  }
+  return null;
+};
+var divideFinite = (numerator, denominator) => numerator != null && denominator != null && Number.isFinite(numerator) && Number.isFinite(denominator) && Math.abs(denominator) > Number.EPSILON ? numerator / Math.abs(denominator) : null;
+var resolveIntervalMs = (interval) => {
+  if (typeof interval !== "string" || interval.length === 0) {
+    return null;
+  }
+  try {
+    const value = intervalToMs(interval);
+    return Number.isFinite(value) && value > 0 ? value : null;
+  } catch {
+    return null;
+  }
+};
+var resolveElapsedBars = ({
+  from,
+  to,
+  intervalMs
+}) => {
+  if (from == null || to == null || intervalMs == null || to < from) {
+    return null;
+  }
+  const bars = (to - from) / intervalMs;
+  return Number.isFinite(bars) ? bars : null;
+};
+var resolveSlopePctPerBar = ({
+  fromValue,
+  toValue,
+  bars
+}) => {
+  if (fromValue == null || toValue == null || bars == null || bars <= 0 || Math.abs(fromValue) <= Number.EPSILON) {
+    return null;
+  }
+  return Math.abs(toValue - fromValue) / Math.abs(fromValue) / bars * 100;
+};
+var buildDoubleTapSetupFeatures = ({
+  context,
+  interval,
+  signalTimestamp
+}) => {
+  const pivots = Array.isArray(context.pivots) ? context.pivots : [];
+  const readPivotNumber = (index, key) => asNumber2(asRecord(pivots[index])?.[key]);
+  const p1Timestamp = readPivotNumber(0, "timestamp");
+  const p2Timestamp = readPivotNumber(1, "timestamp");
+  const p3Timestamp = readPivotNumber(2, "timestamp");
+  const p4Timestamp = readPivotNumber(3, "timestamp");
+  const p2Value = readPivotNumber(1, "value");
+  const p3Value = readPivotNumber(2, "value");
+  const p4Value = readPivotNumber(3, "value");
+  const intervalMs = resolveIntervalMs(interval);
+  const leadInBars = resolveElapsedBars({
+    from: p1Timestamp,
+    to: p2Timestamp,
+    intervalMs
+  });
+  const firstLegBars = resolveElapsedBars({
+    from: p2Timestamp,
+    to: p3Timestamp,
+    intervalMs
+  });
+  const secondLegBars = resolveElapsedBars({
+    from: p3Timestamp,
+    to: p4Timestamp,
+    intervalMs
+  });
+  const tapSpacingBars = resolveElapsedBars({
+    from: p2Timestamp,
+    to: p4Timestamp,
+    intervalMs
+  });
+  const breakoutLagBars = resolveElapsedBars({
+    from: p4Timestamp,
+    to: asNumber2(signalTimestamp),
+    intervalMs
+  });
+  const heightValue = asNumber2(context.height);
+  const height = heightValue == null ? null : Math.abs(heightValue);
+  const neckline = asNumber2(context.neckline);
+  const currentPrice = asNumber2(context.currentPrice);
+  const stopLossPrice = asNumber2(context.stopLossPrice);
+  const targetPrice = asNumber2(context.targetPrice);
+  const breakoutDistance = currentPrice == null || neckline == null ? null : Math.abs(currentPrice - neckline);
+  const breakoutDistanceHeightRatio = divideFinite(breakoutDistance, height);
+  const tapPriceDeviation = p2Value == null || p4Value == null ? null : Math.abs(p2Value - p4Value);
+  const averageTapPrice = p2Value == null || p4Value == null ? null : (Math.abs(p2Value) + Math.abs(p4Value)) / 2;
+  const patternHeightPriceRatio = divideFinite(height, neckline);
+  const tapPriceDeviationRatio = divideFinite(
+    tapPriceDeviation,
+    averageTapPrice
+  );
+  const firstLegSlopePctPerBar = resolveSlopePctPerBar({
+    fromValue: p2Value,
+    toValue: p3Value,
+    bars: firstLegBars
+  });
+  const secondLegSlopePctPerBar = resolveSlopePctPerBar({
+    fromValue: p3Value,
+    toValue: p4Value,
+    bars: secondLegBars
+  });
+  return {
+    geometry: {
+      patternHeightPct: patternHeightPriceRatio == null ? null : patternHeightPriceRatio * 100,
+      breakoutDistanceHeightRatio,
+      tapPriceDeviationPct: tapPriceDeviationRatio == null ? null : tapPriceDeviationRatio * 100,
+      tapDeviationHeightRatio: divideFinite(tapPriceDeviation, height),
+      stopDistanceHeightRatio: currentPrice == null || stopLossPrice == null ? null : divideFinite(Math.abs(currentPrice - stopLossPrice), height),
+      targetDistanceHeightRatio: currentPrice == null || targetPrice == null ? null : divideFinite(Math.abs(targetPrice - currentPrice), height)
+    },
+    path: {
+      leadInBars,
+      firstLegBars,
+      secondLegBars,
+      tapSpacingBars,
+      breakoutLagBars,
+      legDurationSymmetryRatio: firstLegBars == null || secondLegBars == null ? null : divideFinite(
+        Math.min(firstLegBars, secondLegBars),
+        Math.max(firstLegBars, secondLegBars)
+      ),
+      firstLegSlopePctPerBar,
+      secondLegSlopePctPerBar,
+      legSlopeSymmetryRatio: firstLegSlopePctPerBar == null || secondLegSlopePctPerBar == null ? null : divideFinite(
+        Math.min(firstLegSlopePctPerBar, secondLegSlopePctPerBar),
+        Math.max(firstLegSlopePctPerBar, secondLegSlopePctPerBar)
+      ),
+      breakoutSpeedHeightRatioPerBar: breakoutDistanceHeightRatio == null || breakoutLagBars == null ? null : breakoutDistanceHeightRatio / Math.max(1, breakoutLagBars)
+    }
+  };
+};
+var getDoubleTapContext = (payload) => {
+  const additional = asRecord(payload.additionalIndicators);
+  return (additional?.doubleTapContext ?? {}) || {};
+};
+var getNestedRecord = (record, path) => path.reduce(
+  (current, key) => asRecord(current?.[key]),
+  record
+);
+var getNestedNumber = (record, path) => asNumber2(
+  path.reduce((current, key) => {
+    return asRecord(current)?.[key];
+  }, record)
+);
+var getNestedString = (record, path) => {
+  const value = path.reduce((current, key) => {
+    return asRecord(current)?.[key];
+  }, record);
+  return typeof value === "string" && value.trim() ? value : null;
+};
+var getNestedBoolean = (record, path) => {
+  const value = path.reduce((current, key) => {
+    return asRecord(current)?.[key];
+  }, record);
+  return typeof value === "boolean" ? value : null;
+};
+var getStringArray = (value) => Array.isArray(value) ? value.filter(
+  (entry) => typeof entry === "string" && entry.trim().length > 0
+) : [];
+var resolveGeometryQuality = (context) => {
+  const breakoutDistancePct = asNumber2(context.breakoutDistancePct) ?? 999;
+  const height = asNumber2(context.height) ?? 0;
+  if (height <= 0) {
+    return 1;
+  }
+  if (breakoutDistancePct <= 0.8) {
+    return 4;
+  }
+  if (breakoutDistancePct <= 1.4) {
+    return 3;
+  }
+  if (breakoutDistancePct <= 2.5) {
+    return 2;
+  }
+  return 1;
+};
+var isDirectionalCrowding = (direction, riskFlags) => direction === "LONG" ? riskFlags.includes("crowded_long") : direction === "SHORT" ? riskFlags.includes("crowded_short") : false;
+var isBenchmarkAligned = ({
+  direction,
+  trendAlignment,
+  benchmarkBias
+}) => direction === "LONG" ? trendAlignment === "aligned_bull" || benchmarkBias === "bull" : direction === "SHORT" ? trendAlignment === "aligned_bear" || benchmarkBias === "bear" : false;
+var buildDoubleTapGateFeatures = ({
+  setupFeatures,
+  signalDirection,
+  height,
+  breakoutDistancePct,
+  trendAligned,
+  benchmarkAligned,
+  volumeRel20,
+  derivativesDirectionAligned,
+  derivativesRiskFlags,
+  venueSpreadZScore,
+  directionalCrowding,
+  approvalPocket,
+  bnbOiRotationPocket,
+  bnbOiRotationBlocked,
+  xrpOiShortNoHtfPocket,
+  xrpOiShortNoHtfBlocked,
+  ethVolumeBreadthCompressionPocket,
+  ethVolumeBreadthCompressionBlocked,
+  highPrecisionPocket,
+  highPrecisionApprovalBlocked,
+  q4DerivativesPocket,
+  q4DerivativesApprovalBlocked,
+  q4ApprovalBlocked,
+  defaultApprovalAllowed,
+  q4AltDispersionOk,
+  q4DerivativesCmcRiskOk,
+  q4DerivativesDirectionSessionOk,
+  bnbOiRotationContextAvailable,
+  bnbOiRotationMomentumOk,
+  xrpOiShortNoHtfContextAvailable,
+  ethVolumeBreadthContextAvailable,
+  ethVsBtcVolumeRatioApprovalOk,
+  strictMomentumApproved,
+  strictMomentumRoc1dOk,
+  protectiveApprovalContextAvailable,
+  protectiveApprovalContextOk
+}) => {
+  const patternGeometry = height == null ? "unknown" : height <= 0 ? "invalid" : breakoutDistancePct != null && breakoutDistancePct <= 1.4 ? "compact" : "extended";
+  const necklineBreakout = breakoutDistancePct == null ? "missing" : breakoutDistancePct <= 0.25 ? "early_noise" : breakoutDistancePct <= 0.8 ? "compact" : breakoutDistancePct <= 1.4 ? "confirmed" : "extended";
+  const trendContext = signalDirection == null ? "unknown" : trendAligned || benchmarkAligned ? "aligned" : "neutral";
+  const participationState = volumeRel20 == null ? "unknown" : volumeRel20 < 0.8 ? "thin" : volumeRel20 >= 2 ? "strong" : "normal";
+  const derivativesState = derivativesDirectionAligned === true ? "aligned" : derivativesDirectionAligned === false ? "conflict" : directionalCrowding ? "crowded" : derivativesRiskFlags.length > 0 ? "neutral" : "unknown";
+  const executionSpreadState = venueSpreadZScore == null ? "unknown" : venueSpreadZScore >= 1 ? "supportive" : venueSpreadZScore <= -1 ? "adverse" : "neutral";
+  return {
+    ...setupFeatures,
+    patternGeometry,
+    necklineBreakout,
+    trendContext,
+    participationState,
+    derivativesState,
+    executionSpreadState,
+    approvalPocket: bnbOiRotationMomentumOk ? bnbOiRotationBlocked ? "bnb_oi_rotation_blocked" : "bnb_oi_rotation" : xrpOiShortNoHtfPocket ? xrpOiShortNoHtfBlocked ? "xrp_oi_short_no_htf_blocked" : "xrp_oi_short_no_htf" : ethVolumeBreadthCompressionPocket ? ethVolumeBreadthCompressionBlocked ? "eth_volume_breadth_blocked" : "eth_volume_breadth" : bnbOiRotationPocket ? bnbOiRotationBlocked ? "bnb_oi_rotation_blocked" : "bnb_oi_rotation" : highPrecisionPocket ? highPrecisionApprovalBlocked ? "high_precision_blocked" : "high_precision" : q4DerivativesPocket ? q4DerivativesApprovalBlocked ? "q4_derivatives_blocked" : "q4_derivatives" : approvalPocket && q4ApprovalBlocked ? "q4_blocked" : approvalPocket ? "q4" : "watch",
+    highQualityCadencePocket: bnbOiRotationMomentumOk && !bnbOiRotationBlocked || xrpOiShortNoHtfPocket && !xrpOiShortNoHtfBlocked,
+    defaultApprovalAllowed,
+    q4AltDispersionOk,
+    q4DerivativesPocket,
+    q4DerivativesCmcRiskOk,
+    q4DerivativesDirectionSessionOk,
+    bnbOiRotationPocket,
+    bnbOiRotationContextAvailable,
+    bnbOiRotationMomentumOk,
+    xrpOiShortNoHtfPocket,
+    xrpOiShortNoHtfContextAvailable,
+    ethVolumeBreadthContextAvailable,
+    ethVolumeBreadthCompressionPocket,
+    ethVsBtcVolumeRatioApprovalOk,
+    strictMomentumApproved,
+    strictMomentumRoc1dOk,
+    protectiveApprovalContextAvailable,
+    protectiveApprovalContextOk
+  };
+};
+var buildDoubleTapAiContext = (payload) => {
+  const context = getDoubleTapContext(payload);
+  const additional = asRecord(payload.additionalIndicators);
+  const baseContext = asRecord(additional?.baseContext);
+  const derivativesSummary = getNestedRecord(baseContext, [
+    "derivatives",
+    "summary"
+  ]);
+  const signalDirection = context.signalDirection === "LONG" || context.signalDirection === "SHORT" ? context.signalDirection : null;
+  const breakoutDistancePct = asNumber2(context.breakoutDistancePct);
+  const height = asNumber2(context.height);
+  const baseContextAvailable = Boolean(baseContext);
+  const primarySession = getNestedString(baseContext, [
+    "regime",
+    "session",
+    "sessionPhase"
+  ]);
+  const sessionWindowPhase = getNestedString(baseContext, [
+    "regime",
+    "session",
+    "sessionWindowPhase"
+  ]);
+  const trendBias = getNestedString(baseContext, ["regime", "trend", "bias"]);
+  const swingBias = getNestedString(baseContext, [
+    "structure",
+    "swing",
+    "bias"
+  ]);
+  const breakoutState = getNestedString(baseContext, [
+    "structure",
+    "localRange",
+    "breakoutState"
+  ]);
+  const barsSinceBreakout = getNestedNumber(baseContext, [
+    "structure",
+    "localRange",
+    "barsSinceBreakout"
+  ]);
+  const lowTouchCount20 = getNestedNumber(baseContext, [
+    "structure",
+    "levels",
+    "lowTouchCount20"
+  ]);
+  const volumeRel20 = getNestedNumber(baseContext, [
+    "participation",
+    "volume",
+    "volumeRel20"
+  ]);
+  const benchmarkTrendAlignment = getNestedString(baseContext, [
+    "relative",
+    "benchmark",
+    "trendAlignment"
+  ]);
+  const benchmarkRelativeStrength4h = getNestedNumber(baseContext, [
+    "relative",
+    "benchmark",
+    "relativeStrength4h"
+  ]);
+  const benchmarkBias = getNestedString(baseContext, [
+    "relative",
+    "benchmark",
+    "bias"
+  ]);
+  const derivativesDirectionAligned = typeof derivativesSummary?.directionAligned === "boolean" ? derivativesSummary.directionAligned : null;
+  const derivativesRiskFlags = getStringArray(derivativesSummary?.riskFlags);
+  const bodyStrength = getNestedNumber(baseContext, [
+    "regime",
+    "momentum",
+    "bodyStrength"
+  ]);
+  const roc1d = getNestedNumber(baseContext, ["regime", "momentum", "roc1d"]);
+  const venueSpreadZScore = getNestedNumber(baseContext, [
+    "relative",
+    "execution",
+    "venueSpreadZScore"
+  ]);
+  const rewardToVolatility = getNestedNumber(baseContext, [
+    "gateFeatures",
+    "setup",
+    "rewardToVolatility"
+  ]);
+  const executionScore = getNestedNumber(baseContext, [
+    "gateFeatures",
+    "scores",
+    "execution"
+  ]);
+  const volumeStructureAligned = getNestedBoolean(baseContext, [
+    "gateFeatures",
+    "participation",
+    "volumeStructureAligned"
+  ]);
+  const benchmarkConflict = getNestedBoolean(baseContext, [
+    "gateFeatures",
+    "relative",
+    "benchmarkConflict"
+  ]);
+  const cmcAltVolumeChange24hPct = getNestedNumber(baseContext, [
+    "relative",
+    "cmcGlobal",
+    "altVolumeChange24hPct"
+  ]);
+  const cmcExchangeLiquidityVolumeChange24hPct = getNestedNumber(baseContext, [
+    "gateFeatures",
+    "relative",
+    "cmcExchangeLiquidityVolumeChange24hPct"
+  ]) ?? getNestedNumber(baseContext, [
+    "relative",
+    "cmcExchangeLiquidity",
+    "totalVolumeChange24hPct"
+  ]);
+  const cmcBtcDominanceChange24hPct = getNestedNumber(baseContext, [
+    "relative",
+    "cmcGlobal",
+    "btcDominanceChange24hPct"
+  ]);
+  const cmcEthDominanceChange24hPct = getNestedNumber(baseContext, [
+    "relative",
+    "cmcGlobal",
+    "ethDominanceChange24hPct"
+  ]);
+  const cmc20ToCmc100RatioChange24hPct = getNestedNumber(baseContext, [
+    "relative",
+    "cmcIndexes",
+    "cmc20ToCmc100RatioChange24hPct"
+  ]) ?? getNestedNumber(baseContext, [
+    "gateFeatures",
+    "relative",
+    "cmc20ToCmc100RatioChange24hPct"
+  ]);
+  const ethVsBtcVolumeRatio = getNestedNumber(baseContext, [
+    "relative",
+    "cmcReferenceAssets",
+    "ethVsBtcVolumeRatio"
+  ]);
+  const marketBreadthTop5Dispersion = getNestedNumber(baseContext, [
+    "relative",
+    "marketBreadths",
+    "top5",
+    "dispersion"
+  ]);
+  const btcVsAltReturn24h = getNestedNumber(baseContext, [
+    "relative",
+    "btcAltRegime",
+    "btcVsAltReturn24h"
+  ]) ?? getNestedNumber(baseContext, [
+    "gateFeatures",
+    "relative",
+    "btcVsAltReturn24h"
+  ]);
+  const ethCrowdingPersistenceBars = getNestedNumber(baseContext, [
+    "derivatives",
+    "referenceContexts",
+    "ETHUSDT",
+    "summary",
+    "crowdingPersistenceBars"
+  ]);
+  const solFundingZScore15m = getNestedNumber(baseContext, [
+    "derivatives",
+    "referenceContexts",
+    "SOLUSDT",
+    "intervals",
+    "15m",
+    "fundingZScore"
+  ]);
+  const bnbOiChangePct24h15m = getNestedNumber(baseContext, [
+    "derivatives",
+    "referenceContexts",
+    "BNBUSDT",
+    "intervals",
+    "15m",
+    "oiChangePct24h"
+  ]);
+  const bnbOiChangePct1h1h = getNestedNumber(baseContext, [
+    "derivatives",
+    "referenceContexts",
+    "BNBUSDT",
+    "intervals",
+    "1h",
+    "oiChangePct1h"
+  ]);
+  const bnbReferencePressure = getNestedString(baseContext, [
+    "derivatives",
+    "referenceContexts",
+    "BNBUSDT",
+    "summary",
+    "pressure"
+  ]);
+  const xrpOiChangePct1h15m = getNestedNumber(baseContext, [
+    "derivatives",
+    "referenceContexts",
+    "XRPUSDT",
+    "intervals",
+    "15m",
+    "oiChangePct1h"
+  ]);
+  const higherTimeframeConflict = getNestedBoolean(baseContext, [
+    "gateFeatures",
+    "mtf",
+    "higherTimeframeConflict"
+  ]);
+  const altDispersion24h = getNestedNumber(baseContext, [
+    "relative",
+    "btcAltRegime",
+    "altDispersion24h"
+  ]);
+  const structuralHardBlockReasons = [];
+  if (!baseContextAvailable) {
+    structuralHardBlockReasons.push("missing_base_context");
+  }
+  if ((height ?? 0) <= 0) {
+    structuralHardBlockReasons.push("invalid_pattern_height");
+  }
+  if (breakoutDistancePct == null || breakoutDistancePct > 1.4) {
+    structuralHardBlockReasons.push("extended_or_missing_breakout");
+  }
+  const geometryQuality = resolveGeometryQuality(context);
+  const compactButNotTooEarly = breakoutDistancePct != null && breakoutDistancePct > 0.35 && breakoutDistancePct <= 0.8;
+  const directionalCrowding = isDirectionalCrowding(
+    signalDirection,
+    derivativesRiskFlags
+  );
+  const benchmarkAligned = isBenchmarkAligned({
+    direction: signalDirection,
+    trendAlignment: benchmarkTrendAlignment,
+    benchmarkBias
+  });
+  const trendAligned = signalDirection === "LONG" ? trendBias === "bull" : signalDirection === "SHORT" ? trendBias === "bear" : false;
+  const breakoutAligned = signalDirection === "LONG" ? breakoutState === "above_high_level" : signalDirection === "SHORT" ? breakoutState === "below_low_level" : false;
+  const legacyLongHighPrecisionShapeCandidate = signalDirection === "LONG" && breakoutDistancePct != null && breakoutDistancePct > 0.5 && breakoutDistancePct <= 1.4 && primarySession !== "us" && volumeRel20 != null && volumeRel20 > 2 && barsSinceBreakout != null && barsSinceBreakout <= 1;
+  const legacyShortHighPrecisionShapeCandidate = signalDirection === "SHORT" && breakoutDistancePct != null && breakoutDistancePct > 0.25 && breakoutDistancePct <= 0.8 && (primarySession === "europe" || primarySession === "off_hours") && volumeRel20 != null && volumeRel20 > 0.8 && !directionalCrowding && trendAligned;
+  const legacyHighPrecisionShapeCandidate = legacyLongHighPrecisionShapeCandidate || legacyShortHighPrecisionShapeCandidate;
+  const legacyLongStructuralShapeCandidate = signalDirection === "LONG" && breakoutDistancePct != null && breakoutDistancePct > 0.25 && breakoutDistancePct <= 0.8 && primarySession !== "us" && volumeRel20 != null && volumeRel20 > 0.8 && breakoutAligned;
+  const legacyShortStructuralShapeCandidate = signalDirection === "SHORT" && compactButNotTooEarly && !directionalCrowding && (primarySession === "europe" || primarySession === "off_hours" || volumeRel20 != null && volumeRel20 > 1.2 || benchmarkAligned) && (primarySession !== "us" || trendAligned || volumeRel20 != null && volumeRel20 > 2);
+  const legacyStructuralShapeCandidate = legacyLongStructuralShapeCandidate || legacyShortStructuralShapeCandidate;
+  const legacyShapeCandidate = baseContextAvailable && (legacyStructuralShapeCandidate || legacyHighPrecisionShapeCandidate);
+  const baseIndicatorCandidate = sessionWindowPhase === "active" && executionScore != null && executionScore >= MIN_EXECUTION_SCORE_FOR_AI_GATE && lowTouchCount20 != null && lowTouchCount20 >= MIN_LOW_TOUCH_COUNT20_FOR_AI_GATE;
+  const q4CmcApproval = legacyShapeCandidate && !legacyHighPrecisionShapeCandidate && baseIndicatorCandidate && cmcBtcDominanceChange24hPct != null && cmcBtcDominanceChange24hPct > Q4_CMC_BTC_DOMINANCE_CHANGE_MIN && cmcBtcDominanceChange24hPct <= Q4_CMC_BTC_DOMINANCE_CHANGE_MAX && altDispersion24h != null && altDispersion24h < Q4_ALT_DISPERSION_24H_MAX;
+  const q4DerivativesBadCmcPocket = btcVsAltReturn24h != null && cmc20ToCmc100RatioChange24hPct != null && btcVsAltReturn24h <= Q4_DERIVATIVES_BAD_BTC_VS_ALT_RETURN_24H_MAX && cmc20ToCmc100RatioChange24hPct <= Q4_DERIVATIVES_BAD_CMC20_TO_CMC100_CHANGE_24H_MAX;
+  const q4DerivativesPocket = baseContextAvailable && btcVsAltReturn24h != null && ethCrowdingPersistenceBars != null && solFundingZScore15m != null && btcVsAltReturn24h <= Q4_DERIVATIVES_BTC_VS_ALT_RETURN_24H_MAX && ethCrowdingPersistenceBars >= Q4_DERIVATIVES_ETH_CROWDING_PERSISTENCE_MIN && solFundingZScore15m <= Q4_DERIVATIVES_SOL_FUNDING_Z_SCORE_15M_MAX;
+  const q4DerivativesDirectionSessionOk = q4DerivativesPocket ? signalDirection === "LONG" ? primarySession === "europe" : signalDirection === "SHORT" ? true : false : null;
+  const bnbOiRotationContextAvailable = bnbOiChangePct24h15m != null && bnbOiChangePct1h1h != null;
+  const bnbOiRotationPocket = baseContextAvailable && bnbOiChangePct24h15m != null && bnbOiChangePct1h1h != null && bnbOiChangePct24h15m >= BNB_OI_ROTATION_CHANGE_24H_15M_MIN && bnbOiChangePct1h1h <= BNB_OI_ROTATION_CHANGE_1H_1H_MAX;
+  const strictMomentumRoc1dOk = roc1d == null ? null : roc1d >= STRICT_MOMENTUM_ROC1D_MIN;
+  const bnbOiRotationMomentumOk = bnbOiRotationPocket && strictMomentumRoc1dOk === true;
+  const xrpOiShortNoHtfContextAvailable = xrpOiChangePct1h15m != null && higherTimeframeConflict != null;
+  const xrpOiShortNoHtfPocket = baseContextAvailable && signalDirection === "SHORT" && xrpOiChangePct1h15m != null && xrpOiChangePct1h15m >= XRP_OI_SHORT_NO_HTF_CHANGE_1H_15M_MIN && higherTimeframeConflict === false;
+  const ethVolumeBreadthContextAvailable = ethVsBtcVolumeRatio != null && marketBreadthTop5Dispersion != null && cmcEthDominanceChange24hPct != null;
+  const ethVolumeBreadthCompressionPocket = baseContextAvailable && ethVsBtcVolumeRatio != null && ethVsBtcVolumeRatio <= ETH_VOLUME_BREADTH_ETH_VS_BTC_VOLUME_RATIO_MAX && marketBreadthTop5Dispersion != null && marketBreadthTop5Dispersion <= ETH_VOLUME_BREADTH_TOP5_DISPERSION_MAX && cmcEthDominanceChange24hPct != null && cmcEthDominanceChange24hPct > ETH_VOLUME_BREADTH_ETH_DOMINANCE_CHANGE_MIN;
+  const ethVsBtcVolumeRatioApprovalOk = ethVsBtcVolumeRatio == null ? null : ethVsBtcVolumeRatio >= APPROVAL_ETH_VS_BTC_VOLUME_RATIO_MIN;
+  const protectiveApprovalContextAvailable = benchmarkRelativeStrength4h != null && cmcExchangeLiquidityVolumeChange24hPct != null && bnbReferencePressure != null;
+  const protectiveApprovalContextOk = benchmarkRelativeStrength4h != null && benchmarkRelativeStrength4h <= PROTECTIVE_RELATIVE_STRENGTH_4H_MAX && cmcExchangeLiquidityVolumeChange24hPct != null && cmcExchangeLiquidityVolumeChange24hPct >= PROTECTIVE_CMC_EXCHANGE_LIQUIDITY_CHANGE_24H_MIN && bnbReferencePressure != null && bnbReferencePressure !== PROTECTIVE_BNB_REFERENCE_PRESSURE_BLOCK;
+  const protectiveApprovalSourceAllowed = bnbOiRotationMomentumOk || xrpOiShortNoHtfPocket;
+  const approvalSourceAllowed = protectiveApprovalSourceAllowed;
+  const xrpOiShortNoHtfMissingContext = !bnbOiRotationMomentumOk && signalDirection === "SHORT" && !xrpOiShortNoHtfContextAvailable;
+  const bnbOiRotationMissingContext = !xrpOiShortNoHtfPocket && !bnbOiRotationContextAvailable;
+  const bnbOiRotationOutsideGate = !xrpOiShortNoHtfPocket && bnbOiRotationContextAvailable && !bnbOiRotationPocket;
+  const softBlockReasons = [
+    ...bnbOiRotationMissingContext ? ["missing_bnb_oi_rotation_context"] : [],
+    ...bnbOiRotationOutsideGate ? ["bnb_oi_rotation_outside_gate"] : [],
+    ...bnbOiRotationPocket && strictMomentumRoc1dOk === false ? ["bnb_oi_rotation_roc1d_below_gate"] : [],
+    ...bnbOiRotationPocket && strictMomentumRoc1dOk == null ? ["missing_roc1d_for_bnb_oi_rotation"] : [],
+    ...xrpOiShortNoHtfMissingContext ? ["missing_xrp_oi_short_no_htf_context"] : [],
+    ...xrpOiChangePct1h15m != null && xrpOiChangePct1h15m < XRP_OI_SHORT_NO_HTF_CHANGE_1H_15M_MIN ? ["xrp_oi_short_no_htf_outside_gate"] : [],
+    ...xrpOiChangePct1h15m != null && xrpOiChangePct1h15m >= XRP_OI_SHORT_NO_HTF_CHANGE_1H_15M_MIN && signalDirection !== "SHORT" ? ["xrp_oi_short_no_htf_requires_short_signal"] : [],
+    ...xrpOiChangePct1h15m != null && xrpOiChangePct1h15m >= XRP_OI_SHORT_NO_HTF_CHANGE_1H_15M_MIN && signalDirection === "SHORT" && higherTimeframeConflict !== false ? ["xrp_oi_short_no_htf_higher_timeframe_conflict"] : [],
+    ...protectiveApprovalSourceAllowed && benchmarkRelativeStrength4h == null ? ["missing_relative_strength_4h_for_protective_gate"] : [],
+    ...protectiveApprovalSourceAllowed && benchmarkRelativeStrength4h != null && benchmarkRelativeStrength4h > PROTECTIVE_RELATIVE_STRENGTH_4H_MAX ? ["relative_strength_4h_above_protective_gate"] : [],
+    ...protectiveApprovalSourceAllowed && cmcExchangeLiquidityVolumeChange24hPct == null ? ["missing_cmc_exchange_liquidity_change_for_protective_gate"] : [],
+    ...protectiveApprovalSourceAllowed && cmcExchangeLiquidityVolumeChange24hPct != null && cmcExchangeLiquidityVolumeChange24hPct < PROTECTIVE_CMC_EXCHANGE_LIQUIDITY_CHANGE_24H_MIN ? ["cmc_exchange_liquidity_change_below_protective_gate"] : [],
+    ...protectiveApprovalSourceAllowed && bnbReferencePressure == null ? ["missing_bnb_reference_pressure_for_protective_gate"] : [],
+    ...protectiveApprovalSourceAllowed && bnbReferencePressure === PROTECTIVE_BNB_REFERENCE_PRESSURE_BLOCK ? ["bnb_reference_pressure_crowded_long_protective_gate"] : [],
+    ...protectiveApprovalSourceAllowed && ethVsBtcVolumeRatio == null ? ["missing_eth_vs_btc_volume_ratio_for_approval"] : [],
+    ...protectiveApprovalSourceAllowed && ethVsBtcVolumeRatio != null && ethVsBtcVolumeRatio < APPROVAL_ETH_VS_BTC_VOLUME_RATIO_MIN ? ["eth_vs_btc_volume_ratio_below_approval_gate"] : [],
+    ...ethVolumeBreadthCompressionPocket ? ["eth_volume_breadth_observation_only"] : [],
+    ...legacyShapeCandidate && sessionWindowPhase !== "active" ? ["inactive_session_window"] : [],
+    ...legacyShapeCandidate && (executionScore == null || executionScore < MIN_EXECUTION_SCORE_FOR_AI_GATE) ? ["low_or_missing_execution_score"] : [],
+    ...legacyShapeCandidate && (lowTouchCount20 == null || lowTouchCount20 < MIN_LOW_TOUCH_COUNT20_FOR_AI_GATE) ? ["low_touch_count_below_gate"] : [],
+    ...legacyHighPrecisionShapeCandidate && volumeStructureAligned !== true ? ["high_precision_volume_structure_not_aligned"] : [],
+    ...legacyHighPrecisionShapeCandidate && benchmarkConflict !== false ? ["high_precision_benchmark_conflict_or_missing"] : [],
+    ...legacyHighPrecisionShapeCandidate && cmcAltVolumeChange24hPct == null ? ["missing_cmc_alt_volume_change"] : [],
+    ...legacyHighPrecisionShapeCandidate && cmcAltVolumeChange24hPct != null && cmcAltVolumeChange24hPct > HIGH_PRECISION_CMC_ALT_VOLUME_CHANGE_MAX ? ["cmc_alt_volume_change_too_hot"] : [],
+    ...legacyShapeCandidate && !legacyHighPrecisionShapeCandidate && cmcBtcDominanceChange24hPct == null ? ["missing_cmc_btc_dominance_change"] : [],
+    ...legacyShapeCandidate && !legacyHighPrecisionShapeCandidate && cmcBtcDominanceChange24hPct != null && (cmcBtcDominanceChange24hPct <= Q4_CMC_BTC_DOMINANCE_CHANGE_MIN || cmcBtcDominanceChange24hPct > Q4_CMC_BTC_DOMINANCE_CHANGE_MAX) ? ["cmc_btc_dominance_change_outside_band"] : [],
+    ...legacyShapeCandidate && !legacyHighPrecisionShapeCandidate && cmcBtcDominanceChange24hPct != null && cmcBtcDominanceChange24hPct > Q4_CMC_BTC_DOMINANCE_CHANGE_MIN && cmcBtcDominanceChange24hPct <= Q4_CMC_BTC_DOMINANCE_CHANGE_MAX && altDispersion24h == null ? ["missing_alt_dispersion_24h_for_q4"] : [],
+    ...legacyShapeCandidate && !legacyHighPrecisionShapeCandidate && altDispersion24h != null && altDispersion24h >= Q4_ALT_DISPERSION_24H_MAX ? ["alt_dispersion_24h_too_high_for_q4"] : [],
+    ...q4CmcApproval ? ["legacy_q4_structural_observation_only"] : [],
+    ...q4DerivativesPocket && signalDirection === "LONG" && q4DerivativesDirectionSessionOk === false ? ["long_q4_derivatives_outside_europe_session"] : [],
+    ...q4DerivativesPocket && signalDirection == null ? ["missing_signal_direction_for_q4_derivatives"] : []
+  ];
+  const highPrecisionApprovalBlocked = legacyHighPrecisionShapeCandidate && !bnbOiRotationMomentumOk && !xrpOiShortNoHtfPocket;
+  const q4DerivativesApprovalBlocked = q4DerivativesPocket && !bnbOiRotationMomentumOk && !xrpOiShortNoHtfPocket;
+  const q4ApprovalBlocked = legacyShapeCandidate && !legacyHighPrecisionShapeCandidate && !bnbOiRotationMomentumOk && !xrpOiShortNoHtfPocket;
+  const protectiveApprovalBlocked = protectiveApprovalSourceAllowed && !protectiveApprovalContextOk;
+  const approvalLiquidityBlocked = protectiveApprovalSourceAllowed && ethVsBtcVolumeRatioApprovalOk !== true;
+  const approvalBlocked = !approvalSourceAllowed && (highPrecisionApprovalBlocked || q4ApprovalBlocked || q4DerivativesApprovalBlocked);
+  const approvalSourcePassesOwnGuards = protectiveApprovalSourceAllowed && protectiveApprovalContextOk && ethVsBtcVolumeRatioApprovalOk === true;
+  const defaultApprovalAllowed = structuralHardBlockReasons.length === 0 && approvalSourcePassesOwnGuards && !approvalBlocked;
+  const bnbOiRotationBlocked = bnbOiRotationPocket && (structuralHardBlockReasons.length > 0 || !bnbOiRotationMomentumOk || protectiveApprovalBlocked || approvalLiquidityBlocked);
+  const xrpOiShortNoHtfBlocked = xrpOiShortNoHtfPocket && (structuralHardBlockReasons.length > 0 || protectiveApprovalBlocked || approvalLiquidityBlocked);
+  const ethVolumeBreadthCompressionBlocked = ethVolumeBreadthCompressionPocket;
+  const strictMomentumBlockReasons = [];
+  const strictMomentumApprovalAllowedNow = bnbOiRotationMomentumOk && structuralHardBlockReasons.length === 0 && protectiveApprovalContextOk && strictMomentumRoc1dOk === true && ethVsBtcVolumeRatioApprovalOk === true;
+  const approvalAllowedNow = defaultApprovalAllowed;
+  const setupFeatures = buildDoubleTapSetupFeatures({
+    context,
+    interval: payload.signal?.interval,
+    signalTimestamp: payload.signal?.timestamp
+  });
+  const doubleTapGateFeatures = buildDoubleTapGateFeatures({
+    setupFeatures,
+    signalDirection,
+    height,
+    breakoutDistancePct,
+    trendAligned,
+    benchmarkAligned,
+    volumeRel20,
+    derivativesDirectionAligned,
+    derivativesRiskFlags,
+    venueSpreadZScore,
+    directionalCrowding,
+    approvalPocket: legacyShapeCandidate,
+    bnbOiRotationPocket,
+    bnbOiRotationBlocked,
+    xrpOiShortNoHtfPocket,
+    xrpOiShortNoHtfBlocked,
+    ethVolumeBreadthCompressionPocket,
+    ethVolumeBreadthCompressionBlocked,
+    highPrecisionPocket: legacyHighPrecisionShapeCandidate,
+    highPrecisionApprovalBlocked,
+    q4DerivativesPocket,
+    q4DerivativesApprovalBlocked,
+    q4ApprovalBlocked,
+    defaultApprovalAllowed,
+    q4AltDispersionOk: altDispersion24h == null ? null : altDispersion24h < Q4_ALT_DISPERSION_24H_MAX,
+    q4DerivativesCmcRiskOk: btcVsAltReturn24h == null || cmc20ToCmc100RatioChange24hPct == null ? null : !q4DerivativesBadCmcPocket,
+    q4DerivativesDirectionSessionOk,
+    bnbOiRotationContextAvailable,
+    bnbOiRotationMomentumOk,
+    xrpOiShortNoHtfContextAvailable,
+    ethVolumeBreadthContextAvailable,
+    ethVsBtcVolumeRatioApprovalOk,
+    strictMomentumApproved: strictMomentumApprovalAllowedNow,
+    strictMomentumRoc1dOk,
+    protectiveApprovalContextAvailable,
+    protectiveApprovalContextOk
+  });
+  const deterministicQuality = structuralHardBlockReasons.length > 0 ? Math.min(geometryQuality, 2) : approvalSourcePassesOwnGuards ? 4 : Math.min(geometryQuality, 3);
+  return {
+    ...context,
+    baseContextAvailable,
+    primarySession,
+    sessionWindowPhase,
+    trendBias,
+    swingBias,
+    breakoutState,
+    barsSinceBreakout,
+    lowTouchCount20,
+    volumeRel20,
+    benchmarkTrendAlignment,
+    benchmarkRelativeStrength4h,
+    benchmarkBias,
+    derivativesDirectionAligned,
+    derivativesRiskFlags,
+    bodyStrength,
+    roc1d,
+    venueSpreadZScore,
+    rewardToVolatility,
+    executionScore,
+    volumeStructureAligned,
+    benchmarkConflict,
+    cmcAltVolumeChange24hPct,
+    cmcExchangeLiquidityVolumeChange24hPct,
+    cmcBtcDominanceChange24hPct,
+    cmcEthDominanceChange24hPct,
+    cmc20ToCmc100RatioChange24hPct,
+    ethVsBtcVolumeRatio,
+    marketBreadthTop5Dispersion,
+    btcVsAltReturn24h,
+    ethCrowdingPersistenceBars,
+    solFundingZScore15m,
+    bnbOiChangePct24h15m,
+    bnbOiChangePct1h1h,
+    bnbReferencePressure,
+    xrpOiChangePct1h15m,
+    ethVolumeBreadthContextAvailable,
+    ethVolumeBreadthCompressionPocket,
+    ethVsBtcVolumeRatioApprovalOk,
+    higherTimeframeConflict,
+    altDispersion24h,
+    q4DerivativesDirectionSessionOk,
+    doubleTapGateFeatures,
+    structuralHardBlockReasons,
+    softBlockReasons,
+    strictMomentumBlockReasons,
+    deterministicQuality,
+    approvalAllowedNow: deterministicQuality >= 4 && approvalAllowedNow,
+    protectiveApprovalContextAvailable,
+    protectiveApprovalContextOk,
+    strictMomentumApprovalAllowedNow,
+    maxAllowedQuality: deterministicQuality
+  };
+};
+var withDoubleTapGateFeatures = ({
+  baseContext,
+  context
+}) => baseContext == null ? baseContext : {
+  ...baseContext,
+  doubleTapGateFeatures: context.doubleTapGateFeatures
+};
+var doubleTapBaseAiAdapter = {
+  buildPayload: ({ signal, basePayload }) => {
+    const baseAdditional = basePayload.additionalIndicators ?? {};
+    const payload = {
+      ...basePayload,
+      additionalIndicators: {
+        ...baseAdditional,
+        doubleTapContext: signal.additionalIndicators?.doubleTapContext
+      }
+    };
+    const context = buildDoubleTapAiContext(payload);
+    const baseContext = baseAdditional.baseContext ?? null;
+    return {
+      ...payload,
+      additionalIndicators: {
+        ...payload.additionalIndicators,
+        baseContext: withDoubleTapGateFeatures({
+          baseContext,
+          context
+        }),
+        doubleTapContext: context
+      }
+    };
+  },
+  postProcessAnalysis: ({ payload, analysis }) => {
+    const context = buildDoubleTapAiContext(payload);
+    const direction = analysis.direction === "LONG" || analysis.direction === "SHORT" ? analysis.direction : context.signalDirection;
+    const quality = context.deterministicQuality;
+    const approved = context.approvalAllowedNow && Boolean(direction);
+    return {
+      ...analysis,
+      direction: approved ? direction ?? null : null,
+      quality,
+      qualityReason: approved ? analysis.qualityReason : "DoubleTap breakout is not in a strict baseContext-supported approval pocket."
+    };
+  },
+  buildHumanPromptAddon: ({ payload }) => {
+    const context = buildDoubleTapAiContext(payload);
+    return `
+Additional DoubleTap context:
+- patternKind=${context.patternKind ?? "n/a"}
+- signalDirection=${context.signalDirection ?? "n/a"}
+- neckline=${String(context.neckline ?? "n/a")}
+- targetPrice=${String(context.targetPrice ?? "n/a")}
+- stopLossPrice=${String(context.stopLossPrice ?? "n/a")}
+- height=${String(context.height ?? "n/a")}
+- pivotTolerancePct=${String(context.pivotTolerancePct ?? "n/a")}
+- breakoutDistancePct=${String(context.breakoutDistancePct ?? "n/a")}
+- currentPrice=${String(context.currentPrice ?? "n/a")}
+- baseContextAvailable=${String(context.baseContextAvailable)}
+- primarySession=${context.primarySession ?? "n/a"}
+- sessionWindowPhase=${context.sessionWindowPhase ?? "n/a"}
+- trendBias=${context.trendBias ?? "n/a"}
+- swingBias=${context.swingBias ?? "n/a"}
+- breakoutState=${context.breakoutState ?? "n/a"}
+- barsSinceBreakout=${String(context.barsSinceBreakout ?? "n/a")}
+- lowTouchCount20=${String(context.lowTouchCount20 ?? "n/a")}
+- volumeRel20=${String(context.volumeRel20 ?? "n/a")}
+- benchmarkTrendAlignment=${context.benchmarkTrendAlignment ?? "n/a"}
+- benchmarkRelativeStrength4h=${String(context.benchmarkRelativeStrength4h ?? "n/a")}
+- derivativesDirectionAligned=${String(context.derivativesDirectionAligned ?? "n/a")}
+- derivativesRiskFlags=${JSON.stringify(context.derivativesRiskFlags)}
+- bodyStrength=${String(context.bodyStrength ?? "n/a")}
+- roc1d=${String(context.roc1d ?? "n/a")}
+- venueSpreadZScore=${String(context.venueSpreadZScore ?? "n/a")}
+- rewardToVolatility=${String(context.rewardToVolatility ?? "n/a")}
+- executionScore=${String(context.executionScore ?? "n/a")}
+- volumeStructureAligned=${String(context.volumeStructureAligned ?? "n/a")}
+- benchmarkConflict=${String(context.benchmarkConflict ?? "n/a")}
+- cmcAltVolumeChange24hPct=${String(context.cmcAltVolumeChange24hPct ?? "n/a")}
+- cmcExchangeLiquidityVolumeChange24hPct=${String(context.cmcExchangeLiquidityVolumeChange24hPct ?? "n/a")}
+- cmcBtcDominanceChange24hPct=${String(context.cmcBtcDominanceChange24hPct ?? "n/a")}
+- cmcEthDominanceChange24hPct=${String(context.cmcEthDominanceChange24hPct ?? "n/a")}
+- cmc20ToCmc100RatioChange24hPct=${String(context.cmc20ToCmc100RatioChange24hPct ?? "n/a")}
+- ethVsBtcVolumeRatio=${String(context.ethVsBtcVolumeRatio ?? "n/a")}
+- marketBreadthTop5Dispersion=${String(context.marketBreadthTop5Dispersion ?? "n/a")}
+- btcVsAltReturn24h=${String(context.btcVsAltReturn24h ?? "n/a")}
+- ethCrowdingPersistenceBars=${String(context.ethCrowdingPersistenceBars ?? "n/a")}
+- solFundingZScore15m=${String(context.solFundingZScore15m ?? "n/a")}
+- bnbOiChangePct24h15m=${String(context.bnbOiChangePct24h15m ?? "n/a")}
+- bnbOiChangePct1h1h=${String(context.bnbOiChangePct1h1h ?? "n/a")}
+- bnbReferencePressure=${context.bnbReferencePressure ?? "n/a"}
+- xrpOiChangePct1h15m=${String(context.xrpOiChangePct1h15m ?? "n/a")}
+- ethVolumeBreadthContextAvailable=${String(context.ethVolumeBreadthContextAvailable)}
+- ethVolumeBreadthCompressionPocket=${String(context.ethVolumeBreadthCompressionPocket)}
+- higherTimeframeConflict=${String(context.higherTimeframeConflict ?? "n/a")}
+- altDispersion24h=${String(context.altDispersion24h ?? "n/a")}
+- doubleTapGatePatternGeometry=${context.doubleTapGateFeatures.patternGeometry}
+- doubleTapGateNecklineBreakout=${context.doubleTapGateFeatures.necklineBreakout}
+- doubleTapGateTrendContext=${context.doubleTapGateFeatures.trendContext}
+- doubleTapGateParticipationState=${context.doubleTapGateFeatures.participationState}
+- doubleTapGateDerivativesState=${context.doubleTapGateFeatures.derivativesState}
+- doubleTapGateExecutionSpreadState=${context.doubleTapGateFeatures.executionSpreadState}
+- doubleTapGateGeometry=${JSON.stringify(context.doubleTapGateFeatures.geometry)}
+- doubleTapGatePath=${JSON.stringify(context.doubleTapGateFeatures.path)}
+- doubleTapGateApprovalPocket=${context.doubleTapGateFeatures.approvalPocket}
+- doubleTapGateHighQualityCadencePocket=${String(context.doubleTapGateFeatures.highQualityCadencePocket)}
+- doubleTapGateDefaultApprovalAllowed=${String(context.doubleTapGateFeatures.defaultApprovalAllowed)}
+- doubleTapGateQ4AltDispersionOk=${String(context.doubleTapGateFeatures.q4AltDispersionOk ?? "n/a")}
+- doubleTapGateQ4DerivativesPocket=${String(context.doubleTapGateFeatures.q4DerivativesPocket)}
+- doubleTapGateQ4DerivativesCmcRiskOk=${String(context.doubleTapGateFeatures.q4DerivativesCmcRiskOk ?? "n/a")}
+- doubleTapGateQ4DerivativesDirectionSessionOk=${String(context.doubleTapGateFeatures.q4DerivativesDirectionSessionOk ?? "n/a")}
+- doubleTapGateBnbOiRotationPocket=${String(context.doubleTapGateFeatures.bnbOiRotationPocket)}
+- doubleTapGateBnbOiRotationContextAvailable=${String(context.doubleTapGateFeatures.bnbOiRotationContextAvailable)}
+- doubleTapGateBnbOiRotationMomentumOk=${String(context.doubleTapGateFeatures.bnbOiRotationMomentumOk)}
+- doubleTapGateXrpOiShortNoHtfPocket=${String(context.doubleTapGateFeatures.xrpOiShortNoHtfPocket)}
+- doubleTapGateXrpOiShortNoHtfContextAvailable=${String(context.doubleTapGateFeatures.xrpOiShortNoHtfContextAvailable)}
+- doubleTapGateEthVolumeBreadthContextAvailable=${String(context.doubleTapGateFeatures.ethVolumeBreadthContextAvailable)}
+- doubleTapGateEthVolumeBreadthCompressionPocket=${String(context.doubleTapGateFeatures.ethVolumeBreadthCompressionPocket)}
+- doubleTapGateEthVsBtcVolumeRatioApprovalOk=${String(context.doubleTapGateFeatures.ethVsBtcVolumeRatioApprovalOk ?? "n/a")}
+- doubleTapGateStrictMomentumApproved=${String(context.doubleTapGateFeatures.strictMomentumApproved)}
+- doubleTapGateStrictMomentumRoc1dOk=${String(context.doubleTapGateFeatures.strictMomentumRoc1dOk ?? "n/a")}
+- doubleTapGateProtectiveApprovalContextAvailable=${String(context.doubleTapGateFeatures.protectiveApprovalContextAvailable)}
+- doubleTapGateProtectiveApprovalContextOk=${String(context.doubleTapGateFeatures.protectiveApprovalContextOk)}
+- deterministicQuality=${String(context.deterministicQuality)}
+- approvalAllowedNow=${String(context.approvalAllowedNow)}
+- protectiveApprovalContextAvailable=${String(context.protectiveApprovalContextAvailable)}
+- protectiveApprovalContextOk=${String(context.protectiveApprovalContextOk)}
+- strictMomentumApprovalAllowedNow=${String(context.strictMomentumApprovalAllowedNow)}
+- structuralHardBlockReasons=${JSON.stringify(context.structuralHardBlockReasons)}
+- softBlockReasons=${JSON.stringify(context.softBlockReasons)}
+- strictMomentumBlockReasons=${JSON.stringify(context.strictMomentumBlockReasons)}
+- pivots=${JSON.stringify(context.pivots ?? [])}
+
+Interpretation rules for DoubleTap:
+- This strategy enters only after a confirmed neckline break of a double bottom or double top.
+- Prefer compact breaks close to the neckline; late/extended breaks should be downgraded.
+- Extremely tiny breaks can still be early noise; live approval needs support from baseContext.
+- Treat deterministicQuality and approvalAllowedNow as the normalized local gate result.
+- Local q4 approval comes from BNB reference OI rotation with ROC1D confirmation or an XRP OI short/no-HTF-conflict pocket.
+- BNB approval requires BNB 15m oiChangePct24h >= 0.65, BNB 1h oiChangePct1h <= -0.28, roc1d >= -5.25, and ethVsBtcVolumeRatio >= 0.34.
+- XRP approval requires a SHORT signal, XRP 15m oiChangePct1h >= 0.32, higherTimeframeConflict=false, and ethVsBtcVolumeRatio >= 0.34.
+- The BNB/XRP protective gate requires benchmark relativeStrength4h <= 7.77009, CMC exchange liquidity volume change >= -0.378662, and BNB reference pressure not crowded_long.
+- The ETH volume/breadth pocket requires ethVsBtcVolumeRatio <= 0.39, top5 market-breadth dispersion <= 0.0007, and CMC ETH dominance change > -0.05; it is retained only as observation context and should not be treated as local approval.
+- Legacy high-precision CMC, structural q4 CMC, and old BTC/ETH/SOL derivatives pockets are retained only as observation context and should not be treated as local approval.
+- A good long has two comparable lows and a clean close above the neckline.
+- A good short has two comparable highs and a clean close below the neckline.
+- Venue spread, trend bias, body strength, and reward-to-volatility are diagnostics for this gate, not strict local blockers.
+`.trim();
+  },
+  mapEntryRuntimeFromConfig: (config2) => mapAiRuntimeFromConfig(
+    config2
+  )
+};
+var doubleTapAiAdapter = withStrategyLocalAiGate(
+  doubleTapBaseAiAdapter,
+  {
+    id: "double_tap_direction_aware_release_candidate",
+    approves: ({ signal, payload }) => {
+      const altDispersion24h = getAiPayloadNumber(
+        payload,
+        "additionalIndicators.doubleTapContext.altDispersion24h"
+      );
+      const pricePositionInChannel = getAiPayloadNumber(
+        payload,
+        "additionalIndicators.baseContext.regime.trend.adaptiveChannel.pricePositionInChannel"
+      );
+      const barsSinceSwingHigh = getAiPayloadNumber(
+        payload,
+        "additionalIndicators.baseContext.structure.pivots.barsSinceSwingHigh"
+      );
+      return signal.direction === "LONG" && altDispersion24h != null && altDispersion24h >= 0.0285 && pricePositionInChannel != null && pricePositionInChannel >= 0.757 || signal.direction === "SHORT" && barsSinceSwingHigh != null && barsSinceSwingHigh <= 47;
+    }
+  }
+);
+
+// src/DoubleTap/manifest.ts
+var doubleTapManifest = {
+  name: "DoubleTap",
+  aiAdapter: doubleTapAiAdapter
+};
+
+// src/DoubleTap/strategy.ts
+var DoubleTapStrategyDefinition = {
+  defaults: config,
+  createCore: createDoubleTapCore,
+  manifest: doubleTapManifest
+};
+
+// src/index.ts
+var strategyEntries = [
+  DoubleTapStrategyDefinition
+];
+var defaultConfigs = {
+  DoubleTap: config
+};
+var getBuiltInStrategyDefaultConfig = (strategyName) => defaultConfigs[strategyName];
+var index_default = defineStrategyPlugin({ strategyEntries });
+export {
+  DoubleTapStrategyDefinition,
+  index_default as default,
+  doubleTapAiAdapter,
+  config as doubleTapDefaultConfig,
+  doubleTapManifest,
+  getBuiltInStrategyDefaultConfig,
+  strategyEntries
+};