@tradejs/cli 1.0.8 → 1.0.9

package/dist/scripts/signals.js

@@ -474,6 +474,80 @@ var backfillDerivativesContext = async (params, enabled) => {
 };
 var backfillDerivativesContextForSignals = async (params) => backfillDerivativesContext(params, isSignalsDerivativesContextEnabled());
 
+// src/lib/runtimeSignalsStorage.ts
+var DAY_MS2 = 864e5;
+var RUNTIME_STORAGE_DAY_OFFSET_MS = 5 * 60 * 60 * 1e3;
+var toIsoDayKey = (timestamp) => new Date(timestamp).toISOString().slice(0, 10);
+var toRuntimeStorageDayTimestamp = (timestamp) => Math.floor((timestamp + RUNTIME_STORAGE_DAY_OFFSET_MS) / DAY_MS2) * DAY_MS2;
+var getRuntimeStorageDayKey = (timestamp) => toIsoDayKey(toRuntimeStorageDayTimestamp(timestamp));
+var toRuntimeSignalBucketRef = (signal) => ({
+  signalId: signal.signalId,
+  symbol: signal.symbol,
+  strategy: signal.strategy,
+  timestamp: signal.timestamp
+});
+var normalizeRuntimeSignalSkipReason = (reason, fallbackSource) => {
+  let source = fallbackSource;
+  let normalizedReason = reason;
+  if (reason.startsWith("AI_QUALITY_BELOW_MIN")) {
+    source = "AI";
+    normalizedReason = "MIN_AI_QUALITY";
+  } else if (reason === "AI_QUALITY_UNAVAILABLE") {
+    source = "AI";
+    normalizedReason = "QUALITY_UNAVAILABLE";
+  } else if (reason === "ML_RESULT_UNAVAILABLE") {
+    source = "ML";
+    normalizedReason = "RESULT_UNAVAILABLE";
+  } else if (reason.startsWith("ML_THRESHOLD_NOT_MET")) {
+    source = "ML";
+    normalizedReason = "ML_THRESHOLD";
+  } else if (reason.startsWith("HOOK_BEFORE_ENTRY_GATE:")) {
+    source = "hook";
+    normalizedReason = `BEFORE_ENTRY_GATE:${reason.slice(
+      "HOOK_BEFORE_ENTRY_GATE:".length
+    )}`;
+  } else if (reason === "HOOK_BEFORE_ENTRY_GATE") {
+    source = "hook";
+    normalizedReason = "BEFORE_ENTRY_GATE";
+  } else if (reason === "MAKE_ORDERS_DISABLED" || reason === "ENTRY_POLICY_BLOCKED") {
+    source = "policy";
+  }
+  return {
+    source: `skip from ${source}`,
+    reason: normalizedReason
+  };
+};
+var buildStatsReasonField = (source, reason) => `reason:${source}:${reason}`;
+var buildRuntimeSignalStatsIncrements = (evaluation) => {
+  const increments = {
+    evaluated: 1
+  };
+  if (evaluation.status === "signal") {
+    increments.signals = 1;
+  }
+  let skipReason = null;
+  let fallbackSource = "core";
+  if (evaluation.status === "skip") {
+    skipReason = evaluation.reason || "NO_SIGNAL";
+    fallbackSource = "core";
+  } else if (evaluation.status === "signal" && (evaluation.orderStatus === "skipped" || evaluation.orderStatus === "canceled")) {
+    skipReason = evaluation.orderSkipReason || evaluation.reason || `orderStatus=${evaluation.orderStatus}`;
+    fallbackSource = "runtime";
+  } else if (evaluation.status === "error") {
+    skipReason = evaluation.reason || "EVALUATION_ERROR";
+    fallbackSource = "runtime";
+  }
+  if (skipReason) {
+    const normalized = normalizeRuntimeSignalSkipReason(
+      skipReason,
+      fallbackSource
+    );
+    increments[buildStatsReasonField(normalized.source, normalized.reason)] = 1;
+  }
+  return increments;
+};
+var shouldStoreDetailedRuntimeSignalEvaluation = (evaluation) => evaluation.status !== "skip";
+
 // src/scripts/signals.ts
 import_args.default.option(["t", "tickers"], "Selected tickers");
 import_args.default.option(["e", "exclude"], "Exclude tickers from tests");
@@ -589,40 +663,13 @@ var createStrategySkipStats = (runtimeStrategies) => new Map(
     }
   ])
 );
-var normalizeSkipStatsReason = (reason, fallbackSource) => {
-  let source = fallbackSource;
-  let normalizedReason = reason;
-  if (reason.startsWith("AI_QUALITY_BELOW_MIN")) {
-    source = "AI";
-    normalizedReason = "MIN_AI_QUALITY";
-  } else if (reason === "AI_QUALITY_UNAVAILABLE") {
-    source = "AI";
-    normalizedReason = "QUALITY_UNAVAILABLE";
-  } else if (reason === "ML_RESULT_UNAVAILABLE") {
-    source = "ML";
-    normalizedReason = "RESULT_UNAVAILABLE";
-  } else if (reason.startsWith("ML_THRESHOLD_NOT_MET")) {
-    source = "ML";
-    normalizedReason = "ML_THRESHOLD";
-  } else if (reason.startsWith("HOOK_BEFORE_ENTRY_GATE:")) {
-    source = "hook";
-    normalizedReason = `BEFORE_ENTRY_GATE:${reason.slice(
-      "HOOK_BEFORE_ENTRY_GATE:".length
-    )}`;
-  } else if (reason === "HOOK_BEFORE_ENTRY_GATE") {
-    source = "hook";
-    normalizedReason = "BEFORE_ENTRY_GATE";
-  } else if (reason === "MAKE_ORDERS_DISABLED" || reason === "ENTRY_POLICY_BLOCKED") {
-    source = "policy";
-  }
-  return `skip from ${source} / ${normalizedReason}`;
-};
 var recordStrategyReason = (strategyStats, strategyName, reason, fallbackSource = "core") => {
   const stats = strategyStats.get(strategyName);
   if (!stats) {
     return;
   }
-  const normalizedReason = normalizeSkipStatsReason(reason, fallbackSource);
+  const normalized = normalizeRuntimeSignalSkipReason(reason, fallbackSource);
+  const normalizedReason = `${normalized.source} / ${normalized.reason}`;
   stats.reasons.set(
     normalizedReason,
     (stats.reasons.get(normalizedReason) ?? 0) + 1
@@ -633,28 +680,34 @@ var buildRuntimeSignalEvaluationId = ({
   symbol,
   timestamp
 }) => `${strategyName}:${symbol}:${timestamp}`;
-var hasMeaningfulEvaluationReason = (value) => {
-  const reason = typeof value === "string" ? value.trim() : "";
-  return reason.length > 0 && reason !== "NO_SIGNAL";
-};
-var resolveRuntimeSignalEvaluationTtl = (evaluation) => {
-  if (evaluation.status === "signal" || evaluation.status === "error") {
-    return import_constants2.TTL_1M;
-  }
-  if (hasMeaningfulEvaluationReason(evaluation.reason) || hasMeaningfulEvaluationReason(evaluation.orderSkipReason)) {
-    return import_constants2.TTL_1M;
-  }
-  return import_constants2.TTL_3D;
-};
+var getTelegramDeliverableSignals = (signals2) => signals2.filter(
+  (signal) => signal.orderStatus !== "skipped" && signal.orderStatus !== "canceled"
+);
 var saveRuntimeSignalEvaluation = async (evaluation) => {
-  await (0, import_redis.setData)(
-    import_redis.redisKeys.runtimeSignalEvaluation(
+  const dayKey = getRuntimeStorageDayKey(evaluation.timestamp);
+  if (shouldStoreDetailedRuntimeSignalEvaluation(evaluation)) {
+    await (0, import_redis.setHashJsonField)(
+      import_redis.redisKeys.runtimeSignalEvaluationBucket(
+        evaluation.userName,
+        dayKey,
+        evaluation.strategy
+      ),
+      evaluation.evaluationId,
+      evaluation,
+      {
+        expire: import_constants2.TTL_10D
+      }
+    );
+  }
+  await (0, import_redis.incrHashFields)(
+    import_redis.redisKeys.runtimeSignalEvaluationStatsBucket(
       evaluation.userName,
-      evaluation.evaluationId
+      dayKey,
+      evaluation.strategy
     ),
-    evaluation,
+    buildRuntimeSignalStatsIncrements(evaluation),
     {
-      expire: resolveRuntimeSignalEvaluationTtl(evaluation)
+      expire: import_constants2.TTL_10D
     }
   );
 };
@@ -711,6 +764,8 @@ var findSignals = async (symbol, connector, btcBinanceData, btcCoinbaseData, run
       interval
     })
   ]);
+  cachedData.pop();
+  btcCachedData.pop();
   const lastCandle = cachedData.pop();
   const btcLastCandle = btcCachedData.pop();
   if (!lastCandle || !btcLastCandle) {
@@ -772,17 +827,19 @@ var findSignals = async (symbol, connector, btcBinanceData, btcCoinbaseData, run
       );
     }
     strategySignals.push(signal);
-    await (0, import_redis.setData)(import_redis.redisKeys.signal(symbol, signal.signalId), signal, {
-      expire: import_constants2.TTL_1D
-    });
     await (0, import_redis.setData)(import_redis.redisKeys.storeSignal(symbol, signal.signalId), signal, {
-      expire: import_constants2.TTL_3M
+      expire: import_constants2.TTL_10D
     });
-    await (0, import_redis.setData)(
-      import_redis.redisKeys.runtimeSignal(flags.user, signal.signalId),
-      signal,
+    await (0, import_redis.setHashJsonField)(
+      import_redis.redisKeys.runtimeSignalBucket(
+        flags.user,
+        getRuntimeStorageDayKey(signal.timestamp),
+        signal.strategy
+      ),
+      signal.signalId,
+      toRuntimeSignalBucketRef(signal),
       {
-        expire: import_constants2.TTL_1M
+        expire: import_constants2.TTL_10D
       }
     );
     await saveRuntimeSignalEvaluation({
@@ -1008,11 +1065,12 @@ var signals = async () => {
         symbol: import_chalk2.default.gray(symbol)
       });
     });
-    if (!flags.skipScreenshots) {
-      await (0, import_cli.makeScreenshots)(signals2, "15", flags.user);
-    }
     if (flags.notify) {
-      await (0, import_cli.sendToTG)(signals2, "15", flags.user);
+      const telegramSignals = getTelegramDeliverableSignals(signals2);
+      if (!flags.skipScreenshots && telegramSignals.length > 0) {
+        await (0, import_cli.makeScreenshots)(telegramSignals, "15", flags.user);
+      }
+      await (0, import_cli.sendToTG)(telegramSignals, "15", flags.user);
     }
     import_logger.logger.info(
       JSON.stringify(

package/dist/scripts/signalsSummary.js

@@ -37,7 +37,7 @@ var import_config = require("dotenv/config");
 var import_args = __toESM(require("args"));
 var import_constants = require("@tradejs/core/constants");
 var import_logger = require("@tradejs/infra/logger");
-var import_redis = require("@tradejs/infra/redis");
+var import_redis2 = require("@tradejs/infra/redis");
 var import_connectors = require("@tradejs/node/connectors");
 
 // src/lib/telegramReports.ts
@@ -100,6 +100,124 @@ ${chunk}`, {
   return chunks.length;
 };
 
+// src/lib/runtimeSignalsLoader.ts
+var import_redis = require("@tradejs/infra/redis");
+
+// src/lib/runtimeSignalsStorage.ts
+var DAY_MS = 864e5;
+var RUNTIME_STORAGE_DAY_OFFSET_MS = 5 * 60 * 60 * 1e3;
+var toIsoDayKey = (timestamp) => new Date(timestamp).toISOString().slice(0, 10);
+var toRuntimeStorageDayTimestamp = (timestamp) => Math.floor((timestamp + RUNTIME_STORAGE_DAY_OFFSET_MS) / DAY_MS) * DAY_MS;
+var getRuntimeStorageDayKeys = (startTime, endTime) => {
+  if (!Number.isFinite(startTime) || !Number.isFinite(endTime)) {
+    return [];
+  }
+  const start = Math.min(startTime, endTime);
+  const endExclusive = Math.max(startTime, endTime);
+  const normalizedEnd = Math.max(start, endExclusive - 1);
+  const keys = [];
+  const startDay = toRuntimeStorageDayTimestamp(start);
+  const endDay = toRuntimeStorageDayTimestamp(normalizedEnd);
+  for (let current = startDay; current <= endDay; current += DAY_MS) {
+    keys.push(toIsoDayKey(current));
+  }
+  return keys;
+};
+var isRuntimeSignalBucketRef = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.signalId === "string" && typeof record.symbol === "string" && typeof record.strategy === "string" && typeof record.timestamp === "number";
+};
+var toCount = (value) => {
+  const parsed = Number.parseInt(String(value ?? "0"), 10);
+  return Number.isFinite(parsed) ? parsed : 0;
+};
+var parseRuntimeSignalStatsBucket = (value) => {
+  const reasonGroups = /* @__PURE__ */ new Map();
+  for (const [field, rawCount] of Object.entries(value)) {
+    if (!field.startsWith("reason:")) {
+      continue;
+    }
+    const [, source, ...reasonParts] = field.split(":");
+    const reason = reasonParts.join(":");
+    if (!source || !reason) {
+      continue;
+    }
+    const reasons = reasonGroups.get(source) ?? /* @__PURE__ */ new Map();
+    reasons.set(reason, toCount(rawCount));
+    reasonGroups.set(source, reasons);
+  }
+  return {
+    evaluated: toCount(value.evaluated),
+    signals: toCount(value.signals),
+    reasonGroups
+  };
+};
+
+// src/lib/runtimeSignalsLoader.ts
+var isSignalRecord = (value) => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const record = value;
+  return typeof record.signalId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.timestamp === "number";
+};
+var sortByTimestamp = (records) => [...records].sort((left, right) => left.timestamp - right.timestamp);
+var loadRuntimeSignals = async (userName) => {
+  const bucketKeys = await (0, import_redis.getKeys)(import_redis.redisKeys.runtimeSignalBuckets(userName));
+  const refs = (await Promise.all(bucketKeys.map((key) => (0, import_redis.getHashJsonValues)(key)))).flat().filter(isRuntimeSignalBucketRef);
+  const seen = /* @__PURE__ */ new Set();
+  const payloads = await Promise.all(
+    refs.map(async (ref) => {
+      const dedupeKey = `${ref.symbol}:${ref.signalId}`;
+      if (seen.has(dedupeKey)) {
+        return null;
+      }
+      seen.add(dedupeKey);
+      const signal = await (0, import_redis.getData)(
+        import_redis.redisKeys.storeSignal(ref.symbol, ref.signalId),
+        null
+      );
+      return isSignalRecord(signal) ? signal : null;
+    })
+  );
+  return sortByTimestamp(payloads.filter(isSignalRecord));
+};
+var parseBucketKey = (prefix, key) => {
+  if (!key.startsWith(prefix)) {
+    return null;
+  }
+  const suffix = key.slice(prefix.length);
+  const firstColon = suffix.indexOf(":");
+  if (firstColon <= 0 || firstColon >= suffix.length - 1) {
+    return null;
+  }
+  return {
+    dayKey: suffix.slice(0, firstColon),
+    strategy: suffix.slice(firstColon + 1)
+  };
+};
+var loadRuntimeSignalEvaluationStatsBuckets = async (userName) => {
+  const prefix = import_redis.redisKeys.runtimeSignalEvaluationStatsBuckets(userName);
+  const keys = await (0, import_redis.getKeys)(prefix);
+  const entries = await Promise.all(
+    keys.map(async (key) => {
+      const parsedKey = parseBucketKey(prefix, key);
+      if (!parsedKey) {
+        return null;
+      }
+      return {
+        key,
+        ...parsedKey,
+        stats: parseRuntimeSignalStatsBucket(await (0, import_redis.getHashData)(key))
+      };
+    })
+  );
+  return entries.filter(Boolean);
+};
+
 // src/scripts/signalsSummary.ts
 import_args.default.option(["u", "user"], "Use user config", "root");
 import_args.default.option(
@@ -139,51 +257,6 @@ var normalizeStatus = (value) => {
   }
   return "unknown";
 };
-var normalizeSkipStatsReason = (reason, fallbackSource) => {
-  let source = fallbackSource;
-  let normalizedReason = reason;
-  if (reason.startsWith("AI_QUALITY_BELOW_MIN")) {
-    source = "AI";
-    normalizedReason = "MIN_AI_QUALITY";
-  } else if (reason === "AI_QUALITY_UNAVAILABLE") {
-    source = "AI";
-    normalizedReason = "QUALITY_UNAVAILABLE";
-  } else if (reason === "ML_RESULT_UNAVAILABLE") {
-    source = "ML";
-    normalizedReason = "RESULT_UNAVAILABLE";
-  } else if (reason.startsWith("ML_THRESHOLD_NOT_MET")) {
-    source = "ML";
-    normalizedReason = "ML_THRESHOLD";
-  } else if (reason.startsWith("HOOK_BEFORE_ENTRY_GATE:")) {
-    source = "hook";
-    normalizedReason = `BEFORE_ENTRY_GATE:${reason.slice(
-      "HOOK_BEFORE_ENTRY_GATE:".length
-    )}`;
-  } else if (reason === "HOOK_BEFORE_ENTRY_GATE") {
-    source = "hook";
-    normalizedReason = "BEFORE_ENTRY_GATE";
-  } else if (reason === "MAKE_ORDERS_DISABLED" || reason === "ENTRY_POLICY_BLOCKED") {
-    source = "policy";
-  }
-  return {
-    source: `skip from ${source}`,
-    reason: normalizedReason
-  };
-};
-var isSignalRecord = (value) => {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const record = value;
-  return typeof record.signalId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.timestamp === "number";
-};
-var isRuntimeSignalEvaluationRecord = (value) => {
-  if (!value || typeof value !== "object") {
-    return false;
-  }
-  const record = value;
-  return typeof record.evaluationId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.timestamp === "number" && (record.status === "signal" || record.status === "skip" || record.status === "error");
-};
 var isRuntimeTradeRecord = (value) => {
   if (!value || typeof value !== "object") {
     return false;
@@ -203,16 +276,6 @@ var resolveSummaryConnectorName = async (value) => {
   );
   return import_connectors.DEFAULT_CONNECTOR_NAME;
 };
-var loadRuntimeSignals = async (userName) => {
-  const keys = await (0, import_redis.getKeys)(import_redis.redisKeys.runtimeSignals(userName));
-  const signals = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
-  return signals.filter(isSignalRecord).sort((left, right) => left.timestamp - right.timestamp);
-};
-var loadRuntimeSignalEvaluations = async (userName) => {
-  const keys = await (0, import_redis.getKeys)(import_redis.redisKeys.runtimeSignalEvaluations(userName));
-  const evaluations = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
-  return evaluations.filter(isRuntimeSignalEvaluationRecord).sort((left, right) => left.timestamp - right.timestamp);
-};
 var resolveStrategyNameByConfigKey = (userName, key) => {
   const parts = key.split(":");
   if (parts.length !== 5) {
@@ -225,14 +288,30 @@ var resolveStrategyNameByConfigKey = (userName, key) => {
   return strategyName;
 };
 var loadRuntimeStrategyNames = async (userName) => {
-  const keys = await (0, import_redis.getKeys)(`${import_redis.redisKeys.strategies(userName)}:`);
+  const keys = await (0, import_redis2.getKeys)(`${import_redis2.redisKeys.strategies(userName)}:`);
   return keys.filter((key) => key.endsWith(":config")).map((key) => resolveStrategyNameByConfigKey(userName, key)).filter((value) => Boolean(value)).sort((left, right) => left.localeCompare(right));
 };
 var loadRuntimeTrades = async (userName) => {
-  const keys = await (0, import_redis.getKeys)(import_redis.redisKeys.runtimeTrades(userName));
-  const trades = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
+  const keys = await (0, import_redis2.getKeys)(import_redis2.redisKeys.runtimeTrades(userName));
+  const trades = await Promise.all(keys.map((key) => (0, import_redis2.getData)(key, null)));
   return trades.filter(isRuntimeTradeRecord).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
 };
+var createRuntimeSignalStats = () => ({
+  evaluated: 0,
+  signals: 0,
+  reasonGroups: /* @__PURE__ */ new Map()
+});
+var mergeRuntimeSignalStats = (target, source) => {
+  target.evaluated += source.evaluated;
+  target.signals += source.signals;
+  for (const [group, reasons] of source.reasonGroups.entries()) {
+    const targetReasons = target.reasonGroups.get(group) ?? /* @__PURE__ */ new Map();
+    for (const [reason, count] of reasons.entries()) {
+      targetReasons.set(reason, (targetReasons.get(reason) ?? 0) + count);
+    }
+    target.reasonGroups.set(group, targetReasons);
+  }
+};
 var loadClosedPnlRows = async ({
   connector,
   startTime,
@@ -286,8 +365,8 @@ var syncRuntimeTrades = async ({
   const symbols = [...new Set(trades.map((trade) => trade.symbol))];
   await Promise.all(
     symbols.map(async (symbol) => {
-      const activeRef = await (0, import_redis.getData)(
-        import_redis.redisKeys.runtimeActiveTrade(userName, symbol),
+      const activeRef = await (0, import_redis2.getData)(
+        import_redis2.redisKeys.runtimeActiveTrade(userName, symbol),
         null
       );
       activeOrderIdBySymbol.set(
@@ -324,8 +403,8 @@ var syncRuntimeTrades = async ({
         currentPnl: openPosition.unrealizedPnl,
         lastSyncedAt: endTime
       };
-      await (0, import_redis.setData)(
-        import_redis.redisKeys.runtimeTrade(userName, trade.orderId),
+      await (0, import_redis2.setData)(
+        import_redis2.redisKeys.runtimeTrade(userName, trade.orderId),
         nextTrade2,
         {
           expire: 0
@@ -346,10 +425,10 @@ var syncRuntimeTrades = async ({
       lastSyncedAt: endTime
     };
     await Promise.all([
-      (0, import_redis.setData)(import_redis.redisKeys.runtimeTrade(userName, trade.orderId), nextTrade, {
+      (0, import_redis2.setData)(import_redis2.redisKeys.runtimeTrade(userName, trade.orderId), nextTrade, {
         expire: import_constants.TTL_1M
       }),
-      ...isCurrentActiveTrade ? [(0, import_redis.delKey)(import_redis.redisKeys.runtimeActiveTrade(userName, trade.symbol))] : []
+      ...isCurrentActiveTrade ? [(0, import_redis2.delKey)(import_redis2.redisKeys.runtimeActiveTrade(userName, trade.symbol))] : []
     ]);
     syncedTrades.push(nextTrade);
   }
@@ -361,7 +440,7 @@ var buildSummaryMessage = ({
   endTime,
   configuredStrategyNames,
   signals,
-  signalEvaluations,
+  evaluationStatsByStrategy,
   trades
 }) => {
   const lines = [];
@@ -374,7 +453,6 @@ var buildSummaryMessage = ({
   ];
   const strategyNames = /* @__PURE__ */ new Set();
   const signalStats = /* @__PURE__ */ new Map();
-  const evaluationStats = /* @__PURE__ */ new Map();
   const tradeStats = /* @__PURE__ */ new Map();
   for (const strategyName of configuredStrategyNames) {
     if (strategyName) {
@@ -388,38 +466,6 @@ var buildSummaryMessage = ({
     stats.set(status, (stats.get(status) ?? 0) + 1);
     signalStats.set(signal.strategy, stats);
   }
-  for (const evaluation of signalEvaluations) {
-    strategyNames.add(evaluation.strategy);
-    const stats = evaluationStats.get(evaluation.strategy) ?? {
-      evaluated: 0,
-      signals: 0,
-      reasonGroups: /* @__PURE__ */ new Map()
-    };
-    stats.evaluated += 1;
-    if (evaluation.status === "signal") {
-      stats.signals += 1;
-    }
-    const orderStatus = normalizeStatus(evaluation.orderStatus);
-    let skipReason = null;
-    let fallbackSource = "core";
-    if (evaluation.status === "skip") {
-      skipReason = evaluation.reason || "NO_SIGNAL";
-      fallbackSource = "core";
-    } else if (evaluation.status === "signal" && (orderStatus === "skipped" || orderStatus === "canceled")) {
-      skipReason = evaluation.orderSkipReason || evaluation.reason || `orderStatus=${orderStatus}`;
-      fallbackSource = "runtime";
-    } else if (evaluation.status === "error") {
-      skipReason = evaluation.reason || "EVALUATION_ERROR";
-      fallbackSource = "runtime";
-    }
-    if (skipReason) {
-      const normalized = normalizeSkipStatsReason(skipReason, fallbackSource);
-      const reasons = stats.reasonGroups.get(normalized.source) ?? /* @__PURE__ */ new Map();
-      reasons.set(normalized.reason, (reasons.get(normalized.reason) ?? 0) + 1);
-      stats.reasonGroups.set(normalized.source, reasons);
-    }
-    evaluationStats.set(evaluation.strategy, stats);
-  }
   for (const trade of trades) {
     strategyNames.add(trade.strategy);
     const stats = tradeStats.get(trade.strategy) ?? {
@@ -494,7 +540,7 @@ var buildSummaryMessage = ({
     return lines.join("\n");
   }
   const appendEvaluationDetails = (strategyName) => {
-    const evaluation = evaluationStats.get(strategyName);
+    const evaluation = evaluationStatsByStrategy.get(strategyName);
     if (!evaluation) {
       return;
     }
@@ -524,7 +570,7 @@ var buildSummaryMessage = ({
   for (const strategyName of sortedStrategies) {
     const stats = signalStats.get(strategyName);
     if (!stats || stats.size === 0) {
-      const evaluation = evaluationStats.get(strategyName);
+      const evaluation = evaluationStatsByStrategy.get(strategyName);
       lines.push("");
       lines.push(
         evaluation?.evaluated ? `<b>${escapeHtml(strategyName)}</b>
@@ -593,10 +639,10 @@ var signalsSummary = async () => {
   const connector = await connectorFactory({
     userName: flags.user
   });
-  const [configuredStrategyNames, signals, signalEvaluations, trades] = await Promise.all([
+  const [configuredStrategyNames, signals, evaluationStatsBuckets, trades] = await Promise.all([
     loadRuntimeStrategyNames(flags.user),
     loadRuntimeSignals(flags.user),
-    loadRuntimeSignalEvaluations(flags.user),
+    loadRuntimeSignalEvaluationStatsBuckets(flags.user),
     loadRuntimeTrades(flags.user)
   ]);
   const syncedTrades = await syncRuntimeTrades({
@@ -607,16 +653,23 @@ var signalsSummary = async () => {
     endTime
   });
   const windowSignals = signals.filter(
-    (signal) => signal.timestamp >= startTime && signal.timestamp <= endTime
-  );
-  const windowSignalEvaluations = signalEvaluations.filter(
-    (evaluation) => evaluation.timestamp >= startTime && evaluation.timestamp <= endTime
+    (signal) => signal.timestamp >= startTime && signal.timestamp < endTime
   );
+  const windowDayKeys = new Set(getRuntimeStorageDayKeys(startTime, endTime));
+  const windowEvaluationStats = /* @__PURE__ */ new Map();
+  for (const entry of evaluationStatsBuckets) {
+    if (!windowDayKeys.has(entry.dayKey)) {
+      continue;
+    }
+    const stats = windowEvaluationStats.get(entry.strategy) ?? createRuntimeSignalStats();
+    mergeRuntimeSignalStats(stats, entry.stats);
+    windowEvaluationStats.set(entry.strategy, stats);
+  }
   const signalIds = new Set(
     signals.map((signal) => signal.signalId).filter(Boolean)
   );
   const windowTrades = syncedTrades.filter(
-    (trade) => trade.entryTimestamp >= startTime && trade.entryTimestamp <= endTime && trade.signalId != null && signalIds.has(trade.signalId)
+    (trade) => trade.entryTimestamp >= startTime && trade.entryTimestamp < endTime && trade.signalId != null && signalIds.has(trade.signalId)
   );
   const message = buildSummaryMessage({
     hours,
@@ -624,14 +677,18 @@ var signalsSummary = async () => {
     endTime,
     configuredStrategyNames,
     signals: windowSignals,
-    signalEvaluations: windowSignalEvaluations,
+    evaluationStatsByStrategy: windowEvaluationStats,
     trades: windowTrades
   });
+  const windowEvaluationsCount = [...windowEvaluationStats.values()].reduce(
+    (sum, stats) => sum + stats.evaluated,
+    0
+  );
   import_logger.logger.info(
     "signals summary window=%sh signals=%s evaluations=%s trades=%s connector=%s user=%s",
     hours,
     windowSignals.length,
-    windowSignalEvaluations.length,
+    windowEvaluationsCount,
     windowTrades.length,
     connectorName,
     flags.user

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/cli",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Official CLI for the TradeJS open-source framework: infra setup, backtests, signals, bots, and ML workflows.",
   "keywords": [
     "tradejs",
@@ -29,14 +29,14 @@
     "tradejs": "dist/cli.js"
   },
   "dependencies": {
-    "@tradejs/base": "^1.0.8",
-    "@tradejs/connectors": "^1.0.8",
-    "@tradejs/core": "^1.0.8",
-    "@tradejs/indicators": "^1.0.8",
-    "@tradejs/infra": "^1.0.8",
-    "@tradejs/node": "^1.0.8",
-    "@tradejs/strategies": "^1.0.8",
-    "@tradejs/types": "^1.0.8",
+    "@tradejs/base": "^1.0.9",
+    "@tradejs/connectors": "^1.0.9",
+    "@tradejs/core": "^1.0.9",
+    "@tradejs/indicators": "^1.0.9",
+    "@tradejs/infra": "^1.0.9",
+    "@tradejs/node": "^1.0.9",
+    "@tradejs/strategies": "^1.0.9",
+    "@tradejs/types": "^1.0.9",
     "args": "^5.0.3",
     "bcryptjs": "^2.4.3",
     "chalk": "4.1.2",