@tradejs/strategies 1.0.5 → 1.0.8

package/dist/chunk-TDUTYEGH.mjs

@@ -0,0 +1,797 @@
+// src/TrendLine/adapters/ai.ts
+import { mapAiRuntimeFromConfig } from "@tradejs/core/strategies";
+
+// src/TrendLine/guardrails.ts
+var TRENDLINE_CLEAR_BREAK_PCT = 0.35;
+var TRENDLINE_TIMING_WINDOW = 6;
+var WEAK_CLEAN_BREAK_ATR_RATIO_MAX = 0.45;
+var COMPRESSED_CLEAN_BREAK_ATR_RATIO_MAX = 0.6;
+var COMPRESSED_CLEAN_BREAK_DISTANCE_MAX = 120;
+var COMPRESSED_CLEAN_BREAK_TOUCHES_MIN = 5;
+var WEAK_LONG_FAR_BREAK_ATR_RATIO_MAX = 0.6;
+var WEAK_LONG_FAR_BREAK_DISTANCE_MIN = 1e3;
+var WEAK_LONG_FAR_BREAK_BTC_SPREAD_MAX = 0.35;
+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 getFiniteTailNumbers = (value, count) => {
+  if (!Array.isArray(value) || count <= 0) {
+    return [];
+  }
+  const tail = value.slice(-count);
+  return tail.map((item) => toFiniteNumberOrNull(item));
+};
+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 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 getBreakoutSide = ({
+  direction,
+  priceVsLinePct
+}) => {
+  if (direction == null || priceVsLinePct == null) {
+    return null;
+  }
+  return direction === "SHORT" ? priceVsLinePct < 0 : priceVsLinePct > 0;
+};
+var getClearBreakAtPct = ({
+  direction,
+  priceVsLinePct
+}) => {
+  if (direction == null || priceVsLinePct == null) {
+    return null;
+  }
+  return direction === "SHORT" ? priceVsLinePct <= -TRENDLINE_CLEAR_BREAK_PCT : priceVsLinePct >= TRENDLINE_CLEAR_BREAK_PCT;
+};
+var getLineSlopeDirection = (value) => {
+  if (value == null) {
+    return null;
+  }
+  if (value > 0) {
+    return "rising";
+  }
+  if (value < 0) {
+    return "falling";
+  }
+  return "flat";
+};
+var buildTrendlineStructuralContext = (signal) => {
+  const trendLine = getTrendLineFromPayload(signal);
+  const currentPrice = toFiniteNumberOrNull(signal.prices?.currentPrice);
+  const signalDirection = signal.direction === "LONG" || signal.direction === "SHORT" ? signal.direction : null;
+  const points = Array.isArray(trendLine?.points) ? trendLine.points : [];
+  const latestPoint = points.length ? points[points.length - 1] : null;
+  const currentLinePrice = toFiniteNumberOrNull(
+    latestPoint && typeof latestPoint === "object" ? latestPoint.value : null
+  );
+  const priceVsLinePct = currentPrice != null && currentLinePrice != null && currentLinePrice !== 0 ? (currentPrice - currentLinePrice) / currentLinePrice * 100 : null;
+  const priceVsLineSide = priceVsLinePct == null ? null : priceVsLinePct > 0 ? "above" : priceVsLinePct < 0 ? "below" : "at";
+  const priceVsLinePctAbs = priceVsLinePct == null ? null : Math.abs(priceVsLinePct);
+  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 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 === "SHORT" ? btcMaBias === "bearish" : btcMaBias === "bullish";
+  const clearBreak = getClearBreakAtPct({
+    direction: signalDirection,
+    priceVsLinePct
+  });
+  const nearLineNoise = priceVsLinePctAbs == null ? null : priceVsLinePctAbs < TRENDLINE_CLEAR_BREAK_PCT;
+  const breakVsAtrRatio = priceVsLinePctAbs != null && atrPct != null && atrPct > 0 ? priceVsLinePctAbs / atrPct : null;
+  const weakCleanBreak = clearBreak === true && nearLineNoise === false && breakVsAtrRatio != null && breakVsAtrRatio < WEAK_CLEAN_BREAK_ATR_RATIO_MAX;
+  const compressedCleanBreak = clearBreak === true && nearLineNoise === false && breakVsAtrRatio != null && breakVsAtrRatio < COMPRESSED_CLEAN_BREAK_ATR_RATIO_MAX && (touches ?? 0) >= COMPRESSED_CLEAN_BREAK_TOUCHES_MIN && distance != null && distance < COMPRESSED_CLEAN_BREAK_DISTANCE_MAX;
+  const weakLongFarBreak = signalDirection === "LONG" && trendLine?.mode === "highs" && clearBreak === true && nearLineNoise === false && breakVsAtrRatio != null && breakVsAtrRatio < WEAK_LONG_FAR_BREAK_ATR_RATIO_MAX && distance != null && distance > WEAK_LONG_FAR_BREAK_DISTANCE_MIN && btcBiasAligned === true && btcMaSpreadPct != null && btcMaSpreadPct < WEAK_LONG_FAR_BREAK_BTC_SPREAD_MAX;
+  const structuralHardBlockReasons = [];
+  if (clearBreak === false) {
+    structuralHardBlockReasons.push("no_clear_break");
+  }
+  if (nearLineNoise === true) {
+    structuralHardBlockReasons.push("near_line_noise");
+  }
+  if (weakCleanBreak) {
+    structuralHardBlockReasons.push("weak_clean_break");
+  }
+  if (compressedCleanBreak) {
+    structuralHardBlockReasons.push("compressed_clean_break");
+  }
+  if (weakLongFarBreak) {
+    structuralHardBlockReasons.push("weak_long_far_break");
+  }
+  return {
+    signalDirection,
+    mode: typeof trendLine?.mode === "string" ? trendLine.mode : null,
+    touches,
+    distance,
+    currentLinePrice,
+    currentPrice,
+    priceVsLinePct,
+    priceVsLineSide,
+    priceVsLinePctAbs,
+    clearBreak,
+    nearLineNoise,
+    atrPct,
+    breakVsAtrRatio,
+    btcMaFast,
+    btcMaSlow,
+    btcMaBias,
+    btcMaSpreadPct,
+    btcBiasAligned,
+    weakCleanBreak,
+    compressedCleanBreak,
+    weakLongFarBreak,
+    structuralHardBlockReasons
+  };
+};
+var buildTrendlineTimingContext = ({
+  signal,
+  candles,
+  structuralContext
+}) => {
+  const structural = structuralContext ?? buildTrendlineStructuralContext(signal);
+  const trendLine = getTrendLineFromPayload(signal);
+  const evaluator = buildTrendLineEvaluator(trendLine);
+  const timingCandles = Array.isArray(candles) ? candles.slice(-TRENDLINE_TIMING_WINDOW) : [];
+  const sortedCandles = [...timingCandles].sort(
+    (left, right) => Number(left?.timestamp ?? 0) - Number(right?.timestamp ?? 0)
+  );
+  const atrTail = getFiniteTailNumbers(
+    signal.indicators?.atrPct,
+    sortedCandles.length
+  );
+  const atrValues = Array.from({ length: sortedCandles.length }, (_, index) => {
+    const offset = index - (sortedCandles.length - atrTail.length);
+    return offset >= 0 ? atrTail[offset] : null;
+  });
+  const recentSamples = evaluator ? sortedCandles.map((candle, index) => {
+    const timestamp = toFiniteNumberOrNull(candle.timestamp);
+    const close = toFiniteNumberOrNull(candle.close);
+    const high = toFiniteNumberOrNull(candle.high);
+    const low = toFiniteNumberOrNull(candle.low);
+    if (timestamp == null || close == null || high == null || low == null) {
+      return null;
+    }
+    const linePrice = evaluator.evaluate(timestamp);
+    const priceVsLinePct = linePrice !== 0 ? (close - linePrice) / linePrice * 100 : null;
+    const priceVsLinePctAbs = priceVsLinePct == null ? null : Math.abs(priceVsLinePct);
+    const breakoutSideClose = getBreakoutSide({
+      direction: structural.signalDirection,
+      priceVsLinePct
+    });
+    const clearBreakClose = getClearBreakAtPct({
+      direction: structural.signalDirection,
+      priceVsLinePct
+    });
+    const nearLineClose = priceVsLinePctAbs == null ? null : priceVsLinePctAbs < TRENDLINE_CLEAR_BREAK_PCT;
+    const lineTouched = low <= linePrice && high >= linePrice;
+    const distanceAtrRatio = priceVsLinePctAbs != null && atrValues[index] != null && atrValues[index] > 0 ? priceVsLinePctAbs / atrValues[index] : null;
+    return {
+      timestamp,
+      linePrice,
+      priceVsLinePct,
+      priceVsLinePctAbs,
+      breakoutSideClose,
+      clearBreakClose,
+      nearLineClose,
+      lineTouched,
+      distanceAtrRatio
+    };
+  }).filter(Boolean) : [];
+  const lastSample = recentSamples.length > 0 ? recentSamples[recentSamples.length - 1] : null;
+  const prevSample = recentSamples.length > 1 ? recentSamples[recentSamples.length - 2] : null;
+  const prevPrevSample = recentSamples.length > 2 ? recentSamples[recentSamples.length - 3] : null;
+  let latestLineCrossIndex = null;
+  let latestClearBreakIndex = null;
+  for (let index = 0; index < recentSamples.length; index += 1) {
+    const sample = recentSamples[index];
+    const prev = index > 0 ? recentSamples[index - 1] : null;
+    if (sample.breakoutSideClose === true && (prev == null || prev.breakoutSideClose !== true)) {
+      latestLineCrossIndex = index;
+    }
+    if (sample.clearBreakClose === true && (prev == null || prev.clearBreakClose !== true)) {
+      latestClearBreakIndex = index;
+    }
+  }
+  let latestRetestIndex = null;
+  if (latestLineCrossIndex != null) {
+    for (let index = latestLineCrossIndex + 1; index < recentSamples.length - 1; index += 1) {
+      const sample = recentSamples[index];
+      if (sample.lineTouched || sample.nearLineClose === true) {
+        latestRetestIndex = index;
+      }
+    }
+  }
+  const currentIndex = recentSamples.length - 1;
+  const barsSinceLineCross = latestLineCrossIndex != null ? currentIndex - latestLineCrossIndex : null;
+  const barsSinceClearBreak = latestClearBreakIndex != null ? currentIndex - latestClearBreakIndex : null;
+  const barsSinceRetest = latestRetestIndex != null ? currentIndex - latestRetestIndex : null;
+  const retestHappened = latestRetestIndex != null;
+  const retestConfirmed = retestHappened === true && barsSinceRetest != null && barsSinceRetest > 0 && lastSample?.clearBreakClose === true;
+  const breakoutFresh = barsSinceLineCross != null && barsSinceLineCross >= 0 && barsSinceLineCross <= 1;
+  const staleBreakout = lastSample?.clearBreakClose === true && barsSinceLineCross != null && barsSinceLineCross > 1 && retestConfirmed !== true;
+  const currentDistanceAtrRatio = lastSample?.distanceAtrRatio ?? null;
+  const previousDistanceAtrRatio = prevSample?.distanceAtrRatio ?? null;
+  const distanceAtrVelocity = currentDistanceAtrRatio != null && previousDistanceAtrRatio != null ? currentDistanceAtrRatio - previousDistanceAtrRatio : null;
+  const distanceAtrAcceleration = currentDistanceAtrRatio != null && previousDistanceAtrRatio != null && prevPrevSample?.distanceAtrRatio != null ? currentDistanceAtrRatio - 2 * previousDistanceAtrRatio + prevPrevSample.distanceAtrRatio : null;
+  const distanceAtrRecent = recentSamples.map((sample) => sample.distanceAtrRatio).filter((value) => value != null);
+  const maxDistanceAtrRatioRecent = distanceAtrRecent.length > 0 ? Math.max(...distanceAtrRecent) : null;
+  const minDistanceAtrRatioRecent = distanceAtrRecent.length > 0 ? Math.min(...distanceAtrRecent) : null;
+  const firstPoint = evaluator?.firstPoint ?? null;
+  const lastPoint = evaluator?.lastPoint ?? null;
+  const intervalMs = sortedCandles.length > 1 ? toFiniteNumberOrNull(
+    sortedCandles[sortedCandles.length - 1].timestamp
+  ) - toFiniteNumberOrNull(
+    sortedCandles[sortedCandles.length - 2].timestamp
+  ) : null;
+  const lineBarsSpan = firstPoint != null && lastPoint != null && intervalMs != null && intervalMs > 0 ? Math.max(
+    1,
+    Math.round((lastPoint.timestamp - firstPoint.timestamp) / intervalMs)
+  ) : null;
+  const lineSlopePct = firstPoint != null && lastPoint != null && firstPoint.value !== 0 ? (lastPoint.value - firstPoint.value) / firstPoint.value * 100 : null;
+  const lineSlopePctPerBar = lineSlopePct != null && lineBarsSpan != null && lineBarsSpan > 0 ? lineSlopePct / lineBarsSpan : null;
+  const lineSlopeDirection = getLineSlopeDirection(lineSlopePctPerBar);
+  const lineSlopeAligned = lineSlopeDirection == null || structural.mode == null ? null : structural.mode === "lows" ? lineSlopeDirection === "rising" : structural.mode === "highs" ? lineSlopeDirection === "falling" : null;
+  let entryTiming = "unknown";
+  if (lastSample?.clearBreakClose === true) {
+    if (retestConfirmed) {
+      entryTiming = "ready_retest";
+    } else if (barsSinceLineCross === 0) {
+      entryTiming = "ready_breakout";
+    } else if (barsSinceLineCross === 1 && (distanceAtrVelocity == null || distanceAtrVelocity >= 0)) {
+      entryTiming = "ready_follow_through";
+    } else if (retestHappened) {
+      entryTiming = "wait_retest_confirmation";
+    } else if (staleBreakout) {
+      entryTiming = "stale_breakout";
+    } else {
+      entryTiming = "wait_retest";
+    }
+  }
+  return {
+    lineCrossDetected: latestLineCrossIndex != null,
+    clearBreakDetected: latestClearBreakIndex != null,
+    barsSinceLineCross,
+    barsSinceClearBreak,
+    barsSinceRetest,
+    breakoutFresh,
+    retestHappened,
+    retestConfirmed,
+    staleBreakout,
+    entryTiming,
+    entryReadyNow: entryTiming === "ready_breakout" || entryTiming === "ready_follow_through" || entryTiming === "ready_retest",
+    lineSlopePct,
+    lineSlopePctPerBar,
+    lineSlopeDirection,
+    lineSlopeAligned,
+    currentDistanceAtrRatio,
+    previousDistanceAtrRatio,
+    distanceAtrVelocity,
+    distanceAtrAcceleration,
+    maxDistanceAtrRatioRecent,
+    minDistanceAtrRatioRecent
+  };
+};
+
+// src/TrendLine/adapters/ai.ts
+var TRENDLINE_CONTEXT_PROMPT = `
+TrendLine addon:
+- This setup is based on breakout or reaction around a trendline. 'payload.figures.trendline' contains the line geometry, and 'payload.additionalIndicators.trendlineContext' contains a compact summary of price location versus the line.
+- For TrendLine, geometry and price structure have higher priority than indicator confirmation.
+- Touches strengthen a line but do not confirm the signal by themselves. Without a confirmed breakout or retest, do not raise quality only because there were many touches.
+- For SHORT on rising support ('trendline.mode="lows"'), you usually need either a clear move below the line or a retest from below with rejection. If price remains above the line or directly on it, use 'direction=null' and usually 'quality <= 2'.
+- For LONG on descending resistance ('trendline.mode="highs"'), the mirror logic applies: you usually need a move above the line or a retest from above. If price remains below the line or directly on it, use 'direction=null' and usually 'quality <= 2'.
+- If 'payload.additionalIndicators.trendlineContext.nearLineNoise=true', do not treat that as a confirmed breakout. Quality is usually '<= 2-3', and a retest or confirmation is still needed.
+- If 'payload.additionalIndicators.trendlineContext.coinBiasAligned=false' or 'btcBiasAligned=false', treat it as a direct conflict with the signal direction. In that case, the signal is usually not confirmed unless the structural edge is exceptional.
+- If 'payload.additionalIndicators.derivativesContext' exists, use it as Coinalyze-based breakout confirmation or conflict: open interest should support the move, funding should not be extremely crowded against the entry quality, and liquidation spikes can indicate flush, squeeze, or exhaustion.
+- If 'derivativesContext.summary.riskFlags' contains 'oi_not_confirming', treat it as a direct sign that open interest does not confirm the breakout yet. Without very strong follow-through, do not elevate the signal to immediate entry.
+- For SHORT during 'off_hours' or session overlap, require cleaner structural follow-through than during normal hours; those windows are noisier and less suitable for immediate approval.
+- If 'payload.additionalIndicators.trendlineContext.clearBreak=false' and price is still near the line, do not describe it as a clean breakout.
+- If 'clearBreak=true' but 'trendlineContext.weakCleanBreak=true', treat it as a formally valid but too-weak breakout: structure has been touched, but displacement margin is still limited. This usually calls for follow-through or retest, not immediate confirmation.
+- If 'clearBreak=true' but 'trendlineContext.compressedCleanBreak=true', treat it as a compressed breakout after a cluster of close touches on a short line. Even with a formal line exit, this still usually calls for follow-through or retest rather than immediate confirmation.
+- If 'clearBreak=true', 'trendlineContext.breakVsAtrRatio < 0.5', and 'trendlineContext.weakBtcLedBreak=true', treat it as a weak BTC-led break without enough coin-specific follow-through. This usually calls for retest or extra confirmation rather than immediate confirmation.
+- For LONG on descending resistance, if the line is very long, the move above it is still modest, and BTC only weakly supports the break, treat it as an early breakout without sufficient follow-through. That usually needs retest or confirmation rather than immediate confirmation.
+- For TrendLine, quality 4-5 is only allowed when all of the following are true at once: 'clearBreak=true', 'nearLineNoise=false', 'coinBiasAligned=true', and 'btcBiasAligned=true'. If any one of these conditions is not met, do not set quality above 3.
+- Rare exception: if 'trendlineContext.aggressivePreBreakPressure=true', this is an aggressive pre-break-pressure setup. In that case 'quality=4' is allowed even without 'clearBreak', but only as early structural confirmation and only when coin/BTC bias is not conflicting.
+- Another rare exception: if 'trendlineContext.strongNearBreakPressure=true', this is a mature line with pressure already building in the signal direction and very strong aligned pressure from both the coin and BTC. In that case 'quality=4' is allowed even when 'nearLineNoise=true', but only as early structural confirmation on strong structure.
+`;
+var TRENDLINE_PAYLOAD_PROMPT = `
+- 'payload.figures.trendline' contains the full trendline geometry without trimming so touches and structure can be evaluated.
+- 'payload.additionalIndicators.trendlineContext' contains 'mode / touches / distance / currentLinePrice / priceVsLinePct / priceVsLineSide / clearBreak / nearLineNoise / coinMaBias / btcMaBias / maxAllowedQuality / approvalAllowedNow / hardBlockReasons'.
+- It also includes 'atrPct / breakVsAtrRatio / coinMaSpreadPct / btcMaSpreadPct / aggressivePreBreakPressure / strongNearBreakPressure / weakCleanBreak / compressedCleanBreak / weakBtcLedBreak / weakLongFarBreak'.
+- If 'payload.additionalIndicators.derivativesContext' exists, it contains Coinalyze-derived open interest, funding, and liquidation fields for the signal moment; do not treat 'stale' or 'missing_derivatives' as confirmation or conflict.
+`;
+var buildTrendlineContext = (signal) => {
+  const marketContext = signal.additionalIndicators && typeof signal.additionalIndicators.marketContext === "object" && signal.additionalIndicators.marketContext && !Array.isArray(signal.additionalIndicators.marketContext) ? signal.additionalIndicators.marketContext : null;
+  const tradingSession = marketContext && typeof marketContext.tradingSession === "object" && marketContext.tradingSession && !Array.isArray(marketContext.tradingSession) ? marketContext.tradingSession : null;
+  const sessionPrimary = typeof tradingSession?.primarySession === "string" ? tradingSession.primarySession : null;
+  const sessionIsOverlap = tradingSession?.isOverlap === true;
+  const derivativesContext = signal.additionalIndicators && typeof signal.additionalIndicators.derivativesContext === "object" && signal.additionalIndicators.derivativesContext && !Array.isArray(signal.additionalIndicators.derivativesContext) ? signal.additionalIndicators.derivativesContext : null;
+  const derivativesSummary = derivativesContext && typeof derivativesContext.summary === "object" && derivativesContext.summary && !Array.isArray(derivativesContext.summary) ? derivativesContext.summary : null;
+  const derivativesRiskFlags = Array.isArray(derivativesSummary?.riskFlags) ? derivativesSummary.riskFlags.filter(
+    (flag) => typeof flag === "string" && flag.length > 0
+  ) : [];
+  const oiNotConfirming = derivativesRiskFlags.includes("oi_not_confirming");
+  const structural = buildTrendlineStructuralContext(signal);
+  const trendLine = getTrendLineFromPayload(signal);
+  const coinMaFast = getLastFiniteNumber(signal.indicators?.maFast);
+  const coinMaSlow = getLastFiniteNumber(signal.indicators?.maSlow);
+  const coinMaBias = getBias(coinMaFast, coinMaSlow);
+  const coinMaSpreadPct = getSpreadPct(coinMaFast, coinMaSlow);
+  const entryTiming = typeof signal.additionalIndicators?.trendlineTiming === "object" && signal.additionalIndicators?.trendlineTiming && typeof signal.additionalIndicators.trendlineTiming.entryTiming === "string" ? signal.additionalIndicators.trendlineTiming.entryTiming : null;
+  const coinBiasAligned = structural.signalDirection == null || coinMaBias == null ? null : structural.signalDirection === "SHORT" ? coinMaBias === "bearish" : coinMaBias === "bullish";
+  const aggressivePreBreakPressure = structural.signalDirection === "SHORT" && trendLine?.mode === "lows" && structural.priceVsLinePct != null && structural.priceVsLinePct > 0 && structural.priceVsLinePct <= 0.15 && (structural.touches ?? 0) >= 5 && structural.distance != null && structural.distance >= 90 && structural.distance <= 120 && coinBiasAligned === true && structural.btcBiasAligned === true && coinMaSpreadPct != null && coinMaSpreadPct <= -1 && structural.btcMaSpreadPct != null && structural.btcMaSpreadPct <= -0.3;
+  const strongNearBreakPressure = structural.signalDirection === "SHORT" && trendLine?.mode === "lows" && structural.clearBreak === false && structural.nearLineNoise === true && structural.priceVsLinePct != null && structural.priceVsLinePct < 0 && structural.breakVsAtrRatio != null && structural.breakVsAtrRatio >= 0.25 && structural.breakVsAtrRatio <= 0.35 && coinBiasAligned === true && structural.btcBiasAligned === true && coinMaSpreadPct != null && coinMaSpreadPct <= -1.5 && structural.btcMaSpreadPct != null && structural.btcMaSpreadPct <= -0.5 && (structural.touches ?? 0) >= 5 && structural.distance != null && structural.distance >= 300;
+  const weakBtcLedBreak = structural.signalDirection === "SHORT" ? structural.clearBreak === true && structural.breakVsAtrRatio != null && structural.breakVsAtrRatio < 0.5 && coinBiasAligned === true && structural.btcBiasAligned === true && coinMaSpreadPct != null && coinMaSpreadPct > -0.6 && structural.btcMaSpreadPct != null && structural.btcMaSpreadPct <= -0.3 : structural.signalDirection === "LONG" ? structural.clearBreak === true && structural.breakVsAtrRatio != null && structural.breakVsAtrRatio < 0.5 && coinBiasAligned === true && structural.btcBiasAligned === true && coinMaSpreadPct != null && coinMaSpreadPct < 0.6 && structural.btcMaSpreadPct != null && structural.btcMaSpreadPct >= 0.3 : false;
+  const hardBlockReasons = [...structural.structuralHardBlockReasons];
+  if (coinBiasAligned === false) {
+    hardBlockReasons.push("coin_bias_conflict");
+  }
+  if (structural.btcBiasAligned === false) {
+    hardBlockReasons.push("btc_bias_conflict");
+  }
+  if (weakBtcLedBreak) {
+    hardBlockReasons.push("weak_btc_led_break");
+  }
+  if (oiNotConfirming && !hardBlockReasons.includes("oi_not_confirming")) {
+    hardBlockReasons.push("oi_not_confirming");
+  }
+  if (structural.signalDirection === "SHORT" && (entryTiming === "ready_follow_through" || entryTiming === "ready_retest") && (sessionPrimary === "off_hours" || sessionIsOverlap) && !hardBlockReasons.includes("short_session_risk")) {
+    hardBlockReasons.push("short_session_risk");
+  }
+  const deterministicQuality = getDeterministicTrendlineQuality({
+    signalDirection: structural.signalDirection,
+    clearBreak: structural.clearBreak,
+    nearLineNoise: structural.nearLineNoise,
+    breakVsAtrRatio: structural.breakVsAtrRatio,
+    priceVsLinePctAbs: structural.priceVsLinePctAbs,
+    touches: structural.touches,
+    distance: structural.distance,
+    btcMaSpreadPct: structural.btcMaSpreadPct,
+    aggressivePreBreakPressure,
+    strongNearBreakPressure,
+    hardBlockReasons,
+    entryTiming,
+    coinMaSpreadPct
+  });
+  const maxAllowedQuality = deterministicQuality;
+  const approvalAllowedNow = deterministicQuality >= 4;
+  return {
+    ...structural,
+    entryTiming,
+    coinMaFast,
+    coinMaSlow,
+    coinMaBias,
+    coinMaSpreadPct,
+    coinBiasAligned,
+    aggressivePreBreakPressure,
+    strongNearBreakPressure,
+    weakBtcLedBreak,
+    sessionPrimary,
+    sessionIsOverlap,
+    derivativesRiskFlags,
+    oiNotConfirming,
+    deterministicQuality,
+    maxAllowedQuality,
+    approvalAllowedNow,
+    hardBlockReasons
+  };
+};
+var formatPromptNumber = (value, fractionDigits = 4) => {
+  if (value == null) {
+    return "n/a";
+  }
+  return value.toFixed(fractionDigits);
+};
+var getHardBlockReasonText = (reason) => {
+  switch (reason) {
+    case "no_clear_break":
+      return "there is no clean breakout of the line";
+    case "near_line_noise":
+      return "price is too close to the line and looks like noise";
+    case "coin_bias_conflict":
+      return "coin bias conflicts with the direction";
+    case "btc_bias_conflict":
+      return "BTC context conflicts with the direction";
+    case "weak_clean_break":
+      return "the formal breakout exists, but displacement is still too weak relative to ATR";
+    case "compressed_clean_break":
+      return "the breakout looks too compressed: clustered close touches on a short line without enough follow-through";
+    case "weak_btc_led_break":
+      return "the breakout is too small relative to ATR and looks more like a BTC-led move without enough coin follow-through";
+    case "weak_long_far_break":
+      return "for LONG, the breakout of the very long line is still too modest and BTC support is too weak";
+    case "oi_not_confirming":
+      return "open interest does not confirm the move, so the breakout still looks unconfirmed on derivatives context";
+    case "short_session_risk":
+      return "for SHORT, the current session is too noisy or thin (off-hours or overlap), so clearer follow-through is required";
+    default:
+      return reason;
+  }
+};
+var mergeShortText = (primary, fallback, maxLength) => {
+  const value = primary.trim() || fallback;
+  return value.slice(0, maxLength);
+};
+var getDeterministicTrendlineQuality = (trendlineContext) => {
+  if (trendlineContext.aggressivePreBreakPressure === true || trendlineContext.strongNearBreakPressure === true) {
+    return 4;
+  }
+  if (trendlineContext.hardBlockReasons.length > 0) {
+    return trendlineContext.clearBreak === true ? 3 : 2;
+  }
+  if (trendlineContext.clearBreak !== true || trendlineContext.nearLineNoise !== false || trendlineContext.signalDirection == null) {
+    return 2;
+  }
+  const breakVsAtrRatio = trendlineContext.breakVsAtrRatio ?? 0;
+  const priceVsLinePctAbs = trendlineContext.priceVsLinePctAbs ?? 0;
+  const touches = trendlineContext.touches ?? 0;
+  const distance = trendlineContext.distance ?? Number.POSITIVE_INFINITY;
+  const btcMaSpreadPct = trendlineContext.btcMaSpreadPct ?? 0;
+  const coinMaSpreadPct = trendlineContext.coinMaSpreadPct ?? 0;
+  const entryTiming = trendlineContext.entryTiming;
+  if (trendlineContext.signalDirection === "LONG") {
+    const quality52 = breakVsAtrRatio >= 1.1 && priceVsLinePctAbs >= 1 && touches >= 5 && distance < 250 && btcMaSpreadPct >= 0.5;
+    if (quality52) {
+      return 5;
+    }
+    const compactBreakoutQuality4 = breakVsAtrRatio >= 0.75 && priceVsLinePctAbs >= 0.7 && distance < 150 && (btcMaSpreadPct >= 0.4 || breakVsAtrRatio >= 1) && (touches >= 5 || breakVsAtrRatio >= 0.85);
+    const shortLineStrengthQuality4 = breakVsAtrRatio >= 0.6 && priceVsLinePctAbs >= 0.65 && touches >= 6 && distance < 120 && btcMaSpreadPct >= 0.75;
+    const matureLineQuality4 = breakVsAtrRatio >= 0.8 && priceVsLinePctAbs >= 0.7 && touches >= 5 && distance < 350 && btcMaSpreadPct >= 0.4;
+    const extendedHighConvictionQuality4 = breakVsAtrRatio >= 0.75 && priceVsLinePctAbs >= 0.65 && touches >= 5 && distance < 600 && btcMaSpreadPct >= 0.9;
+    const alignedRecentFollowThroughQuality4 = (entryTiming === "ready_follow_through" || entryTiming === "ready_retest") && breakVsAtrRatio >= 0.58 && breakVsAtrRatio <= 0.72 && priceVsLinePctAbs >= 0.48 && priceVsLinePctAbs <= 0.7 && touches >= 5 && distance <= 420 && btcMaSpreadPct >= 0.45 && coinMaSpreadPct >= 0.25;
+    return compactBreakoutQuality4 || shortLineStrengthQuality4 || matureLineQuality4 || extendedHighConvictionQuality4 || alignedRecentFollowThroughQuality4 ? 4 : 3;
+  }
+  const quality5 = breakVsAtrRatio >= 5 && priceVsLinePctAbs >= 10 && touches >= 5 && distance >= 240 && distance <= 400 && btcMaSpreadPct <= -1;
+  if (quality5) {
+    return 5;
+  }
+  const quality4 = breakVsAtrRatio >= 1 && breakVsAtrRatio < 2.5 && priceVsLinePctAbs >= 1 && touches >= 5 && distance < 300 && btcMaSpreadPct <= -0.5;
+  const strongReadyBreakoutQuality4 = entryTiming === "ready_breakout" && breakVsAtrRatio >= 2 && priceVsLinePctAbs >= 1.8 && touches >= 5 && btcMaSpreadPct <= -1 && (coinMaSpreadPct <= -1 || breakVsAtrRatio >= 3);
+  const moderateReadyBreakoutQuality4 = entryTiming === "ready_breakout" && breakVsAtrRatio >= 0.65 && breakVsAtrRatio <= 1.2 && priceVsLinePctAbs >= 0.65 && priceVsLinePctAbs <= 1 && touches >= 5 && distance >= 150 && distance <= 320 && btcMaSpreadPct <= -0.05 && coinMaSpreadPct <= -0.25;
+  if ((quality4 || moderateReadyBreakoutQuality4) && entryTiming === "ready_breakout") {
+    return 4;
+  }
+  return strongReadyBreakoutQuality4 ? 4 : 3;
+};
+var getDeterministicTrendlineQualityReason = (trendlineContext) => {
+  if (trendlineContext.hardBlockReasons.length > 0) {
+    return `TrendLine guardrail: entry is blocked because ${trendlineContext.hardBlockReasons.map(getHardBlockReasonText).join("; ")}.`;
+  }
+  if (trendlineContext.signalDirection === "LONG") {
+    return "TrendLine deterministic quality: the breakout exists, but LONG still lacks enough displacement, BTC support, or a compact enough line for immediate entry.";
+  }
+  if (trendlineContext.signalDirection === "SHORT") {
+    return "TrendLine deterministic quality: the breakout exists, but SHORT still lacks enough bearish displacement or follow-through, so entry is still too early.";
+  }
+  return "TrendLine deterministic quality: the structure is still not strong enough for entry right now.";
+};
+var getTrendlineContextFromPayload = (payload, signal) => {
+  const additional = payload.additionalIndicators;
+  const fromPayload = additional?.trendlineContext;
+  return fromPayload ?? buildTrendlineContext(signal);
+};
+var trendLineAiAdapter = {
+  // Shared builder trims nested series/figures; TrendLine keeps trendline geometry untrimmed on purpose.
+  buildPayload: ({ signal, basePayload }) => {
+    const mergedAdditionalIndicators = {
+      ...signal.additionalIndicators ?? {},
+      ...basePayload.additionalIndicators ?? {}
+    };
+    const trendlineContext = buildTrendlineContext({
+      ...signal,
+      additionalIndicators: mergedAdditionalIndicators
+    });
+    return {
+      ...basePayload,
+      figures: {
+        ...basePayload.figures,
+        // Keep raw line geometry available exactly where the shared prompt expects it.
+        trendline: getTrendLineFromPayload(signal)
+      },
+      additionalIndicators: {
+        ...mergedAdditionalIndicators,
+        trendlineContext
+      }
+    };
+  },
+  postProcessAnalysis: ({ signal, payload, analysis }) => {
+    const trendlineContext = getTrendlineContextFromPayload(payload, signal);
+    const quality = trendlineContext.deterministicQuality;
+    const signalDirection = signal.direction === "LONG" || signal.direction === "SHORT" ? signal.direction : null;
+    if ((trendlineContext.aggressivePreBreakPressure === true || trendlineContext.strongNearBreakPressure === true) && signalDirection != null) {
+      const fallbackReason = trendlineContext.strongNearBreakPressure === true ? "TrendLine strong near-break pressure: a mature line is already compressing in the trade direction, so early entry is allowed by strategy code." : "TrendLine aggressive pre-break pressure: early structural confirmation is allowed under strong bearish pressure.";
+      const fallbackComment = trendlineContext.strongNearBreakPressure === true ? "TrendLine strong near-break pressure: early entry is allowed by strategy code." : "TrendLine aggressive pre-break pressure: early entry is allowed by strategy code.";
+      return {
+        ...analysis,
+        direction: signalDirection,
+        quality: 4,
+        needRetest: false,
+        retestPrice: null,
+        takeProfitPrice: analysis.takeProfitPrice ?? signal.prices?.takeProfitPrice ?? null,
+        stopLossPrice: analysis.stopLossPrice ?? signal.prices?.stopLossPrice ?? null,
+        qualityReason: mergeShortText(
+          analysis.qualityReason ?? "",
+          fallbackReason,
+          400
+        ),
+        comment: mergeShortText(analysis.comment ?? "", fallbackComment, 1024)
+      };
+    }
+    if (trendlineContext.approvalAllowedNow === true && signalDirection != null) {
+      return {
+        ...analysis,
+        direction: signalDirection,
+        quality,
+        needRetest: false,
+        retestPrice: null,
+        takeProfitPrice: analysis.takeProfitPrice ?? signal.prices?.takeProfitPrice ?? null,
+        stopLossPrice: analysis.stopLossPrice ?? signal.prices?.stopLossPrice ?? null
+      };
+    }
+    const retestPrice = trendlineContext.currentLinePrice ?? analysis.retestPrice ?? null;
+    const qualityReason = mergeShortText(
+      getDeterministicTrendlineQualityReason(trendlineContext),
+      "TrendLine guardrail: entry is blocked until the structure is confirmed.",
+      400
+    );
+    const triggerInvalidation = mergeShortText(
+      trendlineContext.hardBlockReasons.length > 0 ? `Wait for a clean breakout or retest of the line and resolve the conflicts: ${trendlineContext.hardBlockReasons.map(getHardBlockReasonText).join("; ")}.` : "Wait for stronger breakout follow-through or a line retest confirmed by both the coin and BTC.",
+      "Wait for a clean line breakout or retest plus confirmation from the coin and BTC.",
+      400
+    );
+    const comment = mergeShortText(
+      trendlineContext.hardBlockReasons.length > 0 ? `TrendLine guardrail blocked the entry: ${trendlineContext.hardBlockReasons.map(getHardBlockReasonText).join("; ")}.` : "TrendLine deterministic quality downgraded the entry to watch or reject until stronger structure appears.",
+      "TrendLine guardrail blocked the entry until the structure is confirmed.",
+      1024
+    );
+    return {
+      ...analysis,
+      direction: null,
+      quality,
+      needRetest: true,
+      retestPrice,
+      takeProfitPrice: null,
+      stopLossPrice: null,
+      setup: mergeShortText(
+        analysis.setup ?? "",
+        "There is no confirmed trendline breakout or retest for entry right now.",
+        400
+      ),
+      retestPlan: mergeShortText(
+        analysis.retestPlan ?? "",
+        "Wait for a return to the line and a reaction in the trade direction before a new entry.",
+        400
+      ),
+      qualityReason,
+      triggerInvalidation,
+      comment
+    };
+  },
+  buildSystemPromptAddon: () => `
+${TRENDLINE_CONTEXT_PROMPT}
+${TRENDLINE_PAYLOAD_PROMPT}
+`,
+  buildHumanPromptAddon: ({ payload }) => {
+    const additional = payload.additionalIndicators;
+    const trendlineContext = additional?.trendlineContext;
+    if (!trendlineContext) {
+      return "";
+    }
+    return `
+
+Additional TrendLine context:
+- trendline.mode=${trendlineContext.mode ?? "n/a"}
+- trendline.touches=${formatPromptNumber(trendlineContext.touches, 0)}
+- trendline.distance=${formatPromptNumber(trendlineContext.distance, 0)}
+- trendline.currentLinePrice=${formatPromptNumber(trendlineContext.currentLinePrice, 6)}
+- trendline.currentPrice=${formatPromptNumber(trendlineContext.currentPrice, 6)}
+- trendline.priceVsLinePct=${formatPromptNumber(trendlineContext.priceVsLinePct, 3)}%
+- trendline.priceVsLineSide=${trendlineContext.priceVsLineSide ?? "n/a"}
+- trendline.clearBreak=${String(trendlineContext.clearBreak)}
+- trendline.nearLineNoise=${String(trendlineContext.nearLineNoise)}
+- trendline.atrPct=${formatPromptNumber(trendlineContext.atrPct, 3)}%
+- trendline.breakVsAtrRatio=${formatPromptNumber(trendlineContext.breakVsAtrRatio, 3)}
+- trendline.aggressivePreBreakPressure=${String(trendlineContext.aggressivePreBreakPressure)}
+- trendline.strongNearBreakPressure=${String(trendlineContext.strongNearBreakPressure)}
+- trendline.weakCleanBreak=${String(trendlineContext.weakCleanBreak)}
+- trendline.compressedCleanBreak=${String(trendlineContext.compressedCleanBreak)}
+- trendline.weakBtcLedBreak=${String(trendlineContext.weakBtcLedBreak)}
+- trendline.weakLongFarBreak=${String(trendlineContext.weakLongFarBreak)}
+- trendline.entryTiming=${trendlineContext.entryTiming ?? "n/a"}
+- trendline.deterministicQuality=${String(trendlineContext.deterministicQuality)}
+- trendline.maxAllowedQuality=${String(trendlineContext.maxAllowedQuality)}
+- trendline.approvalAllowedNow=${String(trendlineContext.approvalAllowedNow)}
+- trendline.hardBlockReasons=${JSON.stringify(trendlineContext.hardBlockReasons)}
+- coin.maFastLast=${formatPromptNumber(trendlineContext.coinMaFast, 6)}
+- coin.maSlowLast=${formatPromptNumber(trendlineContext.coinMaSlow, 6)}
+- coin.maBias=${trendlineContext.coinMaBias ?? "n/a"}
+- coin.maSpreadPct=${formatPromptNumber(trendlineContext.coinMaSpreadPct, 3)}%
+- coin.biasAligned=${String(trendlineContext.coinBiasAligned)}
+- btc.maFastLast=${formatPromptNumber(trendlineContext.btcMaFast, 2)}
+- btc.maSlowLast=${formatPromptNumber(trendlineContext.btcMaSlow, 2)}
+- btc.maBias=${trendlineContext.btcMaBias ?? "n/a"}
+- btc.maSpreadPct=${formatPromptNumber(trendlineContext.btcMaSpreadPct, 3)}%
+- btc.biasAligned=${String(trendlineContext.btcBiasAligned)}
+
+Interpretation rules for TrendLine:
+- SHORT from a 'lows' line is confirmed only by a clear move below the line or a retest from below with rejection.
+- LONG from a 'highs' line is confirmed only by a clear move above the line or a retest from above with rejection.
+- If 'trendline.nearLineNoise=true' or any bias alignment is false, it is better to return 'direction=null' and quality 1-3 than to describe the signal as confirmed without margin.
+- If 'trendline.weakCleanBreak=true', the formal breakout exists but is too weak in displacement; it needs follow-through or retest rather than quality 4-5.
+- If 'trendline.compressedCleanBreak=true', the breakout exists formally, but the line is too short and compressed after clustered touches; this usually needs follow-through or retest rather than immediate confirmation.
+- If 'trendline.weakBtcLedBreak=true', treat it as a small breakout driven more by BTC than by the coin itself; this usually calls for retest and quality 1-3.
+- If 'clearBreak=false' or any alignment is false, do not raise quality above 3.
+- If 'trendline.aggressivePreBreakPressure=true', an early SHORT before a clear breakout may be considered only as an exception: quality can be at most 4, and the explanation must clearly state that the structural confirmation is still aggressive.
+- If 'trendline.strongNearBreakPressure=true', an early SHORT may be considered when pressure is already strong on the correct side of the line even if the breakout still falls short of the 'clearBreak' threshold: quality can be at most 4.
+- The strategy deterministically normalizes final quality to 'trendline.deterministicQuality'; your job is to explain the decision within that frame, not to argue with the tier.
+- If 'trendline.approvalAllowedNow=false', do not describe the signal as fully confirmed right now; explain what is still missing for confirmation.
+`;
+  },
+  mapEntryRuntimeFromConfig: (config2) => mapAiRuntimeFromConfig(
+    config2
+  )
+};
+
+// src/TrendLine/adapters/ml.ts
+import { mapMlRuntimeFromConfig } from "@tradejs/core/strategies";
+var toTrendLineMlStrategyConfig = (input) => {
+  if (!input) return void 0;
+  return {
+    ...input,
+    TRENDLINE_CONFIG: input.TRENDLINE_CONFIG ?? input.TRENDLINE ?? {}
+  };
+};
+var trendLineMlAdapter = {
+  normalizeSignal: (signal) => {
+    const nextSignal = {
+      ...signal,
+      indicators: {
+        ...signal.indicators ?? {}
+      }
+    };
+    const additional = signal.additionalIndicators ?? {};
+    if (nextSignal.indicators.touches == null && additional.touches != null) {
+      nextSignal.indicators.touches = additional.touches;
+    }
+    if (nextSignal.indicators.distance == null && additional.distance != null) {
+      nextSignal.indicators.distance = additional.distance;
+    }
+    return nextSignal;
+  },
+  normalizeStrategyConfig: (strategyConfig) => {
+    return toTrendLineMlStrategyConfig(strategyConfig);
+  },
+  mapEntryRuntimeFromConfig: (config2) => mapMlRuntimeFromConfig(config2, {
+    strategyConfig: toTrendLineMlStrategyConfig(
+      config2
+    )
+  })
+};
+
+// src/TrendLine/manifest.ts
+var trendLineManifest = {
+  name: "TrendLine",
+  aiAdapter: trendLineAiAdapter,
+  mlAdapter: trendLineMlAdapter
+};
+
+// src/TrendLine/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,
+  TRENDLINE: {
+    minTouches: 4,
+    offset: 3,
+    epsilon: 3e-3,
+    epsilonOffset: 4e-3
+  },
+  HIGHS: {
+    enable: true,
+    direction: "LONG",
+    TP: 4,
+    SL: 1.3,
+    minRiskRatio: 2
+  },
+  LOWS: {
+    enable: true,
+    direction: "SHORT",
+    TP: 4,
+    SL: 1.3,
+    minRiskRatio: 2
+  }
+};
+
+export {
+  buildTrendlineStructuralContext,
+  buildTrendlineTimingContext,
+  trendLineManifest,
+  config
+};