@tradejs/strategy-head-and-shoulders 3.0.0

package/dist/index.cjs

@@ -0,0 +1,1074 @@
+"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, {
+  HeadAndShouldersStrategyDefinition: () => HeadAndShouldersStrategyDefinition,
+  default: () => index_default,
+  getBuiltInStrategyDefaultConfig: () => getBuiltInStrategyDefaultConfig,
+  headAndShouldersAiAdapter: () => headAndShouldersAiAdapter,
+  headAndShouldersDefaultConfig: () => config,
+  headAndShouldersManifest: () => headAndShouldersManifest,
+  strategyEntries: () => strategyEntries
+});
+module.exports = __toCommonJS(index_exports);
+var import_config4 = require("@tradejs/core/config");
+
+// src/HeadAndShoulders/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: 4,
+  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,
+  HEADSHOULDERS_PIVOT_LOOKBACK: 3,
+  HEADSHOULDERS_SHOULDER_TOLERANCE_PCT: 15,
+  HEADSHOULDERS_MIN_HEAD_PROMINENCE_RATIO: 0.2,
+  HEADSHOULDERS_TARGET_HEIGHT_PCT: 100,
+  HEADSHOULDERS_TARGET_HEIGHT_PCT_LONG: 120,
+  HEADSHOULDERS_TARGET_HEIGHT_PCT_SHORT: 100,
+  HEADSHOULDERS_STOP_BUFFER_HEIGHT_PCT: 5,
+  HEADSHOULDERS_MIN_HEAD_HEIGHT_PCT: 0.8,
+  HEADSHOULDERS_MIN_HEAD_HEIGHT_ATR: 2.5,
+  HEADSHOULDERS_ATR_PERIOD: 14,
+  HEADSHOULDERS_MIN_PATTERN_BARS: 8,
+  HEADSHOULDERS_MAX_PATTERN_BARS: 180,
+  HEADSHOULDERS_MIN_PATTERN_SYMMETRY_RATIO: 0.45,
+  HEADSHOULDERS_MAX_NECKLINE_SLOPE_RATIO: 0.2,
+  HEADSHOULDERS_MAX_PATTERN_AGE_BARS: 220,
+  HEADSHOULDERS_PRIOR_TREND_LOOKBACK: 80,
+  HEADSHOULDERS_MAX_PRIOR_MOVE_ATR: 3,
+  HEADSHOULDERS_MIN_BREAKOUT_DISTANCE_ATR: 0.2,
+  HEADSHOULDERS_MAX_BREAKOUT_DISTANCE_HEIGHT_RATIO: 0.35,
+  HEADSHOULDERS_MAX_BREAKOUT_DISTANCE_PCT: 0.8,
+  HEADSHOULDERS_MAX_BREAKOUT_DELAY_BARS: 8,
+  HEADSHOULDERS_REQUIRE_BREAKOUT_CROSS: false,
+  HEADSHOULDERS_ENTRY_MODE: "close_acceptance",
+  HEADSHOULDERS_CONFIRMATION_MAX_BARS: 2,
+  HEADSHOULDERS_MIN_CONFIRMATION_BODY_ATR: 0,
+  HEADSHOULDERS_MAX_CONFIRMATION_CLOSE_LOCATION: 1,
+  HEADSHOULDERS_CONFIRMATION_VOLUME_PERIOD: 20,
+  HEADSHOULDERS_MIN_CONFIRMATION_VOLUME_REL: 0.8,
+  HEADSHOULDERS_RETEST_MAX_BARS: 4,
+  HEADSHOULDERS_RETEST_TOLERANCE_ATR: 0.25,
+  HEADSHOULDERS_MIN_SIGNAL_BODY_STRENGTH: 0,
+  HEADSHOULDERS_MIN_SIGNAL_BODY_STRENGTH_LONG: 0.5,
+  HEADSHOULDERS_MIN_SIGNAL_BODY_STRENGTH_SHORT: 0,
+  HEADSHOULDERS_MIN_ENTRY_HEAD_HEIGHT_ATR: 0,
+  HEADSHOULDERS_MIN_ENTRY_HEAD_HEIGHT_ATR_LONG: 4,
+  HEADSHOULDERS_MIN_ENTRY_HEAD_HEIGHT_ATR_SHORT: 0,
+  HEADSHOULDERS_EXIT_ON_OPPOSITE_PATTERN: false,
+  LONG: {
+    enable: false,
+    direction: "LONG",
+    minRiskRatio: 0.7
+  },
+  SHORT: {
+    enable: true,
+    direction: "SHORT",
+    minRiskRatio: 0.7
+  }
+};
+
+// src/HeadAndShoulders/core.ts
+var import_math = require("@tradejs/core/math");
+
+// src/HeadAndShoulders/engine.ts
+var import_config = require("@tradejs/strategy-kit/config");
+var asNumber = (value) => {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : null;
+};
+var clampNumber = ({
+  value,
+  fallback,
+  min,
+  max
+}) => {
+  const numeric = Number(value);
+  const resolved = Number.isFinite(numeric) ? numeric : fallback;
+  return Math.min(max ?? Infinity, Math.max(min, resolved));
+};
+var getConfigNumbers = (config2) => ({
+  pivotLookback: Math.max(
+    1,
+    Math.floor(Number(config2.HEADSHOULDERS_PIVOT_LOOKBACK ?? 3))
+  ),
+  shoulderTolerancePct: clampNumber({
+    value: config2.HEADSHOULDERS_SHOULDER_TOLERANCE_PCT,
+    fallback: 20,
+    min: 0
+  }),
+  minHeadProminenceRatio: clampNumber({
+    value: config2.HEADSHOULDERS_MIN_HEAD_PROMINENCE_RATIO,
+    fallback: 0.2,
+    min: 0
+  }),
+  targetHeightPctLong: clampNumber({
+    value: (0, import_config.resolveDirectionalConfigNumber)({
+      config: config2,
+      key: "HEADSHOULDERS_TARGET_HEIGHT_PCT",
+      direction: "LONG",
+      fallback: 100
+    }),
+    fallback: 100,
+    min: 0
+  }),
+  targetHeightPctShort: clampNumber({
+    value: (0, import_config.resolveDirectionalConfigNumber)({
+      config: config2,
+      key: "HEADSHOULDERS_TARGET_HEIGHT_PCT",
+      direction: "SHORT",
+      fallback: 100
+    }),
+    fallback: 100,
+    min: 0
+  }),
+  stopBufferHeightPct: clampNumber({
+    value: config2.HEADSHOULDERS_STOP_BUFFER_HEIGHT_PCT,
+    fallback: 5,
+    min: 0
+  }),
+  minHeadHeightPct: clampNumber({
+    value: config2.HEADSHOULDERS_MIN_HEAD_HEIGHT_PCT,
+    fallback: 0.8,
+    min: 0
+  }),
+  minHeadHeightAtr: clampNumber({
+    value: config2.HEADSHOULDERS_MIN_HEAD_HEIGHT_ATR,
+    fallback: 2,
+    min: 0
+  }),
+  atrPeriod: Math.max(
+    2,
+    Math.floor(Number(config2.HEADSHOULDERS_ATR_PERIOD ?? 14))
+  ),
+  minPatternBars: Math.max(
+    4,
+    Math.floor(Number(config2.HEADSHOULDERS_MIN_PATTERN_BARS ?? 8))
+  ),
+  maxPatternBars: Math.max(
+    4,
+    Math.floor(Number(config2.HEADSHOULDERS_MAX_PATTERN_BARS ?? 180))
+  ),
+  minPatternSymmetryRatio: clampNumber({
+    value: config2.HEADSHOULDERS_MIN_PATTERN_SYMMETRY_RATIO,
+    fallback: 0.25,
+    min: 0,
+    max: 1
+  }),
+  maxNecklineSlopeRatio: clampNumber({
+    value: config2.HEADSHOULDERS_MAX_NECKLINE_SLOPE_RATIO,
+    fallback: 0.5,
+    min: 0
+  }),
+  maxPatternAgeBars: Math.max(
+    4,
+    Math.floor(Number(config2.HEADSHOULDERS_MAX_PATTERN_AGE_BARS ?? 220))
+  ),
+  priorTrendLookback: Math.max(
+    1,
+    Math.floor(Number(config2.HEADSHOULDERS_PRIOR_TREND_LOOKBACK ?? 80))
+  ),
+  maxPriorMoveAtr: clampNumber({
+    value: config2.HEADSHOULDERS_MAX_PRIOR_MOVE_ATR,
+    fallback: 0,
+    min: 0
+  }),
+  minBreakoutDistanceAtr: clampNumber({
+    value: config2.HEADSHOULDERS_MIN_BREAKOUT_DISTANCE_ATR,
+    fallback: 0.05,
+    min: 0
+  }),
+  maxBreakoutDistanceHeightRatio: clampNumber({
+    value: config2.HEADSHOULDERS_MAX_BREAKOUT_DISTANCE_HEIGHT_RATIO,
+    fallback: 0.35,
+    min: 0
+  }),
+  maxBreakoutDistancePct: clampNumber({
+    value: config2.HEADSHOULDERS_MAX_BREAKOUT_DISTANCE_PCT,
+    fallback: 0.8,
+    min: 0
+  }),
+  maxBreakoutDelayBars: Math.max(
+    0,
+    Math.floor(Number(config2.HEADSHOULDERS_MAX_BREAKOUT_DELAY_BARS ?? 0))
+  ),
+  requireBreakoutCross: Boolean(config2.HEADSHOULDERS_REQUIRE_BREAKOUT_CROSS),
+  entryMode: config2.HEADSHOULDERS_ENTRY_MODE ?? "close_acceptance",
+  confirmationMaxBars: Math.max(
+    1,
+    Math.floor(Number(config2.HEADSHOULDERS_CONFIRMATION_MAX_BARS ?? 2))
+  ),
+  minConfirmationBodyAtr: clampNumber({
+    value: config2.HEADSHOULDERS_MIN_CONFIRMATION_BODY_ATR,
+    fallback: 0,
+    min: 0
+  }),
+  maxConfirmationCloseLocation: clampNumber({
+    value: config2.HEADSHOULDERS_MAX_CONFIRMATION_CLOSE_LOCATION,
+    fallback: 1,
+    min: 0,
+    max: 1
+  }),
+  confirmationVolumePeriod: Math.max(
+    2,
+    Math.floor(Number(config2.HEADSHOULDERS_CONFIRMATION_VOLUME_PERIOD ?? 20))
+  ),
+  minConfirmationVolumeRel: clampNumber({
+    value: config2.HEADSHOULDERS_MIN_CONFIRMATION_VOLUME_REL,
+    fallback: 0,
+    min: 0
+  }),
+  retestMaxBars: Math.max(
+    1,
+    Math.floor(Number(config2.HEADSHOULDERS_RETEST_MAX_BARS ?? 4))
+  ),
+  retestToleranceAtr: clampNumber({
+    value: config2.HEADSHOULDERS_RETEST_TOLERANCE_ATR,
+    fallback: 0.25,
+    min: 0
+  })
+});
+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) {
+    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 calculateAtrAt = ({
+  state,
+  absoluteIndex,
+  period
+}) => {
+  const trueRanges = [];
+  for (let index = absoluteIndex - period + 1; index <= absoluteIndex; index += 1) {
+    const candle = getBufferedCandle(state, index);
+    const previous = getBufferedCandle(state, 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 resolveConfirmedPivot = ({
+  state,
+  candidateIndex,
+  lookback,
+  atrPeriod,
+  priorTrendLookback
+}) => {
+  const candidate = getBufferedCandle(state, candidateIndex);
+  const high = asNumber(candidate?.high);
+  const low = asNumber(candidate?.low);
+  if (!candidate || high == null || low == null) return null;
+  const window = [];
+  for (let index = candidateIndex - lookback; index <= candidateIndex + lookback; index += 1) {
+    const candle = getBufferedCandle(state, index);
+    if (!candle) return null;
+    window.push(candle);
+  }
+  const otherCandles = window.filter((_, index) => index !== lookback);
+  const isHigh = otherCandles.every((candle) => high >= Number(candle.high)) && otherCandles.some((candle) => high > Number(candle.high));
+  const isLow = otherCandles.every((candle) => low <= Number(candle.low)) && otherCandles.some((candle) => low < Number(candle.low));
+  if (isHigh === isLow) return null;
+  const atr = calculateAtrAt({
+    state,
+    absoluteIndex: candidateIndex,
+    period: atrPeriod
+  });
+  const priorClose = asNumber(
+    getBufferedCandle(state, candidateIndex - priorTrendLookback)?.close
+  );
+  const priorMove = priorClose == null ? null : isHigh ? high - priorClose : priorClose - low;
+  return {
+    timestamp: candidate.timestamp,
+    index: candidateIndex,
+    value: isHigh ? high : low,
+    kind: isHigh ? "high" : "low",
+    atr,
+    priorMoveAtr: priorMove != null && atr != null && atr > 0 ? priorMove / atr : null
+  };
+};
+var recordPivot = (state, pivot) => {
+  if (!pivot) return;
+  const latest = state.pivots[state.pivots.length - 1];
+  if (!latest || latest.kind !== pivot.kind) {
+    state.pivots.push(pivot);
+    if (state.pivots.length > 20) state.pivots.shift();
+    return;
+  }
+  const isMoreExtreme = pivot.kind === "high" ? pivot.value >= latest.value : pivot.value <= latest.value;
+  if (isMoreExtreme) state.pivots[state.pivots.length - 1] = pivot;
+};
+var lineValueAt = ({
+  left,
+  right,
+  index
+}) => {
+  const duration = right.index - left.index;
+  if (duration <= 0) return left.value;
+  return left.value + (right.value - left.value) / duration * (index - left.index);
+};
+var clonePattern = (pattern) => pattern ? { ...pattern, pivots: [...pattern.pivots] } : null;
+var clonePending = (pending) => pending ? {
+  ...pending,
+  pattern: clonePattern(pending.pattern)
+} : null;
+var rememberConsumed = (state, setupId) => {
+  if (state.consumedSetupIds.includes(setupId)) return;
+  state.consumedSetupIds.push(setupId);
+  if (state.consumedSetupIds.length > 64) state.consumedSetupIds.shift();
+};
+var isBeyondNeckline = (direction, close, neckline, minimumDistance) => direction === "LONG" ? close >= neckline + minimumDistance : close <= neckline - minimumDistance;
+var buildBreakoutPattern = ({
+  state,
+  candle,
+  prevClose,
+  atr,
+  direction,
+  options
+}) => {
+  if (state.pivots.length < 5) return null;
+  const pivots = state.pivots.slice(-5);
+  const [leftShoulder, leftNeck, head, rightNeck, rightShoulder] = pivots;
+  const expectedKinds = direction === "SHORT" ? ["high", "low", "high", "low", "high"] : ["low", "high", "low", "high", "low"];
+  if (pivots.some((pivot, index) => pivot.kind !== expectedKinds[index])) {
+    return null;
+  }
+  const close = asNumber(candle.close);
+  if (close == null) return null;
+  const necklineAtHead = lineValueAt({
+    left: leftNeck,
+    right: rightNeck,
+    index: head.index
+  });
+  const directionMultiplier = direction === "LONG" ? 1 : -1;
+  const headHeight = direction === "LONG" ? necklineAtHead - head.value : head.value - necklineAtHead;
+  if (headHeight <= 0) return null;
+  const headHeightPct = necklineAtHead !== 0 ? headHeight / Math.abs(necklineAtHead) * 100 : 0;
+  const headHeightAtr = atr != null && atr > 0 ? headHeight / atr : 0;
+  const leftHeadProminence = direction === "LONG" ? leftShoulder.value - head.value : head.value - leftShoulder.value;
+  const rightHeadProminence = direction === "LONG" ? rightShoulder.value - head.value : head.value - rightShoulder.value;
+  const leftHeadProminenceRatio = leftHeadProminence / headHeight;
+  const rightHeadProminenceRatio = rightHeadProminence / headHeight;
+  const shoulderDifferencePct = Math.abs(leftShoulder.value - rightShoulder.value) / headHeight * 100;
+  if (headHeightPct < options.minHeadHeightPct || headHeightAtr < options.minHeadHeightAtr || leftHeadProminenceRatio < options.minHeadProminenceRatio || rightHeadProminenceRatio < options.minHeadProminenceRatio || shoulderDifferencePct > options.shoulderTolerancePct) {
+    return null;
+  }
+  const leftShoulderNeckline = lineValueAt({
+    left: leftNeck,
+    right: rightNeck,
+    index: leftShoulder.index
+  });
+  const rightShoulderNeckline = lineValueAt({
+    left: leftNeck,
+    right: rightNeck,
+    index: rightShoulder.index
+  });
+  const shouldersRemainOnPatternSide = direction === "LONG" ? leftShoulder.value < leftShoulderNeckline && rightShoulder.value < rightShoulderNeckline : leftShoulder.value > leftShoulderNeckline && rightShoulder.value > rightShoulderNeckline;
+  if (!shouldersRemainOnPatternSide) return null;
+  const patternDurationBars = rightShoulder.index - leftShoulder.index;
+  const leftHalfBars = head.index - leftShoulder.index;
+  const rightHalfBars = rightShoulder.index - head.index;
+  const patternSymmetryRatio = Math.max(leftHalfBars, rightHalfBars) > 0 ? Math.min(leftHalfBars, rightHalfBars) / Math.max(leftHalfBars, rightHalfBars) : 0;
+  const patternAgeBars = state.currentIndex - leftShoulder.index;
+  const breakoutDelayBars = state.currentIndex - rightShoulder.index;
+  const necklineSlopePerBar = (rightNeck.value - leftNeck.value) / (rightNeck.index - leftNeck.index);
+  const necklineSlopeRatio = Math.abs(rightNeck.value - leftNeck.value) / headHeight;
+  const priorMoveAtr = leftShoulder.priorMoveAtr ?? null;
+  if (patternDurationBars < options.minPatternBars || patternDurationBars > options.maxPatternBars || patternSymmetryRatio < options.minPatternSymmetryRatio || necklineSlopeRatio > options.maxNecklineSlopeRatio || patternAgeBars > options.maxPatternAgeBars || options.maxBreakoutDelayBars > 0 && breakoutDelayBars > options.maxBreakoutDelayBars || options.maxPriorMoveAtr > 0 && (priorMoveAtr == null || priorMoveAtr > options.maxPriorMoveAtr)) {
+    return null;
+  }
+  const neckline = lineValueAt({
+    left: leftNeck,
+    right: rightNeck,
+    index: state.currentIndex
+  });
+  const breakoutDistance = Math.abs(close - neckline);
+  const breakoutDistancePct = neckline !== 0 ? breakoutDistance / Math.abs(neckline) * 100 : 0;
+  const breakoutDistanceAtr = atr != null && atr > 0 ? breakoutDistance / atr : 0;
+  const breakoutDistanceHeightRatio = breakoutDistance / headHeight;
+  if (!isBeyondNeckline(direction, close, neckline, 0) || breakoutDistanceAtr < options.minBreakoutDistanceAtr || options.maxBreakoutDistanceHeightRatio > 0 && breakoutDistanceHeightRatio > options.maxBreakoutDistanceHeightRatio || options.maxBreakoutDistancePct > 0 && breakoutDistancePct > options.maxBreakoutDistancePct) {
+    return null;
+  }
+  const previousNeckline = lineValueAt({
+    left: leftNeck,
+    right: rightNeck,
+    index: state.currentIndex - 1
+  });
+  const breakoutCrossedOnSignalBar = prevClose != null && (direction === "LONG" ? prevClose <= previousNeckline && close > neckline : prevClose >= previousNeckline && close < neckline);
+  if (options.requireBreakoutCross && !breakoutCrossedOnSignalBar) return null;
+  const kind = direction === "LONG" ? "inverse_head_and_shoulders" : "head_and_shoulders";
+  const setupId = `${kind}:${pivots.map((pivot) => pivot.timestamp).join(":")}`;
+  if (state.consumedSetupIds.includes(setupId)) return null;
+  return {
+    setupId,
+    kind,
+    direction,
+    entryMode: options.entryMode,
+    entryStage: "breakout",
+    pivots,
+    neckline,
+    necklineSlopePerBar,
+    targetPrice: neckline + directionMultiplier * headHeight * ((direction === "LONG" ? options.targetHeightPctLong : options.targetHeightPctShort) / 100),
+    stopLossPrice: head.value - directionMultiplier * headHeight * (options.stopBufferHeightPct / 100),
+    headHeight,
+    headHeightPct,
+    headHeightAtr,
+    shoulderDifferencePct,
+    leftHeadProminenceRatio,
+    rightHeadProminenceRatio,
+    patternDurationBars,
+    patternSymmetryRatio,
+    patternAgeBars,
+    necklineSlopeRatio,
+    priorMoveAtr,
+    breakoutDistancePct,
+    breakoutDistanceAtr,
+    breakoutDistanceHeightRatio,
+    breakoutDelayBars,
+    breakoutCrossedOnSignalBar,
+    breakoutTimestamp: candle.timestamp,
+    confirmationBars: 0,
+    confirmationBodyAtr: null,
+    confirmationCloseLocation: null,
+    confirmationVolumeRel: null,
+    timestamp: candle.timestamp,
+    close
+  };
+};
+var getPatternNecklineAt = (pattern, index) => {
+  const leftNeck = pattern.pivots[1];
+  return leftNeck.value + pattern.necklineSlopePerBar * (index - leftNeck.index);
+};
+var resolvePending = ({
+  state,
+  candle,
+  atr,
+  options
+}) => {
+  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 open = asNumber(candle.open);
+  const high = asNumber(candle.high);
+  const low = asNumber(candle.low);
+  if (close == null || open == 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" ? options.retestMaxBars : options.confirmationMaxBars;
+  if (invalidated || confirmationBars > maxBars) {
+    rememberConsumed(state, pending.setupId);
+    state.pending = null;
+    return null;
+  }
+  const neckline = getPatternNecklineAt(pattern, state.currentIndex);
+  const effectiveAtr = atr != null && atr > 0 ? atr : pattern.headHeight;
+  const minimumDistance = effectiveAtr * options.minBreakoutDistanceAtr;
+  const closeAccepted = isBeyondNeckline(
+    pattern.direction,
+    close,
+    neckline,
+    minimumDistance
+  );
+  const confirmationBody = pattern.direction === "LONG" ? close - open : open - close;
+  const confirmationBodyAtr = effectiveAtr > 0 ? confirmationBody / effectiveAtr : 0;
+  const candleRange = high - low;
+  const confirmationCloseLocation = candleRange > 0 ? pattern.direction === "LONG" ? (high - close) / candleRange : (close - low) / candleRange : 1;
+  const priorVolumeCandles = state.candles.slice(
+    -(options.confirmationVolumePeriod + 1),
+    -1
+  );
+  const priorVolumes = priorVolumeCandles.map((item) => asNumber(item.volume)).filter((value) => value != null && value >= 0);
+  const averagePriorVolume = priorVolumes.length > 0 ? priorVolumes.reduce((sum, value) => sum + value, 0) / priorVolumes.length : null;
+  const currentVolume = asNumber(candle.volume);
+  const confirmationVolumeRel = currentVolume != null && averagePriorVolume != null && averagePriorVolume > 0 ? currentVolume / averagePriorVolume : null;
+  const confirmationQualityAccepted = (options.minConfirmationBodyAtr <= 0 || confirmationBodyAtr >= options.minConfirmationBodyAtr) && confirmationCloseLocation <= options.maxConfirmationCloseLocation && (options.minConfirmationVolumeRel <= 0 || confirmationVolumeRel != null && confirmationVolumeRel >= options.minConfirmationVolumeRel);
+  let entryStage = null;
+  if (pending.mode === "close_acceptance") {
+    if (closeAccepted && confirmationQualityAccepted) {
+      entryStage = "close_accepted";
+    }
+  } else {
+    const tolerance = effectiveAtr * options.retestToleranceAtr;
+    const touched = pattern.direction === "LONG" ? low <= neckline + tolerance && low >= neckline - tolerance : high >= neckline - tolerance && high <= neckline + tolerance;
+    if (touched && closeAccepted && confirmationQualityAccepted) {
+      entryStage = "retest_held";
+    }
+  }
+  if (!entryStage) return null;
+  rememberConsumed(state, pending.setupId);
+  state.pending = null;
+  return {
+    ...pattern,
+    entryStage,
+    neckline,
+    confirmationBars,
+    confirmationBodyAtr,
+    confirmationCloseLocation,
+    confirmationVolumeRel,
+    timestamp: candle.timestamp,
+    close
+  };
+};
+var buildHeadAndShouldersSignalContext = (pattern) => ({
+  setupId: pattern.setupId,
+  patternKind: pattern.kind,
+  signalDirection: pattern.direction,
+  entryMode: pattern.entryMode,
+  entryStage: pattern.entryStage,
+  neckline: pattern.neckline,
+  necklineSlopePerBar: pattern.necklineSlopePerBar,
+  targetPrice: pattern.targetPrice,
+  stopLossPrice: pattern.stopLossPrice,
+  headHeight: pattern.headHeight,
+  headHeightPct: pattern.headHeightPct,
+  headHeightAtr: pattern.headHeightAtr,
+  shoulderDifferencePct: pattern.shoulderDifferencePct,
+  leftHeadProminenceRatio: pattern.leftHeadProminenceRatio,
+  rightHeadProminenceRatio: pattern.rightHeadProminenceRatio,
+  patternDurationBars: pattern.patternDurationBars,
+  patternSymmetryRatio: pattern.patternSymmetryRatio,
+  patternAgeBars: pattern.patternAgeBars,
+  necklineSlopeRatio: pattern.necklineSlopeRatio,
+  priorMoveAtr: pattern.priorMoveAtr,
+  breakoutDistancePct: pattern.breakoutDistancePct,
+  breakoutDistanceAtr: pattern.breakoutDistanceAtr,
+  breakoutDistanceHeightRatio: pattern.breakoutDistanceHeightRatio,
+  breakoutDelayBars: pattern.breakoutDelayBars,
+  breakoutCrossedOnSignalBar: pattern.breakoutCrossedOnSignalBar,
+  breakoutTimestamp: pattern.breakoutTimestamp,
+  confirmationBars: pattern.confirmationBars,
+  confirmationBodyAtr: pattern.confirmationBodyAtr,
+  confirmationCloseLocation: pattern.confirmationCloseLocation,
+  confirmationVolumeRel: pattern.confirmationVolumeRel,
+  currentPrice: pattern.close,
+  pivots: pattern.pivots.map(({ timestamp, value, kind }) => ({
+    timestamp,
+    value,
+    kind
+  }))
+});
+var createHeadAndShouldersEngine = ({
+  config: config2,
+  initialCandles = []
+}) => {
+  const options = getConfigNumbers(config2);
+  const state = {
+    candles: [],
+    candleStartIndex: 0,
+    currentIndex: -1,
+    pivots: [],
+    pattern: null,
+    pending: null,
+    consumedSetupIds: [],
+    lastTimestamp: null
+  };
+  const snapshot = () => ({
+    pattern: clonePattern(state.pattern),
+    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.pivotLookback * 2 + 1,
+      options.atrPeriod + 1,
+      options.priorTrendLookback + options.pivotLookback + 1,
+      options.confirmationVolumePeriod + 1
+    );
+    const currentIndex = pushBoundedCandle(state, candle, maxCandles);
+    const atr = calculateAtr(state.candles, options.atrPeriod);
+    const pendingPattern = resolvePending({ state, candle, atr, options });
+    recordPivot(
+      state,
+      resolveConfirmedPivot({
+        state,
+        candidateIndex: currentIndex - options.pivotLookback,
+        lookback: options.pivotLookback,
+        atrPeriod: options.atrPeriod,
+        priorTrendLookback: options.priorTrendLookback
+      })
+    );
+    if (pendingPattern) {
+      state.pattern = pendingPattern;
+      return snapshot();
+    }
+    if (state.pending) return snapshot();
+    const breakout = buildBreakoutPattern({
+      state,
+      candle,
+      prevClose,
+      atr,
+      direction: "SHORT",
+      options
+    }) ?? buildBreakoutPattern({
+      state,
+      candle,
+      prevClose,
+      atr,
+      direction: "LONG",
+      options
+    });
+    if (!breakout) return snapshot();
+    if (options.entryMode === "breakout") {
+      rememberConsumed(state, breakout.setupId);
+      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/HeadAndShoulders/figures.ts
+var buildHeadAndShouldersFigures = ({
+  pattern,
+  entryTimestamp,
+  entryPrice
+}) => {
+  const color = pattern.direction === "LONG" ? "#22c55e" : "#ef4444";
+  const [leftShoulder, leftNeck, head, rightNeck, rightShoulder] = pattern.pivots;
+  const patternPoints = [
+    leftShoulder,
+    leftNeck,
+    head,
+    rightNeck,
+    rightShoulder
+  ].map(({ timestamp, value }) => ({ timestamp, value }));
+  const lines = [
+    {
+      id: `headshoulders-pattern-${entryTimestamp}`,
+      kind: `headshoulders_${pattern.kind}_pattern`,
+      points: [
+        ...patternPoints,
+        { timestamp: entryTimestamp, value: entryPrice }
+      ],
+      color,
+      width: 2,
+      style: "solid"
+    },
+    {
+      id: `headshoulders-neckline-${entryTimestamp}`,
+      kind: "headshoulders_neckline",
+      points: [
+        { timestamp: leftNeck.timestamp, value: leftNeck.value },
+        { timestamp: entryTimestamp, value: pattern.neckline }
+      ],
+      color: "#f59e0b",
+      width: 2,
+      style: "dashed"
+    },
+    {
+      id: `headshoulders-target-${entryTimestamp}`,
+      kind: "headshoulders_target",
+      points: [
+        { timestamp: rightNeck.timestamp, value: pattern.targetPrice },
+        { timestamp: entryTimestamp, value: pattern.targetPrice }
+      ],
+      color: "#22c55e",
+      width: 1,
+      style: "dashed"
+    },
+    {
+      id: `headshoulders-stop-${entryTimestamp}`,
+      kind: "headshoulders_stop",
+      points: [
+        { timestamp: head.timestamp, value: pattern.stopLossPrice },
+        { timestamp: entryTimestamp, value: pattern.stopLossPrice }
+      ],
+      color: "#ef4444",
+      width: 1,
+      style: "dashed"
+    }
+  ];
+  const points = [
+    {
+      id: `headshoulders-pivots-${entryTimestamp}`,
+      kind: `headshoulders_${pattern.kind}_pivots`,
+      points: patternPoints,
+      color,
+      radius: 4
+    },
+    {
+      id: `headshoulders-entry-${entryTimestamp}`,
+      kind: "headshoulders_entry",
+      points: [{ timestamp: entryTimestamp, value: entryPrice }],
+      color,
+      radius: 5
+    }
+  ];
+  return { lines, points };
+};
+
+// src/HeadAndShoulders/filters.ts
+var import_config2 = require("@tradejs/strategy-kit/config");
+var asPositiveThreshold = (value) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+};
+var getHeadAndShouldersCoreFilterSkipCode = ({
+  pattern,
+  config: config2,
+  baseContext
+}) => {
+  const direction = pattern.direction;
+  const minBodyStrength = asPositiveThreshold(
+    (0, import_config2.resolveDirectionalConfigNumber)({
+      config: config2,
+      key: "HEADSHOULDERS_MIN_SIGNAL_BODY_STRENGTH",
+      direction,
+      fallback: 0
+    })
+  );
+  if (minBodyStrength != null) {
+    const bodyStrength = Number(baseContext?.regime?.momentum?.bodyStrength);
+    if (!Number.isFinite(bodyStrength) || bodyStrength < minBodyStrength) {
+      return "HEADSHOULDERS_SIGNAL_BODY_TOO_WEAK";
+    }
+  }
+  const minHeadHeightAtr = asPositiveThreshold(
+    (0, import_config2.resolveDirectionalConfigNumber)({
+      config: config2,
+      key: "HEADSHOULDERS_MIN_ENTRY_HEAD_HEIGHT_ATR",
+      direction,
+      fallback: 0
+    })
+  );
+  if (minHeadHeightAtr != null && (!Number.isFinite(pattern.headHeightAtr) || pattern.headHeightAtr < minHeadHeightAtr)) {
+    return "HEADSHOULDERS_HEAD_TOO_SHALLOW_AT_ENTRY";
+  }
+  return null;
+};
+
+// src/HeadAndShoulders/core.ts
+var import_risk = require("@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 buildHeadAndShouldersStateKey = (config2) => JSON.stringify({
+  pivotLookback: config2.HEADSHOULDERS_PIVOT_LOOKBACK,
+  shoulderTolerancePct: config2.HEADSHOULDERS_SHOULDER_TOLERANCE_PCT,
+  minHeadProminenceRatio: config2.HEADSHOULDERS_MIN_HEAD_PROMINENCE_RATIO,
+  targetHeightPct: config2.HEADSHOULDERS_TARGET_HEIGHT_PCT,
+  targetHeightPctLong: config2.HEADSHOULDERS_TARGET_HEIGHT_PCT_LONG,
+  targetHeightPctShort: config2.HEADSHOULDERS_TARGET_HEIGHT_PCT_SHORT,
+  stopBufferHeightPct: config2.HEADSHOULDERS_STOP_BUFFER_HEIGHT_PCT,
+  minHeadHeightPct: config2.HEADSHOULDERS_MIN_HEAD_HEIGHT_PCT,
+  minHeadHeightAtr: config2.HEADSHOULDERS_MIN_HEAD_HEIGHT_ATR,
+  atrPeriod: config2.HEADSHOULDERS_ATR_PERIOD,
+  minPatternBars: config2.HEADSHOULDERS_MIN_PATTERN_BARS,
+  maxPatternBars: config2.HEADSHOULDERS_MAX_PATTERN_BARS,
+  minPatternSymmetryRatio: config2.HEADSHOULDERS_MIN_PATTERN_SYMMETRY_RATIO,
+  maxNecklineSlopeRatio: config2.HEADSHOULDERS_MAX_NECKLINE_SLOPE_RATIO,
+  maxPatternAgeBars: config2.HEADSHOULDERS_MAX_PATTERN_AGE_BARS,
+  priorTrendLookback: config2.HEADSHOULDERS_PRIOR_TREND_LOOKBACK,
+  maxPriorMoveAtr: config2.HEADSHOULDERS_MAX_PRIOR_MOVE_ATR,
+  minBreakoutDistanceAtr: config2.HEADSHOULDERS_MIN_BREAKOUT_DISTANCE_ATR,
+  maxBreakoutDistanceHeightRatio: config2.HEADSHOULDERS_MAX_BREAKOUT_DISTANCE_HEIGHT_RATIO,
+  maxBreakoutDistancePct: config2.HEADSHOULDERS_MAX_BREAKOUT_DISTANCE_PCT,
+  maxBreakoutDelayBars: config2.HEADSHOULDERS_MAX_BREAKOUT_DELAY_BARS,
+  requireBreakoutCross: config2.HEADSHOULDERS_REQUIRE_BREAKOUT_CROSS,
+  entryMode: config2.HEADSHOULDERS_ENTRY_MODE,
+  confirmationMaxBars: config2.HEADSHOULDERS_CONFIRMATION_MAX_BARS,
+  minConfirmationBodyAtr: config2.HEADSHOULDERS_MIN_CONFIRMATION_BODY_ATR,
+  maxConfirmationCloseLocation: config2.HEADSHOULDERS_MAX_CONFIRMATION_CLOSE_LOCATION,
+  confirmationVolumePeriod: config2.HEADSHOULDERS_CONFIRMATION_VOLUME_PERIOD,
+  minConfirmationVolumeRel: config2.HEADSHOULDERS_MIN_CONFIRMATION_VOLUME_REL,
+  retestMaxBars: config2.HEADSHOULDERS_RETEST_MAX_BARS,
+  retestToleranceAtr: config2.HEADSHOULDERS_RETEST_TOLERANCE_ATR
+});
+var createHeadAndShouldersCore = async ({ config: config2, data: initialData, strategyApi, indicatorsState }) => {
+  const detectorState = strategyApi.createStateController(
+    "HeadAndShoulders",
+    () => ({
+      engine: createHeadAndShouldersEngine({
+        config: config2,
+        initialCandles: initialData
+      })
+    }),
+    {
+      configKey: buildHeadAndShouldersStateKey(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 !== pattern.direction;
+      if (Boolean(config2.HEADSHOULDERS_EXIT_ON_OPPOSITE_PATTERN) && oppositePattern) {
+        return strategyApi.exit({
+          code: "HEADSHOULDERS_OPPOSITE_PATTERN_EXIT",
+          direction: position.direction
+        });
+      }
+      return strategyApi.skip("POSITION_EXISTS");
+    }
+    if (lastTradeController.isInCooldown(candle.timestamp)) {
+      return strategyApi.skip("DEV_TRADE_COOLDOWN");
+    }
+    const sideConfig = pattern.direction === "LONG" ? config2.LONG : config2.SHORT;
+    if (!sideConfig.enable) return strategyApi.skip("STRATEGY_DISABLED");
+    const filterSkipCode = getHeadAndShouldersCoreFilterSkipCode({
+      pattern,
+      config: config2,
+      baseContext: strategyApi.getBaseContext()
+    });
+    if (filterSkipCode) return strategyApi.skip(filterSkipCode);
+    const { timestamp, currentPrice } = await strategyApi.getDecisionPriceContext();
+    if (!(0, import_risk.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 = (0, import_risk.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 = {
+      ...buildHeadAndShouldersSignalContext({
+        ...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 <= sideConfig.minRiskRatio) {
+      return strategyApi.skip(`RISK_RATIO:${(0, import_math.round)(riskRatio)}`);
+    }
+    const indicators = indicatorsState.snapshot();
+    lastTradeController.markTrade(timestamp);
+    return strategyApi.entry({
+      code: pattern.direction === "LONG" ? `HEADSHOULDERS_INVERSE_${pattern.entryStage.toUpperCase()}` : `HEADSHOULDERS_CLASSIC_${pattern.entryStage.toUpperCase()}`,
+      direction: sideConfig.direction,
+      indicators,
+      additionalIndicators: {
+        headAndShouldersContext: signalContext
+      },
+      figures: buildHeadAndShouldersFigures({
+        pattern,
+        entryTimestamp: timestamp,
+        entryPrice: currentPrice
+      }),
+      orderPlan: {
+        qty,
+        stopLossPrice: pattern.stopLossPrice,
+        takeProfits: [{ rate: 1, price: pattern.targetPrice }]
+      }
+    });
+  };
+};
+
+// src/HeadAndShoulders/adapters/ai.ts
+var import_strategies = require("@tradejs/core/strategies");
+var import_ai_gate = require("@tradejs/strategy-kit/ai-gate");
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+var getContext = (payload) => asRecord(
+  asRecord(payload.additionalIndicators).headAndShouldersContext
+);
+var headAndShouldersBaseAiAdapter = {
+  buildPayload: ({ signal, basePayload }) => ({
+    ...basePayload,
+    additionalIndicators: {
+      ...asRecord(basePayload.additionalIndicators),
+      headAndShouldersContext: asRecord(signal.additionalIndicators).headAndShouldersContext
+    }
+  }),
+  buildHumanPromptAddon: ({ payload }) => {
+    const context = getContext(payload);
+    return `
+Additional HeadAndShoulders context:
+- patternKind=${context.patternKind ?? "n/a"}
+- signalDirection=${context.signalDirection ?? "n/a"}
+- entryMode=${context.entryMode ?? "n/a"}
+- entryStage=${context.entryStage ?? "n/a"}
+- neckline=${String(context.neckline ?? "n/a")}
+- necklineSlopeRatio=${String(context.necklineSlopeRatio ?? "n/a")}
+- headHeightPct=${String(context.headHeightPct ?? "n/a")}
+- headHeightAtr=${String(context.headHeightAtr ?? "n/a")}
+- shoulderDifferencePct=${String(context.shoulderDifferencePct ?? "n/a")}
+- leftHeadProminenceRatio=${String(context.leftHeadProminenceRatio ?? "n/a")}
+- rightHeadProminenceRatio=${String(context.rightHeadProminenceRatio ?? "n/a")}
+- patternSymmetryRatio=${String(context.patternSymmetryRatio ?? "n/a")}
+- priorMoveAtr=${String(context.priorMoveAtr ?? "n/a")}
+- breakoutDistanceAtr=${String(context.breakoutDistanceAtr ?? "n/a")}
+- breakoutDistanceHeightRatio=${String(context.breakoutDistanceHeightRatio ?? "n/a")}
+- breakoutDelayBars=${String(context.breakoutDelayBars ?? "n/a")}
+- breakoutCrossedOnSignalBar=${String(context.breakoutCrossedOnSignalBar ?? "n/a")}
+- confirmationBodyAtr=${String(context.confirmationBodyAtr ?? "n/a")}
+- confirmationCloseLocation=${String(context.confirmationCloseLocation ?? "n/a")}
+- confirmationVolumeRel=${String(context.confirmationVolumeRel ?? "n/a")}
+
+Interpretation rules for HeadAndShoulders:
+- SHORT is a classic head-and-shoulders neckline breakdown; LONG is the mirrored inverse pattern.
+- Prefer balanced shoulders, a clearly prominent head, a moderate neckline slope, and a compact breakout.
+- Treat strongly asymmetric patterns, shallow heads, or overextended breakouts as lower quality.
+`.trim();
+  },
+  mapEntryRuntimeFromConfig: (config2) => (0, import_strategies.mapAiRuntimeFromConfig)(
+    config2
+  )
+};
+var headAndShouldersAiAdapter = (0, import_ai_gate.withStrategyLocalAiGate)(
+  headAndShouldersBaseAiAdapter,
+  {
+    id: "head_and_shoulders_short_wick_breadth_2026_08_12",
+    approves: ({ signal, payload }) => {
+      const upperWickPct = (0, import_ai_gate.getAiPayloadNumber)(
+        payload,
+        "additionalIndicators.baseContext.structure.candleQuality.upperWickPct"
+      );
+      const altBasketReturn24h = (0, import_ai_gate.getAiPayloadNumber)(
+        payload,
+        "additionalIndicators.baseContext.relative.btcAltRegime.altBasketReturn24h"
+      );
+      return signal.direction === "SHORT" && upperWickPct != null && upperWickPct <= 0.3 && altBasketReturn24h != null && altBasketReturn24h >= -5e-3;
+    }
+  }
+);
+
+// src/HeadAndShoulders/manifest.ts
+var headAndShouldersManifest = {
+  name: "HeadAndShoulders",
+  aiAdapter: headAndShouldersAiAdapter
+};
+
+// src/HeadAndShoulders/strategy.ts
+var HeadAndShouldersStrategyDefinition = {
+  defaults: config,
+  createCore: createHeadAndShouldersCore,
+  manifest: headAndShouldersManifest
+};
+
+// src/index.ts
+var strategyEntries = [
+  HeadAndShouldersStrategyDefinition
+];
+var defaultConfigs = {
+  HeadAndShoulders: 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 = {
+  HeadAndShouldersStrategyDefinition,
+  getBuiltInStrategyDefaultConfig,
+  headAndShouldersAiAdapter,
+  headAndShouldersDefaultConfig,
+  headAndShouldersManifest,
+  strategyEntries
+});