@tradejs/strategies 1.0.5 → 1.0.8

package/dist/chunk-UK4YHD2E.mjs

@@ -0,0 +1,683 @@
+// src/ReverseTrendLine/adapters/ai.ts
+import { mapAiRuntimeFromConfig } from "@tradejs/core/strategies";
+
+// src/ReverseTrendLine/guardrails.ts
+var REVERSE_TRENDLINE_NEAR_LINE_PCT = 0.45;
+var REVERSE_TRENDLINE_FAILED_BOUNCE_PCT = 0.35;
+var REVERSE_TRENDLINE_TIMING_WINDOW = 6;
+var MIN_REJECTION_WICK_PCT = 0.12;
+var MIN_REJECTION_STRENGTH_PCT = 0.08;
+var FOLLOW_THROUGH_STRENGTH_PCT = 0.18;
+var toFiniteNumberOrNull = (value) => {
+  const num = Number(value);
+  return Number.isFinite(num) ? num : null;
+};
+var getLastFiniteNumber = (value) => {
+  if (!Array.isArray(value) || value.length === 0) {
+    return null;
+  }
+  return toFiniteNumberOrNull(value[value.length - 1]);
+};
+var getBias = (fast, slow) => {
+  if (fast == null || slow == null) {
+    return null;
+  }
+  if (fast > slow) {
+    return "bullish";
+  }
+  if (fast < slow) {
+    return "bearish";
+  }
+  return "flat";
+};
+var getSpreadPct = (fast, slow) => {
+  if (fast == null || slow == null || slow === 0) {
+    return null;
+  }
+  return (fast - slow) / slow * 100;
+};
+var getTrendLineFromPayload = (signal) => signal.figures?.trendLine ?? signal.additionalIndicators?.trendLine ?? null;
+var deriveDirectionFromMode = (mode) => {
+  if (mode === "lows") {
+    return "LONG";
+  }
+  if (mode === "highs") {
+    return "SHORT";
+  }
+  return null;
+};
+var getSortedTrendLinePoints = (trendLine) => {
+  const rawPoints = Array.isArray(trendLine?.points) ? trendLine.points : [];
+  return rawPoints.map((point) => {
+    if (!point || typeof point !== "object") {
+      return null;
+    }
+    const typedPoint = point;
+    const timestamp = toFiniteNumberOrNull(typedPoint.timestamp);
+    const value = toFiniteNumberOrNull(typedPoint.value);
+    if (timestamp == null || value == null) {
+      return null;
+    }
+    return { timestamp, value };
+  }).filter(Boolean).sort((left, right) => left.timestamp - right.timestamp);
+};
+var buildTrendLineEvaluator = (trendLine) => {
+  const points = getSortedTrendLinePoints(trendLine);
+  if (points.length === 0) {
+    return null;
+  }
+  const firstPoint = points[0];
+  const lastPoint = points[points.length - 1];
+  const deltaTime = lastPoint.timestamp - firstPoint.timestamp;
+  if (deltaTime === 0) {
+    return {
+      firstPoint,
+      lastPoint,
+      evaluate: (_timestamp) => lastPoint.value
+    };
+  }
+  const slope = (lastPoint.value - firstPoint.value) / deltaTime;
+  return {
+    firstPoint,
+    lastPoint,
+    evaluate: (timestamp) => firstPoint.value + slope * (timestamp - firstPoint.timestamp)
+  };
+};
+var getCurrentCandle = (signal) => {
+  const candle = signal.additionalIndicators?.currentCandle;
+  return candle && typeof candle === "object" ? candle : null;
+};
+var getLineTouched = ({
+  low,
+  high,
+  linePrice
+}) => {
+  if (low == null || high == null || linePrice == null) {
+    return false;
+  }
+  return low <= linePrice && high >= linePrice;
+};
+var getCloseOnBounceSide = ({
+  direction,
+  priceVsLinePct
+}) => {
+  if (direction == null || priceVsLinePct == null) {
+    return null;
+  }
+  return direction === "LONG" ? priceVsLinePct >= 0 : priceVsLinePct <= 0;
+};
+var getFailedBounceBreak = ({
+  direction,
+  priceVsLinePct
+}) => {
+  if (direction == null || priceVsLinePct == null) {
+    return null;
+  }
+  return direction === "LONG" ? priceVsLinePct <= -REVERSE_TRENDLINE_FAILED_BOUNCE_PCT : priceVsLinePct >= REVERSE_TRENDLINE_FAILED_BOUNCE_PCT;
+};
+var getBodyAligned = ({
+  direction,
+  open,
+  close
+}) => {
+  if (direction == null || open == null || close == null) {
+    return null;
+  }
+  return direction === "LONG" ? close >= open : close <= open;
+};
+var getRejectionWickPct = ({
+  direction,
+  open,
+  close,
+  high,
+  low
+}) => {
+  if (direction == null || open == null || close == null || high == null || low == null || close <= 0) {
+    return null;
+  }
+  const lowerWick = Math.max(0, Math.min(open, close) - low);
+  const upperWick = Math.max(0, high - Math.max(open, close));
+  return direction === "LONG" ? lowerWick / close * 100 : upperWick / close * 100;
+};
+var getRejectionStrengthPct = ({
+  direction,
+  close,
+  linePrice
+}) => {
+  if (direction == null || close == null || linePrice == null || linePrice === 0) {
+    return null;
+  }
+  if (direction === "LONG") {
+    return close >= linePrice ? (close - linePrice) / linePrice * 100 : 0;
+  }
+  return close <= linePrice ? (linePrice - close) / linePrice * 100 : 0;
+};
+var getRejectionBar = ({
+  direction,
+  lineTouched,
+  closeOnBounceSide,
+  bodyAligned,
+  rejectionWickPct,
+  rejectionStrengthPct
+}) => {
+  if (direction == null) {
+    return false;
+  }
+  return lineTouched && closeOnBounceSide === true && bodyAligned === true && (rejectionWickPct ?? 0) >= MIN_REJECTION_WICK_PCT && (rejectionStrengthPct ?? 0) >= MIN_REJECTION_STRENGTH_PCT;
+};
+var buildReverseTrendlineStructuralContext = (signal) => {
+  const trendLine = getTrendLineFromPayload(signal);
+  const evaluator = buildTrendLineEvaluator(trendLine);
+  const currentPrice = toFiniteNumberOrNull(signal.prices?.currentPrice);
+  const currentCandle = getCurrentCandle(signal);
+  const currentTimestamp = toFiniteNumberOrNull(currentCandle?.timestamp);
+  const currentOpen = toFiniteNumberOrNull(currentCandle?.open);
+  const currentClose = toFiniteNumberOrNull(currentCandle?.close) ?? currentPrice;
+  const currentHigh = toFiniteNumberOrNull(currentCandle?.high);
+  const currentLow = toFiniteNumberOrNull(currentCandle?.low);
+  const signalDirection = signal.direction === "LONG" || signal.direction === "SHORT" ? signal.direction : deriveDirectionFromMode(trendLine?.mode);
+  const currentLinePrice = currentTimestamp != null && evaluator ? evaluator.evaluate(currentTimestamp) : evaluator?.lastPoint.value ?? null;
+  const priceVsLinePct = currentClose != null && currentLinePrice != null && currentLinePrice !== 0 ? (currentClose - currentLinePrice) / currentLinePrice * 100 : null;
+  const priceVsLinePctAbs = priceVsLinePct == null ? null : Math.abs(priceVsLinePct);
+  const priceVsLineSide = priceVsLinePct == null ? null : priceVsLinePct > 0 ? "above" : priceVsLinePct < 0 ? "below" : "at";
+  const nearLine = priceVsLinePctAbs == null ? null : priceVsLinePctAbs <= REVERSE_TRENDLINE_NEAR_LINE_PCT;
+  const lineTouchedNow = getLineTouched({
+    low: currentLow,
+    high: currentHigh,
+    linePrice: currentLinePrice
+  });
+  const closeOnBounceSide = getCloseOnBounceSide({
+    direction: signalDirection,
+    priceVsLinePct
+  });
+  const failedBounceBreak = getFailedBounceBreak({
+    direction: signalDirection,
+    priceVsLinePct
+  });
+  const bodyAligned = getBodyAligned({
+    direction: signalDirection,
+    open: currentOpen,
+    close: currentClose
+  });
+  const rejectionWickPct = getRejectionWickPct({
+    direction: signalDirection,
+    open: currentOpen,
+    close: currentClose,
+    high: currentHigh,
+    low: currentLow
+  });
+  const rejectionStrengthPct = getRejectionStrengthPct({
+    direction: signalDirection,
+    close: currentClose,
+    linePrice: currentLinePrice
+  });
+  const rejectionBarNow = getRejectionBar({
+    direction: signalDirection,
+    lineTouched: lineTouchedNow,
+    closeOnBounceSide,
+    bodyAligned,
+    rejectionWickPct,
+    rejectionStrengthPct
+  });
+  const touchesTotal = toFiniteNumberOrNull(
+    signal.additionalIndicators?.touches
+  );
+  const distance = toFiniteNumberOrNull(signal.additionalIndicators?.distance);
+  const touches = touchesTotal != null ? touchesTotal : Array.isArray(trendLine?.touches) ? trendLine.touches.length : null;
+  const atrPct = getLastFiniteNumber(signal.indicators?.atrPct);
+  const breakVsAtrRatio = rejectionStrengthPct != null && atrPct != null && atrPct > 0 ? rejectionStrengthPct / atrPct : null;
+  const coinMaFast = getLastFiniteNumber(signal.indicators?.maFast);
+  const coinMaSlow = getLastFiniteNumber(signal.indicators?.maSlow);
+  const coinMaBias = getBias(coinMaFast, coinMaSlow);
+  const coinMaSpreadPct = getSpreadPct(coinMaFast, coinMaSlow);
+  const coinBiasAligned = signalDirection == null || coinMaBias == null ? null : signalDirection === "LONG" ? coinMaBias === "bullish" : coinMaBias === "bearish";
+  const btcMaFast = getLastFiniteNumber(signal.indicators?.btcMaFast);
+  const btcMaSlow = getLastFiniteNumber(signal.indicators?.btcMaSlow);
+  const btcMaBias = getBias(btcMaFast, btcMaSlow);
+  const btcMaSpreadPct = getSpreadPct(btcMaFast, btcMaSlow);
+  const btcBiasAligned = signalDirection == null || btcMaBias == null ? null : signalDirection === "LONG" ? btcMaBias === "bullish" : btcMaBias === "bearish";
+  const structuralHardBlockReasons = [];
+  if (failedBounceBreak === true) {
+    structuralHardBlockReasons.push("failed_bounce_break");
+  }
+  return {
+    signalDirection,
+    mode: typeof trendLine?.mode === "string" ? trendLine.mode : null,
+    currentPrice,
+    currentLinePrice,
+    priceVsLinePct,
+    priceVsLinePctAbs,
+    priceVsLineSide,
+    nearLine,
+    lineTouchedNow,
+    closeOnBounceSide,
+    failedBounceBreak,
+    bodyAligned,
+    rejectionWickPct,
+    rejectionStrengthPct,
+    rejectionBarNow,
+    touches,
+    distance,
+    atrPct,
+    breakVsAtrRatio,
+    coinMaFast,
+    coinMaSlow,
+    coinMaBias,
+    coinMaSpreadPct,
+    coinBiasAligned,
+    btcMaFast,
+    btcMaSlow,
+    btcMaBias,
+    btcMaSpreadPct,
+    btcBiasAligned,
+    structuralHardBlockReasons
+  };
+};
+var buildReverseTrendlineTimingContext = ({
+  signal,
+  candles,
+  structuralContext
+}) => {
+  const structural = structuralContext ?? buildReverseTrendlineStructuralContext(signal);
+  const trendLine = getTrendLineFromPayload(signal);
+  const evaluator = buildTrendLineEvaluator(trendLine);
+  const timingCandles = Array.isArray(candles) ? candles.slice(-REVERSE_TRENDLINE_TIMING_WINDOW) : [];
+  const sortedCandles = [...timingCandles].sort(
+    (left, right) => Number(left?.timestamp ?? 0) - Number(right?.timestamp ?? 0)
+  );
+  const recentSamples = evaluator ? sortedCandles.map((candle) => {
+    const timestamp = toFiniteNumberOrNull(candle.timestamp);
+    const open = toFiniteNumberOrNull(candle.open);
+    const close = toFiniteNumberOrNull(candle.close);
+    const high = toFiniteNumberOrNull(candle.high);
+    const low = toFiniteNumberOrNull(candle.low);
+    if (timestamp == null || open == null || close == null || high == null || low == null) {
+      return null;
+    }
+    const linePrice = evaluator.evaluate(timestamp);
+    const priceVsLinePct = linePrice !== 0 ? (close - linePrice) / linePrice * 100 : null;
+    const closeOnBounceSide = getCloseOnBounceSide({
+      direction: structural.signalDirection,
+      priceVsLinePct
+    });
+    const failedBounceBreak = getFailedBounceBreak({
+      direction: structural.signalDirection,
+      priceVsLinePct
+    });
+    const lineTouched = getLineTouched({
+      low,
+      high,
+      linePrice
+    });
+    const bodyAligned = getBodyAligned({
+      direction: structural.signalDirection,
+      open,
+      close
+    });
+    const rejectionWickPct = getRejectionWickPct({
+      direction: structural.signalDirection,
+      open,
+      close,
+      high,
+      low
+    });
+    const rejectionStrengthPct = getRejectionStrengthPct({
+      direction: structural.signalDirection,
+      close,
+      linePrice
+    });
+    const rejectionBar = getRejectionBar({
+      direction: structural.signalDirection,
+      lineTouched,
+      closeOnBounceSide,
+      bodyAligned,
+      rejectionWickPct,
+      rejectionStrengthPct
+    });
+    return {
+      timestamp,
+      priceVsLinePct,
+      lineTouched,
+      closeOnBounceSide,
+      failedBounceBreak,
+      rejectionWickPct,
+      rejectionStrengthPct,
+      rejectionBar
+    };
+  }).filter(Boolean) : [];
+  const currentIndex = recentSamples.length - 1;
+  const lastSample = currentIndex >= 0 ? recentSamples[currentIndex] : null;
+  const prevSample = currentIndex > 0 ? recentSamples[currentIndex - 1] : null;
+  let latestRejectionIndex = null;
+  for (let index = 0; index < recentSamples.length; index += 1) {
+    if (recentSamples[index].rejectionBar === true) {
+      latestRejectionIndex = index;
+    }
+  }
+  const barsSinceRejection = latestRejectionIndex != null ? currentIndex - latestRejectionIndex : null;
+  const rejectionFresh = barsSinceRejection != null && barsSinceRejection >= 0 && barsSinceRejection <= 1;
+  const followThroughReady = latestRejectionIndex != null && latestRejectionIndex === currentIndex - 1 && lastSample?.closeOnBounceSide === true && lastSample.failedBounceBreak !== true && lastSample.lineTouched === false && (lastSample.rejectionStrengthPct ?? 0) >= FOLLOW_THROUGH_STRENGTH_PCT;
+  const staleReaction = latestRejectionIndex != null && barsSinceRejection != null && barsSinceRejection > 1 && lastSample?.failedBounceBreak !== true;
+  let entryTiming = "unknown";
+  if (lastSample?.failedBounceBreak === true) {
+    entryTiming = "stale_reaction";
+  } else if (lastSample?.rejectionBar === true) {
+    entryTiming = "ready_rejection";
+  } else if (followThroughReady) {
+    entryTiming = "ready_follow_through";
+  } else if (lastSample?.lineTouched === true && lastSample.closeOnBounceSide === true && !lastSample.rejectionBar) {
+    entryTiming = "wait_reaction_confirmation";
+  } else if (staleReaction) {
+    entryTiming = "stale_reaction";
+  } else {
+    entryTiming = "wait_touch";
+  }
+  return {
+    rejectionDetected: latestRejectionIndex != null,
+    barsSinceRejection,
+    rejectionFresh,
+    followThroughReady,
+    staleReaction,
+    entryTiming,
+    entryReadyNow: entryTiming === "ready_rejection" || entryTiming === "ready_follow_through",
+    currentRejectionStrengthPct: lastSample?.rejectionStrengthPct ?? null,
+    previousRejectionStrengthPct: prevSample?.rejectionStrengthPct ?? null
+  };
+};
+
+// src/ReverseTrendLine/adapters/ai.ts
+var REVERSE_TRENDLINE_CONTEXT_PROMPT = `
+ReverseTrendLine addon:
+- This is a trendline bounce strategy, not a breakout strategy.
+- For LONG on a support line (\`trendline.mode="lows"\`), you need a touch or false break of the line followed by a close back above it.
+- For SHORT on a resistance line (\`trendline.mode="highs"\`), you need a touch or false break of the line followed by a close back below it.
+- If price has already broken through the line with conviction in the opposite direction, this is not a bounce setup: use \`direction=null\` and \`quality <= 2\`.
+- For bounce setups, prioritize candle reaction at the line, rejection wick quality, a close on the correct side, and next-bar follow-through.
+- If \`payload.additionalIndicators.reverseTrendlineContext.failedBounceBreak=true\`, do not treat the signal as structurally confirmed.
+- If \`payload.additionalIndicators.reverseTrendlineContext.entryTiming\` is not \`ready_rejection\` or \`ready_follow_through\`, quality is usually \`<= 3\`.
+- Baseline deterministic approval for same-bar rejection is intentionally strict:
+  - a strong conflict-only rejection may qualify for \`quality=4\`;
+  - some same-bar rejections with \`conflictState=none\` or \`both\` may reach \`quality=4\` only with a very strong deterministic rejection score.
+- For SHORT bounce setups with \`btc_bias_conflict\`, do not overstate quality; those cases usually stay in watch mode unless the structural confirmation is much stronger.
+- If \`deterministicRejectionScore\` is low or medium, do not assign \`quality=4\` just because the candle visually resembles a rejection.
+`;
+var REVERSE_TRENDLINE_PAYLOAD_PROMPT = `
+- \`payload.figures.trendline\` contains the line geometry.
+- \`payload.additionalIndicators.reverseTrendlineContext\` contains a compact bounce summary: direction, price distance to the line, whether the line was touched, whether there was a rejection candle, rejection strength, timing stage, bias conflicts, and \`deterministicRejectionScore\`.
+`;
+var getReverseTrendlineBiasConflictState = (context) => {
+  const coinConflict = context.coinBiasAligned === false;
+  const btcConflict = context.btcBiasAligned === false;
+  if (coinConflict && btcConflict) {
+    return "both";
+  }
+  if (coinConflict) {
+    return "coin_only";
+  }
+  if (btcConflict) {
+    return "btc_only";
+  }
+  if (context.coinBiasAligned === true && context.btcBiasAligned === true) {
+    return "none";
+  }
+  return "unknown";
+};
+var getDeterministicReverseTrendlineQuality = (context) => {
+  if (context.hardBlockReasons.length > 0) {
+    return 2;
+  }
+  if (context.entryTiming !== "ready_rejection" && context.entryTiming !== "ready_follow_through") {
+    return 3;
+  }
+  const rejectionStrengthPct = context.rejectionStrengthPct ?? 0;
+  const rejectionWickPct = context.rejectionWickPct ?? 0;
+  const touches = context.touches ?? 0;
+  const distance = context.distance ?? Number.POSITIVE_INFINITY;
+  const biasConflictState = getReverseTrendlineBiasConflictState(context);
+  const noConflict = biasConflictState === "none";
+  const conflictOnly = biasConflictState === "coin_only" || biasConflictState === "btc_only";
+  const quality5 = context.entryTiming === "ready_follow_through" && noConflict && rejectionStrengthPct >= 0.25 && rejectionWickPct >= 0.18 && touches >= 4 && distance < 500;
+  if (quality5) {
+    return 5;
+  }
+  const quality4FollowThrough = context.entryTiming === "ready_follow_through" && noConflict && rejectionStrengthPct >= 0.22 && rejectionWickPct >= 0.18 && touches >= 4;
+  if (quality4FollowThrough) {
+    return 4;
+  }
+  const quality4ConflictRejection = context.entryTiming === "ready_rejection" && conflictOnly && rejectionStrengthPct >= 0.45 && touches >= 5 && !(context.signalDirection === "SHORT" && biasConflictState === "coin_only" && distance <= 180 && rejectionWickPct <= 0.45) && !(context.signalDirection === "SHORT" && biasConflictState === "btc_only");
+  if (quality4ConflictRejection) {
+    return 4;
+  }
+  const rejectionScore = getDeterministicReverseTrendlineRejectionScore(context);
+  const quality4EliteShortBtcOnlyRejection = context.entryTiming === "ready_rejection" && context.signalDirection === "SHORT" && biasConflictState === "btc_only" && rejectionScore != null && rejectionScore >= 5 && rejectionWickPct >= 0.6 && touches >= 5 && distance <= 200;
+  if (quality4EliteShortBtcOnlyRejection) {
+    return 4;
+  }
+  const quality4ScoredRejection = context.entryTiming === "ready_rejection" && (biasConflictState === "none" || biasConflictState === "both") && rejectionScore != null && rejectionScore >= 7 && !(context.signalDirection === "SHORT" && biasConflictState === "none" && distance <= 150 && (rejectionWickPct >= 0.7 || rejectionStrengthPct >= 1.3));
+  if (quality4ScoredRejection) {
+    return 4;
+  }
+  const quality4EliteAlignedRejection = context.entryTiming === "ready_rejection" && noConflict && rejectionStrengthPct >= 0.9 && rejectionWickPct >= 0.15 && touches >= 5 && distance <= 250;
+  return quality4EliteAlignedRejection ? 4 : 3;
+};
+var getDeterministicReverseTrendlineRejectionScore = (context) => {
+  if (context.entryTiming !== "ready_rejection") {
+    return null;
+  }
+  const biasConflictState = getReverseTrendlineBiasConflictState(context);
+  const rejectionStrengthPct = context.rejectionStrengthPct ?? 0;
+  const rejectionWickPct = context.rejectionWickPct ?? 0;
+  const touches = context.touches ?? 0;
+  const distance = context.distance ?? Number.POSITIVE_INFINITY;
+  let score = 0;
+  if (rejectionStrengthPct >= 0.25) {
+    score += 1;
+  }
+  if (rejectionStrengthPct >= 0.6) {
+    score += 1;
+  }
+  if (rejectionWickPct >= 0.18) {
+    score += 1;
+  }
+  if (touches >= 4) {
+    score += 1;
+  }
+  if (distance <= 250) {
+    score += 1;
+  }
+  if (context.signalDirection === "LONG") {
+    if (biasConflictState === "both") {
+      score += 1;
+    }
+    if (rejectionWickPct >= 0.75) {
+      score += 1;
+    }
+  }
+  if (context.signalDirection === "SHORT") {
+    if (biasConflictState === "none") {
+      score += 1;
+    }
+    if (distance <= 150) {
+      score += 1;
+    }
+  }
+  return score;
+};
+var buildReverseTrendlineAiContext = (signal) => {
+  const structural = buildReverseTrendlineStructuralContext(signal);
+  const computedTiming = buildReverseTrendlineTimingContext({ signal });
+  const timingFromSignal = typeof signal.additionalIndicators?.reverseTrendlineTiming === "object" && signal.additionalIndicators?.reverseTrendlineTiming && typeof signal.additionalIndicators.reverseTrendlineTiming.entryTiming === "string" ? signal.additionalIndicators.reverseTrendlineTiming : null;
+  const timing = timingFromSignal ? {
+    ...computedTiming,
+    ...timingFromSignal,
+    entryReadyNow: timingFromSignal.entryTiming === "ready_rejection" || timingFromSignal.entryTiming === "ready_follow_through"
+  } : computedTiming;
+  const hardBlockReasons = [...structural.structuralHardBlockReasons];
+  const deterministicRejectionScore = getDeterministicReverseTrendlineRejectionScore({
+    ...structural,
+    ...timing,
+    hardBlockReasons
+  });
+  const deterministicQuality = getDeterministicReverseTrendlineQuality({
+    ...structural,
+    ...timing,
+    hardBlockReasons
+  });
+  return {
+    ...structural,
+    ...timing,
+    deterministicQuality,
+    deterministicRejectionScore,
+    approvalAllowedNow: deterministicQuality >= 4,
+    hardBlockReasons
+  };
+};
+var getReverseTrendlineContextFromPayload = (payload, signal) => {
+  const additional = payload.additionalIndicators;
+  const fromPayload = additional?.reverseTrendlineContext;
+  return fromPayload ?? buildReverseTrendlineAiContext(signal);
+};
+var getHardBlockReasonText = (reason) => {
+  switch (reason) {
+    case "failed_bounce_break":
+      return "price broke through the line against the intended bounce";
+    case "coin_bias_conflict":
+      return "coin bias conflicts with the bounce direction";
+    case "btc_bias_conflict":
+      return "BTC context conflicts with the bounce direction";
+    default:
+      return reason;
+  }
+};
+var reverseTrendLineAiAdapter = {
+  buildPayload: ({ signal, basePayload }) => ({
+    ...basePayload,
+    figures: {
+      ...basePayload.figures,
+      trendline: getTrendLineFromPayload(signal)
+    },
+    additionalIndicators: {
+      ...basePayload.additionalIndicators,
+      reverseTrendlineContext: buildReverseTrendlineAiContext(signal)
+    }
+  }),
+  postProcessAnalysis: ({ signal, payload, analysis }) => {
+    const context = getReverseTrendlineContextFromPayload(payload, signal);
+    const signalDirection = signal.direction === "LONG" || signal.direction === "SHORT" ? signal.direction : null;
+    if (context.approvalAllowedNow === true && signalDirection != null) {
+      return {
+        ...analysis,
+        direction: signalDirection,
+        quality: context.deterministicQuality,
+        needRetest: false,
+        retestPrice: null,
+        takeProfitPrice: analysis.takeProfitPrice ?? signal.prices?.takeProfitPrice ?? null,
+        stopLossPrice: analysis.stopLossPrice ?? signal.prices?.stopLossPrice ?? null
+      };
+    }
+    return {
+      ...analysis,
+      direction: null,
+      quality: context.deterministicQuality,
+      needRetest: true,
+      retestPrice: context.currentLinePrice ?? null,
+      takeProfitPrice: null,
+      stopLossPrice: null,
+      qualityReason: context.hardBlockReasons.length > 0 ? `ReverseTrendLine guardrail: ${context.hardBlockReasons.map(getHardBlockReasonText).join("; ")}.` : "ReverseTrendLine deterministic quality requires either a strong conflict-only rejection or a confirmed aligned follow-through for a bounce.",
+      triggerInvalidation: context.hardBlockReasons.length > 0 ? `Wait for a new bounce setup: ${context.hardBlockReasons.map(getHardBlockReasonText).join("; ")}.` : "Wait for a line touch, a rejection candle, and a close held on the correct side of the line.",
+      comment: context.hardBlockReasons.length > 0 ? `ReverseTrendLine guardrail blocked the entry: ${context.hardBlockReasons.map(getHardBlockReasonText).join("; ")}.` : "ReverseTrendLine keeps the setup in watch mode until the bounce is confirmed."
+    };
+  },
+  buildSystemPromptAddon: () => `${REVERSE_TRENDLINE_CONTEXT_PROMPT}
+${REVERSE_TRENDLINE_PAYLOAD_PROMPT}`,
+  buildHumanPromptAddon: ({ signal, payload }) => {
+    const context = getReverseTrendlineContextFromPayload(payload, signal);
+    return `
+
+Additional ReverseTrendLine context:
+- entryTiming=${context.entryTiming}
+- lineTouchedNow=${context.lineTouchedNow}
+- closeOnBounceSide=${context.closeOnBounceSide}
+- failedBounceBreak=${context.failedBounceBreak}
+- rejectionWickPct=${context.rejectionWickPct?.toFixed?.(3) ?? "n/a"}%
+- rejectionStrengthPct=${context.rejectionStrengthPct?.toFixed?.(3) ?? "n/a"}%
+- touches=${context.touches ?? "n/a"}
+- distance=${context.distance ?? "n/a"}
+- coinBiasAligned=${context.coinBiasAligned}
+- btcBiasAligned=${context.btcBiasAligned}
+- deterministicRejectionScore=${context.deterministicRejectionScore ?? "n/a"}
+- approvalAllowedNow=${context.approvalAllowedNow}
+- hardBlockReasons=${context.hardBlockReasons.join(", ") || "none"}
+
+Interpretation rules for ReverseTrendLine:
+- look for structural confirmation of a reaction from the line, not a breakout through the line;
+- if \`failedBounceBreak=true\` is already present, do not treat the signal as confirmed;
+- if the setup is still in \`wait_touch\`, \`wait_reaction_confirmation\`, or \`stale_reaction\`, do not overstate quality;
+- if \`deterministicRejectionScore\` is high, use it only as an extra signal together with the proper bounce context, not as a replacement for structure.
+`;
+  },
+  mapEntryRuntimeFromConfig: (config2) => mapAiRuntimeFromConfig(
+    config2
+  )
+};
+
+// src/ReverseTrendLine/manifest.ts
+var reverseTrendLineManifest = {
+  name: "ReverseTrendLine",
+  aiAdapter: reverseTrendLineAiAdapter
+};
+
+// src/ReverseTrendLine/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",
+  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,
+  TRENDLINE: {
+    minTouches: 4,
+    offset: 3,
+    epsilon: 3e-3,
+    epsilonOffset: 4e-3
+  },
+  HIGHS: {
+    enable: true,
+    direction: "SHORT",
+    TP: 3.2,
+    SL: 1.1,
+    minRiskRatio: 1.6
+  },
+  LOWS: {
+    enable: true,
+    direction: "LONG",
+    TP: 3.2,
+    SL: 1.1,
+    minRiskRatio: 1.6
+  }
+};
+
+export {
+  toFiniteNumberOrNull,
+  buildReverseTrendlineStructuralContext,
+  buildReverseTrendlineTimingContext,
+  reverseTrendLineAiAdapter,
+  reverseTrendLineManifest,
+  config
+};