@tradejs/cli 2.0.1 → 2.0.3

package/dist/lib/aiPocketSearch.js

@@ -327,6 +327,23 @@ var addDirectionalDerivedFeatures = (features) => {
   }
   features["derived.directIndicatorSupportCount"] = supportCount;
 };
+var addSignalRiskDistanceFeatures = ({
+  features,
+  signal
+}) => {
+  const currentPrice = isFiniteNumber(signal.prices?.currentPrice) ? signal.prices.currentPrice : null;
+  const stopLossPrice = isFiniteNumber(signal.prices?.stopLossPrice) ? signal.prices.stopLossPrice : null;
+  const takeProfitPrice = isFiniteNumber(signal.prices?.takeProfitPrice) ? signal.prices.takeProfitPrice : null;
+  if (currentPrice == null || currentPrice === 0) {
+    return;
+  }
+  if (stopLossPrice != null) {
+    features["derived.stopDistanceBps"] = Math.abs(currentPrice - stopLossPrice) / Math.abs(currentPrice) * 1e4;
+  }
+  if (takeProfitPrice != null) {
+    features["derived.takeProfitDistanceBps"] = Math.abs(takeProfitPrice - currentPrice) / Math.abs(currentPrice) * 1e4;
+  }
+};
 var collectAiPocketFeatures = ({
   payload,
   gateContext,
@@ -354,6 +371,7 @@ var collectAiPocketFeatures = ({
     maxDepth: 8,
     shouldSkipPath: featureProfile === "compact" ? isCompactFeaturePathSkipped : void 0
   });
+  addSignalRiskDistanceFeatures({ features, signal });
   addDirectionalDerivedFeatures(features);
   return features;
 };

package/dist/lib/aiTrainCharts.js

@@ -34,6 +34,7 @@ var divideOrNull = (num, denom) => {
 var DAY_MS = 24 * 60 * 60 * 1e3;
 var DAYS_PER_WEEK = 7;
 var DAYS_PER_MONTH = 30.4375;
+var DAYS_PER_YEAR = 365;
 var getEvaluationPeriodDays = (evaluations) => {
   let minTimestamp = null;
   let maxTimestamp = null;
@@ -55,6 +56,40 @@ var getEvaluationPeriodDays = (evaluations) => {
   return Math.max((maxTimestamp - minTimestamp) / DAY_MS, 1);
 };
 var qualitySortKey = (quality) => quality == null ? Number.POSITIVE_INFINITY : quality;
+var calculateTradePnlRiskRatios = ({
+  profits,
+  totalProfit,
+  maxDrawdown,
+  periodDays
+}) => {
+  if (!profits.length || periodDays == null || periodDays <= 0) {
+    return {
+      sharpeRatio: null,
+      sortinoRatio: null,
+      calmarRatio: null
+    };
+  }
+  const meanProfit = totalProfit / profits.length;
+  const variance = profits.reduce((sum, profit) => {
+    const diff = profit - meanProfit;
+    return sum + diff * diff;
+  }, 0) / profits.length;
+  const stdDev = Math.sqrt(variance);
+  const downsideDeviation = Math.sqrt(
+    profits.reduce(
+      (sum, profit) => profit < 0 ? sum + profit * profit : sum,
+      0
+    ) / profits.length
+  );
+  const annualizationScale = Math.sqrt(
+    profits.length / periodDays * DAYS_PER_YEAR
+  );
+  return {
+    sharpeRatio: stdDev > 0 && annualizationScale > 0 ? meanProfit / stdDev * annualizationScale : null,
+    sortinoRatio: downsideDeviation > 0 && annualizationScale > 0 ? meanProfit / downsideDeviation * annualizationScale : null,
+    calmarRatio: maxDrawdown > 0 ? totalProfit / periodDays * DAYS_PER_YEAR / maxDrawdown : null
+  };
+};
 var emptyRiskSummary = () => ({
   trades: 0,
   totalProfit: 0,
@@ -70,12 +105,15 @@ var emptyRiskSummary = () => ({
   maxDrawdown: 0,
   maxDrawdownPctOfGrossProfit: null,
   maxDrawdownPctOfTotalProfit: null,
+  sharpeRatio: null,
+  sortinoRatio: null,
+  calmarRatio: null,
   recoveryFactor: null,
   ulcerIndex: null,
   maxConsecutiveWins: 0,
   maxConsecutiveLosses: 0
 });
-var summarizeApprovedRisk = (evaluations) => {
+var summarizeApprovedRisk = (evaluations, periodDays = getEvaluationPeriodDays(evaluations)) => {
   const approvedEvaluations = evaluations.filter((evaluation) => evaluation.aiApproved).sort((left, right) => {
     const leftTimestamp = typeof left.timestamp === "number" && Number.isFinite(left.timestamp) ? left.timestamp : Number.POSITIVE_INFINITY;
     const rightTimestamp = typeof right.timestamp === "number" && Number.isFinite(right.timestamp) ? right.timestamp : Number.POSITIVE_INFINITY;
@@ -98,8 +136,10 @@ var summarizeApprovedRisk = (evaluations) => {
   let currentLossStreak = 0;
   let maxConsecutiveWins = 0;
   let maxConsecutiveLosses = 0;
+  const approvedProfits = [];
   for (const evaluation of approvedEvaluations) {
     const profit = evaluation.profit;
+    approvedProfits.push(profit);
     if (profit > 0) {
       grossProfit += profit;
       wins += 1;
@@ -127,6 +167,12 @@ var summarizeApprovedRisk = (evaluations) => {
   const totalProfit = grossProfit - grossLoss;
   const avgWin = divideOrNull(grossProfit, wins);
   const avgLoss = divideOrNull(grossLoss, losses);
+  const riskRatios = calculateTradePnlRiskRatios({
+    profits: approvedProfits,
+    totalProfit,
+    maxDrawdown,
+    periodDays
+  });
   return {
     trades: approvedEvaluations.length,
     totalProfit,
@@ -142,6 +188,7 @@ var summarizeApprovedRisk = (evaluations) => {
     maxDrawdown,
     maxDrawdownPctOfGrossProfit: grossProfit > 0 ? maxDrawdown / grossProfit : null,
     maxDrawdownPctOfTotalProfit: totalProfit > 0 ? maxDrawdown / totalProfit : null,
+    ...riskRatios,
     recoveryFactor: maxDrawdown > 0 ? totalProfit / maxDrawdown : null,
     ulcerIndex: Math.sqrt(drawdownSquares / approvedEvaluations.length),
     maxConsecutiveWins,
@@ -240,7 +287,7 @@ var summarizeAiTrainEvaluations = (evaluations) => {
     avgApprovedTradesPerDay,
     avgApprovedTradesPerWeek,
     expectancyDelta,
-    approvedRisk: summarizeApprovedRisk(evaluations),
+    approvedRisk: summarizeApprovedRisk(evaluations, periodDays),
     qualityBuckets: [...bucketMap.values()].sort(
       (a, b) => qualitySortKey(a.quality) - qualitySortKey(b.quality)
     )

package/dist/lib/aiTrainMetrics.js

@@ -35,6 +35,7 @@ var divideOrNull = (num, denom) => {
 var DAY_MS = 24 * 60 * 60 * 1e3;
 var DAYS_PER_WEEK = 7;
 var DAYS_PER_MONTH = 30.4375;
+var DAYS_PER_YEAR = 365;
 var getEvaluationPeriodDays = (evaluations) => {
   let minTimestamp = null;
   let maxTimestamp = null;
@@ -56,6 +57,40 @@ var getEvaluationPeriodDays = (evaluations) => {
   return Math.max((maxTimestamp - minTimestamp) / DAY_MS, 1);
 };
 var qualitySortKey = (quality) => quality == null ? Number.POSITIVE_INFINITY : quality;
+var calculateTradePnlRiskRatios = ({
+  profits,
+  totalProfit,
+  maxDrawdown,
+  periodDays
+}) => {
+  if (!profits.length || periodDays == null || periodDays <= 0) {
+    return {
+      sharpeRatio: null,
+      sortinoRatio: null,
+      calmarRatio: null
+    };
+  }
+  const meanProfit = totalProfit / profits.length;
+  const variance = profits.reduce((sum, profit) => {
+    const diff = profit - meanProfit;
+    return sum + diff * diff;
+  }, 0) / profits.length;
+  const stdDev = Math.sqrt(variance);
+  const downsideDeviation = Math.sqrt(
+    profits.reduce(
+      (sum, profit) => profit < 0 ? sum + profit * profit : sum,
+      0
+    ) / profits.length
+  );
+  const annualizationScale = Math.sqrt(
+    profits.length / periodDays * DAYS_PER_YEAR
+  );
+  return {
+    sharpeRatio: stdDev > 0 && annualizationScale > 0 ? meanProfit / stdDev * annualizationScale : null,
+    sortinoRatio: downsideDeviation > 0 && annualizationScale > 0 ? meanProfit / downsideDeviation * annualizationScale : null,
+    calmarRatio: maxDrawdown > 0 ? totalProfit / periodDays * DAYS_PER_YEAR / maxDrawdown : null
+  };
+};
 var emptyRiskSummary = () => ({
   trades: 0,
   totalProfit: 0,
@@ -71,12 +106,15 @@ var emptyRiskSummary = () => ({
   maxDrawdown: 0,
   maxDrawdownPctOfGrossProfit: null,
   maxDrawdownPctOfTotalProfit: null,
+  sharpeRatio: null,
+  sortinoRatio: null,
+  calmarRatio: null,
   recoveryFactor: null,
   ulcerIndex: null,
   maxConsecutiveWins: 0,
   maxConsecutiveLosses: 0
 });
-var summarizeApprovedRisk = (evaluations) => {
+var summarizeApprovedRisk = (evaluations, periodDays = getEvaluationPeriodDays(evaluations)) => {
   const approvedEvaluations = evaluations.filter((evaluation) => evaluation.aiApproved).sort((left, right) => {
     const leftTimestamp = typeof left.timestamp === "number" && Number.isFinite(left.timestamp) ? left.timestamp : Number.POSITIVE_INFINITY;
     const rightTimestamp = typeof right.timestamp === "number" && Number.isFinite(right.timestamp) ? right.timestamp : Number.POSITIVE_INFINITY;
@@ -99,8 +137,10 @@ var summarizeApprovedRisk = (evaluations) => {
   let currentLossStreak = 0;
   let maxConsecutiveWins = 0;
   let maxConsecutiveLosses = 0;
+  const approvedProfits = [];
   for (const evaluation of approvedEvaluations) {
     const profit = evaluation.profit;
+    approvedProfits.push(profit);
     if (profit > 0) {
       grossProfit += profit;
       wins += 1;
@@ -128,6 +168,12 @@ var summarizeApprovedRisk = (evaluations) => {
   const totalProfit = grossProfit - grossLoss;
   const avgWin = divideOrNull(grossProfit, wins);
   const avgLoss = divideOrNull(grossLoss, losses);
+  const riskRatios = calculateTradePnlRiskRatios({
+    profits: approvedProfits,
+    totalProfit,
+    maxDrawdown,
+    periodDays
+  });
   return {
     trades: approvedEvaluations.length,
     totalProfit,
@@ -143,6 +189,7 @@ var summarizeApprovedRisk = (evaluations) => {
     maxDrawdown,
     maxDrawdownPctOfGrossProfit: grossProfit > 0 ? maxDrawdown / grossProfit : null,
     maxDrawdownPctOfTotalProfit: totalProfit > 0 ? maxDrawdown / totalProfit : null,
+    ...riskRatios,
     recoveryFactor: maxDrawdown > 0 ? totalProfit / maxDrawdown : null,
     ulcerIndex: Math.sqrt(drawdownSquares / approvedEvaluations.length),
     maxConsecutiveWins,
@@ -241,7 +288,7 @@ var summarizeAiTrainEvaluations = (evaluations) => {
     avgApprovedTradesPerDay,
     avgApprovedTradesPerWeek,
     expectancyDelta,
-    approvedRisk: summarizeApprovedRisk(evaluations),
+    approvedRisk: summarizeApprovedRisk(evaluations, periodDays),
     qualityBuckets: [...bucketMap.values()].sort(
       (a, b) => qualitySortKey(a.quality) - qualitySortKey(b.quality)
     )

package/dist/lib/aiTrainResearch.js

@@ -52,6 +52,7 @@ var divideOrNull = (num, denom) => {
 var DAY_MS = 24 * 60 * 60 * 1e3;
 var DAYS_PER_WEEK = 7;
 var DAYS_PER_MONTH = 30.4375;
+var DAYS_PER_YEAR = 365;
 var getEvaluationPeriodDays = (evaluations) => {
   let minTimestamp = null;
   let maxTimestamp = null;
@@ -73,6 +74,40 @@ var getEvaluationPeriodDays = (evaluations) => {
   return Math.max((maxTimestamp - minTimestamp) / DAY_MS, 1);
 };
 var qualitySortKey = (quality) => quality == null ? Number.POSITIVE_INFINITY : quality;
+var calculateTradePnlRiskRatios = ({
+  profits,
+  totalProfit,
+  maxDrawdown,
+  periodDays
+}) => {
+  if (!profits.length || periodDays == null || periodDays <= 0) {
+    return {
+      sharpeRatio: null,
+      sortinoRatio: null,
+      calmarRatio: null
+    };
+  }
+  const meanProfit = totalProfit / profits.length;
+  const variance = profits.reduce((sum, profit) => {
+    const diff = profit - meanProfit;
+    return sum + diff * diff;
+  }, 0) / profits.length;
+  const stdDev = Math.sqrt(variance);
+  const downsideDeviation = Math.sqrt(
+    profits.reduce(
+      (sum, profit) => profit < 0 ? sum + profit * profit : sum,
+      0
+    ) / profits.length
+  );
+  const annualizationScale = Math.sqrt(
+    profits.length / periodDays * DAYS_PER_YEAR
+  );
+  return {
+    sharpeRatio: stdDev > 0 && annualizationScale > 0 ? meanProfit / stdDev * annualizationScale : null,
+    sortinoRatio: downsideDeviation > 0 && annualizationScale > 0 ? meanProfit / downsideDeviation * annualizationScale : null,
+    calmarRatio: maxDrawdown > 0 ? totalProfit / periodDays * DAYS_PER_YEAR / maxDrawdown : null
+  };
+};
 var emptyRiskSummary = () => ({
   trades: 0,
   totalProfit: 0,
@@ -88,12 +123,15 @@ var emptyRiskSummary = () => ({
   maxDrawdown: 0,
   maxDrawdownPctOfGrossProfit: null,
   maxDrawdownPctOfTotalProfit: null,
+  sharpeRatio: null,
+  sortinoRatio: null,
+  calmarRatio: null,
   recoveryFactor: null,
   ulcerIndex: null,
   maxConsecutiveWins: 0,
   maxConsecutiveLosses: 0
 });
-var summarizeApprovedRisk = (evaluations) => {
+var summarizeApprovedRisk = (evaluations, periodDays = getEvaluationPeriodDays(evaluations)) => {
   const approvedEvaluations = evaluations.filter((evaluation) => evaluation.aiApproved).sort((left, right) => {
     const leftTimestamp = typeof left.timestamp === "number" && Number.isFinite(left.timestamp) ? left.timestamp : Number.POSITIVE_INFINITY;
     const rightTimestamp = typeof right.timestamp === "number" && Number.isFinite(right.timestamp) ? right.timestamp : Number.POSITIVE_INFINITY;
@@ -116,8 +154,10 @@ var summarizeApprovedRisk = (evaluations) => {
   let currentLossStreak = 0;
   let maxConsecutiveWins = 0;
   let maxConsecutiveLosses = 0;
+  const approvedProfits = [];
   for (const evaluation of approvedEvaluations) {
     const profit = evaluation.profit;
+    approvedProfits.push(profit);
     if (profit > 0) {
       grossProfit += profit;
       wins += 1;
@@ -145,6 +185,12 @@ var summarizeApprovedRisk = (evaluations) => {
   const totalProfit = grossProfit - grossLoss;
   const avgWin = divideOrNull(grossProfit, wins);
   const avgLoss = divideOrNull(grossLoss, losses);
+  const riskRatios = calculateTradePnlRiskRatios({
+    profits: approvedProfits,
+    totalProfit,
+    maxDrawdown,
+    periodDays
+  });
   return {
     trades: approvedEvaluations.length,
     totalProfit,
@@ -160,6 +206,7 @@ var summarizeApprovedRisk = (evaluations) => {
     maxDrawdown,
     maxDrawdownPctOfGrossProfit: grossProfit > 0 ? maxDrawdown / grossProfit : null,
     maxDrawdownPctOfTotalProfit: totalProfit > 0 ? maxDrawdown / totalProfit : null,
+    ...riskRatios,
     recoveryFactor: maxDrawdown > 0 ? totalProfit / maxDrawdown : null,
     ulcerIndex: Math.sqrt(drawdownSquares / approvedEvaluations.length),
     maxConsecutiveWins,
@@ -258,7 +305,7 @@ var summarizeAiTrainEvaluations = (evaluations) => {
     avgApprovedTradesPerDay,
     avgApprovedTradesPerWeek,
     expectancyDelta,
-    approvedRisk: summarizeApprovedRisk(evaluations),
+    approvedRisk: summarizeApprovedRisk(evaluations, periodDays),
     qualityBuckets: [...bucketMap.values()].sort(
       (a, b) => qualitySortKey(a.quality) - qualitySortKey(b.quality)
     )
@@ -286,6 +333,12 @@ var RESEARCH_CONTEXT_ENV_KEYS = [
   "COINMARKETCAP_CONTEXT_BACKFILL_MAX_DAYS",
   "COINMARKETCAP_CONTEXT_BACKFILL_WARMUP_DAYS"
 ];
+var DERIVATIVES_CONTEXT_DATA_MODEL = {
+  derivativesSourceIntervals: "15m",
+  derivativesDerivedIntervals: "1h",
+  derivativesHourlyFallback: "stored-1h",
+  derivativesDataModelVersion: 2
+};
 var normalizeForStableJson = (value) => {
   if (Array.isArray(value)) {
     return value.map(normalizeForStableJson);
@@ -398,6 +451,7 @@ var resolveGateFingerprint = async (projectRoot, strategyName, gitSha) => {
   const relativeCandidates = [
     `packages/strategies/src/${strategyName}/adapters/ai.ts`,
     `packages/strategies/src/${strategyName}/guardrails.ts`,
+    `packages/strategies/src/${strategyName}/pockets.ts`,
     `packages/strategies/src/${strategyName}/config.ts`,
     "packages/node/src/ai.ts"
   ];
@@ -444,7 +498,8 @@ var buildAiTrainLineage = async ({
     ...Object.fromEntries(
       RESEARCH_CONTEXT_ENV_KEYS.map((key) => [key, env[key] ?? null])
     ),
-    ...runContext
+    ...runContext,
+    ...DERIVATIVES_CONTEXT_DATA_MODEL
   };
   return {
     gitSha,

package/dist/lib/derivativesContextBackfill.js

@@ -47,6 +47,7 @@ __export(derivativesContextBackfill_exports, {
   resolveDerivativesContextLookbackMs: () => resolveDerivativesContextLookbackMs,
   resolveDerivativesContextMissingCoverageFetchFromMs: () => resolveDerivativesContextMissingCoverageFetchFromMs,
   resolveDerivativesContextMissingFetchFromMs: () => resolveDerivativesContextMissingFetchFromMs,
+  resolveDerivativesContextRequiredFetchFromMs: () => resolveDerivativesContextRequiredFetchFromMs,
   shouldBackfillDerivativesContextForBacktest: () => shouldBackfillDerivativesContextForBacktest,
   shouldBackfillDerivativesContextForSignals: () => shouldBackfillDerivativesContextForSignals
 });
@@ -179,6 +180,38 @@ var resolveDerivativesContextMissingFetchFromMs = (params) => {
   return null;
 };
 var resolveDerivativesContextFetchFromMs = (params) => resolveDerivativesContextMissingFetchFromMs(params) ?? (params.refreshClosedTail ? params.toMs : null);
+var resolveDerivativesContextRequiredFetchFromMs = (params) => {
+  const dataCoverageFromMs = params.dataCoverageKeyExists ? null : params.mode === "signals" ? params.fromMs : resolveDerivativesContextMissingCoverageFetchFromMs({
+    ranges: params.dataCoverageRanges,
+    fromMs: params.fromMs,
+    toMs: params.toMs,
+    intervalMs: params.intervalMs
+  });
+  const edgesFromMs = dataCoverageFromMs == null ? null : resolveDerivativesContextFetchFromMs({
+    edges: params.edges,
+    fromMs: params.fromMs,
+    toMs: params.toMs,
+    intervalMs: params.intervalMs,
+    refreshClosedTail: params.mode === "signals"
+  });
+  const dataFetchFromMs = dataCoverageFromMs != null && edgesFromMs != null ? Math.max(dataCoverageFromMs, edgesFromMs) : null;
+  const confirmedLiquidationWindow = (0, import_indicators.resolveCoinalyzeConfirmedIntradayCoverage)({
+    interval: params.interval,
+    fromMs: params.fromMs,
+    toMs: params.toMs,
+    nowMs: params.nowMs
+  });
+  const liquidationFetchFromMs = confirmedLiquidationWindow ? resolveDerivativesContextMissingCoverageFetchFromMs({
+    ranges: params.liquidationCoverageRanges,
+    fromMs: confirmedLiquidationWindow.fromMs,
+    toMs: confirmedLiquidationWindow.toMs,
+    intervalMs: params.intervalMs
+  }) : null;
+  const fetchStarts = [dataFetchFromMs, liquidationFetchFromMs].filter(
+    (value) => value != null
+  );
+  return fetchStarts.length ? Math.min(...fetchStarts) : null;
+};
 var countBackfillWindows = (params) => {
   let count = 0;
   let cursor = params.fromMs;
@@ -517,7 +550,8 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
     mode,
     startMs,
     endMs,
-    preloadStartMs: params.preloadStartMs
+    preloadStartMs: params.preloadStartMs,
+    nowMs: Date.now()
   });
   if (safeEndMs <= fromMs) {
     return skippedBackfillResult();
@@ -551,15 +585,33 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
   );
   const coverageKeysByInterval = /* @__PURE__ */ new Map();
   const coverageRangesByInterval = /* @__PURE__ */ new Map();
+  const liquidationCoverageRangesByInterval = /* @__PURE__ */ new Map();
+  const coverageNowMs = Date.now();
   await Promise.all(
     intervalWindows.map(async (window) => {
-      const coverageRows = await (0, import_timescale.getDerivativesBackfillCoverage)({
-        source: "coinalyze",
-        symbols,
+      const confirmedLiquidationWindow = (0, import_indicators.resolveCoinalyzeConfirmedIntradayCoverage)({
         interval: window.interval,
         fromMs: window.fromMs,
-        toMs: window.toMs
+        toMs: window.toMs,
+        nowMs: coverageNowMs
       });
+      const [coverageRows, liquidationCoverageRows] = await Promise.all([
+        (0, import_timescale.getDerivativesBackfillCoverage)({
+          source: "coinalyze",
+          symbols,
+          interval: window.interval,
+          fromMs: window.fromMs,
+          toMs: window.toMs
+        }),
+        confirmedLiquidationWindow ? (0, import_timescale.getDerivativesMetricCoverage)({
+          source: "coinalyze",
+          metric: "liquidation",
+          symbols,
+          interval: window.interval,
+          fromMs: confirmedLiquidationWindow.fromMs,
+          toMs: confirmedLiquidationWindow.toMs
+        }) : Promise.resolve([])
+      ]);
       coverageKeysByInterval.set(
         window.interval,
         new Set(
@@ -581,6 +633,17 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
         rangesBySymbol.set(symbol, ranges);
       }
       coverageRangesByInterval.set(window.interval, rangesBySymbol);
+      const liquidationRangesBySymbol = /* @__PURE__ */ new Map();
+      for (const row of liquidationCoverageRows) {
+        const symbol = row.symbol.toUpperCase();
+        const ranges = liquidationRangesBySymbol.get(symbol) ?? [];
+        ranges.push({ fromMs: row.fromMs, toMs: row.toMs });
+        liquidationRangesBySymbol.set(symbol, ranges);
+      }
+      liquidationCoverageRangesByInterval.set(
+        window.interval,
+        liquidationRangesBySymbol
+      );
     })
   );
   const cachedWindows = intervalWindows.reduce(
@@ -605,7 +668,7 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
       (symbol) => backfillWindows.every((backfillWindow) => {
         const normalizedSymbol = symbol.toUpperCase();
         const coverageRanges = coverageRangesByInterval.get(window.interval)?.get(normalizedSymbol) ?? [];
-        return hasDerivativesWindowCoverage({
+        const dataCovered = hasDerivativesWindowCoverage({
           edges: edgesBySymbol?.get(normalizedSymbol),
           fromMs: backfillWindow.fromMs,
           toMs: backfillWindow.toMs
@@ -622,6 +685,19 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
             toMs: backfillWindow.toMs
           })
         );
+        const confirmedLiquidationWindow = (0, import_indicators.resolveCoinalyzeConfirmedIntradayCoverage)({
+          interval: window.interval,
+          fromMs: backfillWindow.fromMs,
+          toMs: backfillWindow.toMs,
+          nowMs: coverageNowMs
+        });
+        const liquidationCovered = confirmedLiquidationWindow == null || resolveDerivativesContextMissingCoverageFetchFromMs({
+          ranges: liquidationCoverageRangesByInterval.get(window.interval)?.get(normalizedSymbol) ?? [],
+          fromMs: confirmedLiquidationWindow.fromMs,
+          toMs: confirmedLiquidationWindow.toMs,
+          intervalMs: window.intervalMs
+        }) == null;
+        return dataCovered && liquidationCovered;
       })
     );
   });
@@ -706,6 +782,11 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
     coverageKeysByInterval.set(interval, coverageKeys);
     const coverageRangesBySymbol = coverageRangesByInterval.get(interval) ?? /* @__PURE__ */ new Map();
     coverageRangesByInterval.set(interval, coverageRangesBySymbol);
+    const liquidationCoverageRangesBySymbol = liquidationCoverageRangesByInterval.get(interval) ?? /* @__PURE__ */ new Map();
+    liquidationCoverageRangesByInterval.set(
+      interval,
+      liquidationCoverageRangesBySymbol
+    );
     for (let batchIdx = 0; batchIdx < symbolBatches.length; batchIdx += 1) {
       const batch = symbolBatches[batchIdx];
       let cursor = window.fromMs;
@@ -718,33 +799,25 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
             fromMs: cursor,
             toMs
           });
-          if (coverageKeys.has(key)) {
-            return null;
-          }
           const normalizedSymbol = item.symbol.toUpperCase();
-          const coverageFromMs = mode === "signals" ? cursor : resolveDerivativesContextMissingCoverageFetchFromMs({
-            ranges: coverageRangesBySymbol.get(normalizedSymbol),
-            fromMs: cursor,
-            toMs,
-            intervalMs
-          });
-          if (coverageFromMs == null) {
-            return null;
-          }
-          const edges = edgesBySymbol.get(normalizedSymbol);
-          const edgesFromMs = resolveDerivativesContextFetchFromMs({
-            edges,
-            fromMs: cursor,
-            toMs,
-            intervalMs,
-            refreshClosedTail: mode === "signals"
-          });
-          if (edgesFromMs == null) {
-            return null;
-          }
+          const requiredFromMs = resolveDerivativesContextRequiredFetchFromMs(
+            {
+              mode,
+              interval,
+              intervalMs,
+              fromMs: cursor,
+              toMs,
+              nowMs: coverageNowMs,
+              dataCoverageKeyExists: coverageKeys.has(key),
+              dataCoverageRanges: coverageRangesBySymbol.get(normalizedSymbol),
+              liquidationCoverageRanges: liquidationCoverageRangesBySymbol.get(normalizedSymbol),
+              edges: edgesBySymbol.get(normalizedSymbol)
+            }
+          );
+          if (requiredFromMs == null) return null;
           return {
             item,
-            fromMs: Math.max(coverageFromMs, edgesFromMs)
+            fromMs: requiredFromMs
           };
         }).filter(
           (item) => item != null
@@ -769,6 +842,7 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
               );
               let rows = [];
               let missingClosedSymbols = [];
+              let liquidationRowsByMarket = /* @__PURE__ */ new Map();
               for (let attempt = 1; attempt <= maxClosedBarAttempts; attempt += 1) {
                 const oiMap = await fetchMetricBatch({
                   endpoint: oiPath,
@@ -788,7 +862,7 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
                   fromMs: group.fromMs,
                   toMs
                 });
-                const liqMap = await fetchMetricBatch({
+                liquidationRowsByMarket = await fetchMetricBatch({
                   endpoint: liqPath,
                   metric: "liq",
                   marketSymbols,
@@ -803,7 +877,7 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
                     symbol: item.symbol,
                     oiRaw: oiMap.get(marketSymbol) ?? [],
                     fundingRaw: fundingMap.get(marketSymbol) ?? [],
-                    liqRaw: liqMap.get(marketSymbol) ?? []
+                    liqRaw: liquidationRowsByMarket.get(marketSymbol) ?? []
                   });
                   return (0, import_indicators.coinalyzePointsToRows)(points, interval, "coinalyze");
                 });
@@ -826,6 +900,42 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
                 await (0, import_timescale.upsertDerivatives)(rows);
                 totalRows += rows.length;
               }
+              const confirmedLiquidationWindow = (0, import_indicators.resolveCoinalyzeConfirmedIntradayCoverage)({
+                interval,
+                fromMs: group.fromMs,
+                toMs,
+                nowMs: coverageNowMs
+              });
+              if (confirmedLiquidationWindow) {
+                const metricCoverageRows = missingBatch.map((item) => {
+                  const marketSymbol = item.marketSymbol.toUpperCase();
+                  const eventRowsCount = (liquidationRowsByMarket.get(marketSymbol) ?? []).filter((point) => {
+                    const timestamp = (0, import_indicators.toCoinalyzeTimestampMs)(
+                      point.t ?? point.ts ?? point.time ?? point.timestamp
+                    );
+                    return timestamp != null && timestamp >= confirmedLiquidationWindow.fromMs && timestamp <= confirmedLiquidationWindow.toMs;
+                  }).length;
+                  return {
+                    source: "coinalyze",
+                    metric: "liquidation",
+                    symbol: item.symbol,
+                    interval,
+                    fromMs: confirmedLiquidationWindow.fromMs,
+                    toMs: confirmedLiquidationWindow.toMs,
+                    eventRowsCount
+                  };
+                });
+                await (0, import_timescale.applyDerivativesMetricCoverage)(metricCoverageRows);
+                for (const coverageRow of metricCoverageRows) {
+                  const symbol = coverageRow.symbol.toUpperCase();
+                  const ranges = liquidationCoverageRangesBySymbol.get(symbol) ?? [];
+                  ranges.push({
+                    fromMs: coverageRow.fromMs,
+                    toMs: coverageRow.toMs
+                  });
+                  liquidationCoverageRangesBySymbol.set(symbol, ranges);
+                }
+              }
               if (mode === "backtest") {
                 const rowsCountBySymbol = /* @__PURE__ */ new Map();
                 for (const row of rows) {
@@ -939,6 +1049,7 @@ var backfillDerivativesContextForSignals = async (params) => backfillDerivatives
   resolveDerivativesContextLookbackMs,
   resolveDerivativesContextMissingCoverageFetchFromMs,
   resolveDerivativesContextMissingFetchFromMs,
+  resolveDerivativesContextRequiredFetchFromMs,
   shouldBackfillDerivativesContextForBacktest,
   shouldBackfillDerivativesContextForSignals
 });