@tradejs/strategies 1.0.5 → 1.0.8

package/dist/chunk-QVWMBYYM.mjs

@@ -0,0 +1,836 @@
+// src/VolumeDivergence/adapters/ai.ts
+import { mapAiRuntimeFromConfig } from "@tradejs/core/strategies";
+
+// src/VolumeDivergence/setup.ts
+var clamp = (value, min, max) => Math.min(max, Math.max(min, value));
+var DEFAULT_VOLUME_DIVERGENCE_ENTRY_THRESHOLDS = {
+  allowStructureAdvanceEntry: false,
+  minDivergenceAmplitudeAtrRatio: 0.35,
+  minReclaimPct: 105,
+  minConfirmationCandleQuality: 0.58
+};
+var VOLUME_DIVERGENCE_AI_THRESHOLDS = {
+  LONG: {
+    q4DivergenceAmplitudeAtrRatio: 0.45,
+    q4ReclaimPct: 115,
+    q4ConfirmationCandleQuality: 0.62,
+    q5DivergenceAmplitudeAtrRatio: 0.8,
+    q5ReclaimPct: 145,
+    q5ConfirmationCandleQuality: 0.8
+  },
+  SHORT: {
+    q4DivergenceAmplitudeAtrRatio: 0.6,
+    q4ReclaimPct: 125,
+    q4ConfirmationCandleQuality: 0.7,
+    q5DivergenceAmplitudeAtrRatio: 0.95,
+    q5ReclaimPct: 160,
+    q5ConfirmationCandleQuality: 0.82
+  }
+};
+var getVolumeDivergenceEntryThresholds = ({
+  ALLOW_STRUCTURE_ADVANCE_ENTRY,
+  MIN_DIVERGENCE_AMPLITUDE_ATR_RATIO,
+  MIN_RECLAIM_PCT,
+  MIN_CONFIRMATION_CANDLE_QUALITY
+}) => ({
+  allowStructureAdvanceEntry: ALLOW_STRUCTURE_ADVANCE_ENTRY,
+  minDivergenceAmplitudeAtrRatio: MIN_DIVERGENCE_AMPLITUDE_ATR_RATIO,
+  minReclaimPct: MIN_RECLAIM_PCT,
+  minConfirmationCandleQuality: MIN_CONFIRMATION_CANDLE_QUALITY
+});
+var getVolumeDivergenceAiThresholds = (direction) => VOLUME_DIVERGENCE_AI_THRESHOLDS[direction];
+var calculateAverageTrueRange = (candles, period) => {
+  if (!Array.isArray(candles) || candles.length < 2 || period <= 0) {
+    return null;
+  }
+  let total = 0;
+  let count = 0;
+  const startIndex = Math.max(1, candles.length - period);
+  for (let i = startIndex; i < candles.length; i += 1) {
+    const candle = candles[i];
+    const previousClose = Number(candles[i - 1]?.close);
+    const high = Number(candle?.high);
+    const low = Number(candle?.low);
+    if (!Number.isFinite(previousClose) || !Number.isFinite(high) || !Number.isFinite(low)) {
+      continue;
+    }
+    const trueRange = Math.max(
+      high - low,
+      Math.abs(high - previousClose),
+      Math.abs(low - previousClose)
+    );
+    total += trueRange;
+    count += 1;
+  }
+  return count > 0 ? total / count : null;
+};
+var getConfirmationCandleQuality = ({
+  candle,
+  direction
+}) => {
+  const high = Number(candle.high);
+  const low = Number(candle.low);
+  const open = Number(candle.open);
+  const close = Number(candle.close);
+  if (!Number.isFinite(high) || !Number.isFinite(low) || !Number.isFinite(open) || !Number.isFinite(close)) {
+    return null;
+  }
+  const range = Math.max(high - low, 1e-9);
+  const bodyPct = clamp(Math.abs(close - open) / range, 0, 1);
+  const closeLocation = direction === "LONG" ? clamp((close - low) / range, 0, 1) : clamp((high - close) / range, 0, 1);
+  return closeLocation * 0.7 + bodyPct * 0.3;
+};
+var calculateAtrPct = ({
+  atrAbsolute,
+  currentPrice
+}) => atrAbsolute != null && currentPrice > 0 ? atrAbsolute / currentPrice * 100 : null;
+var calculateDivergenceAmplitudeAtrRatio = ({
+  direction,
+  atrAbsolute,
+  currentPivotLow,
+  previousPivotLow,
+  currentPivotHigh,
+  previousPivotHigh
+}) => {
+  const divergenceAmplitude = direction === "LONG" ? previousPivotLow - currentPivotLow : currentPivotHigh - previousPivotHigh;
+  return atrAbsolute != null && atrAbsolute > 0 && divergenceAmplitude > 0 ? divergenceAmplitude / atrAbsolute : null;
+};
+var calculateReclaimPct = ({
+  direction,
+  currentPrice,
+  currentPivotLow,
+  currentPivotHigh
+}) => {
+  const reclaimRange = currentPivotHigh - currentPivotLow;
+  const reclaimProgress = direction === "LONG" ? currentPrice - currentPivotLow : currentPivotHigh - currentPrice;
+  return reclaimRange > 0 ? reclaimProgress / reclaimRange * 100 : null;
+};
+var calculateConfirmationDistancePct = ({
+  direction,
+  currentPrice,
+  currentPivotLow,
+  currentPivotHigh
+}) => {
+  const confirmationPrice = direction === "LONG" ? currentPivotHigh : currentPivotLow;
+  if (!(confirmationPrice > 0)) {
+    return null;
+  }
+  return direction === "LONG" ? (currentPrice - confirmationPrice) / confirmationPrice * 100 : (confirmationPrice - currentPrice) / confirmationPrice * 100;
+};
+var buildVolumeDivergenceSetupFeatures = ({
+  candles,
+  currentCandle,
+  direction,
+  currentPrice,
+  currentPivotLow,
+  previousPivotLow,
+  currentPivotHigh,
+  previousPivotHigh,
+  atrPeriod
+}) => {
+  const atrAbsolute = calculateAverageTrueRange(candles, atrPeriod);
+  const atrPct = calculateAtrPct({ atrAbsolute, currentPrice });
+  const divergenceAmplitudeAtrRatio = calculateDivergenceAmplitudeAtrRatio({
+    direction,
+    atrAbsolute,
+    currentPivotLow,
+    previousPivotLow,
+    currentPivotHigh,
+    previousPivotHigh
+  });
+  const reclaimPct = calculateReclaimPct({
+    direction,
+    currentPrice,
+    currentPivotLow,
+    currentPivotHigh
+  });
+  const confirmationCandleQuality = getConfirmationCandleQuality({
+    candle: currentCandle,
+    direction
+  });
+  const confirmationDistancePct = calculateConfirmationDistancePct({
+    direction,
+    currentPrice,
+    currentPivotLow,
+    currentPivotHigh
+  });
+  return {
+    atrAbsolute,
+    atrPct,
+    divergenceAmplitudeAtrRatio,
+    reclaimPct,
+    confirmationCandleQuality,
+    confirmationDistancePct
+  };
+};
+
+// src/VolumeDivergence/adapters/ai.ts
+var VOLUME_DIVERGENCE_CONTEXT_PROMPT = `
+VolumeDivergence addon:
+- This is a reversal setup built on price and normalized-volume divergence, not a breakout strategy.
+- Bullish divergence means price makes a lower low while volume makes a higher low.
+- Bearish divergence means price makes a higher high while volume makes a lower high.
+- For a bullish signal, do not overstate quality if price still failed to bounce meaningfully away from the current pivot low or failed to reclaim enough structure.
+- For a bearish signal, mirror that logic: do not overstate quality if price failed to move down meaningfully away from the current pivot high.
+- If \`payload.additionalIndicators.volumeDivergenceContext.confirmationReady=false\`, this is usually not a fully confirmed reversal yet; quality is often \`<= 4\` and a retest or confirmation is often still needed.
+- For live approval, treat \`confirmationReady\` as much more important than \`structureAdvanced\`; structure advance alone does not mean the reversal is entry-ready.
+- For a reversal setup, do not automatically reward quality just because the coin or BTC MA bias already matches the signal direction.
+- For LONG with \`entryTiming=structure_advance\`, avoid \`quality=5\`; that is an intermediate phase, not a fully confirmed reversal.
+- Be stricter for SHORT than for LONG: a bearish reversal should require cleaner follow-through, and bias or delta conflict should reduce quality more aggressively.
+- If \`deltaAtPivot\` conflicts with the reversal direction or the coin/BTC bias conflicts with the signal, do not overstate quality just because divergence exists.
+- Use \`divergenceAmplitudeAtrRatio\`, \`reclaimPct\`, and \`confirmationCandleQuality\` as explicit setup features describing how meaningful the divergence is relative to ATR, how much structure price reclaimed, and how strong the confirmation candle was.
+- \`confirmationDistancePct\` tells you how far price moved beyond the confirmation level; do not overstate quality when confirmation exists only marginally.
+- \`additionalIndicators.deltaAtPivot\` is a proxy net-volume value on the pivot candle, not true lower-timeframe TradingView volume delta.
+- If \`payload.additionalIndicators.derivativesContext\` exists, use Coinalyze-derived open interest, funding, and liquidations as positioning context: a liquidation flush can strengthen reversal odds, while crowded positioning against the trade or stale or missing data should not mechanically increase quality.
+`;
+var VOLUME_DIVERGENCE_PAYLOAD_PROMPT = `
+- \`payload.additionalIndicators.volumeDivergenceContext\` contains a compact divergence-strength summary:
+  divergenceKind / confirmationPrice / confirmationReady / structureAdvanced / reboundFromPivotPct / confirmationDistancePct / priceDisplacementPct / divergenceAmplitudeAtrRatio / reclaimPct / confirmationCandleQuality / volumeDivergenceStrength / deltaAligned / coinBiasAligned / btcBiasAligned / deterministicQuality / approvalAllowedNow / structuralHardBlockReasons / maxAllowedQuality.
+- Use this context as the explicit strategy-specific summary instead of trying to derive the same conclusion again only from generic candles.
+- If \`payload.additionalIndicators.derivativesContext\` exists, it is a Coinalyze-derived summary of derivatives state at signal time; \`stale\` or \`missing_derivatives\` means that Coinalyze context must not be used.
+`;
+var toFiniteNumberOrNull = (value) => {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+};
+var getLastFiniteNumber = (value) => {
+  if (Array.isArray(value)) {
+    for (let i = value.length - 1; i >= 0; i -= 1) {
+      const item = toFiniteNumberOrNull(value[i]);
+      if (item != null) {
+        return item;
+      }
+    }
+    return null;
+  }
+  return toFiniteNumberOrNull(value);
+};
+var getBias = (fast, slow) => {
+  if (fast == null || slow == null) {
+    return null;
+  }
+  if (fast > slow) {
+    return "bullish";
+  }
+  if (fast < slow) {
+    return "bearish";
+  }
+  return null;
+};
+var getSignalDirection = (signal) => signal.direction === "LONG" || signal.direction === "SHORT" ? signal.direction : null;
+var getDivergenceSummary = (signal) => {
+  const additional = signal.additionalIndicators;
+  const divergence = additional?.divergence;
+  return divergence && typeof divergence === "object" ? divergence : {};
+};
+var getVolumeDivergenceSetupSummary = (signal) => {
+  const additional = signal.additionalIndicators;
+  const setup = additional?.volumeDivergenceSetup;
+  return setup && typeof setup === "object" ? setup : {};
+};
+var getVolumeDivergenceThresholdSummary = (signal) => {
+  const additional = signal.additionalIndicators;
+  const thresholds = additional?.volumeDivergenceThresholds;
+  if (!thresholds || typeof thresholds !== "object") {
+    return DEFAULT_VOLUME_DIVERGENCE_ENTRY_THRESHOLDS;
+  }
+  const candidate = thresholds;
+  return {
+    allowStructureAdvanceEntry: typeof candidate.allowStructureAdvanceEntry === "boolean" ? candidate.allowStructureAdvanceEntry : DEFAULT_VOLUME_DIVERGENCE_ENTRY_THRESHOLDS.allowStructureAdvanceEntry,
+    minDivergenceAmplitudeAtrRatio: toFiniteNumberOrNull(candidate.minDivergenceAmplitudeAtrRatio) ?? DEFAULT_VOLUME_DIVERGENCE_ENTRY_THRESHOLDS.minDivergenceAmplitudeAtrRatio,
+    minReclaimPct: toFiniteNumberOrNull(candidate.minReclaimPct) ?? DEFAULT_VOLUME_DIVERGENCE_ENTRY_THRESHOLDS.minReclaimPct,
+    minConfirmationCandleQuality: toFiniteNumberOrNull(candidate.minConfirmationCandleQuality) ?? DEFAULT_VOLUME_DIVERGENCE_ENTRY_THRESHOLDS.minConfirmationCandleQuality
+  };
+};
+var isAtLeast = (value, threshold) => value != null && value >= threshold;
+var isAtMost = (value, threshold) => value != null && value <= threshold;
+var isInRange = (value, min, max) => value != null && value >= min && value <= max;
+var getConfirmationDistancePct = ({
+  signalDirection,
+  currentPrice,
+  confirmationPrice,
+  setupValue
+}) => {
+  if (setupValue != null) {
+    return setupValue;
+  }
+  if (signalDirection == null || currentPrice == null || confirmationPrice == null || confirmationPrice <= 0) {
+    return null;
+  }
+  return signalDirection === "LONG" ? (currentPrice - confirmationPrice) / confirmationPrice * 100 : (confirmationPrice - currentPrice) / confirmationPrice * 100;
+};
+var buildHardBlockReasons = ({
+  confirmationReady,
+  reboundFromPivotPct,
+  divergenceAmplitudeAtrRatio,
+  reclaimPct,
+  confirmationCandleQuality,
+  entryThresholds
+}) => {
+  const reasons = [];
+  if (reboundFromPivotPct != null && reboundFromPivotPct <= 0) {
+    reasons.push("no_rebound_from_pivot");
+  }
+  if (divergenceAmplitudeAtrRatio != null && divergenceAmplitudeAtrRatio < entryThresholds.minDivergenceAmplitudeAtrRatio) {
+    reasons.push("weak_divergence_amplitude");
+  }
+  if (confirmationReady && reclaimPct != null && reclaimPct < entryThresholds.minReclaimPct) {
+    reasons.push("weak_reclaim");
+  }
+  if (confirmationReady && confirmationCandleQuality != null && confirmationCandleQuality < entryThresholds.minConfirmationCandleQuality) {
+    reasons.push("weak_confirmation_candle");
+  }
+  return reasons;
+};
+var getLongQ4Demotion = ({
+  divergenceAmplitudeAtrRatio,
+  volumeDivergenceRatio,
+  coinBiasAligned,
+  btcBiasAligned,
+  confirmationDistancePct,
+  barsSinceDetection,
+  atrPct,
+  reclaimPct
+}) => {
+  const longOverextendedWithoutVolumeSupport = isAtLeast(divergenceAmplitudeAtrRatio, 2.2) && volumeDivergenceRatio != null && volumeDivergenceRatio < 2.2;
+  const longBtcLedWithoutCoinSupport = coinBiasAligned === false && btcBiasAligned === true && volumeDivergenceRatio != null && volumeDivergenceRatio < 2.6;
+  const longDoubleConflictWithoutMaturity = coinBiasAligned === false && btcBiasAligned === false && (!isAtLeast(confirmationDistancePct, 0.35) || !isAtLeast(barsSinceDetection, 2) || !isAtMost(atrPct, 0.95));
+  const longDoubleConflictOverextended = coinBiasAligned === false && btcBiasAligned === false && (!isAtMost(confirmationDistancePct, 1.4) || !isAtMost(divergenceAmplitudeAtrRatio, 2.2) || !isAtMost(atrPct, 1) || !isAtLeast(reclaimPct, 130));
+  const longDoubleConflictStaleConfirmation = coinBiasAligned === false && btcBiasAligned === false && isAtLeast(barsSinceDetection, 5);
+  const longFullyAlignedLateWeakConfirmation = coinBiasAligned === true && btcBiasAligned === true && isAtLeast(barsSinceDetection, 5) && (!isAtLeast(confirmationDistancePct, 1.2) || !isAtLeast(reclaimPct, 170));
+  const longLateExtendedConfirmation = isAtLeast(barsSinceDetection, 6) && isAtLeast(confirmationDistancePct, 1.5) && !isAtMost(atrPct, 1);
+  return longOverextendedWithoutVolumeSupport || longBtcLedWithoutCoinSupport || longDoubleConflictWithoutMaturity || longDoubleConflictOverextended || longDoubleConflictStaleConfirmation || longFullyAlignedLateWeakConfirmation || longLateExtendedConfirmation;
+};
+var getLongDeterministicQuality = ({
+  confirmationReady,
+  structureAdvanced,
+  hardBlockReasons,
+  divergenceAmplitudeAtrRatio,
+  reclaimPct,
+  confirmationCandleQuality,
+  atrPct,
+  confirmationDistancePct,
+  reboundFromPivotPct,
+  volumeDivergenceStrength,
+  volumeDivergenceRatio,
+  deltaAligned,
+  barsSinceDetection,
+  coinBiasAligned,
+  btcBiasAligned,
+  entryThresholds,
+  aiThresholds
+}) => {
+  if (hardBlockReasons.length > 0) {
+    return 2;
+  }
+  const reboundModerate = isAtLeast(reboundFromPivotPct, 0.6);
+  const reboundStrong = isAtLeast(reboundFromPivotPct, 1.2);
+  const reboundVeryStrong = isAtLeast(reboundFromPivotPct, 1.8);
+  const confirmationDistanceModerate = isAtLeast(confirmationDistancePct, 0.35);
+  const confirmationDistanceStrong = isAtLeast(confirmationDistancePct, 0.7);
+  const confirmationDistanceContained = isAtMost(confirmationDistancePct, 1.4);
+  const confirmationDistanceBalanced = isInRange(
+    confirmationDistancePct,
+    0.45,
+    1.1
+  );
+  const maturityReady = isAtLeast(barsSinceDetection, 2);
+  const maturityFresh = isInRange(barsSinceDetection, 2, 5);
+  const maturityCounterTrend = isInRange(barsSinceDetection, 2, 4);
+  const calmAtr = isAtMost(atrPct, 0.95);
+  const veryCalmAtr = isAtMost(atrPct, 0.85);
+  const volumeModerate = isAtLeast(volumeDivergenceStrength, 5);
+  const volumeStrong = isAtLeast(volumeDivergenceStrength, 15);
+  const volumeVeryStrong = isAtLeast(volumeDivergenceStrength, 30);
+  const volumeRatioModerate = isAtLeast(volumeDivergenceRatio, 1.3);
+  const volumeRatioStrong = isAtLeast(volumeDivergenceRatio, 1.7);
+  const volumeRatioVeryStrong = isAtLeast(volumeDivergenceRatio, 2.2);
+  const longBiasConflictCount = Number(coinBiasAligned === false) + Number(btcBiasAligned === false);
+  const longQ4Demotion = getLongQ4Demotion({
+    divergenceAmplitudeAtrRatio,
+    volumeDivergenceRatio,
+    coinBiasAligned,
+    btcBiasAligned,
+    confirmationDistancePct,
+    barsSinceDetection,
+    atrPct,
+    reclaimPct
+  });
+  const q4SetupReady = aiThresholds != null && isAtLeast(
+    divergenceAmplitudeAtrRatio,
+    aiThresholds.q4DivergenceAmplitudeAtrRatio
+  ) && isAtLeast(reclaimPct, aiThresholds.q4ReclaimPct) && isAtLeast(
+    confirmationCandleQuality,
+    aiThresholds.q4ConfirmationCandleQuality
+  );
+  const q5SetupReady = aiThresholds != null && isAtLeast(
+    divergenceAmplitudeAtrRatio,
+    aiThresholds.q5DivergenceAmplitudeAtrRatio
+  ) && isAtLeast(reclaimPct, aiThresholds.q5ReclaimPct) && isAtLeast(
+    confirmationCandleQuality,
+    aiThresholds.q5ConfirmationCandleQuality
+  );
+  const minimumSetupReady = isAtLeast(
+    divergenceAmplitudeAtrRatio,
+    entryThresholds.minDivergenceAmplitudeAtrRatio
+  ) && isAtLeast(reclaimPct, entryThresholds.minReclaimPct) && isAtLeast(
+    confirmationCandleQuality,
+    entryThresholds.minConfirmationCandleQuality
+  );
+  const longSelectivePromotion = confirmationReady && minimumSetupReady && reboundStrong && confirmationDistanceBalanced && maturityFresh && calmAtr && volumeStrong && volumeRatioStrong && isAtLeast(reclaimPct, Math.max(entryThresholds.minReclaimPct + 15, 130)) && isAtLeast(
+    confirmationCandleQuality,
+    Math.max(entryThresholds.minConfirmationCandleQuality + 0.1, 0.7)
+  ) && deltaAligned !== false && longBiasConflictCount <= 1 && !longQ4Demotion;
+  const longAlignedFnPromotion = confirmationReady && minimumSetupReady && coinBiasAligned === true && btcBiasAligned === true && reboundModerate && calmAtr && isAtLeast(reclaimPct, 145) && isAtLeast(confirmationCandleQuality, 0.8) && isAtMost(divergenceAmplitudeAtrRatio, 1.8) && isAtMost(confirmationDistancePct, 0.8) && !longQ4Demotion;
+  const longSemiAlignedFnPromotion = confirmationReady && minimumSetupReady && (coinBiasAligned === true || btcBiasAligned === true) && reboundModerate && isAtLeast(reclaimPct, 140) && isAtLeast(confirmationCandleQuality, 0.8) && isAtMost(divergenceAmplitudeAtrRatio, 2.5) && !longQ4Demotion;
+  const longCounterTrendSelectivePromotion = confirmationReady && minimumSetupReady && reboundStrong && confirmationDistanceBalanced && maturityCounterTrend && veryCalmAtr && volumeVeryStrong && volumeRatioVeryStrong && isAtLeast(reclaimPct, 130) && isAtLeast(
+    confirmationCandleQuality,
+    Math.max(entryThresholds.minConfirmationCandleQuality + 0.1, 0.7)
+  ) && longBiasConflictCount === 2 && !longQ4Demotion;
+  if (confirmationReady && q5SetupReady && reboundVeryStrong && confirmationDistanceStrong && confirmationDistanceContained && maturityReady && calmAtr && volumeVeryStrong && volumeRatioVeryStrong && deltaAligned === true && longBiasConflictCount === 0 && !longQ4Demotion) {
+    return 5;
+  }
+  if (longCounterTrendSelectivePromotion || longSemiAlignedFnPromotion || longAlignedFnPromotion || longSelectivePromotion || confirmationReady && q4SetupReady && reboundModerate && confirmationDistanceModerate && confirmationDistanceContained && volumeModerate && volumeRatioModerate && !longQ4Demotion && deltaAligned !== false) {
+    return 4;
+  }
+  if (confirmationReady && minimumSetupReady && reboundModerate) {
+    return 3;
+  }
+  if (structureAdvanced && isAtLeast(reboundFromPivotPct, 0.25)) {
+    return 3;
+  }
+  return 2;
+};
+var getShortDeterministicQuality = ({
+  confirmationReady,
+  structureAdvanced,
+  hardBlockReasons,
+  divergenceAmplitudeAtrRatio,
+  reclaimPct,
+  confirmationCandleQuality,
+  reboundFromPivotPct,
+  volumeDivergenceStrength,
+  deltaAligned,
+  coinBiasAligned,
+  btcBiasAligned,
+  entryThresholds,
+  aiThresholds
+}) => {
+  if (hardBlockReasons.length > 0) {
+    return 2;
+  }
+  const reboundModerate = isAtLeast(reboundFromPivotPct, 0.6);
+  const reboundStrong = isAtLeast(reboundFromPivotPct, 1.2);
+  const reboundVeryStrong = isAtLeast(reboundFromPivotPct, 1.8);
+  const volumeVeryStrong = isAtLeast(volumeDivergenceStrength, 30);
+  const shortBiasConflictCount = Number(coinBiasAligned === false) + Number(btcBiasAligned === false);
+  const q4SetupReady = aiThresholds != null && isAtLeast(
+    divergenceAmplitudeAtrRatio,
+    aiThresholds.q4DivergenceAmplitudeAtrRatio
+  ) && isAtLeast(reclaimPct, aiThresholds.q4ReclaimPct) && isAtLeast(
+    confirmationCandleQuality,
+    aiThresholds.q4ConfirmationCandleQuality
+  );
+  const q5SetupReady = aiThresholds != null && isAtLeast(
+    divergenceAmplitudeAtrRatio,
+    aiThresholds.q5DivergenceAmplitudeAtrRatio
+  ) && isAtLeast(reclaimPct, aiThresholds.q5ReclaimPct) && isAtLeast(
+    confirmationCandleQuality,
+    aiThresholds.q5ConfirmationCandleQuality
+  );
+  const minimumSetupReady = isAtLeast(
+    divergenceAmplitudeAtrRatio,
+    entryThresholds.minDivergenceAmplitudeAtrRatio
+  ) && isAtLeast(reclaimPct, entryThresholds.minReclaimPct) && isAtLeast(
+    confirmationCandleQuality,
+    entryThresholds.minConfirmationCandleQuality
+  );
+  if (confirmationReady && q5SetupReady && reboundVeryStrong && volumeVeryStrong && deltaAligned === true && shortBiasConflictCount === 0) {
+    return 5;
+  }
+  if (confirmationReady && q4SetupReady && reboundStrong && volumeVeryStrong && deltaAligned === true && shortBiasConflictCount === 0) {
+    return 4;
+  }
+  if (confirmationReady && minimumSetupReady && reboundModerate && deltaAligned !== false) {
+    return 3;
+  }
+  if (structureAdvanced && isAtLeast(reboundFromPivotPct, 0.25) && deltaAligned !== false) {
+    return 3;
+  }
+  return 2;
+};
+var getVolumeDivergenceContext = (signal) => {
+  const signalDirection = getSignalDirection(signal);
+  const divergence = getDivergenceSummary(signal);
+  const divergenceKind = divergence.kind === "bullish" || divergence.kind === "bearish" ? divergence.kind : null;
+  const currentPrice = toFiniteNumberOrNull(signal.prices?.currentPrice);
+  const currentPivotLow = toFiniteNumberOrNull(
+    divergence.currentPivot?.priceLow
+  );
+  const currentPivotHigh = toFiniteNumberOrNull(
+    divergence.currentPivot?.priceHigh
+  );
+  const previousPivotLow = toFiniteNumberOrNull(
+    divergence.previousPivot?.priceLow
+  );
+  const previousPivotHigh = toFiniteNumberOrNull(
+    divergence.previousPivot?.priceHigh
+  );
+  const currentVolumeNorm = toFiniteNumberOrNull(
+    divergence.currentPivot?.volumeNorm
+  );
+  const previousVolumeNorm = toFiniteNumberOrNull(
+    divergence.previousPivot?.volumeNorm
+  );
+  const pivotLookbackRight = toFiniteNumberOrNull(
+    divergence.pivotLookbackRight
+  );
+  const barsBetweenPivotConfirmations = toFiniteNumberOrNull(
+    divergence.barsBetweenPivotConfirmations
+  );
+  const timing = signal.additionalIndicators?.volumeDivergenceSignalTiming;
+  const entryTiming = timing?.entryTiming === "confirmation_ready" || timing?.entryTiming === "structure_advance" ? timing.entryTiming : null;
+  const barsSinceDetection = toFiniteNumberOrNull(timing?.barsSinceDetection);
+  const deltaAtPivot = toFiniteNumberOrNull(
+    signal.additionalIndicators?.deltaAtPivot
+  );
+  const setup = getVolumeDivergenceSetupSummary(signal);
+  const atrPct = toFiniteNumberOrNull(setup.atrPct);
+  const divergenceAmplitudeAtrRatio = toFiniteNumberOrNull(
+    setup.divergenceAmplitudeAtrRatio
+  );
+  const reclaimPct = toFiniteNumberOrNull(setup.reclaimPct);
+  const confirmationCandleQuality = toFiniteNumberOrNull(
+    setup.confirmationCandleQuality
+  );
+  const setupConfirmationDistancePct = toFiniteNumberOrNull(
+    setup.confirmationDistancePct
+  );
+  const entryThresholds = getVolumeDivergenceThresholdSummary(signal);
+  const coinMaBias = getBias(
+    getLastFiniteNumber(signal.indicators?.maFast),
+    getLastFiniteNumber(signal.indicators?.maSlow)
+  );
+  const btcMaBias = getBias(
+    getLastFiniteNumber(signal.indicators?.btcMaFast),
+    getLastFiniteNumber(signal.indicators?.btcMaSlow)
+  );
+  const confirmationPrice = divergenceKind === "bullish" ? currentPivotHigh : divergenceKind === "bearish" ? currentPivotLow : null;
+  const confirmationReady = divergenceKind === "bullish" ? currentPrice != null && confirmationPrice != null && currentPrice >= confirmationPrice : divergenceKind === "bearish" ? currentPrice != null && confirmationPrice != null && currentPrice <= confirmationPrice : false;
+  const confirmationDistancePct = getConfirmationDistancePct({
+    signalDirection,
+    currentPrice,
+    confirmationPrice,
+    setupValue: setupConfirmationDistancePct
+  });
+  const structureAdvanced = divergenceKind === "bullish" ? currentPrice != null && previousPivotLow != null && currentPrice >= previousPivotLow : divergenceKind === "bearish" ? currentPrice != null && previousPivotHigh != null && currentPrice <= previousPivotHigh : false;
+  const reboundFromPivotPct = divergenceKind === "bullish" && currentPrice != null && currentPivotLow != null && currentPivotLow > 0 ? (currentPrice - currentPivotLow) / currentPivotLow * 100 : divergenceKind === "bearish" && currentPrice != null && currentPivotHigh != null && currentPivotHigh > 0 ? (currentPivotHigh - currentPrice) / currentPivotHigh * 100 : null;
+  const priceDisplacementPct = divergenceKind === "bullish" && currentPivotLow != null && previousPivotLow != null && previousPivotLow > 0 ? (previousPivotLow - currentPivotLow) / previousPivotLow * 100 : divergenceKind === "bearish" && currentPivotHigh != null && previousPivotHigh != null && previousPivotHigh > 0 ? (currentPivotHigh - previousPivotHigh) / previousPivotHigh * 100 : null;
+  const volumeDivergenceStrength = divergenceKind === "bullish" && currentVolumeNorm != null && previousVolumeNorm != null ? currentVolumeNorm - previousVolumeNorm : divergenceKind === "bearish" && currentVolumeNorm != null && previousVolumeNorm != null ? previousVolumeNorm - currentVolumeNorm : null;
+  const volumeDivergenceRatio = divergenceKind === "bullish" && currentVolumeNorm != null && previousVolumeNorm != null && previousVolumeNorm > 0 ? currentVolumeNorm / previousVolumeNorm : divergenceKind === "bearish" && currentVolumeNorm != null && previousVolumeNorm != null && currentVolumeNorm > 0 ? previousVolumeNorm / currentVolumeNorm : null;
+  const deltaAligned = signalDirection === "LONG" ? deltaAtPivot != null ? deltaAtPivot > 0 : null : signalDirection === "SHORT" ? deltaAtPivot != null ? deltaAtPivot < 0 : null : null;
+  const coinBiasAligned = signalDirection === "LONG" ? coinMaBias != null ? coinMaBias === "bullish" : null : signalDirection === "SHORT" ? coinMaBias != null ? coinMaBias === "bearish" : null : null;
+  const btcBiasAligned = signalDirection === "LONG" ? btcMaBias != null ? btcMaBias === "bullish" : null : signalDirection === "SHORT" ? btcMaBias != null ? btcMaBias === "bearish" : null : null;
+  const aiThresholds = signalDirection != null ? getVolumeDivergenceAiThresholds(signalDirection) : null;
+  const hardBlockReasons = buildHardBlockReasons({
+    confirmationReady,
+    reboundFromPivotPct,
+    divergenceAmplitudeAtrRatio,
+    reclaimPct,
+    confirmationCandleQuality,
+    entryThresholds
+  });
+  const deterministicQuality = signalDirection === "LONG" ? getLongDeterministicQuality({
+    confirmationReady,
+    structureAdvanced,
+    hardBlockReasons,
+    divergenceAmplitudeAtrRatio,
+    reclaimPct,
+    confirmationCandleQuality,
+    atrPct,
+    confirmationDistancePct,
+    reboundFromPivotPct,
+    volumeDivergenceStrength,
+    volumeDivergenceRatio,
+    deltaAligned,
+    barsSinceDetection,
+    coinBiasAligned,
+    btcBiasAligned,
+    entryThresholds,
+    aiThresholds
+  }) : signalDirection === "SHORT" ? getShortDeterministicQuality({
+    confirmationReady,
+    structureAdvanced,
+    hardBlockReasons,
+    divergenceAmplitudeAtrRatio,
+    reclaimPct,
+    confirmationCandleQuality,
+    reboundFromPivotPct,
+    volumeDivergenceStrength,
+    deltaAligned,
+    coinBiasAligned,
+    btcBiasAligned,
+    entryThresholds,
+    aiThresholds
+  }) : hardBlockReasons.length > 0 ? 2 : 3;
+  const approvalAllowedNow = hardBlockReasons.length === 0 && deterministicQuality >= 4 && confirmationReady;
+  return {
+    signalDirection,
+    divergenceKind,
+    confirmationPrice,
+    confirmationReady,
+    structureAdvanced,
+    reboundFromPivotPct,
+    confirmationDistancePct,
+    priceDisplacementPct,
+    atrPct,
+    divergenceAmplitudeAtrRatio,
+    reclaimPct,
+    confirmationCandleQuality,
+    volumeDivergenceStrength,
+    volumeDivergenceRatio,
+    deltaAtPivot,
+    deltaAligned,
+    barsSincePivot: pivotLookbackRight,
+    barsBetweenPivotConfirmations,
+    entryTiming,
+    barsSinceDetection,
+    coinMaBias,
+    btcMaBias,
+    coinBiasAligned,
+    btcBiasAligned,
+    hardBlockReasons,
+    structuralHardBlockReasons: [...hardBlockReasons],
+    deterministicQuality,
+    approvalAllowedNow,
+    maxAllowedQuality: deterministicQuality
+  };
+};
+var getVolumeDivergenceContextFromPayload = (payload, signal) => {
+  const additional = payload.additionalIndicators;
+  const fromPayload = additional?.volumeDivergenceContext;
+  if (fromPayload && typeof fromPayload === "object") {
+    return fromPayload;
+  }
+  return getVolumeDivergenceContext(signal);
+};
+var clampQuality = (quality, maxAllowedQuality) => Math.max(1, Math.min(5, Math.min(quality, maxAllowedQuality)));
+var getHardBlockReasonText = (reason) => {
+  switch (reason) {
+    case "no_rebound_from_pivot":
+      return "price failed to move away from the pivot in the reversal direction";
+    case "weak_divergence_amplitude":
+      return "divergence amplitude is too small relative to ATR";
+    case "weak_reclaim":
+      return "price reclaimed too little structure after the pivot";
+    case "weak_confirmation_candle":
+      return "confirmation candle is too weak";
+    default:
+      return reason;
+  }
+};
+var buildGuardrailReason = (context) => {
+  if (context.hardBlockReasons.length > 0) {
+    return `VolumeDivergence guardrail: ${context.hardBlockReasons.map(getHardBlockReasonText).join("; ")}.`;
+  }
+  if (!context.confirmationReady && context.entryTiming == null) {
+    return "VolumeDivergence guardrail: reversal is visible, but the confirmation level has not been cleared yet.";
+  }
+  return "VolumeDivergence guardrail: quality is limited by confirmation state and the strength of reversal away from the pivot.";
+};
+var postProcessAnalysis = ({
+  signal,
+  payload,
+  analysis
+}) => {
+  const context = getVolumeDivergenceContextFromPayload(payload, signal);
+  const signalDirection = getSignalDirection(signal);
+  const requestedDirection = analysis.direction === signalDirection ? signalDirection : null;
+  const finalDirection = requestedDirection != null && context.approvalAllowedNow ? requestedDirection : null;
+  const requestedQuality = typeof analysis.quality === "number" ? analysis.quality : context.maxAllowedQuality;
+  const finalQuality = clampQuality(
+    requestedQuality,
+    context.maxAllowedQuality
+  );
+  const needRetest = finalDirection == null;
+  const retestPrice = needRetest ? context.confirmationPrice : null;
+  if (finalDirection == null) {
+    return {
+      ...analysis,
+      direction: null,
+      quality: finalQuality,
+      needRetest,
+      retestPrice,
+      takeProfitPrice: null,
+      stopLossPrice: null,
+      qualityReason: analysis.qualityReason || buildGuardrailReason(context),
+      triggerInvalidation: analysis.triggerInvalidation || (context.confirmationPrice != null ? `Wait for reversal confirmation relative to level ${context.confirmationPrice}.` : "Wait for a confirmed reversal after the pivot."),
+      comment: analysis.comment || (context.hardBlockReasons.length > 0 ? `VolumeDivergence rejected: ${context.hardBlockReasons.map(getHardBlockReasonText).join("; ")}.` : "VolumeDivergence remains in watch mode until the reversal is confirmed.")
+    };
+  }
+  return {
+    ...analysis,
+    direction: finalDirection,
+    quality: finalQuality,
+    needRetest,
+    retestPrice,
+    takeProfitPrice: signal.prices?.takeProfitPrice ?? null,
+    stopLossPrice: signal.prices?.stopLossPrice ?? null
+  };
+};
+var volumeDivergenceAiAdapter = {
+  buildPayload: ({ signal, basePayload }) => ({
+    ...basePayload,
+    additionalIndicators: {
+      ...basePayload.additionalIndicators,
+      volumeDivergenceContext: getVolumeDivergenceContext(signal)
+    }
+  }),
+  postProcessAnalysis,
+  buildSystemPromptAddon: () => `${VOLUME_DIVERGENCE_CONTEXT_PROMPT}
+${VOLUME_DIVERGENCE_PAYLOAD_PROMPT}`,
+  buildHumanPromptAddon: ({ signal, payload }) => {
+    const context = getVolumeDivergenceContextFromPayload(payload, signal);
+    return `
+
+Additional VolumeDivergence context:
+- divergenceKind=${context.divergenceKind ?? "n/a"}
+- confirmationPrice=${context.confirmationPrice ?? "n/a"}
+- confirmationReady=${context.confirmationReady}
+- structureAdvanced=${context.structureAdvanced}
+- reboundFromPivotPct=${context.reboundFromPivotPct?.toFixed?.(3) ?? "n/a"}%
+- atrPct=${context.atrPct?.toFixed?.(3) ?? "n/a"}%
+- divergenceAmplitudeAtrRatio=${context.divergenceAmplitudeAtrRatio?.toFixed?.(3) ?? "n/a"}
+- reclaimPct=${context.reclaimPct?.toFixed?.(3) ?? "n/a"}
+- confirmationCandleQuality=${context.confirmationCandleQuality?.toFixed?.(3) ?? "n/a"}
+- confirmationDistancePct=${context.confirmationDistancePct?.toFixed?.(3) ?? "n/a"}%
+- priceDisplacementPct=${context.priceDisplacementPct?.toFixed?.(3) ?? "n/a"}%
+- volumeDivergenceStrength=${context.volumeDivergenceStrength?.toFixed?.(3) ?? "n/a"}
+- volumeDivergenceRatio=${context.volumeDivergenceRatio?.toFixed?.(3) ?? "n/a"}
+- deltaAligned=${context.deltaAligned}
+- coinBiasAligned=${context.coinBiasAligned}
+- btcBiasAligned=${context.btcBiasAligned}
+- barsSincePivot=${context.barsSincePivot ?? "n/a"}
+- barsBetweenPivotConfirmations=${context.barsBetweenPivotConfirmations ?? "n/a"}
+- entryTiming=${context.entryTiming ?? "n/a"}
+- barsSinceDetection=${context.barsSinceDetection ?? "n/a"}
+- deterministicQuality=${context.deterministicQuality}
+- approvalAllowedNow=${context.approvalAllowedNow}
+- structuralHardBlockReasons=${context.structuralHardBlockReasons.join(", ") || "none"}
+- maxAllowedQuality=${context.maxAllowedQuality}
+- hardBlockReasons=${context.hardBlockReasons.join(", ") || "none"}
+
+Interpretation rules for VolumeDivergence:
+- first evaluate whether there is a real reversal away from the pivot, not just divergence on paper;
+- \`confirmationReady=false\` usually means the reversal is not fully confirmed yet;
+- if price did not bounce away from the current pivot in the signal direction, do not treat the setup as confirmed;
+- delta or bias conflict should reduce quality, not be ignored.
+`;
+  },
+  mapEntryRuntimeFromConfig: (config2) => mapAiRuntimeFromConfig(
+    config2
+  )
+};
+
+// src/VolumeDivergence/adapters/ml.ts
+import { mapMlRuntimeFromConfig } from "@tradejs/core/strategies";
+var toVolumeDivergenceMlStrategyConfig = (input) => {
+  if (!input) return void 0;
+  return {
+    ...input,
+    VOLUME_DIVERGENCE_CONFIG: input.VOLUME_DIVERGENCE_CONFIG ?? {
+      normalizationLength: input.NORMALIZATION_LENGTH,
+      pivotLookbackLeft: input.PIVOT_LOOKBACK_LEFT,
+      pivotLookbackRight: input.PIVOT_LOOKBACK_RIGHT,
+      maxBarsBetweenPivots: input.MAX_BARS_BETWEEN_PIVOTS,
+      minBarsBetweenPivots: input.MIN_BARS_BETWEEN_PIVOTS,
+      bullish: input.BULLISH,
+      bearish: input.BEARISH
+    }
+  };
+};
+var volumeDivergenceMlAdapter = {
+  normalizeStrategyConfig: (strategyConfig) => {
+    return toVolumeDivergenceMlStrategyConfig(strategyConfig);
+  },
+  mapEntryRuntimeFromConfig: (config2) => mapMlRuntimeFromConfig(config2, {
+    strategyConfig: toVolumeDivergenceMlStrategyConfig(
+      config2
+    )
+  })
+};
+
+// src/VolumeDivergence/manifest.ts
+var volumeDivergenceManifest = {
+  name: "VolumeDivergence",
+  aiAdapter: volumeDivergenceAiAdapter,
+  mlAdapter: volumeDivergenceMlAdapter
+};
+
+// src/VolumeDivergence/config.ts
+var config = {
+  ENV: "BACKTEST",
+  INTERVAL: "15",
+  MAKE_ORDERS: true,
+  CLOSE_OPPOSITE_POSITIONS: false,
+  BACKTEST_PRICE_MODE: "mid",
+  AI_ENABLED: false,
+  AI_MODE: "llm",
+  ML_ENABLED: false,
+  ML_THRESHOLD: 0.1,
+  MIN_AI_QUALITY: 3,
+  FEE_PERCENT: 5e-3,
+  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,
+  LEVEL_LOOKBACK: 20,
+  LEVEL_DELAY: 2,
+  NORMALIZATION_LENGTH: 100,
+  PIVOT_LOOKBACK_LEFT: 8,
+  PIVOT_LOOKBACK_RIGHT: 3,
+  MIN_BARS_BETWEEN_PIVOTS: 4,
+  MAX_BARS_BETWEEN_PIVOTS: 36,
+  ALLOW_STRUCTURE_ADVANCE_ENTRY: false,
+  MIN_DIVERGENCE_AMPLITUDE_ATR_RATIO: 0.35,
+  MIN_RECLAIM_PCT: 105,
+  MIN_CONFIRMATION_CANDLE_QUALITY: 0.58,
+  BULLISH: {
+    enable: true,
+    direction: "LONG",
+    TP: 4,
+    SL: 1.3,
+    minRiskRatio: 2
+  },
+  BEARISH: {
+    enable: true,
+    direction: "SHORT",
+    TP: 4,
+    SL: 1.3,
+    minRiskRatio: 2
+  }
+};
+
+export {
+  getVolumeDivergenceEntryThresholds,
+  buildVolumeDivergenceSetupFeatures,
+  volumeDivergenceAiAdapter,
+  volumeDivergenceMlAdapter,
+  volumeDivergenceManifest,
+  config
+};