@tradejs/cli 1.0.6 → 1.0.9

package/dist/scripts/signals.js

@@ -35,17 +35,520 @@ __export(signals_exports, {
 module.exports = __toCommonJS(signals_exports);
 var import_config = require("dotenv/config");
 var import_args = __toESM(require("args"));
-var import_progress = __toESM(require("progress"));
+var import_progress2 = __toESM(require("progress"));
 var import_connectors = require("@tradejs/connectors");
-var import_chalk = __toESM(require("chalk"));
+var import_chalk2 = __toESM(require("chalk"));
 var import_connectors2 = require("@tradejs/node/connectors");
 var import_cli = require("@tradejs/node/cli");
-var import_async = require("@tradejs/core/async");
-var import_constants = require("@tradejs/core/constants");
+var import_async2 = require("@tradejs/core/async");
+var import_constants2 = require("@tradejs/core/constants");
 var import_strategies = require("@tradejs/node/strategies");
 var import_time = require("@tradejs/core/time");
 var import_logger = require("@tradejs/infra/logger");
 var import_redis = require("@tradejs/infra/redis");
+
+// src/lib/derivativesContextBackfill.ts
+var import_chalk = __toESM(require("chalk"));
+var import_progress = __toESM(require("progress"));
+var import_async = require("@tradejs/core/async");
+var import_constants = require("@tradejs/core/constants");
+var import_indicators = require("@tradejs/core/indicators");
+var import_timescale = require("@tradejs/infra/timescale");
+var import_userSettings = require("@tradejs/infra/userSettings");
+var HOUR_MS = 60 * 60 * 1e3;
+var DAY_MS = 24 * HOUR_MS;
+var DEFAULT_LOOKBACK_HOURS = 48;
+var DEFAULT_INTERVALS = ["15m", "1h"];
+var coinalyzeIntervalMap = {
+  "15m": "15min",
+  "1h": "1hour"
+};
+var lastRequestTs = 0;
+var asInt = (value, fallback) => {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var parseList = (value) => String(value ?? "").split(",").map((item) => item.trim().toUpperCase()).filter(Boolean);
+var normalizeSymbols = (symbols) => [
+  ...new Set(
+    symbols.map(
+      (symbol) => String(symbol || "").trim().toUpperCase()
+    ).filter(Boolean)
+  )
+];
+var resolveDerivativesContextBackfillSymbols = (_requestedSymbols = []) => [...import_constants.DERIVATIVES_CONTEXT_REFERENCE_SYMBOLS];
+var chunkArray = (items, size) => {
+  const chunks = [];
+  for (let i = 0; i < items.length; i += size) {
+    chunks.push(items.slice(i, i + size));
+  }
+  return chunks;
+};
+var isSignalsDerivativesContextEnabled = () => isDerivativesContextBackfillEnabled("CRON");
+var isDerivativesContextBackfillEnabled = (env) => {
+  const normalized = String(process.env.DERIVATIVES_CONTEXT_ENABLED ?? "").trim().toLowerCase();
+  if (!normalized) return false;
+  if (["1", "true", "yes", "on"].includes(normalized)) {
+    return true;
+  }
+  if (normalized === "backtest") {
+    return env === "BACKTEST";
+  }
+  if (normalized === "live") {
+    return env !== "BACKTEST";
+  }
+  return false;
+};
+var shouldBackfillDerivativesContextForSignals = (params) => !params.cacheOnly && isSignalsDerivativesContextEnabled();
+var resolveDerivativesContextIntervals = () => {
+  const intervals = (0, import_indicators.normalizeDerivativesIntervals)(
+    process.env.DERIVATIVES_CONTEXT_INTERVALS
+  );
+  return intervals.length ? intervals : DEFAULT_INTERVALS;
+};
+var resolveDerivativesContextLookbackMs = () => {
+  const hours = Number(process.env.DERIVATIVES_CONTEXT_LOOKBACK_HOURS);
+  const normalizedHours = Number.isFinite(hours) && hours > 0 ? hours : DEFAULT_LOOKBACK_HOURS;
+  return normalizedHours * HOUR_MS;
+};
+var resolveDerivativesContextBackfillWindow = (params) => {
+  const { startMs, endMs, preloadStartMs, nowMs = Date.now() } = params;
+  const safeEndMs = Math.min(endMs, nowMs);
+  const safeStartMs = Math.max(0, Math.min(startMs, safeEndMs));
+  const lookbackFromMs = safeStartMs - resolveDerivativesContextLookbackMs();
+  const requestedFromMs = preloadStartMs != null ? Math.max(Number(preloadStartMs), lookbackFromMs) : lookbackFromMs;
+  const fromMs = Math.max(
+    0,
+    Math.min(
+      Number.isFinite(requestedFromMs) ? requestedFromMs : safeStartMs,
+      safeStartMs
+    )
+  );
+  return {
+    fromMs: Math.trunc(fromMs),
+    toMs: Math.trunc(safeEndMs),
+    testStartMs: Math.trunc(safeStartMs)
+  };
+};
+var getCoinalyzeApiKey = async (userName) => {
+  const settings = await (0, import_userSettings.getUserSettings)(userName);
+  return settings.COINALYZE_API_KEY.trim() || String(process.env.COINALYZE_API_KEY ?? "").trim();
+};
+var getCoinalyzeBaseUrl = () => process.env.COINALYZE_BASE_URL?.trim() || "https://api.coinalyze.net/v1";
+var getRequestDelayMs = () => Math.max(
+  100,
+  asInt(
+    process.env.DERIVATIVES_CONTEXT_BACKFILL_REQUEST_DELAY_MS ?? process.env.COINALYZE_MIN_REQUEST_DELAY_MS,
+    200
+  )
+);
+var getRequestTimeoutMs = () => Math.max(5e3, asInt(process.env.COINALYZE_REQUEST_TIMEOUT_MS, 45e3));
+var fetchJsonWithRateLimit = async (url, apiKey) => {
+  const requestDelayMs = getRequestDelayMs();
+  const requestTimeoutMs = getRequestTimeoutMs();
+  const maxRetries = asInt(process.env.COINALYZE_MAX_RETRIES, 4);
+  for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+    const waitMs = Math.max(0, lastRequestTs + requestDelayMs - Date.now());
+    if (waitMs > 0) {
+      await (0, import_async.delay)(waitMs);
+    }
+    lastRequestTs = Date.now();
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), requestTimeoutMs);
+    let response;
+    try {
+      response = await fetch(url, {
+        headers: {
+          api_key: apiKey,
+          "x-api-key": apiKey,
+          Authorization: `Bearer ${apiKey}`
+        },
+        signal: controller.signal
+      });
+    } catch (error) {
+      clearTimeout(timer);
+      const abortError = error instanceof Error && (error.name === "AbortError" || String(error.message).toLowerCase().includes("aborted"));
+      if (attempt < maxRetries && abortError) {
+        await (0, import_async.delay)(Math.min(12e3, 800 * 2 ** attempt));
+        continue;
+      }
+      throw error;
+    } finally {
+      clearTimeout(timer);
+    }
+    if (response.ok) {
+      return response.json();
+    }
+    const text = await response.text();
+    const retryAfterRaw = Number(response.headers.get("retry-after") ?? "");
+    const retryAfterMs = Number.isFinite(retryAfterRaw) && retryAfterRaw > 0 ? retryAfterRaw * 1e3 : null;
+    const transient = response.status === 429 || response.status >= 500;
+    if (attempt < maxRetries && transient) {
+      await (0, import_async.delay)(retryAfterMs ?? Math.min(12e3, 800 * 2 ** attempt));
+      continue;
+    }
+    throw new Error(`Coinalyze ${response.status}: ${text}`);
+  }
+  throw new Error("Coinalyze request failed after retries");
+};
+var fetchCoinalyzeMarkets = async (apiKey) => {
+  const raw = await fetchJsonWithRateLimit(
+    `${getCoinalyzeBaseUrl()}/future-markets`,
+    apiKey
+  );
+  return Array.isArray(raw) ? raw : [];
+};
+var selectBestMarket = (candidates, exchangePriority) => {
+  const scored = candidates.map((item) => {
+    let score = 0;
+    if (item.is_perpetual) score += 50;
+    if (String(item.quote_asset || "").toUpperCase() === "USDT") score += 25;
+    if (item.symbol.includes("_PERP")) score += 10;
+    const exchange = String(item.exchange || "").toUpperCase();
+    const idx = exchangePriority.indexOf(exchange);
+    if (idx >= 0) {
+      score += (exchangePriority.length - idx) * 10;
+    }
+    return { item, score };
+  });
+  scored.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    return a.item.symbol.localeCompare(b.item.symbol);
+  });
+  return scored[0]?.item ?? null;
+};
+var buildMatches = (tickers, markets, exchangePriority) => {
+  const marketByTicker = /* @__PURE__ */ new Map();
+  for (const market of markets) {
+    const key = String(market.symbol_on_exchange || "").trim().toUpperCase();
+    if (!key) continue;
+    const list = marketByTicker.get(key) ?? [];
+    list.push(market);
+    marketByTicker.set(key, list);
+  }
+  const matches = [];
+  const unmatched = [];
+  for (const ticker of tickers) {
+    const candidates = marketByTicker.get(ticker) ?? [];
+    const selected = selectBestMarket(candidates, exchangePriority);
+    if (!selected) {
+      unmatched.push(ticker);
+      continue;
+    }
+    matches.push({
+      symbol: ticker,
+      marketSymbol: selected.symbol,
+      exchange: selected.exchange
+    });
+  }
+  return { matches, unmatched };
+};
+var normalizeMetricPoint = (metric, point) => {
+  if (metric === "oi") {
+    return {
+      ...point,
+      open_interest: point.open_interest ?? point.openInterest ?? point.oi ?? point.c
+    };
+  }
+  if (metric === "funding") {
+    return {
+      ...point,
+      funding_rate: point.funding_rate ?? point.fundingRate ?? point.rate ?? point.c
+    };
+  }
+  return {
+    ...point,
+    liq_long: point.liq_long ?? point.long_liq ?? point.long ?? point.l,
+    liq_short: point.liq_short ?? point.short_liq ?? point.short ?? point.s
+  };
+};
+var toSeriesMap = (raw, metric) => {
+  const out = /* @__PURE__ */ new Map();
+  if (!Array.isArray(raw)) return out;
+  for (const item of raw) {
+    const symbol = String(item.symbol || "").trim().toUpperCase();
+    const history = Array.isArray(item.history) ? item.history : [];
+    if (!symbol) continue;
+    out.set(
+      symbol,
+      history.filter((point) => point && typeof point === "object").map((point) => normalizeMetricPoint(metric, point))
+    );
+  }
+  return out;
+};
+var fetchMetricBatch = async (params) => {
+  const { endpoint, metric, marketSymbols, apiKey, interval: interval2, fromMs, toMs } = params;
+  const url = new URL(`${getCoinalyzeBaseUrl()}${endpoint}`);
+  url.searchParams.set("symbols", marketSymbols.join(","));
+  url.searchParams.set("interval", coinalyzeIntervalMap[interval2] || interval2);
+  url.searchParams.set("from", String(Math.floor(fromMs / 1e3)));
+  url.searchParams.set("to", String(Math.floor(toMs / 1e3)));
+  const raw = await fetchJsonWithRateLimit(url.toString(), apiKey);
+  return toSeriesMap(raw, metric);
+};
+var skippedBackfillResult = () => ({
+  skipped: true,
+  rows: 0,
+  matchedSymbols: 0,
+  unmatchedSymbols: 0,
+  failedWindows: 0,
+  skippedWindows: 0
+});
+var backfillDerivativesContext = async (params, enabled) => {
+  const { userName, startMs, endMs } = params;
+  const requestedSymbols = normalizeSymbols(params.symbols);
+  const symbols = resolveDerivativesContextBackfillSymbols(requestedSymbols);
+  if (!enabled || !requestedSymbols.length || !symbols.length) {
+    return skippedBackfillResult();
+  }
+  const intervals = resolveDerivativesContextIntervals();
+  if (!intervals.length) {
+    return skippedBackfillResult();
+  }
+  const apiKey = await getCoinalyzeApiKey(userName);
+  if (!apiKey) {
+    throw new Error(
+      `Missing COINALYZE_API_KEY for derivatives context backfill (user=${userName})`
+    );
+  }
+  const {
+    fromMs,
+    toMs: safeEndMs,
+    testStartMs: safeStartMs
+  } = resolveDerivativesContextBackfillWindow({
+    startMs,
+    endMs,
+    preloadStartMs: params.preloadStartMs
+  });
+  if (safeEndMs <= fromMs) {
+    return skippedBackfillResult();
+  }
+  const exchangePriority = parseList(
+    process.env.COINALYZE_EXCHANGE_PRIORITY || process.env.DERIVATIVES_CONTEXT_EXCHANGE_PRIORITY || "A,6,0"
+  );
+  const markets = await fetchCoinalyzeMarkets(apiKey);
+  if (!markets.length) {
+    throw new Error("No markets returned by Coinalyze /future-markets");
+  }
+  const { matches, unmatched } = buildMatches(
+    symbols,
+    markets,
+    exchangePriority
+  );
+  if (!matches.length) {
+    throw new Error(
+      "No matched derivatives reference symbols between BTC/ETH and Coinalyze"
+    );
+  }
+  await (0, import_timescale.waitForDbReady)();
+  const batchDays = asInt(
+    process.env.DERIVATIVES_CONTEXT_BACKFILL_BATCH_DAYS,
+    30
+  );
+  const symbolBatchSize = asInt(
+    process.env.DERIVATIVES_CONTEXT_BACKFILL_SYMBOL_BATCH_SIZE,
+    8
+  );
+  const symbolBatches = chunkArray(matches, symbolBatchSize);
+  const windowsPerPair = Math.ceil((safeEndMs - fromMs) / (batchDays * DAY_MS));
+  const totalWindows = symbolBatches.length * intervals.length * windowsPerPair;
+  const bar = new import_progress.default(
+    ":current/:total [:bar][:percent] :eta(s) :batch rows=:rows fail=:fail skip=:skip",
+    {
+      total: Math.max(1, totalWindows),
+      width: 24
+    }
+  );
+  const oiPath = process.env.COINALYZE_OI_PATH?.trim() || "/open-interest-history";
+  const fundingPath = process.env.COINALYZE_FUNDING_PATH?.trim() || "/funding-rate-history";
+  const liqPath = process.env.COINALYZE_LIQ_PATH?.trim() || "/liquidation-history";
+  let totalRows = 0;
+  let failedWindows = 0;
+  let skippedWindows = 0;
+  console.log(
+    import_chalk.default.cyan(
+      `derivatives context backfill: referenceSymbols=${matches.length}, requestedSymbols=${requestedSymbols.length}, unmatched=${unmatched.length}, intervals=${intervals.join(",")}, window=${new Date(fromMs).toISOString()}..${new Date(safeEndMs).toISOString()}, testStart=${new Date(safeStartMs).toISOString()}`
+    )
+  );
+  for (const interval2 of intervals) {
+    const edgesBySymbol = await (0, import_timescale.getDerivativesDataEdgesForSymbols)(
+      matches.map((item) => item.symbol),
+      interval2
+    );
+    for (let batchIdx = 0; batchIdx < symbolBatches.length; batchIdx += 1) {
+      const batch = symbolBatches[batchIdx];
+      let cursor = fromMs;
+      while (cursor < safeEndMs) {
+        const toMs = Math.min(safeEndMs, cursor + batchDays * DAY_MS);
+        const missingBatch = batch.filter((item) => {
+          const edges = edgesBySymbol.get(item.symbol.toUpperCase());
+          return edges?.min == null || edges?.max == null || edges.min > cursor || edges.max < toMs;
+        });
+        try {
+          if (!missingBatch.length) {
+            skippedWindows += 1;
+          } else {
+            const marketSymbols = missingBatch.map((item) => item.marketSymbol);
+            const oiMap = await fetchMetricBatch({
+              endpoint: oiPath,
+              metric: "oi",
+              marketSymbols,
+              apiKey,
+              interval: interval2,
+              fromMs: cursor,
+              toMs
+            });
+            const fundingMap = await fetchMetricBatch({
+              endpoint: fundingPath,
+              metric: "funding",
+              marketSymbols,
+              apiKey,
+              interval: interval2,
+              fromMs: cursor,
+              toMs
+            });
+            const liqMap = await fetchMetricBatch({
+              endpoint: liqPath,
+              metric: "liq",
+              marketSymbols,
+              apiKey,
+              interval: interval2,
+              fromMs: cursor,
+              toMs
+            });
+            const rows = missingBatch.flatMap((item) => {
+              const marketSymbol = item.marketSymbol.toUpperCase();
+              const points = (0, import_indicators.mergeCoinalyzeMetrics)({
+                symbol: item.symbol,
+                oiRaw: oiMap.get(marketSymbol) ?? [],
+                fundingRaw: fundingMap.get(marketSymbol) ?? [],
+                liqRaw: liqMap.get(marketSymbol) ?? []
+              });
+              return (0, import_indicators.coinalyzePointsToRows)(points, interval2, "coinalyze");
+            });
+            if (rows.length) {
+              await (0, import_timescale.upsertDerivatives)(rows);
+              totalRows += rows.length;
+            }
+          }
+        } catch (error) {
+          failedWindows += 1;
+          console.error(
+            import_chalk.default.red(
+              `derivatives context backfill window failed batch=${batchIdx + 1}/${symbolBatches.length} interval=${interval2} ${new Date(cursor).toISOString()}..${new Date(toMs).toISOString()}: ${error}`
+            )
+          );
+        } finally {
+          bar.tick(1, {
+            batch: import_chalk.default.gray(
+              `${batchIdx + 1}/${symbolBatches.length} ${interval2}`
+            ),
+            rows: totalRows,
+            fail: failedWindows,
+            skip: skippedWindows
+          });
+        }
+        cursor = toMs + 1;
+      }
+    }
+  }
+  console.log("");
+  console.log(
+    import_chalk.default.green(
+      `derivatives context backfill done: rows=${totalRows}, failed_windows=${failedWindows}, skipped_windows=${skippedWindows}`
+    )
+  );
+  if (failedWindows > 0) {
+    throw new Error(
+      `Derivatives context backfill failed for ${failedWindows} window(s)`
+    );
+  }
+  return {
+    skipped: false,
+    rows: totalRows,
+    matchedSymbols: matches.length,
+    unmatchedSymbols: unmatched.length,
+    failedWindows,
+    skippedWindows
+  };
+};
+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");
 import_args.default.option(["l", "tickersLimit"], "Tickers limit");
@@ -68,11 +571,50 @@ import_args.default.option(
   "Connector provider or name for signals (e.g. bybit, binance, coinbase, custom)",
   "bybit"
 );
-var PRELOAD_START = (0, import_time.getTimestamp)(import_constants.SIGNALS_CLI_PRELOAD_DAYS);
+var PRELOAD_START = (0, import_time.getTimestamp)(import_constants2.SIGNALS_CLI_PRELOAD_DAYS);
 var projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
 var flags = import_args.default.parse(process.argv);
 var interval = flags.timeframe.toString();
 var formatElapsed = (startedAt) => `${((Date.now() - startedAt) / 1e3).toFixed(1)}s`;
+var formatDuration = (startedAt) => {
+  const seconds = (Date.now() - startedAt) / 1e3;
+  if (seconds < 60) return `${seconds.toFixed(1)}s`;
+  const minutes = Math.floor(seconds / 60);
+  const restSeconds = Math.round(seconds % 60);
+  return `${minutes}m ${restSeconds}s`;
+};
+var timeOperation = async (label, operation) => {
+  const startedAt = Date.now();
+  try {
+    return await operation();
+  } finally {
+    import_logger.logger.info(import_chalk2.default.gray(`${label}: done in ${formatDuration(startedAt)}`));
+  }
+};
+var normalizeHookList = (value) => {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  return value ? [value] : [];
+};
+var invokeBeforeSignalsHooks = async (hooks, params) => {
+  for (const hook of normalizeHookList(
+    hooks?.beforeSignals
+  )) {
+    const result = await hook(params);
+    if (result?.abort === true) {
+      return result;
+    }
+  }
+  return void 0;
+};
+var invokeAfterSignalsHooks = async (hooks, params) => {
+  for (const hook of normalizeHookList(
+    hooks?.afterSignals
+  )) {
+    await hook(params);
+  }
+};
 var resolveStrategyNameByConfigKey = (userName, key) => {
   const parts = key.split(":");
   if (parts.length !== 5) {
@@ -121,15 +663,56 @@ var createStrategySkipStats = (runtimeStrategies) => new Map(
     }
   ])
 );
-var recordStrategyReason = (strategyStats, strategyName, reason) => {
+var recordStrategyReason = (strategyStats, strategyName, reason, fallbackSource = "core") => {
   const stats = strategyStats.get(strategyName);
   if (!stats) {
     return;
   }
-  stats.reasons.set(reason, (stats.reasons.get(reason) ?? 0) + 1);
+  const normalized = normalizeRuntimeSignalSkipReason(reason, fallbackSource);
+  const normalizedReason = `${normalized.source} / ${normalized.reason}`;
+  stats.reasons.set(
+    normalizedReason,
+    (stats.reasons.get(normalizedReason) ?? 0) + 1
+  );
+};
+var buildRuntimeSignalEvaluationId = ({
+  strategyName,
+  symbol,
+  timestamp
+}) => `${strategyName}:${symbol}:${timestamp}`;
+var getTelegramDeliverableSignals = (signals2) => signals2.filter(
+  (signal) => signal.orderStatus !== "skipped" && signal.orderStatus !== "canceled"
+);
+var saveRuntimeSignalEvaluation = async (evaluation) => {
+  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,
+      dayKey,
+      evaluation.strategy
+    ),
+    buildRuntimeSignalStatsIncrements(evaluation),
+    {
+      expire: import_constants2.TTL_10D
+    }
+  );
 };
 var logStrategySkipStats = (runtimeStrategies, strategyStats) => {
-  import_logger.logger.info(import_chalk.default.yellow("skip stats:"));
+  import_logger.logger.info(import_chalk2.default.yellow("skip stats:"));
   for (const { strategyName } of runtimeStrategies) {
     const stats = strategyStats.get(strategyName);
     if (!stats) {
@@ -181,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) {
@@ -209,20 +794,74 @@ var findSignals = async (symbol, connector, btcBinanceData, btcCoinbaseData, run
     });
     const signal = await strategy(lastCandle, btcLastCandle);
     if (!signal || typeof signal === "string") {
+      const reason = typeof signal === "string" && signal.trim() ? signal : "NO_SIGNAL";
       if (typeof signal === "string") {
-        recordStrategyReason(strategyStats, strategyName, signal);
+        recordStrategyReason(strategyStats, strategyName, signal, "core");
       }
+      await saveRuntimeSignalEvaluation({
+        evaluationId: buildRuntimeSignalEvaluationId({
+          strategyName,
+          symbol,
+          timestamp: lastCandle.timestamp
+        }),
+        userName: flags.user,
+        strategy: strategyName,
+        symbol,
+        interval,
+        timestamp: lastCandle.timestamp,
+        evaluatedAt: Date.now(),
+        status: "skip",
+        reason
+      });
       continue;
     }
     if (stats) {
       stats.signals += 1;
     }
+    if (signal.orderStatus === "skipped" && typeof signal.orderSkipReason === "string" && signal.orderSkipReason.trim()) {
+      recordStrategyReason(
+        strategyStats,
+        strategyName,
+        signal.orderSkipReason,
+        "runtime"
+      );
+    }
     strategySignals.push(signal);
-    await (0, import_redis.setData)(import_redis.redisKeys.signal(symbol, signal.signalId), signal, {
-      expire: import_constants.TTL_1D
-    });
     await (0, import_redis.setData)(import_redis.redisKeys.storeSignal(symbol, signal.signalId), signal, {
-      expire: import_constants.TTL_3M
+      expire: import_constants2.TTL_10D
+    });
+    await (0, import_redis.setHashJsonField)(
+      import_redis.redisKeys.runtimeSignalBucket(
+        flags.user,
+        getRuntimeStorageDayKey(signal.timestamp),
+        signal.strategy
+      ),
+      signal.signalId,
+      toRuntimeSignalBucketRef(signal),
+      {
+        expire: import_constants2.TTL_10D
+      }
+    );
+    await saveRuntimeSignalEvaluation({
+      evaluationId: buildRuntimeSignalEvaluationId({
+        strategyName,
+        symbol,
+        timestamp: lastCandle.timestamp
+      }),
+      userName: flags.user,
+      strategy: strategyName,
+      symbol,
+      interval,
+      timestamp: lastCandle.timestamp,
+      evaluatedAt: Date.now(),
+      status: "signal",
+      reason: signal.orderSkipReason || signal.orderStatus || "SIGNAL",
+      signalId: signal.signalId,
+      direction: signal.direction,
+      orderStatus: signal.orderStatus,
+      orderSkipReason: signal.orderSkipReason,
+      ...signal.aiAnalysis ? { aiAnalysis: signal.aiAnalysis } : {},
+      ...signal.ml ? { ml: signal.ml } : {}
     });
     import_logger.logger.info("Signal found %s by strategy %s", symbol, strategyName);
   }
@@ -232,6 +871,8 @@ var signals = async () => {
   const startedAt = Date.now();
   const signals2 = new Array();
   let status = "completed";
+  let projectHooks;
+  let afterSignalsHookContext = null;
   try {
     const connectorName = await resolveSignalsConnectorName(flags.connector);
     const connectorFactory = await (0, import_connectors2.getConnectorCreatorByName)(
@@ -276,61 +917,91 @@ var signals = async () => {
         );
       }
     }
-    const tickers = await (0, import_cli.getTickers)(
-      marketConnector,
-      flags.tickers,
-      flags.exclude,
-      flags.tickersLimit,
-      flags.chunk
+    const tickers = await timeOperation(
+      "tickers load",
+      () => (0, import_cli.getTickers)(
+        marketConnector,
+        flags.tickers,
+        flags.exclude,
+        flags.tickersLimit,
+        flags.chunk
+      )
     );
     if (flags.showTickersList) {
-      console.log(import_chalk.default.gray(JSON.stringify(tickers.sort(), null, 2)));
+      console.log(import_chalk2.default.gray(JSON.stringify(tickers.sort(), null, 2)));
       return;
     }
+    const projectConfig = await (0, import_cli.loadTradejsConfig)(projectRoot);
+    projectHooks = projectConfig.hooks;
     if (!flags.cacheOnly) {
-      await (0, import_cli.update)(
-        marketConnector,
-        interval,
-        tickers,
-        import_constants.SIGNALS_CLI_PRELOAD_DAYS
+      await timeOperation(
+        `update ${connectorName}`,
+        () => (0, import_cli.update)(marketConnector, interval, tickers, import_constants2.SIGNALS_CLI_PRELOAD_DAYS, {
+          connectorLabel: connectorName
+        })
       );
       if (btcBinanceConnector !== marketConnector) {
-        await (0, import_cli.update)(
-          btcBinanceConnector,
-          interval,
-          ["BTCUSDT"],
-          import_constants.SIGNALS_CLI_PRELOAD_DAYS
+        await timeOperation(
+          `update ${import_connectors.ConnectorNames.Binance}`,
+          () => (0, import_cli.update)(
+            btcBinanceConnector,
+            interval,
+            ["BTCUSDT"],
+            import_constants2.SIGNALS_CLI_PRELOAD_DAYS,
+            { connectorLabel: import_connectors.ConnectorNames.Binance }
+          )
         );
       }
       if (btcCoinbaseConnector !== marketConnector) {
-        await (0, import_cli.update)(
-          btcCoinbaseConnector,
-          interval,
-          ["BTCUSDT"],
-          import_constants.SIGNALS_CLI_PRELOAD_DAYS
+        await timeOperation(
+          `update ${import_connectors.ConnectorNames.Coinbase}`,
+          () => (0, import_cli.update)(
+            btcCoinbaseConnector,
+            interval,
+            ["BTCUSDT"],
+            import_constants2.SIGNALS_CLI_PRELOAD_DAYS,
+            { connectorLabel: import_connectors.ConnectorNames.Coinbase }
+          )
         );
       }
     }
     const currentTimestamp = (0, import_time.getTimestamp)();
-    const [btcBinanceData, btcCoinbaseData] = await Promise.all([
-      btcBinanceConnector.kline({
-        symbol: "BTCUSDT",
-        start: PRELOAD_START,
-        end: currentTimestamp,
-        cacheOnly: true,
-        interval
-      }),
-      btcCoinbaseConnector.kline({
-        symbol: "BTCUSDT",
-        start: PRELOAD_START,
-        end: currentTimestamp,
-        cacheOnly: true,
-        interval
-      })
-    ]);
+    if (shouldBackfillDerivativesContextForSignals({
+      cacheOnly: Boolean(flags.cacheOnly)
+    })) {
+      await timeOperation(
+        "derivatives context backfill",
+        () => backfillDerivativesContextForSignals({
+          userName: flags.user,
+          symbols: tickers,
+          startMs: currentTimestamp,
+          endMs: currentTimestamp,
+          preloadStartMs: PRELOAD_START
+        })
+      );
+    }
     if (flags.updateOnly) {
       return;
     }
+    const [btcBinanceData, btcCoinbaseData] = await timeOperation(
+      "reference candles load",
+      () => Promise.all([
+        btcBinanceConnector.kline({
+          symbol: "BTCUSDT",
+          start: PRELOAD_START,
+          end: currentTimestamp,
+          cacheOnly: true,
+          interval
+        }),
+        btcCoinbaseConnector.kline({
+          symbol: "BTCUSDT",
+          start: PRELOAD_START,
+          end: currentTimestamp,
+          cacheOnly: true,
+          interval
+        })
+      ])
+    );
     const runtimeStrategies = await loadRuntimeStrategies(flags.user);
     if (!runtimeStrategies.length) {
       import_logger.logger.warn(
@@ -340,20 +1011,44 @@ var signals = async () => {
       return;
     }
     import_logger.logger.info(
-      import_chalk.default.yellow(
-        `loaded strategies: ${runtimeStrategies.map((s) => s.strategyName).join(", ")}`
+      import_chalk2.default.yellow(
+        `loaded strategies (user=${flags.user}): ${runtimeStrategies.map((s) => s.strategyName).join(", ")}`
+      )
+    );
+    afterSignalsHookContext = {
+      connector: marketConnector,
+      connectorName,
+      userName: flags.user,
+      interval,
+      tickers: [...tickers],
+      runtimeStrategies: runtimeStrategies.map(
+        ({ strategyName, strategyConfig }) => ({
+          strategyName,
+          strategyConfig
+        })
       )
+    };
+    const beforeSignalsResult = await invokeBeforeSignalsHooks(
+      projectHooks,
+      afterSignalsHookContext
     );
+    if (beforeSignalsResult?.abort === true) {
+      import_logger.logger.info(
+        "signals aborted before ticker evaluation: %s",
+        beforeSignalsResult.reason ?? "PROJECT_BEFORE_SIGNALS_ABORTED"
+      );
+      return;
+    }
     const strategyStats = createStrategySkipStats(runtimeStrategies);
-    const bar = new import_progress.default(
+    const bar = new import_progress2.default(
       ":current/:total [:bar][:percent] :found :eta(s) :symbol",
       {
         total: tickers.length,
         width: 30
       }
     );
-    import_logger.logger.info(import_chalk.default.yellow(`tickers: ${tickers.length}`));
-    await (0, import_async.runWithConcurrency)(tickers, 5, async (symbol) => {
+    import_logger.logger.info(import_chalk2.default.yellow(`tickers: ${tickers.length}`));
+    await (0, import_async2.runWithConcurrency)(tickers, 5, async (symbol) => {
       const strategySignals = await findSignals(
         symbol,
         marketConnector,
@@ -366,15 +1061,16 @@ var signals = async () => {
         signals2.push(...strategySignals);
       }
       bar.tick(1, {
-        found: import_chalk.default.cyan(signals2.length),
-        symbol: import_chalk.default.gray(symbol)
+        found: import_chalk2.default.cyan(signals2.length),
+        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(
@@ -394,8 +1090,23 @@ var signals = async () => {
     );
     throw error;
   } finally {
+    if (projectHooks && afterSignalsHookContext) {
+      try {
+        await invokeAfterSignalsHooks(projectHooks, {
+          ...afterSignalsHookContext,
+          signals: [...signals2],
+          status,
+          durationMs: Date.now() - startedAt
+        });
+      } catch (error) {
+        import_logger.logger.error(
+          "afterSignals hook failed: %s",
+          error?.message || String(error)
+        );
+      }
+    }
     import_logger.logger.info(
-      import_chalk.default.yellow(
+      import_chalk2.default.yellow(
         `signals ${status} in ${formatElapsed(startedAt)} (found=${signals2.length})`
       )
     );