@tradejs/cli 2.0.6 → 2.0.7

package/dist/scripts/signalsDaemon.js

@@ -1648,9 +1648,9 @@ var import_chalk7 = __toESM(require("chalk"));
 var import_connectors6 = require("@tradejs/node/connectors");
 var import_cli2 = require("@tradejs/node/cli");
 var import_async3 = require("@tradejs/core/async");
-var import_strategies2 = require("@tradejs/core/strategies");
+var import_strategies3 = require("@tradejs/core/strategies");
 var import_constants3 = require("@tradejs/core/constants");
-var import_strategies3 = require("@tradejs/node/strategies");
+var import_strategies4 = require("@tradejs/node/strategies");
 var import_time3 = require("@tradejs/core/time");
 var import_logger4 = require("@tradejs/infra/logger");
 var import_redis5 = require("@tradejs/infra/redis");
@@ -1662,6 +1662,7 @@ var import_time = require("@tradejs/core/time");
 var SECONDS_PER_DAY = 86400;
 var RUNTIME_SIGNAL_RETENTION_DAYS_ENV = "RUNTIME_SIGNAL_RETENTION_DAYS";
 var DEFAULT_RUNTIME_SIGNAL_RETENTION_TTL_SECONDS = import_constants.TTL_3D;
+var RUNTIME_LINEAGE_SCOPE_RETENTION_TTL_SECONDS = import_constants.TTL_1M;
 var parsePositiveNumber = (value) => {
   if (value == null || value === "") {
     return null;
@@ -1823,6 +1824,7 @@ var import_progress = __toESM(require("progress"));
 var import_chalk = __toESM(require("chalk"));
 var import_connectors = require("@tradejs/connectors");
 var import_connectors2 = require("@tradejs/node/connectors");
+var import_strategies = require("@tradejs/node/strategies");
 var import_timescale = require("@tradejs/infra/timescale");
 
 // src/lib/binanceMarketData.ts
@@ -1832,14 +1834,6 @@ var MARKET_FEATURE_INTERVAL_MS = {
   "15m": 9e5,
   "1h": 36e5
 };
-var STABLE_QUOTE_SYMBOLS = /* @__PURE__ */ new Set([
-  "USDCUSDT",
-  "FDUSDUSDT",
-  "TUSDUSDT",
-  "BUSDUSDT",
-  "USDPUSDT",
-  "DAIUSDT"
-]);
 var safeDivide = (num, den) => Number.isFinite(num) && Number.isFinite(den) && den !== 0 ? num / den : null;
 var mean = (values) => values.length ? values.reduce((sum, value) => sum + value, 0) / values.length : null;
 var standardDeviation = (values) => {
@@ -1883,9 +1877,6 @@ var classifyBtcAltRegime = ({
   if (btcVsAltReturn24h < -5e-3) return "alt_lead";
   return "neutral";
 };
-var selectBreadthUniverseFromTickers = (tickers, limit) => tickers.filter(
-  (ticker) => ticker.symbol.endsWith("USDT") && ticker.symbol !== "BTCUSDT" && !STABLE_QUOTE_SYMBOLS.has(ticker.symbol) && Number.isFinite(ticker.turnover24h) && ticker.turnover24h > 0
-).sort((a, b) => b.turnover24h - a.turnover24h).slice(0, Math.max(0, limit)).map((ticker) => ticker.symbol);
 var aggregateAggTradesToRows = ({
   symbol,
   interval: interval2,
@@ -2367,10 +2358,6 @@ var backfillBinanceMarketContext = async (params, enabled) => {
     process.env.BINANCE_MARKET_CONTEXT_TRADE_FLOW_SYMBOL_LIMIT,
     2
   );
-  const breadthLimit = asInt(
-    process.env.BINANCE_MARKET_CONTEXT_BREADTH_LIMIT,
-    30
-  );
   const breadthChunkDays = asFloat(
     process.env.BINANCE_MARKET_CONTEXT_BREADTH_CHUNK_DAYS,
     30
@@ -2493,88 +2480,113 @@ var backfillBinanceMarketContext = async (params, enabled) => {
     }
   }
   if (includeBreadth) {
-    const tickers = await connector.getTickers();
-    const breadthSymbols = selectBreadthUniverseFromTickers(
-      tickers,
-      breadthLimit
-    );
-    const universe = `binance_top${breadthSymbols.length}_usdt`;
-    const coverage = await (0, import_timescale.getMarketBreadthCoverage)({
-      universe,
-      interval: interval2,
-      startMs: breadthStartMs,
-      endMs
-    });
-    const hasBtcAltMetrics = (coverage?.btcAltMetricsRows ?? 0) >= Math.floor(Math.max(1, coverage?.rows ?? 0) * 0.9);
-    if (!hasCoverage({
-      coverage,
+    const breadthUniverses = (0, import_strategies.getBinanceBreadthUniverses)();
+    const breadthSymbols = breadthUniverses.at(-1)?.symbols ?? [];
+    const connectorInterval = marketIntervalToConnectorInterval(interval2);
+    const chunks = buildBreadthBackfillChunks({
       startMs: breadthStartMs,
       endMs,
-      intervalMs: intervalMs2
-    }) || !hasBtcAltMetrics) {
-      const connectorInterval = marketIntervalToConnectorInterval(interval2);
-      const chunks = buildBreadthBackfillChunks({
-        startMs: breadthStartMs,
-        endMs,
-        intervalMs: intervalMs2,
-        chunkDays: breadthChunkDays
-      });
-      const missingChunks = filterMissingBreadthBackfillChunks({
-        chunks,
-        coverage,
-        intervalMs: intervalMs2
-      });
-      const bar = new import_progress.default(
-        "breadth :current/:total [:bar][:percent] :etas(s) candles=:candles skip=:skip chunk=:chunk :symbol",
-        {
-          total: Math.max(1, missingChunks.length * breadthSymbols.length),
-          width: 24
-        }
-      );
-      let candlesRead = 0;
-      let skippedBreadthChunks = chunks.length - missingChunks.length;
-      if (!missingChunks.length) {
-        bar.tick(1, {
-          candles: 0,
-          skip: skippedBreadthChunks,
-          chunk: "cached",
-          symbol: universe
+      intervalMs: intervalMs2,
+      chunkDays: breadthChunkDays
+    });
+    const plans = await Promise.all(
+      breadthUniverses.map(async (definition) => {
+        const coverage = await (0, import_timescale.getMarketBreadthCoverage)({
+          universe: definition.universe,
+          interval: interval2,
+          startMs: breadthStartMs,
+          endMs
         });
-      }
-      for (let chunkIndex = 0; chunkIndex < missingChunks.length; chunkIndex += 1) {
-        const chunk = missingChunks[chunkIndex];
-        const originalChunkIndex = chunks.findIndex(
-          (item) => item.startMs === chunk.startMs && item.endMs === chunk.endMs
-        );
-        const candlesBySymbol = {};
-        for (const symbol of breadthSymbols) {
-          const candles = await connector.kline({
-            symbol,
-            interval: connectorInterval,
-            start: chunk.fetchStartMs,
-            end: chunk.endMs,
-            silent: true
-          });
-          candlesBySymbol[symbol] = candles;
-          candlesRead += candles.length;
-          bar.tick(1, {
-            candles: candlesRead,
-            skip: skippedBreadthChunks,
-            chunk: `${originalChunkIndex + 1}/${chunks.length}`,
-            symbol
-          });
+        const hasBtcAltMetrics = (coverage?.btcAltMetricsRows ?? 0) >= Math.floor(Math.max(1, coverage?.rows ?? 0) * 0.9);
+        const missingChunks2 = !hasCoverage({
+          coverage,
+          startMs: breadthStartMs,
+          endMs,
+          intervalMs: intervalMs2
+        }) || !hasBtcAltMetrics ? !hasBtcAltMetrics ? chunks : filterMissingBreadthBackfillChunks({
+          chunks,
+          coverage,
+          intervalMs: intervalMs2
+        }) : [];
+        if (!missingChunks2.length) {
+          console.log(
+            import_chalk.default.gray(`breadth cached: universe=${definition.universe}`)
+          );
         }
-        const btcCandles = await connector.kline({
-          symbol: "BTCUSDT",
+        return {
+          definition,
+          missingChunkKeys: new Set(
+            missingChunks2.map((chunk) => `${chunk.startMs}:${chunk.endMs}`)
+          )
+        };
+      })
+    );
+    const missingChunks = chunks.filter((chunk) => {
+      const key = `${chunk.startMs}:${chunk.endMs}`;
+      return plans.some((plan) => plan.missingChunkKeys.has(key));
+    });
+    const bar = new import_progress.default(
+      "breadth :current/:total [:bar][:percent] :etas(s) candles=:candles skip=:skip chunk=:chunk :symbol",
+      {
+        total: Math.max(1, missingChunks.length * breadthSymbols.length),
+        width: 24
+      }
+    );
+    let candlesRead = 0;
+    const skippedBreadthChunks = chunks.length - missingChunks.length;
+    if (!missingChunks.length) {
+      bar.tick(1, {
+        candles: 0,
+        skip: skippedBreadthChunks,
+        chunk: "cached",
+        symbol: "top5/top10/top30/top50/top100"
+      });
+    }
+    for (let chunkIndex = 0; chunkIndex < missingChunks.length; chunkIndex += 1) {
+      const chunk = missingChunks[chunkIndex];
+      const originalChunkIndex = chunks.findIndex(
+        (item) => item.startMs === chunk.startMs && item.endMs === chunk.endMs
+      );
+      const candlesBySymbol = {};
+      for (const symbol of breadthSymbols) {
+        const candles = await connector.kline({
+          symbol,
           interval: connectorInterval,
           start: chunk.fetchStartMs,
           end: chunk.endMs,
           silent: true
         });
+        candlesBySymbol[symbol] = candles;
+        candlesRead += candles.length;
+        bar.tick(1, {
+          candles: candlesRead,
+          skip: skippedBreadthChunks,
+          chunk: `${originalChunkIndex + 1}/${chunks.length}`,
+          symbol
+        });
+      }
+      const btcCandles = await connector.kline({
+        symbol: "BTCUSDT",
+        interval: connectorInterval,
+        start: chunk.fetchStartMs,
+        end: chunk.endMs,
+        silent: true
+      });
+      const chunkKey = `${chunk.startMs}:${chunk.endMs}`;
+      for (const plan of plans) {
+        if (!plan.missingChunkKeys.has(chunkKey)) {
+          continue;
+        }
+        const symbolSet = new Set(plan.definition.symbols);
+        const universeCandles = Object.fromEntries(
+          Object.entries(candlesBySymbol).filter(
+            ([symbol]) => symbolSet.has(symbol)
+          )
+        );
         const rows = buildMarketBreadthRows({
-          universe,
+          universe: plan.definition.universe,
           interval: interval2,
-          candlesBySymbol,
+          candlesBySymbol: universeCandles,
           btcCandles
         }).filter((row) => {
           const ts = row.ts.getTime();
@@ -2583,8 +2595,6 @@ var backfillBinanceMarketContext = async (params, enabled) => {
         await (0, import_timescale.upsertMarketBreadthRows)(rows);
         breadthRows += rows.length;
       }
-    } else {
-      console.log(import_chalk.default.gray(`breadth cached: universe=${universe}`));
     }
   }
   console.log(
@@ -3809,27 +3819,27 @@ var createCoinMarketCapFetchStats = () => ({
   totalCredits: 0,
   byPath: /* @__PURE__ */ new Map()
 });
-var getCoinMarketCapPathLabel = (path) => {
-  if (path.includes("global-metrics")) return "global";
-  if (path.includes("cryptocurrency/quotes")) return "reference";
-  if (path.includes("exchange/quotes")) return "exchangeLiquidity";
-  if (path.includes("fear-and-greed")) return "fearGreed";
-  if (path.includes("cmc100")) return "cmc100";
-  if (path.includes("cmc20")) return "cmc20";
-  return path;
-};
-var recordCoinMarketCapFetchStats = (stats, path, creditCount) => {
+var getCoinMarketCapPathLabel = (path2) => {
+  if (path2.includes("global-metrics")) return "global";
+  if (path2.includes("cryptocurrency/quotes")) return "reference";
+  if (path2.includes("exchange/quotes")) return "exchangeLiquidity";
+  if (path2.includes("fear-and-greed")) return "fearGreed";
+  if (path2.includes("cmc100")) return "cmc100";
+  if (path2.includes("cmc20")) return "cmc20";
+  return path2;
+};
+var recordCoinMarketCapFetchStats = (stats, path2, creditCount) => {
   if (!stats) return;
-  const existing = stats.byPath.get(path) ?? { requests: 0, credits: 0 };
+  const existing = stats.byPath.get(path2) ?? { requests: 0, credits: 0 };
   existing.requests += 1;
   existing.credits += creditCount ?? 0;
   stats.requests += 1;
   stats.totalCredits += creditCount ?? 0;
-  stats.byPath.set(path, existing);
+  stats.byPath.set(path2, existing);
 };
 var formatCoinMarketCapFetchStats = (stats) => {
   const byPath = [...stats.byPath.entries()].map(
-    ([path, item]) => `${getCoinMarketCapPathLabel(path)}=${item.requests}req/${item.credits}cr`
+    ([path2, item]) => `${getCoinMarketCapPathLabel(path2)}=${item.requests}req/${item.credits}cr`
   ).join(" ");
   return `apiRequests=${stats.requests} apiCredits=${stats.totalCredits}${byPath ? ` ${byPath}` : ""}`;
 };
@@ -4901,7 +4911,7 @@ var updateBtcReferenceHistory = async ({
 var import_logger = require("@tradejs/infra/logger");
 var import_redis2 = require("@tradejs/infra/redis");
 var import_tradingAccounts = require("@tradejs/infra/tradingAccounts");
-var import_strategies = require("@tradejs/node/strategies");
+var import_strategies2 = require("@tradejs/node/strategies");
 
 // src/lib/runtimeRedis.ts
 var import_redis = require("@tradejs/infra/redis");
@@ -5001,7 +5011,7 @@ var loadRuntimeStrategies = async ({
         });
         const effectiveAccountId = resolvedAccount?.id ?? requestedAccountId;
         const [strategyCreator, strategyResults] = await Promise.all([
-          (0, import_strategies.getStrategyCreator)(strategyName, projectRoot2),
+          (0, import_strategies2.getStrategyCreator)(strategyName, projectRoot2),
           (0, import_redis2.getData)(import_redis2.redisKeys.strategyResults(userName, strategyName), {})
         ]);
         if (!strategyCreator) {
@@ -5095,6 +5105,214 @@ var logStrategySkipStats = (runtimeStrategies, strategyStats) => {
 
 // src/lib/signals/evaluations.ts
 var import_redis3 = require("@tradejs/infra/redis");
+
+// src/lib/runtimeLineage.ts
+var import_node_child_process = require("child_process");
+var import_node_crypto = require("crypto");
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var RUNTIME_CONTEXT_ENV_KEYS = [
+  "AI_MODE",
+  "MIN_AI_QUALITY",
+  "INTERVAL",
+  "DERIVATIVES_CONTEXT_ENABLED",
+  "DERIVATIVES_CONTEXT_TARGET_ENABLED",
+  "DERIVATIVES_CONTEXT_LOOKBACK_HOURS",
+  "DERIVATIVES_CONTEXT_EXTRA_REFERENCE_SYMBOLS",
+  "DERIVATIVES_CONTEXT_EXCHANGE_PRIORITY",
+  "COINMARKETCAP_CONTEXT_ENABLED",
+  "COINMARKETCAP_CONTEXT_MAX_AGE_MS",
+  "COINMARKETCAP_CONTEXT_EXCHANGE_LIQUIDITY_ENABLED",
+  "COINMARKETCAP_CONTEXT_EXCHANGE_SLUGS",
+  "COINMARKETCAP_CONTEXT_FEAR_GREED_ENABLED",
+  "COINMARKETCAP_CONTEXT_HISTORICAL_ACCESS_MONTHS",
+  "COINMARKETCAP_CONTEXT_BACKFILL_ENABLED",
+  "COINMARKETCAP_CONTEXT_BACKFILL_MAX_DAYS",
+  "COINMARKETCAP_CONTEXT_BACKFILL_WARMUP_DAYS"
+];
+var RUNTIME_CONTEXT_DATA_MODEL = {
+  derivativesSourceIntervals: "15m",
+  derivativesDerivedIntervals: "1h",
+  derivativesHourlyFallback: "stored-1h",
+  derivativesDataModelVersion: 2,
+  coinMarketCapAvailabilityModel: "closed-interval-all-daily",
+  coinMarketCapDataModelVersion: 3,
+  binanceBreadthUniverseModel: "fixed-versioned-top5-top10-top30-top50-top100",
+  binanceBreadthDataModelVersion: 2
+};
+var normalizeForStableJson = (value) => {
+  if (Array.isArray(value)) {
+    return value.map(normalizeForStableJson);
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalizeForStableJson(entry)])
+    );
+  }
+  return value;
+};
+var fingerprintRuntimeValue = (value) => (0, import_node_crypto.createHash)("sha256").update(JSON.stringify(normalizeForStableJson(value))).digest("hex").slice(0, 16);
+var gitLineageCache = /* @__PURE__ */ new Map();
+var gateFingerprintCache = /* @__PURE__ */ new Map();
+var binanceBreadthFingerprintCache = /* @__PURE__ */ new Map();
+var resolveGitLineage = (projectRoot2) => {
+  const cached = gitLineageCache.get(projectRoot2);
+  if (cached) {
+    return cached;
+  }
+  const envSha = String(process.env.TRADEJS_GIT_SHA ?? "").trim();
+  if (envSha && envSha !== "unknown") {
+    const result = {
+      gitSha: envSha,
+      gitDirty: false
+    };
+    gitLineageCache.set(projectRoot2, result);
+    return result;
+  }
+  try {
+    const gitSha = (0, import_node_child_process.execFileSync)("git", ["rev-parse", "HEAD"], {
+      cwd: projectRoot2,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    const status = (0, import_node_child_process.execFileSync)(
+      "git",
+      ["status", "--porcelain", "--untracked-files=normal"],
+      {
+        cwd: projectRoot2,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "ignore"]
+      }
+    ).trim();
+    const result = {
+      gitSha: gitSha || null,
+      gitDirty: status.length > 0
+    };
+    gitLineageCache.set(projectRoot2, result);
+    return result;
+  } catch {
+    const result = {
+      gitSha: null,
+      gitDirty: null
+    };
+    gitLineageCache.set(projectRoot2, result);
+    return result;
+  }
+};
+var readOptionalFile = async (filePath) => {
+  try {
+    return await import_promises.default.readFile(filePath);
+  } catch {
+    return null;
+  }
+};
+var resolveBinanceBreadthFingerprint = async (projectRoot2) => {
+  if (binanceBreadthFingerprintCache.has(projectRoot2)) {
+    return binanceBreadthFingerprintCache.get(projectRoot2) ?? null;
+  }
+  const content = await readOptionalFile(
+    import_node_path.default.join(
+      projectRoot2,
+      "packages/node/src/config/binanceBreadthUniverses.json"
+    )
+  );
+  let result = null;
+  if (content) {
+    try {
+      const parsed = JSON.parse(content.toString("utf8"));
+      result = typeof parsed.fingerprint === "string" && parsed.fingerprint.trim() ? parsed.fingerprint.trim() : null;
+    } catch {
+      result = null;
+    }
+  }
+  binanceBreadthFingerprintCache.set(projectRoot2, result);
+  return result;
+};
+var resolveGateFingerprint = async ({
+  projectRoot: projectRoot2,
+  strategyName,
+  gitSha
+}) => {
+  const cacheKey = `${projectRoot2}:${strategyName}:${gitSha ?? "unknown"}`;
+  const cached = gateFingerprintCache.get(cacheKey);
+  if (cached) {
+    return cached;
+  }
+  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"
+  ];
+  const optionalEntries = await Promise.all(
+    relativeCandidates.map(async (relativePath) => {
+      const content = await readOptionalFile(
+        import_node_path.default.join(projectRoot2, relativePath)
+      );
+      return content == null ? null : { relativePath, content };
+    })
+  );
+  const sourceEntries = [];
+  for (const entry of optionalEntries) {
+    if (entry != null) {
+      sourceEntries.push(entry);
+    }
+  }
+  const hash = (0, import_node_crypto.createHash)("sha256");
+  hash.update(strategyName);
+  if (sourceEntries.length) {
+    for (const entry of sourceEntries) {
+      hash.update(entry.relativePath);
+      hash.update(entry.content);
+    }
+  } else {
+    hash.update(gitSha ?? "unknown-git-sha");
+  }
+  const fingerprint = hash.digest("hex").slice(0, 16);
+  gateFingerprintCache.set(cacheKey, fingerprint);
+  return fingerprint;
+};
+var buildRuntimeLineage = async ({
+  projectRoot: projectRoot2,
+  strategyName,
+  config,
+  runContext,
+  env = process.env
+}) => {
+  const git = resolveGitLineage(projectRoot2);
+  const context = {
+    ...Object.fromEntries(
+      RUNTIME_CONTEXT_ENV_KEYS.map((key) => [key, env[key] ?? null])
+    ),
+    ...RUNTIME_CONTEXT_DATA_MODEL,
+    binanceBreadthUniverseFingerprint: await resolveBinanceBreadthFingerprint(projectRoot2),
+    ...runContext
+  };
+  return {
+    schemaVersion: 1,
+    ...git,
+    gateFingerprint: await resolveGateFingerprint({
+      projectRoot: projectRoot2,
+      strategyName,
+      gitSha: git.gitSha
+    }),
+    configFingerprint: fingerprintRuntimeValue(config),
+    contextFingerprint: fingerprintRuntimeValue(context)
+  };
+};
+var runtimeLineageKey = (lineage) => [
+  lineage.schemaVersion,
+  lineage.gitSha ?? "unknown",
+  lineage.gitDirty == null ? "unknown" : lineage.gitDirty ? "dirty" : "clean",
+  lineage.gateFingerprint,
+  lineage.configFingerprint,
+  lineage.contextFingerprint
+].join(":");
+
+// src/lib/signals/evaluations.ts
+var runtimeLineageScopeCache = /* @__PURE__ */ new Map();
+var runtimeLineageScopeCacheDayKey = "";
 var buildRuntimeSignalEvaluationId = ({
   strategyName,
   symbol,
@@ -5103,7 +5321,46 @@ var buildRuntimeSignalEvaluationId = ({
 }) => runtimeConfigId && runtimeConfigId !== "config" ? [strategyName, runtimeConfigId, symbol, timestamp].join(":") : [strategyName, symbol, timestamp].join(":");
 var saveRuntimeSignalEvaluation = async (evaluation) => {
   const dayKey = (0, import_time.getRuntimeStorageDayKey)(evaluation.timestamp);
+  if (runtimeLineageScopeCacheDayKey !== dayKey) {
+    runtimeLineageScopeCache.clear();
+    runtimeLineageScopeCacheDayKey = dayKey;
+  }
   const runtimeSignalRetentionTtl = getRuntimeSignalRetentionTtlSeconds();
+  if (evaluation.runtimeLineage) {
+    const lineageField = [
+      evaluation.strategy,
+      evaluation.runtimeConfigId ?? "config",
+      evaluation.symbol,
+      runtimeLineageKey(evaluation.runtimeLineage)
+    ].join(":");
+    const lineageBucket = import_redis3.redisKeys.runtimeLineageScopeBucket(
+      evaluation.userName,
+      dayKey
+    );
+    const cacheKey = `${lineageBucket}:${lineageField}`;
+    const existing = runtimeLineageScopeCache.get(cacheKey) ?? await (0, import_redis3.getHashJsonField)(
+      lineageBucket,
+      lineageField
+    );
+    const scope = {
+      strategy: evaluation.strategy,
+      symbol: evaluation.symbol,
+      runtimeConfigId: evaluation.runtimeConfigId,
+      lineage: evaluation.runtimeLineage,
+      firstTimestamp: Math.min(
+        existing?.firstTimestamp ?? evaluation.timestamp,
+        evaluation.timestamp
+      ),
+      lastTimestamp: Math.max(
+        existing?.lastTimestamp ?? evaluation.timestamp,
+        evaluation.timestamp
+      )
+    };
+    runtimeLineageScopeCache.set(cacheKey, scope);
+    await (0, import_redis3.setHashJsonField)(lineageBucket, lineageField, scope, {
+      expire: RUNTIME_LINEAGE_SCOPE_RETENTION_TTL_SECONDS
+    });
+  }
   if (shouldStoreDetailedRuntimeSignalEvaluation(evaluation)) {
     await (0, import_redis3.setHashJsonField)(
       import_redis3.redisKeys.runtimeSignalEvaluationBucket(
@@ -5563,7 +5820,7 @@ var resolveSignalsKlineWsWaitMs = () => resolveNonNegativeInteger(process.env.SI
 var createDefaultSignalsLifecycle = (runtimeInterval = interval) => createSignalsStrategyLifecycle({
   intervalMs: Number(runtimeInterval) * 6e4,
   maxLiveBars: resolveSignalsDaemonMaxLiveBars(runtimeInterval),
-  releaseState: import_strategies2.releaseStrategyReplayCache
+  releaseState: import_strategies3.releaseStrategyReplayCache
 });
 var timeOperation2 = (label, operation) => timeOperation(
   label,
@@ -5708,6 +5965,20 @@ var findSignals = async (symbol, connectorName, connector, btcBinanceData, btcCo
       interval: interval2,
       makeOrders: flags.makeOrders
     });
+    const runtimeLineage = await buildRuntimeLineage({
+      projectRoot,
+      strategyName,
+      config: {
+        configId,
+        strategyConfig,
+        symbolResultConfig: strategyResults?.[symbol]?.config ?? null
+      },
+      runContext: {
+        connectorName: connectorName.toLowerCase(),
+        interval: String(interval2),
+        universe
+      }
+    });
     const lifecycleKey = buildSignalsStrategyLifecycleKey({
       connectorName,
       universe: runtimeScopeUniverse,
@@ -5789,6 +6060,7 @@ var findSignals = async (symbol, connectorName, connector, btcBinanceData, btcCo
         userName: flags.user,
         strategy: strategyName,
         runtimeConfigId: configId,
+        runtimeLineage,
         symbol,
         interval: interval2,
         universe,
@@ -5807,10 +6079,11 @@ var findSignals = async (symbol, connectorName, connector, btcBinanceData, btcCo
       stats.signals += 1;
     }
     signal.runtimeConfigId = configId;
+    signal.runtimeLineage = runtimeLineage;
     if (configId && configId !== "config" && !signal.signalId.endsWith(`:${configId}`)) {
       signal.signalId = `${signal.signalId}:${configId}`;
     }
-    await (0, import_strategies3.enrichSignalWithBinanceMarketContext)({
+    await (0, import_strategies4.enrichSignalWithBinanceMarketContext)({
       signal,
       env: "CRON"
     });
@@ -5853,6 +6126,7 @@ var findSignals = async (symbol, connectorName, connector, btcBinanceData, btcCo
       userName: flags.user,
       strategy: strategyName,
       runtimeConfigId: configId,
+      runtimeLineage,
       symbol,
       interval: interval2,
       universe,