@tradejs/cli 3.1.29-beta.285 → 3.1.29-beta.287

package/dist/cli.js

@@ -15259,6 +15259,513 @@ var init_backtest = __esm({
   }
 });
 
+// src/lib/runtimeModeConfig.ts
+var hasRuntimeEntryGateEnabled, resolveReplayStrategyEnv, buildRuntimeModeStrategyConfig;
+var init_runtimeModeConfig = __esm({
+  "src/lib/runtimeModeConfig.ts"() {
+    "use strict";
+    hasRuntimeEntryGateEnabled = (strategyConfig) => strategyConfig.AI_ENABLED === true || strategyConfig.ML_ENABLED === true;
+    resolveReplayStrategyEnv = ({
+      strategyConfig,
+      forceRuntimeGates = false
+    }) => forceRuntimeGates || hasRuntimeEntryGateEnabled(strategyConfig) ? "PARITY" : "BACKTEST";
+    buildRuntimeModeStrategyConfig = ({
+      strategyConfig,
+      env,
+      interval: interval4,
+      makeOrders,
+      recordRuntimeTrades,
+      aiReplayAnalyses
+    }) => ({
+      ...strategyConfig,
+      ENV: env,
+      MAKE_ORDERS: makeOrders,
+      INTERVAL: strategyConfig.INTERVAL ?? interval4,
+      ...typeof recordRuntimeTrades === "boolean" ? { RECORD_RUNTIME_TRADES: recordRuntimeTrades } : {},
+      ...aiReplayAnalyses?.length ? { AI_REPLAY_ANALYSES: aiReplayAnalyses } : {}
+    });
+  }
+});
+
+// src/lib/replay/support.ts
+var import_chalk16, REPLAY_RESULTS_BY_STRATEGY_HEADERS, REPLAY_RUNTIME_COMPARISON_HEADERS, REPLAY_RESULTS_CONFIG, REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS, REPLAY_RUNTIME_COMPARE_TOLERANCE_MS, formatReplayRuntimeCompareTolerance, getReplayRuntimeUnmatchedCount, buildReplayStrategyConfig, toRecord, compactReplayAdditionalIndicators, compactReplaySignal;
+var init_support = __esm({
+  "src/lib/replay/support.ts"() {
+    "use strict";
+    import_chalk16 = __toESM(require("chalk"));
+    init_runtimeModeConfig();
+    REPLAY_RESULTS_BY_STRATEGY_HEADERS = [
+      import_chalk16.default.blue("STRATEGY"),
+      import_chalk16.default.yellow("TICKERS"),
+      import_chalk16.default.yellow("TRADE TICKERS"),
+      import_chalk16.default.cyan("ORDERS"),
+      import_chalk16.default.cyan("WIN/LOSS (%)"),
+      import_chalk16.default.cyan("PROFIT"),
+      import_chalk16.default.cyan("AVG TRADE")
+    ];
+    REPLAY_RUNTIME_COMPARISON_HEADERS = [
+      import_chalk16.default.blue("STRATEGY"),
+      import_chalk16.default.cyan("BT ENTRIES"),
+      import_chalk16.default.cyan("BT PNL"),
+      import_chalk16.default.yellow("RT TRADES"),
+      import_chalk16.default.yellow("RT PNL"),
+      import_chalk16.default.green("MATCHED"),
+      import_chalk16.default.red("ORDER FAILED"),
+      import_chalk16.default.yellow("RT ONLY"),
+      import_chalk16.default.magenta("BT ONLY"),
+      import_chalk16.default.red("UNMATCHED")
+    ];
+    REPLAY_RESULTS_CONFIG = "replay";
+    REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS = 1;
+    REPLAY_RUNTIME_COMPARE_TOLERANCE_MS = REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS * 15 * 60 * 1e3;
+    formatReplayRuntimeCompareTolerance = () => `${REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS} ${REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS === 1 ? "bar" : "bars"}`;
+    getReplayRuntimeUnmatchedCount = (row) => row.orderFailed + row.runtimeOnly + row.backtestOnly;
+    buildReplayStrategyConfig = ({
+      strategyConfig,
+      interval: interval4
+    }) => ({
+      ...buildRuntimeModeStrategyConfig({
+        strategyConfig,
+        env: "PARITY",
+        interval: interval4,
+        makeOrders: false,
+        recordRuntimeTrades: false
+      }),
+      SIMULATE_ORDERS: true
+    });
+    toRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+    compactReplayAdditionalIndicators = (additionalIndicators) => {
+      const additional = toRecord(additionalIndicators);
+      if (!additional) {
+        return void 0;
+      }
+      const compact = {};
+      if (additional.executionSlippage != null) {
+        compact.executionSlippage = additional.executionSlippage;
+      }
+      if (additional.marketContext != null) {
+        compact.marketContext = additional.marketContext;
+      }
+      const baseContext = toRecord(additional.baseContext);
+      const relative = toRecord(baseContext?.relative);
+      const execution = toRecord(relative?.execution);
+      if (execution) {
+        compact.baseContext = {
+          relative: {
+            execution
+          }
+        };
+      }
+      return Object.keys(compact).length ? compact : void 0;
+    };
+    compactReplaySignal = (signal) => {
+      if (!signal) {
+        return void 0;
+      }
+      return {
+        signalId: signal.signalId,
+        strategy: signal.strategy,
+        symbol: signal.symbol,
+        interval: signal.interval,
+        direction: signal.direction,
+        timestamp: signal.timestamp,
+        prices: signal.prices,
+        indicators: {},
+        figures: {},
+        additionalIndicators: compactReplayAdditionalIndicators(
+          signal.additionalIndicators
+        ),
+        isConfigFromBacktest: signal.isConfigFromBacktest,
+        ...signal.orderStatus ? { orderStatus: signal.orderStatus } : {},
+        ...signal.orderSkipReason ? { orderSkipReason: signal.orderSkipReason } : {},
+        ...signal.aiAnalysis ? { aiAnalysis: signal.aiAnalysis } : {},
+        ...signal.ml ? { ml: signal.ml } : {}
+      };
+    };
+  }
+});
+
+// src/lib/marketData/windows.ts
+var import_indicators2, resolveOpenTimestamp, getClosedCandlesForInterval, splitCandlesForReplayWindow, alignSymbolWithBtcReference;
+var init_windows = __esm({
+  "src/lib/marketData/windows.ts"() {
+    "use strict";
+    import_indicators2 = require("@tradejs/core/indicators");
+    resolveOpenTimestamp = (timestamp, intervalMs) => Number.isFinite(intervalMs) && intervalMs > 0 ? Math.floor(timestamp / intervalMs) * intervalMs : timestamp;
+    getClosedCandlesForInterval = (candles, currentTimestamp, intervalMs) => {
+      const currentOpenTimestamp = resolveOpenTimestamp(
+        currentTimestamp,
+        intervalMs
+      );
+      return candles.filter((candle) => candle.timestamp < currentOpenTimestamp);
+    };
+    splitCandlesForReplayWindow = (candles, start, preloadStart) => {
+      const prevData = [];
+      const replayData = [];
+      for (const candle of candles) {
+        if (candle.timestamp < preloadStart) {
+          continue;
+        }
+        if (candle.timestamp < start) {
+          prevData.push(candle);
+          continue;
+        }
+        replayData.push(candle);
+      }
+      return { prevData, replayData };
+    };
+    alignSymbolWithBtcReference = (symbolCandles, btcCandles) => (0, import_indicators2.alignSortedCandlesByTimestamp)(symbolCandles, btcCandles);
+  }
+});
+
+// src/lib/replay/historicalSignalsReplayPreparation.ts
+var import_data2, buildPreparedData, strategyIncludesSymbol, buildSymbolSharedReplayKey, resolveHistoricalReplayIntervals, prepareMultiIntervalHistoricalReplay, assertBaseReplayCoverage, prepareHistoricalReplay, releaseHistoricalReplayPlan, releaseHistoricalReplayCaches;
+var init_historicalSignalsReplayPreparation = __esm({
+  "src/lib/replay/historicalSignalsReplayPreparation.ts"() {
+    "use strict";
+    import_data2 = require("@tradejs/core/data");
+    init_support();
+    init_windows();
+    buildPreparedData = ({
+      data,
+      btcData,
+      ethData,
+      btcBinanceData,
+      btcCoinbaseData,
+      start,
+      preloadStart
+    }) => {
+      const { prevData: prevDataRaw, replayData: replayDataRaw } = splitCandlesForReplayWindow(data, start, preloadStart);
+      const { prevData: btcPrevDataRaw, replayData: btcReplayDataRaw } = splitCandlesForReplayWindow(btcData, start, preloadStart);
+      const { prevData: ethPrevDataRaw, replayData: ethReplayDataRaw } = splitCandlesForReplayWindow(ethData, start, preloadStart);
+      const { prevData: btcBinancePrevDataRaw } = splitCandlesForReplayWindow(
+        btcBinanceData,
+        start,
+        preloadStart
+      );
+      const { prevData: btcCoinbasePrevDataRaw } = splitCandlesForReplayWindow(
+        btcCoinbaseData,
+        start,
+        preloadStart
+      );
+      const { alignedCoinCandles: prevData, alignedBtcCandles: btcPrevData } = alignSymbolWithBtcReference(prevDataRaw, btcPrevDataRaw);
+      const { alignedCoinCandles: replayData, alignedBtcCandles: btcReplayData } = alignSymbolWithBtcReference(replayDataRaw, btcReplayDataRaw);
+      const { alignedBtcCandles: ethPrevData } = alignSymbolWithBtcReference(
+        prevData,
+        ethPrevDataRaw
+      );
+      const { alignedBtcCandles: ethReplayData } = alignSymbolWithBtcReference(
+        replayData,
+        ethReplayDataRaw
+      );
+      const { alignedBtcCandles: btcBinancePrevData } = alignSymbolWithBtcReference(
+        prevDataRaw,
+        btcBinancePrevDataRaw
+      );
+      const { alignedBtcCandles: btcCoinbasePrevData } = alignSymbolWithBtcReference(prevDataRaw, btcCoinbasePrevDataRaw);
+      return {
+        prevData,
+        btcPrevData,
+        ethPrevData,
+        replayData,
+        btcReplayData,
+        ethReplayData,
+        btcBinancePrevData,
+        btcCoinbasePrevData
+      };
+    };
+    strategyIncludesSymbol = (strategy, symbol) => {
+      const tickers = strategy.selection?.tickers;
+      if (!tickers) return true;
+      const normalizedSymbol = symbol.trim().toUpperCase();
+      return tickers.some(
+        (ticker) => ticker.trim().toUpperCase() === normalizedSymbol
+      );
+    };
+    buildSymbolSharedReplayKey = ({
+      userName: userName3,
+      connectorName,
+      interval: interval4,
+      symbol,
+      start,
+      end
+    }) => ["replay", userName3, connectorName, symbol, interval4, start, end].join(":");
+    resolveHistoricalReplayIntervals = (baseInterval, strategyIntervals) => {
+      const intervals = [
+        ...new Set(
+          strategyIntervals.map((value) => {
+            if (!value || !Number.isFinite((0, import_data2.intervalToMs)(value)) || (0, import_data2.intervalToMs)(value) <= 0)
+              throw new Error(`Invalid replay strategy interval: ${value}`);
+            return value;
+          })
+        )
+      ].sort((a, b) => (0, import_data2.intervalToMs)(a) - (0, import_data2.intervalToMs)(b));
+      if (intervals.length > 1 && intervals.includes("M")) {
+        throw new Error("Mixed replay does not support calendar intervals");
+      }
+      const baseMs = (0, import_data2.intervalToMs)(baseInterval);
+      if (intervals.some(
+        (value) => (0, import_data2.intervalToMs)(value) < baseMs || (0, import_data2.intervalToMs)(value) % baseMs !== 0
+      )) {
+        throw new Error(
+          "Replay strategy intervals must be multiples of the base timeframe"
+        );
+      }
+      if (!intervals.length || !intervals.includes(baseInterval)) {
+        throw new Error(
+          "Replay base timeframe must match an active strategy interval"
+        );
+      }
+      return intervals;
+    };
+    prepareMultiIntervalHistoricalReplay = async (context, adapters, loadReferences) => {
+      const intervals = resolveHistoricalReplayIntervals(
+        context.interval,
+        context.strategies.map((s) => s.strategyConfig.INTERVAL)
+      );
+      const baseMs = (0, import_data2.intervalToMs)(context.interval);
+      const plan = {
+        symbolRuntimes: [],
+        orderedTimestamps: [],
+        sharedReplayKeyPrefixes: [],
+        runtimeLineages: []
+      };
+      const timestamps = /* @__PURE__ */ new Set();
+      const baseRuntimes = /* @__PURE__ */ new Map();
+      const validatedSymbols = /* @__PURE__ */ new Set();
+      try {
+        for (const interval4 of intervals) {
+          const offset = (0, import_data2.intervalToMs)(interval4) - baseMs;
+          const nativeRun = {
+            ...context.preparedRun,
+            preloadStart: context.preparedRun.preloadStart - offset,
+            window: {
+              ...context.preparedRun.window,
+              start: context.preparedRun.window.start - offset,
+              end: context.preparedRun.window.end - offset
+            }
+          };
+          const part = await prepareHistoricalReplay(
+            {
+              ...context,
+              interval: interval4,
+              preparedRun: nativeRun,
+              strategies: context.strategies.filter(
+                (strategy) => strategy.strategyConfig.INTERVAL === interval4
+              ),
+              references: interval4 === context.interval ? context.references : await loadReferences(interval4, nativeRun)
+            },
+            adapters
+          );
+          plan.sharedReplayKeyPrefixes.push(...part.sharedReplayKeyPrefixes);
+          plan.runtimeLineages.push(...part.runtimeLineages);
+          for (const runtime of part.symbolRuntimes) {
+            if (interval4 === context.interval) {
+              baseRuntimes.set(runtime.symbol, runtime);
+            } else if (runtime.strategies.length && !validatedSymbols.has(runtime.symbol)) {
+              assertBaseReplayCoverage(
+                baseRuntimes.get(runtime.symbol),
+                runtime.symbol,
+                context.preparedRun.window,
+                baseMs
+              );
+              validatedSymbols.add(runtime.symbol);
+            }
+            runtime.timestampOffsetMs = offset;
+            runtime.advanceMarket = interval4 === context.interval;
+            plan.symbolRuntimes.push(runtime);
+          }
+          for (const timestamp of part.orderedTimestamps) {
+            const scheduled = timestamp + offset;
+            if (scheduled >= context.preparedRun.window.start && scheduled <= context.preparedRun.window.end)
+              timestamps.add(scheduled);
+          }
+        }
+        plan.orderedTimestamps = [...timestamps].sort((a, b) => a - b);
+        return plan;
+      } catch (error) {
+        releaseHistoricalReplayCaches(plan, adapters);
+        throw error;
+      }
+    };
+    assertBaseReplayCoverage = (runtime, symbol, window, baseMs) => {
+      let index = 0;
+      for (let timestamp = Math.ceil(window.start / baseMs) * baseMs; timestamp <= window.end; timestamp += baseMs) {
+        if (runtime?.replayData[index]?.timestamp !== timestamp) {
+          throw new Error(`Missing base replay candle: ${symbol} at ${timestamp}`);
+        }
+        index += 1;
+      }
+    };
+    prepareHistoricalReplay = async (context, adapters) => {
+      const {
+        userName: userName3,
+        projectRoot: projectRoot18,
+        preparedRun,
+        interval: interval4,
+        connectorName,
+        replayConnector,
+        strategies,
+        references
+      } = context;
+      const symbolRuntimes = [];
+      const orderedTimestamps = /* @__PURE__ */ new Set();
+      const sharedReplayKeyPrefixes = [];
+      const runtimeLineages = [];
+      let skippedSymbols = 0;
+      try {
+        for (const symbol of preparedRun.tickers) {
+          const data = await preparedRun.marketConnector.kline({
+            symbol,
+            start: preparedRun.preloadStart,
+            end: preparedRun.window.end,
+            cacheOnly: true,
+            interval: interval4
+          });
+          if (symbolRuntimes.length % 50 === 0)
+            adapters.sampleMemory?.("history:loaded", {
+              symbols: symbolRuntimes.length + 1,
+              candles: data.length
+            });
+          const preparedData = buildPreparedData({
+            data,
+            btcData: references.btcMarketData,
+            ethData: references.ethMarketData,
+            btcBinanceData: references.btcBinanceData,
+            btcCoinbaseData: references.btcCoinbaseData,
+            start: preparedRun.window.start,
+            preloadStart: preparedRun.preloadStart
+          });
+          if (!preparedData.replayData.length || !preparedData.btcReplayData.length) {
+            skippedSymbols += 1;
+            adapters.progress.tick({
+              skipped: adapters.display.skipped(skippedSymbols),
+              symbol: adapters.display.symbol(symbol)
+            });
+            continue;
+          }
+          const sharedIndicatorsReplayKey = buildSymbolSharedReplayKey({
+            userName: userName3,
+            connectorName,
+            interval: interval4,
+            symbol,
+            start: preparedRun.window.start,
+            end: preparedRun.window.end
+          });
+          sharedReplayKeyPrefixes.push(sharedIndicatorsReplayKey);
+          const initializedStrategies = await Promise.allSettled(
+            strategies.filter((strategy) => strategyIncludesSymbol(strategy, symbol)).map(async (strategy) => {
+              const replayStrategyConfig = buildReplayStrategyConfig({
+                strategyConfig: strategy.strategyConfig,
+                interval: interval4
+              });
+              const runtimeLineage = await adapters.buildLineage({
+                projectRoot: projectRoot18,
+                strategyName: strategy.strategyName,
+                strategyRevision: strategy.strategyRevision,
+                deploymentCompositionId: strategy.deploymentCompositionId,
+                strategyPackageVersion: strategy.strategyPackageVersion,
+                strategyDependencyVersions: strategy.strategyDependencyVersions,
+                runtimePackageVersion: strategy.runtimePackageVersion,
+                config: {
+                  configId: strategy.strategyRevision,
+                  strategyConfig: strategy.strategyConfig,
+                  symbolResultConfig: strategy.strategyResults?.[symbol]?.config ?? null
+                },
+                runContext: {
+                  connectorName: connectorName.toLowerCase(),
+                  interval: String(interval4),
+                  universe: preparedRun.universe ?? null
+                }
+              });
+              runtimeLineages.push({
+                strategy: strategy.strategyName,
+                symbol,
+                ...preparedRun.deploymentId ? { deploymentId: preparedRun.deploymentId } : {},
+                ...preparedRun.accountId ? { accountId: preparedRun.accountId } : {},
+                lineage: runtimeLineage
+              });
+              return {
+                strategyName: strategy.strategyName,
+                strategyConfig: strategy.strategyConfig,
+                runtimeLineage,
+                run: await strategy.strategyCreator({
+                  userName: userName3,
+                  connectorName,
+                  runtimeConfigId: strategy.strategyRevision,
+                  strategyRevision: strategy.strategyRevision,
+                  runtimeLineage,
+                  universe: preparedRun.universe,
+                  accountId: preparedRun.accountId,
+                  deploymentId: preparedRun.deploymentId,
+                  runtimeConfigSnapshot: {
+                    userConfig: replayStrategyConfig
+                  },
+                  config: replayStrategyConfig,
+                  symbol,
+                  data: preparedData.prevData,
+                  btcData: preparedData.btcPrevData,
+                  ethData: preparedData.ethPrevData,
+                  btcBinanceData: preparedData.btcBinancePrevData,
+                  btcCoinbaseData: preparedData.btcCoinbasePrevData,
+                  connector: replayConnector,
+                  sharedIndicatorsReplayKey
+                })
+              };
+            })
+          );
+          const strategiesForSymbol = initializedStrategies.map((result) => {
+            if (result.status === "rejected") throw result.reason;
+            return result.value;
+          });
+          const symbolRuntime = {
+            symbol,
+            replayData: preparedData.replayData,
+            btcReplayData: preparedData.btcReplayData,
+            ethReplayData: preparedData.ethReplayData,
+            currentIndex: 0,
+            strategies: strategiesForSymbol
+          };
+          symbolRuntimes.push(symbolRuntime);
+          if (symbolRuntimes.length % 50 === 0 || symbol === preparedRun.tickers.at(-1))
+            adapters.sampleMemory?.("strategies:initializing", {
+              symbols: symbolRuntimes.length,
+              strategiesPerSymbol: strategiesForSymbol.length
+            });
+          adapters.progress.tick({
+            skipped: adapters.display.skipped(skippedSymbols),
+            symbol: adapters.display.symbol(symbol)
+          });
+          for (const candle of preparedData.replayData) {
+            orderedTimestamps.add(candle.timestamp);
+          }
+        }
+        return {
+          symbolRuntimes,
+          orderedTimestamps: [...orderedTimestamps].sort(
+            (left, right) => left - right
+          ),
+          sharedReplayKeyPrefixes,
+          runtimeLineages
+        };
+      } catch (error) {
+        releaseHistoricalReplayCaches({ sharedReplayKeyPrefixes }, adapters);
+        throw error;
+      }
+    };
+    releaseHistoricalReplayPlan = (plan) => {
+      plan.symbolRuntimes.length = 0;
+      plan.sharedReplayKeyPrefixes.length = 0;
+    };
+    releaseHistoricalReplayCaches = (plan, adapters) => {
+      for (const keyPrefix of plan.sharedReplayKeyPrefixes) {
+        adapters.releaseIndicatorsCache(keyPrefix);
+        adapters.releaseReplayCache(keyPrefix);
+      }
+    };
+  }
+});
+
 // src/lib/replay/cliConfig.ts
 var import_args7, REPLAY_UNSUPPORTED_FLAGS, hasCliFlag2, assertNoUnsupportedReplayFlags, replayNormalizedArgv, replayFlags, replayInterval, replayUserName, replayProjectRoot, replayRuntimeEvidencePath, replayDeploymentId, isReplayUpdateOnlyRun;
 var init_cliConfig2 = __esm({
@@ -15636,149 +16143,23 @@ var init_runtimeEvidenceSource = __esm({
       assertRuntimeRowsMatchDeployment({
         label: "evaluation",
         rows: evaluations,
-        deployment
-      });
-      assertRuntimeRowsMatchDeployment({
-        label: "lineage scope",
-        rows: storedLineageScopes,
-        deployment
-      });
-      return {
-        path: resolvedPath,
-        userName: userName3,
-        startTime,
-        endTime,
-        trades,
-        signals: signals2,
-        evaluations,
-        lineageScopes: storedLineageScopes.length ? storedLineageScopes : buildRuntimeEvidenceLineageScopes({ signals: signals2, evaluations }),
-        deployment
-      };
-    };
-  }
-});
-
-// src/lib/runtimeModeConfig.ts
-var hasRuntimeEntryGateEnabled, resolveReplayStrategyEnv, buildRuntimeModeStrategyConfig;
-var init_runtimeModeConfig = __esm({
-  "src/lib/runtimeModeConfig.ts"() {
-    "use strict";
-    hasRuntimeEntryGateEnabled = (strategyConfig) => strategyConfig.AI_ENABLED === true || strategyConfig.ML_ENABLED === true;
-    resolveReplayStrategyEnv = ({
-      strategyConfig,
-      forceRuntimeGates = false
-    }) => forceRuntimeGates || hasRuntimeEntryGateEnabled(strategyConfig) ? "PARITY" : "BACKTEST";
-    buildRuntimeModeStrategyConfig = ({
-      strategyConfig,
-      env,
-      interval: interval4,
-      makeOrders,
-      recordRuntimeTrades,
-      aiReplayAnalyses
-    }) => ({
-      ...strategyConfig,
-      ENV: env,
-      MAKE_ORDERS: makeOrders,
-      INTERVAL: strategyConfig.INTERVAL ?? interval4,
-      ...typeof recordRuntimeTrades === "boolean" ? { RECORD_RUNTIME_TRADES: recordRuntimeTrades } : {},
-      ...aiReplayAnalyses?.length ? { AI_REPLAY_ANALYSES: aiReplayAnalyses } : {}
-    });
-  }
-});
-
-// src/lib/replay/support.ts
-var import_chalk16, REPLAY_RESULTS_BY_STRATEGY_HEADERS, REPLAY_RUNTIME_COMPARISON_HEADERS, REPLAY_RESULTS_CONFIG, REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS, REPLAY_RUNTIME_COMPARE_TOLERANCE_MS, formatReplayRuntimeCompareTolerance, getReplayRuntimeUnmatchedCount, buildReplayStrategyConfig, toRecord, compactReplayAdditionalIndicators, compactReplaySignal;
-var init_support = __esm({
-  "src/lib/replay/support.ts"() {
-    "use strict";
-    import_chalk16 = __toESM(require("chalk"));
-    init_runtimeModeConfig();
-    REPLAY_RESULTS_BY_STRATEGY_HEADERS = [
-      import_chalk16.default.blue("STRATEGY"),
-      import_chalk16.default.yellow("TICKERS"),
-      import_chalk16.default.yellow("TRADE TICKERS"),
-      import_chalk16.default.cyan("ORDERS"),
-      import_chalk16.default.cyan("WIN/LOSS (%)"),
-      import_chalk16.default.cyan("PROFIT"),
-      import_chalk16.default.cyan("AVG TRADE")
-    ];
-    REPLAY_RUNTIME_COMPARISON_HEADERS = [
-      import_chalk16.default.blue("STRATEGY"),
-      import_chalk16.default.cyan("BT ENTRIES"),
-      import_chalk16.default.cyan("BT PNL"),
-      import_chalk16.default.yellow("RT TRADES"),
-      import_chalk16.default.yellow("RT PNL"),
-      import_chalk16.default.green("MATCHED"),
-      import_chalk16.default.red("ORDER FAILED"),
-      import_chalk16.default.yellow("RT ONLY"),
-      import_chalk16.default.magenta("BT ONLY"),
-      import_chalk16.default.red("UNMATCHED")
-    ];
-    REPLAY_RESULTS_CONFIG = "replay";
-    REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS = 1;
-    REPLAY_RUNTIME_COMPARE_TOLERANCE_MS = REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS * 15 * 60 * 1e3;
-    formatReplayRuntimeCompareTolerance = () => `${REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS} ${REPLAY_RUNTIME_COMPARE_TOLERANCE_BARS === 1 ? "bar" : "bars"}`;
-    getReplayRuntimeUnmatchedCount = (row) => row.orderFailed + row.runtimeOnly + row.backtestOnly;
-    buildReplayStrategyConfig = ({
-      strategyConfig,
-      interval: interval4
-    }) => ({
-      ...buildRuntimeModeStrategyConfig({
-        strategyConfig,
-        env: "PARITY",
-        interval: interval4,
-        makeOrders: false,
-        recordRuntimeTrades: false
-      }),
-      SIMULATE_ORDERS: true
-    });
-    toRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
-    compactReplayAdditionalIndicators = (additionalIndicators) => {
-      const additional = toRecord(additionalIndicators);
-      if (!additional) {
-        return void 0;
-      }
-      const compact = {};
-      if (additional.executionSlippage != null) {
-        compact.executionSlippage = additional.executionSlippage;
-      }
-      if (additional.marketContext != null) {
-        compact.marketContext = additional.marketContext;
-      }
-      const baseContext = toRecord(additional.baseContext);
-      const relative = toRecord(baseContext?.relative);
-      const execution = toRecord(relative?.execution);
-      if (execution) {
-        compact.baseContext = {
-          relative: {
-            execution
-          }
-        };
-      }
-      return Object.keys(compact).length ? compact : void 0;
-    };
-    compactReplaySignal = (signal) => {
-      if (!signal) {
-        return void 0;
-      }
+        deployment
+      });
+      assertRuntimeRowsMatchDeployment({
+        label: "lineage scope",
+        rows: storedLineageScopes,
+        deployment
+      });
       return {
-        signalId: signal.signalId,
-        strategy: signal.strategy,
-        symbol: signal.symbol,
-        interval: signal.interval,
-        direction: signal.direction,
-        timestamp: signal.timestamp,
-        prices: signal.prices,
-        indicators: {},
-        figures: {},
-        additionalIndicators: compactReplayAdditionalIndicators(
-          signal.additionalIndicators
-        ),
-        isConfigFromBacktest: signal.isConfigFromBacktest,
-        ...signal.orderStatus ? { orderStatus: signal.orderStatus } : {},
-        ...signal.orderSkipReason ? { orderSkipReason: signal.orderSkipReason } : {},
-        ...signal.aiAnalysis ? { aiAnalysis: signal.aiAnalysis } : {},
-        ...signal.ml ? { ml: signal.ml } : {}
+        path: resolvedPath,
+        userName: userName3,
+        startTime,
+        endTime,
+        trades,
+        signals: signals2,
+        evaluations,
+        lineageScopes: storedLineageScopes.length ? storedLineageScopes : buildRuntimeEvidenceLineageScopes({ signals: signals2, evaluations }),
+        deployment
       };
     };
   }
@@ -15846,6 +16227,7 @@ var init_portfolioReplayConnector = __esm({
     createPortfolioReplayConnector = (connector) => {
       let state = {};
       let amount = import_constants10.INITIAL_BACKTEST_AMOUNT;
+      let executionTimestamp = null;
       const positionsBySymbol = /* @__PURE__ */ new Map();
       const currentPriceBySymbol = /* @__PURE__ */ new Map();
       const orderLog = [];
@@ -16107,6 +16489,7 @@ var init_portfolioReplayConnector = __esm({
           });
           const nextPosition = {
             ...order,
+            timestamp: executionTimestamp ?? order.timestamp,
             price: entryPrice,
             signal: compactReplaySignal(order.signal),
             amount,
@@ -16131,6 +16514,7 @@ var init_portfolioReplayConnector = __esm({
             positionState,
             data: {
               ...order,
+              timestamp: executionTimestamp ?? order.timestamp,
               price: entryPrice,
               profit,
               fee,
@@ -16194,6 +16578,7 @@ var init_portfolioReplayConnector = __esm({
             positionState,
             data: {
               ...order,
+              timestamp: executionTimestamp ?? order.timestamp,
               price: executionPrice,
               qty: position.qty,
               profit,
@@ -16202,11 +16587,12 @@ var init_portfolioReplayConnector = __esm({
               ...getExecutionSlippageLogData(slippageBreakdown, "exit")
             }
           });
-          clearPosition(order.symbol, order.timestamp);
+          clearPosition(order.symbol, executionTimestamp ?? order.timestamp);
           return true;
         },
         getTickers: connector.getTickers,
         advanceMarket: async ({ symbol, candle }) => {
+          executionTimestamp = candle.timestamp;
           currentPriceBySymbol.set(symbol, candle.close);
           await checkSl({ symbol, candle });
           await checkTp({ symbol, candle });
@@ -16255,270 +16641,12 @@ var init_hooks = __esm({
   }
 });
 
-// src/lib/marketData/windows.ts
-var import_indicators2, resolveOpenTimestamp, getClosedCandlesForInterval, splitCandlesForReplayWindow, alignSymbolWithBtcReference;
-var init_windows = __esm({
-  "src/lib/marketData/windows.ts"() {
-    "use strict";
-    import_indicators2 = require("@tradejs/core/indicators");
-    resolveOpenTimestamp = (timestamp, intervalMs) => Number.isFinite(intervalMs) && intervalMs > 0 ? Math.floor(timestamp / intervalMs) * intervalMs : timestamp;
-    getClosedCandlesForInterval = (candles, currentTimestamp, intervalMs) => {
-      const currentOpenTimestamp = resolveOpenTimestamp(
-        currentTimestamp,
-        intervalMs
-      );
-      return candles.filter((candle) => candle.timestamp < currentOpenTimestamp);
-    };
-    splitCandlesForReplayWindow = (candles, start, preloadStart) => {
-      const prevData = [];
-      const replayData = [];
-      for (const candle of candles) {
-        if (candle.timestamp < preloadStart) {
-          continue;
-        }
-        if (candle.timestamp < start) {
-          prevData.push(candle);
-          continue;
-        }
-        replayData.push(candle);
-      }
-      return { prevData, replayData };
-    };
-    alignSymbolWithBtcReference = (symbolCandles, btcCandles) => (0, import_indicators2.alignSortedCandlesByTimestamp)(symbolCandles, btcCandles);
-  }
-});
-
-// src/lib/replay/historicalSignalsReplayPreparation.ts
-var buildPreparedData, strategyIncludesSymbol, buildSymbolSharedReplayKey, prepareHistoricalReplay, releaseHistoricalReplayPlan;
-var init_historicalSignalsReplayPreparation = __esm({
-  "src/lib/replay/historicalSignalsReplayPreparation.ts"() {
-    "use strict";
-    init_support();
-    init_windows();
-    buildPreparedData = ({
-      data,
-      btcData,
-      ethData,
-      btcBinanceData,
-      btcCoinbaseData,
-      start,
-      preloadStart
-    }) => {
-      const { prevData: prevDataRaw, replayData: replayDataRaw } = splitCandlesForReplayWindow(data, start, preloadStart);
-      const { prevData: btcPrevDataRaw, replayData: btcReplayDataRaw } = splitCandlesForReplayWindow(btcData, start, preloadStart);
-      const { prevData: ethPrevDataRaw, replayData: ethReplayDataRaw } = splitCandlesForReplayWindow(ethData, start, preloadStart);
-      const { prevData: btcBinancePrevDataRaw } = splitCandlesForReplayWindow(
-        btcBinanceData,
-        start,
-        preloadStart
-      );
-      const { prevData: btcCoinbasePrevDataRaw } = splitCandlesForReplayWindow(
-        btcCoinbaseData,
-        start,
-        preloadStart
-      );
-      const { alignedCoinCandles: prevData, alignedBtcCandles: btcPrevData } = alignSymbolWithBtcReference(prevDataRaw, btcPrevDataRaw);
-      const { alignedCoinCandles: replayData, alignedBtcCandles: btcReplayData } = alignSymbolWithBtcReference(replayDataRaw, btcReplayDataRaw);
-      const { alignedBtcCandles: ethPrevData } = alignSymbolWithBtcReference(
-        prevData,
-        ethPrevDataRaw
-      );
-      const { alignedBtcCandles: ethReplayData } = alignSymbolWithBtcReference(
-        replayData,
-        ethReplayDataRaw
-      );
-      const { alignedBtcCandles: btcBinancePrevData } = alignSymbolWithBtcReference(
-        prevDataRaw,
-        btcBinancePrevDataRaw
-      );
-      const { alignedBtcCandles: btcCoinbasePrevData } = alignSymbolWithBtcReference(prevDataRaw, btcCoinbasePrevDataRaw);
-      return {
-        prevData,
-        btcPrevData,
-        ethPrevData,
-        replayData,
-        btcReplayData,
-        ethReplayData,
-        btcBinancePrevData,
-        btcCoinbasePrevData
-      };
-    };
-    strategyIncludesSymbol = (strategy, symbol) => {
-      const tickers = strategy.selection?.tickers;
-      if (!tickers) return true;
-      const normalizedSymbol = symbol.trim().toUpperCase();
-      return tickers.some(
-        (ticker) => ticker.trim().toUpperCase() === normalizedSymbol
-      );
-    };
-    buildSymbolSharedReplayKey = ({
-      userName: userName3,
-      connectorName,
-      interval: interval4,
-      symbol,
-      start,
-      end
-    }) => ["replay", userName3, connectorName, symbol, interval4, start, end].join(":");
-    prepareHistoricalReplay = async (context, adapters) => {
-      const {
-        userName: userName3,
-        projectRoot: projectRoot18,
-        preparedRun,
-        interval: interval4,
-        connectorName,
-        replayConnector,
-        strategies,
-        references
-      } = context;
-      const symbolRuntimes = [];
-      const orderedTimestamps = /* @__PURE__ */ new Set();
-      const sharedReplayKeyPrefixes = [];
-      const runtimeLineages = [];
-      let skippedSymbols = 0;
-      for (const symbol of preparedRun.tickers) {
-        const data = await preparedRun.marketConnector.kline({
-          symbol,
-          start: preparedRun.preloadStart,
-          end: preparedRun.window.end,
-          cacheOnly: true,
-          interval: interval4
-        });
-        if (symbolRuntimes.length % 50 === 0)
-          adapters.sampleMemory?.("history:loaded", {
-            symbols: symbolRuntimes.length + 1,
-            candles: data.length
-          });
-        const preparedData = buildPreparedData({
-          data,
-          btcData: references.btcMarketData,
-          ethData: references.ethMarketData,
-          btcBinanceData: references.btcBinanceData,
-          btcCoinbaseData: references.btcCoinbaseData,
-          start: preparedRun.window.start,
-          preloadStart: preparedRun.preloadStart
-        });
-        if (!preparedData.replayData.length || !preparedData.btcReplayData.length) {
-          skippedSymbols += 1;
-          adapters.progress.tick({
-            skipped: adapters.display.skipped(skippedSymbols),
-            symbol: adapters.display.symbol(symbol)
-          });
-          continue;
-        }
-        const sharedIndicatorsReplayKey = buildSymbolSharedReplayKey({
-          userName: userName3,
-          connectorName,
-          interval: interval4,
-          symbol,
-          start: preparedRun.window.start,
-          end: preparedRun.window.end
-        });
-        sharedReplayKeyPrefixes.push(sharedIndicatorsReplayKey);
-        const strategiesForSymbol = await Promise.all(
-          strategies.filter((strategy) => strategyIncludesSymbol(strategy, symbol)).map(async (strategy) => {
-            const replayStrategyConfig = buildReplayStrategyConfig({
-              strategyConfig: strategy.strategyConfig,
-              interval: interval4
-            });
-            const runtimeLineage = await adapters.buildLineage({
-              projectRoot: projectRoot18,
-              strategyName: strategy.strategyName,
-              strategyRevision: strategy.strategyRevision,
-              deploymentCompositionId: strategy.deploymentCompositionId,
-              strategyPackageVersion: strategy.strategyPackageVersion,
-              strategyDependencyVersions: strategy.strategyDependencyVersions,
-              runtimePackageVersion: strategy.runtimePackageVersion,
-              config: {
-                configId: strategy.strategyRevision,
-                strategyConfig: strategy.strategyConfig,
-                symbolResultConfig: strategy.strategyResults?.[symbol]?.config ?? null
-              },
-              runContext: {
-                connectorName: connectorName.toLowerCase(),
-                interval: String(interval4),
-                universe: preparedRun.universe ?? null
-              }
-            });
-            runtimeLineages.push({
-              strategy: strategy.strategyName,
-              symbol,
-              ...preparedRun.deploymentId ? { deploymentId: preparedRun.deploymentId } : {},
-              ...preparedRun.accountId ? { accountId: preparedRun.accountId } : {},
-              lineage: runtimeLineage
-            });
-            return {
-              strategyName: strategy.strategyName,
-              strategyConfig: strategy.strategyConfig,
-              runtimeLineage,
-              run: await strategy.strategyCreator({
-                userName: userName3,
-                connectorName,
-                runtimeConfigId: strategy.strategyRevision,
-                strategyRevision: strategy.strategyRevision,
-                runtimeLineage,
-                universe: preparedRun.universe,
-                accountId: preparedRun.accountId,
-                deploymentId: preparedRun.deploymentId,
-                runtimeConfigSnapshot: {
-                  userConfig: replayStrategyConfig
-                },
-                config: replayStrategyConfig,
-                symbol,
-                data: preparedData.prevData,
-                btcData: preparedData.btcPrevData,
-                ethData: preparedData.ethPrevData,
-                btcBinanceData: preparedData.btcBinancePrevData,
-                btcCoinbaseData: preparedData.btcCoinbasePrevData,
-                connector: replayConnector,
-                sharedIndicatorsReplayKey
-              })
-            };
-          })
-        );
-        const symbolRuntime = {
-          symbol,
-          replayData: preparedData.replayData,
-          btcReplayData: preparedData.btcReplayData,
-          ethReplayData: preparedData.ethReplayData,
-          currentIndex: 0,
-          strategies: strategiesForSymbol
-        };
-        symbolRuntimes.push(symbolRuntime);
-        if (symbolRuntimes.length % 50 === 0 || symbol === preparedRun.tickers.at(-1))
-          adapters.sampleMemory?.("strategies:initializing", {
-            symbols: symbolRuntimes.length,
-            strategiesPerSymbol: strategiesForSymbol.length
-          });
-        adapters.progress.tick({
-          skipped: adapters.display.skipped(skippedSymbols),
-          symbol: adapters.display.symbol(symbol)
-        });
-        for (const candle of preparedData.replayData) {
-          orderedTimestamps.add(candle.timestamp);
-        }
-      }
-      return {
-        symbolRuntimes,
-        orderedTimestamps: [...orderedTimestamps].sort(
-          (left, right) => left - right
-        ),
-        sharedReplayKeyPrefixes,
-        runtimeLineages
-      };
-    };
-    releaseHistoricalReplayPlan = (plan) => {
-      plan.symbolRuntimes.length = 0;
-      plan.sharedReplayKeyPrefixes.length = 0;
-    };
-  }
-});
-
 // src/lib/replay/historicalSignalsReplaySkipEvidence.ts
-var import_data2, replayScopeKey, appendReplaySignalEvaluationRun, createHistoricalReplaySkipEvidence;
+var import_data3, replayScopeKey, appendReplaySignalEvaluationRun, createHistoricalReplaySkipEvidence;
 var init_historicalSignalsReplaySkipEvidence = __esm({
   "src/lib/replay/historicalSignalsReplaySkipEvidence.ts"() {
     "use strict";
-    import_data2 = require("@tradejs/core/data");
+    import_data3 = require("@tradejs/core/data");
     replayScopeKey = (strategy, symbol) => `${strategy}::${symbol}`;
     appendReplaySignalEvaluationRun = ({
       runs = [],
@@ -16526,7 +16654,7 @@ var init_historicalSignalsReplaySkipEvidence = __esm({
       timestamp,
       interval: interval4
     }) => {
-      const stepMs = (0, import_data2.intervalToMs)(interval4);
+      const stepMs = (0, import_data3.intervalToMs)(interval4);
       const last = runs.at(-1);
       if (last?.reason === reason && last.stepMs === stepMs && timestamp === last.lastTimestamp + stepMs) {
         return [...runs.slice(0, -1), { ...last, lastTimestamp: timestamp }];
@@ -16602,14 +16730,16 @@ var advanceCycleMarket, advanceAbortedCycle, executeHistoricalReplay;
 var init_historicalSignalsReplayExecution = __esm({
   "src/lib/replay/historicalSignalsReplayExecution.ts"() {
     "use strict";
+    init_historicalSignalsReplayPreparation();
     init_historicalSignalsReplaySkipEvidence();
     advanceCycleMarket = async (plan, connector, timestamp) => {
       const cycleSymbols = plan.symbolRuntimes.filter(
-        (symbolRuntime) => symbolRuntime.replayData[symbolRuntime.currentIndex]?.timestamp === timestamp
+        (symbolRuntime) => (symbolRuntime.replayData[symbolRuntime.currentIndex]?.timestamp ?? NaN) + (symbolRuntime.timestampOffsetMs ?? 0) === timestamp
       );
       for (const symbolRuntime of cycleSymbols) {
         const candle = symbolRuntime.replayData[symbolRuntime.currentIndex];
-        if (candle?.timestamp === timestamp) {
+        if (candle && candle.timestamp + (symbolRuntime.timestampOffsetMs ?? 0) === timestamp) {
+          if (symbolRuntime.advanceMarket === false) continue;
           await connector.advanceMarket({
             symbol: symbolRuntime.symbol,
             candle
@@ -16621,7 +16751,7 @@ var init_historicalSignalsReplayExecution = __esm({
     advanceAbortedCycle = (cycleSymbols, timestamp) => {
       for (const symbolRuntime of cycleSymbols ?? []) {
         const candle = symbolRuntime.replayData[symbolRuntime.currentIndex];
-        if (candle?.timestamp === timestamp) {
+        if (candle && candle.timestamp + (symbolRuntime.timestampOffsetMs ?? 0) === timestamp) {
           symbolRuntime.currentIndex += 1;
         }
       }
@@ -16670,21 +16800,21 @@ var init_historicalSignalsReplayExecution = __esm({
             const candle = symbolRuntime.replayData[symbolRuntime.currentIndex];
             const btcCandle = symbolRuntime.btcReplayData[symbolRuntime.currentIndex];
             const ethCandle = symbolRuntime.ethReplayData[symbolRuntime.currentIndex];
-            if (!candle || !btcCandle || candle.timestamp !== timestamp || btcCandle.timestamp !== timestamp) {
+            if (!candle || !btcCandle || candle.timestamp + (symbolRuntime.timestampOffsetMs ?? 0) !== timestamp || btcCandle.timestamp !== candle.timestamp) {
               continue;
             }
             for (const strategyRuntime of symbolRuntime.strategies) {
               const result = await strategyRuntime.run(
                 candle,
                 btcCandle,
-                ethCandle?.timestamp === timestamp ? ethCandle : void 0
+                ethCandle?.timestamp === candle.timestamp ? ethCandle : void 0
               );
               skipEvidence.record({
                 strategyName: strategyRuntime.strategyName,
                 symbol: symbolRuntime.symbol,
                 strategyConfig: strategyRuntime.strategyConfig,
                 runtimeLineage: strategyRuntime.runtimeLineage,
-                timestamp,
+                timestamp: candle.timestamp,
                 result
               });
               if (result && typeof result !== "string") {
@@ -16705,10 +16835,7 @@ var init_historicalSignalsReplayExecution = __esm({
           reportProgress(timestamp);
         }
       } finally {
-        for (const keyPrefix of context.plan.sharedReplayKeyPrefixes) {
-          adapters.releaseIndicatorsCache(keyPrefix);
-          adapters.releaseReplayCache(keyPrefix);
-        }
+        releaseHistoricalReplayCaches(context.plan, adapters);
       }
       return {
         signals: signals2,
@@ -17013,7 +17140,19 @@ var init_historicalSignalsReplay = __esm({
         }
       );
       memory?.("references:loaded");
-      const plan = await prepareHistoricalReplay(
+      const cacheAdapters = {
+        releaseIndicatorsCache: (keyPrefix) => releaseReplayCacheCopies(
+          keyPrefix,
+          import_strategies5.releaseStrategyIndicatorsReplayCache,
+          getProjectReplayCacheReleasers()?.releaseStrategyIndicatorsReplayCache
+        ),
+        releaseReplayCache: (keyPrefix) => releaseReplayCacheCopies(
+          keyPrefix,
+          import_strategies5.releaseStrategyReplayCache,
+          getProjectReplayCacheReleasers()?.releaseStrategyReplayCache
+        )
+      };
+      const plan = await prepareMultiIntervalHistoricalReplay(
         {
           userName: replayUserName,
           projectRoot: replayProjectRoot,
@@ -17030,6 +17169,7 @@ var init_historicalSignalsReplay = __esm({
           }
         },
         {
+          ...cacheAdapters,
           progress: {
             tick: (tokens) => prepareBar.tick(1, tokens)
           },
@@ -17039,7 +17179,11 @@ var init_historicalSignalsReplay = __esm({
           },
           buildLineage: buildRuntimeLineage,
           sampleMemory: memory
-        }
+        },
+        (nativeInterval, nativeRun) => loadHistoricalReplayReferences({
+          preparedRun: nativeRun,
+          interval: nativeInterval
+        })
       );
       memory?.("strategies:prepared", { symbols: plan.symbolRuntimes.length });
       const hookContext = buildAfterSignalsContext({
@@ -17066,6 +17210,7 @@ var init_historicalSignalsReplay = __esm({
           hookContext
         },
         {
+          ...cacheAdapters,
           clock: { now: Date.now },
           progress: {
             enabled: showProgress,
@@ -17078,17 +17223,7 @@ var init_historicalSignalsReplay = __esm({
           },
           invokeBeforeSignals: invokeBeforeSignalsHooks,
           invokeAfterSignals: invokeAfterSignalsHooks,
-          enrichSignal: (signal) => (0, import_strategies6.enrichSignalWithBinanceMarketContext)({ signal, env: "PARITY" }),
-          releaseIndicatorsCache: (keyPrefix) => releaseReplayCacheCopies(
-            keyPrefix,
-            import_strategies5.releaseStrategyIndicatorsReplayCache,
-            getProjectReplayCacheReleasers()?.releaseStrategyIndicatorsReplayCache
-          ),
-          releaseReplayCache: (keyPrefix) => releaseReplayCacheCopies(
-            keyPrefix,
-            import_strategies5.releaseStrategyReplayCache,
-            getProjectReplayCacheReleasers()?.releaseStrategyReplayCache
-          )
+          enrichSignal: (signal) => (0, import_strategies6.enrichSignalWithBinanceMarketContext)({ signal, env: "PARITY" })
         }
       );
       memory?.("execution:complete", { signals: execution.signals.length });
@@ -17668,18 +17803,18 @@ var init_paritySummary = __esm({
 });
 
 // src/lib/runtimeSignalsStorage.ts
-var import_constants12, import_data3, import_time5, appendRuntimeSignalEvaluationRun, SECONDS_PER_DAY, RUNTIME_SIGNAL_RETENTION_DAYS_ENV, DEFAULT_RUNTIME_SIGNAL_RETENTION_TTL_SECONDS, RUNTIME_LINEAGE_SCOPE_RETENTION_TTL_SECONDS, parsePositiveNumber, getRuntimeSignalRetentionTtlSeconds, toRuntimeSignalBucketRef, shouldStoreRuntimeSignalDiagnostics, toStoredRuntimeSignal, isRuntimeSignalBucketRef, normalizeRuntimeSignalSkipReason, buildStatsReasonField, buildRuntimeSignalStatsIncrements, shouldStoreDetailedRuntimeSignalEvaluation, toCount, parseRuntimeSignalStatsBucket;
+var import_constants12, import_data4, import_time5, appendRuntimeSignalEvaluationRun, SECONDS_PER_DAY, RUNTIME_SIGNAL_RETENTION_DAYS_ENV, DEFAULT_RUNTIME_SIGNAL_RETENTION_TTL_SECONDS, RUNTIME_LINEAGE_SCOPE_RETENTION_TTL_SECONDS, parsePositiveNumber, getRuntimeSignalRetentionTtlSeconds, toRuntimeSignalBucketRef, shouldStoreRuntimeSignalDiagnostics, toStoredRuntimeSignal, isRuntimeSignalBucketRef, normalizeRuntimeSignalSkipReason, buildStatsReasonField, buildRuntimeSignalStatsIncrements, shouldStoreDetailedRuntimeSignalEvaluation, toCount, parseRuntimeSignalStatsBucket;
 var init_runtimeSignalsStorage = __esm({
   "src/lib/runtimeSignalsStorage.ts"() {
     "use strict";
     import_constants12 = require("@tradejs/core/constants");
-    import_data3 = require("@tradejs/core/data");
+    import_data4 = require("@tradejs/core/data");
     import_time5 = require("@tradejs/core/time");
     appendRuntimeSignalEvaluationRun = (runs = [], evaluation) => {
       if (evaluation.status !== "skip") {
         return [...runs];
       }
-      const stepMs = (0, import_data3.intervalToMs)(evaluation.interval);
+      const stepMs = (0, import_data4.intervalToMs)(evaluation.interval);
       const reason = evaluation.reason?.trim() || "NO_SIGNAL";
       const existing = runs.find(
         (run) => run.status === "skip" && run.reason === reason && run.stepMs === stepMs && evaluation.timestamp >= run.firstTimestamp && evaluation.timestamp <= run.lastTimestamp && (evaluation.timestamp - run.firstTimestamp) % stepMs === 0
@@ -19419,7 +19554,10 @@ var init_runtimeComparisonCalculations = __esm({
       return candidates.map((candidate) => ({
         ...candidate,
         timestampDiffMs: Math.abs(
-          candidate.timestamp + signalTimestampOffsetMs - exchangeEntry.entryTimestamp
+          candidate.timestamp + resolveTradeParityTimestampOffset(
+            strategyName,
+            signalTimestampOffsetMs
+          ) - exchangeEntry.entryTimestamp
         )
       })).filter((candidate) => candidate.timestampDiffMs <= toleranceMs).sort(
         (left, right) => left.timestampDiffMs - right.timestampDiffMs || Number(right.orderStatus === "failed") - Number(left.orderStatus === "failed")
@@ -19669,11 +19807,12 @@ var init_runtimeComparisonReporting = __esm({
 });
 
 // src/lib/replay/runtimeComparison.ts
-var import_chalk20, getReplayEntryTimestampCompareOffsetMs, buildReplaySignalEvaluations, toFiniteNumberOrNull4, sumOptionalNumbers, firstFiniteNumber, firstString, getExchangeExecutionMergeKey, mergeExchangeExecutionGroup, mergeExchangeEntryExecutions, loadExchangeEntryRows, loadExchangeEntriesForComparison, saveAndPrintReplayExchangeComparison, saveAndPrintReplayRuntimeComparison;
+var import_chalk20, import_data5, replayStrategyIntervals, buildReplaySignalEvaluations, toFiniteNumberOrNull4, sumOptionalNumbers, firstFiniteNumber, firstString, getExchangeExecutionMergeKey, mergeExchangeExecutionGroup, mergeExchangeEntryExecutions, loadExchangeEntryRows, loadExchangeEntriesForComparison, saveAndPrintReplayExchangeComparison, saveAndPrintReplayRuntimeComparison;
 var init_runtimeComparison = __esm({
   "src/lib/replay/runtimeComparison.ts"() {
     "use strict";
     import_chalk20 = __toESM(require("chalk"));
+    import_data5 = require("@tradejs/core/data");
     init_runtimeParity();
     init_paritySummary();
     init_runtimeRedis();
@@ -19688,10 +19827,13 @@ var init_runtimeComparison = __esm({
     init_runtimeComparisonCalculations();
     init_runtimeComparisonReporting();
     init_runtimeComparisonCalculations();
-    getReplayEntryTimestampCompareOffsetMs = () => {
-      const intervalMinutes = Number(replayInterval);
-      return Number.isFinite(intervalMinutes) && intervalMinutes > 0 ? intervalMinutes * 60 * 1e3 : 15 * 60 * 1e3;
-    };
+    replayStrategyIntervals = (summaries) => summaries.map(({ strategyName, strategyConfig }) => {
+      const durationMs = (0, import_data5.intervalToMs)(strategyConfig.INTERVAL);
+      if (!Number.isFinite(durationMs) || durationMs <= 0) {
+        throw new Error(`Invalid replay interval for ${strategyName}`);
+      }
+      return { strategyName, interval: String(durationMs / 6e4) };
+    });
     buildReplaySignalEvaluations = (signals2) => signals2.map((signal) => ({
       evaluationId: `${signal.strategy}:${signal.symbol}:${signal.timestamp}`,
       userName: replayUserName,
@@ -19908,7 +20050,8 @@ var init_runtimeComparison = __esm({
       runtimeSignals,
       runtimeSignalEvaluations,
       runtimeLineageScopes,
-      lineage
+      lineage,
+      timestampOffsetMs
     }) => {
       const { connector, connectorName, window } = getRuntimeCompareContext();
       const rawExchangeEntries = await loadExchangeEntriesForComparison({
@@ -19933,7 +20076,7 @@ var init_runtimeComparison = __esm({
           runtimeSignals,
           runtimeSignalEvaluations,
           toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
-          signalTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs()
+          signalTimestampOffsetMs: timestampOffsetMs
         });
       });
       const comparisonLineage = {
@@ -19955,7 +20098,7 @@ var init_runtimeComparison = __esm({
           backtestEntries,
           strategyNameByOrderLinkKey,
           toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
-          backtestTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs(),
+          backtestTimestampOffsetMs: timestampOffsetMs,
           runtimeSignals,
           runtimeSignalEvaluations,
           replaySignals,
@@ -19994,7 +20137,7 @@ var init_runtimeComparison = __esm({
         exchangeEntries,
         backtestEntries,
         toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
-        backtestTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs()
+        backtestTimestampOffsetMs: timestampOffsetMs
       });
       const { completed: matched, orderFailed } = splitExchangeMatchesByRuntimeOrderStatus({
         matched: comparison.matched,
@@ -20002,7 +20145,7 @@ var init_runtimeComparison = __esm({
         runtimeSignals,
         runtimeSignalEvaluations,
         toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
-        signalTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs()
+        signalTimestampOffsetMs: timestampOffsetMs
       });
       const details = buildReplayExchangeComparisonDetails({
         matched,
@@ -20013,7 +20156,7 @@ var init_runtimeComparison = __esm({
         backtestEntries,
         strategyNameByOrderLinkKey,
         toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
-        backtestTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs(),
+        backtestTimestampOffsetMs: timestampOffsetMs,
         runtimeSignals,
         runtimeSignalEvaluations,
         replaySignals,
@@ -20074,9 +20217,16 @@ var init_runtimeComparison = __esm({
         expectedUserName: replayUserName,
         expectedWindow: window
       }) : null;
-      const replayTimestampOffset = runtimeEvidence2 ? buildTradeParityTimestampOffset(
-        (0, runtimeEvidenceDeployment_exports.activeRuntimeEvidenceStrategies)(runtimeEvidence2.deployment)
-      ) : getReplayEntryTimestampCompareOffsetMs();
+      const declaredIntervals = runtimeEvidence2 ? [] : replayStrategyIntervals(liveStrategySummaries);
+      const replayTimestampOffset = buildTradeParityTimestampOffset(
+        runtimeEvidence2 ? (0, runtimeEvidenceDeployment_exports.activeRuntimeEvidenceStrategies)(runtimeEvidence2.deployment) : declaredIntervals
+      );
+      const metadataStart = runtimeEvidence2 ? window.start : window.start - Math.max(
+        0,
+        ...declaredIntervals.map(
+          ({ interval: interval4 }) => Number(interval4) * 6e4 - (0, import_data5.intervalToMs)(replayInterval)
+        )
+      );
       const [
         rawRuntimeTrades,
         runtimeSignals,
@@ -20093,15 +20243,15 @@ var init_runtimeComparison = __esm({
           endTime: window.end
         }),
         loadRuntimeSignals(replayUserName, {
-          startTime: window.start,
+          startTime: metadataStart,
           endTime: window.end
         }),
         loadRuntimeSignalEvaluations(replayUserName, {
-          startTime: window.start,
+          startTime: metadataStart,
           endTime: window.end
         }),
         loadRuntimeLineageScopes(replayUserName, {
-          startTime: window.start,
+          startTime: metadataStart,
           endTime: window.end
         })
       ]);
@@ -20169,6 +20319,7 @@ var init_runtimeComparison = __esm({
         );
         return saveAndPrintReplayExchangeComparison({
           liveStrategySummaries,
+          timestampOffsetMs: replayTimestampOffset,
           backtestEntries: comparableBacktestEntries,
           replaySignals,
           replaySignalEvaluations,
@@ -21086,13 +21237,14 @@ ${markdownTable2(strategyRows)}
 });
 
 // src/scripts/replayRunner.ts
-var import_chalk21, import_constants14, import_data4, import_time8, import_redis11, import_candles, import_runtimeStrategies4, import_strategies7, prepareReplayBinanceMarketContext, replayMarketContextInterval, cachedTickerSymbols, finishReplay, replayBacktest;
+var import_chalk21, import_constants14, import_data6, import_time8, import_redis11, import_candles, import_runtimeStrategies4, import_strategies7, prepareReplayBinanceMarketContext, replayMarketContextInterval, cachedTickerSymbols, finishReplay, replayBacktest;
 var init_replayRunner = __esm({
   "src/scripts/replayRunner.ts"() {
     "use strict";
+    init_historicalSignalsReplayPreparation();
     import_chalk21 = __toESM(require("chalk"));
     import_constants14 = require("@tradejs/core/constants");
-    import_data4 = require("@tradejs/core/data");
+    import_data6 = require("@tradejs/core/data");
     import_time8 = require("@tradejs/core/time");
     import_redis11 = require("@tradejs/infra/redis");
     import_candles = require("@tradejs/infra/timescale/candles");
@@ -21368,16 +21520,10 @@ var init_replayRunner = __esm({
       if (!replayStrategies.length) {
         throw new Error(`No enabled strategies in deployment ${deployment.id}`);
       }
-      const strategyIntervals = new Set(
-        replayStrategies.map(
-          ({ strategyConfig }) => String(strategyConfig.INTERVAL)
-        )
+      resolveHistoricalReplayIntervals(
+        replayInterval,
+        replayStrategies.map(({ strategyConfig }) => strategyConfig.INTERVAL)
       );
-      if (strategyIntervals.size !== 1 || !strategyIntervals.has(replayInterval)) {
-        throw new Error(
-          `Replay interval does not match deployment ${deployment.id}: replay=${replayInterval}, strategies=${[...strategyIntervals].join(",")}`
-        );
-      }
       const strategyUniverses = new Set(
         replayStrategies.map(
           ({ strategyConfig }) => String(strategyConfig.UNIVERSE)
@@ -21423,13 +21569,13 @@ var init_replayRunner = __esm({
         deploymentId: deployment.id,
         assetClasses: deployment.assetClasses,
         deployment,
-        closedIntervalMs: (0, import_data4.intervalToMs)(replayInterval)
+        closedIntervalMs: (0, import_data6.intervalToMs)(replayInterval)
       });
       if (!preparedRun || isReplayUpdateOnlyRun) {
         return;
       }
       if (useAllData) {
-        const intervalMs = (0, import_data4.intervalToMs)(replayInterval);
+        const intervalMs = (0, import_data6.intervalToMs)(replayInterval);
         const edges = await (0, import_candles.getDataEdgesForSymbols)(
           deployment.provider,
           preparedRun.tickers,
@@ -21914,13 +22060,13 @@ var init_binanceMarketIngest = __esm({
 });
 
 // src/lib/runBot.ts
-var import_lodash, import_connectors10, import_data5, import_strategies10, import_async3, import_constants15, import_time9, import_logger2, import_redis12, projectRoot4, runBot;
+var import_lodash, import_connectors10, import_data7, import_strategies10, import_async3, import_constants15, import_time9, import_logger2, import_redis12, projectRoot4, runBot;
 var init_runBot = __esm({
   "src/lib/runBot.ts"() {
     "use strict";
     import_lodash = __toESM(require("lodash"));
     import_connectors10 = require("@tradejs/node/connectors");
-    import_data5 = require("@tradejs/core/data");
+    import_data7 = require("@tradejs/core/data");
     import_strategies10 = require("@tradejs/node/strategies");
     import_async3 = require("@tradejs/core/async");
     import_constants15 = require("@tradejs/core/constants");
@@ -22039,11 +22185,11 @@ var init_runBot = __esm({
               status: JSON.stringify(status)
             });
           } catch (err) {
-            import_logger2.logger.log("error", "bot %s error: %s", bot.symbol, (0, import_data5.toJson)(err, false));
+            import_logger2.logger.log("error", "bot %s error: %s", bot.symbol, (0, import_data7.toJson)(err, false));
           }
         }
       }
-      import_logger2.logger.log("info", "botResults: %s", (0, import_data5.toJson)(botResults, true));
+      import_logger2.logger.log("info", "botResults: %s", (0, import_data7.toJson)(botResults, true));
       return botResults;
     };
   }
@@ -23502,12 +23648,12 @@ var init_doctor = __esm({
 });
 
 // src/lib/executionCalibration.ts
-var import_constants17, import_data6, import_trade3, roundMetric, asRecord3, asArray, finiteNumber2, finiteString, finiteDirection, metricValues, quantile, summarizeNumbers, getIntervalMs, getSignalKey, addSignalToMap, getRuntimePayload, extractRuntimeTradeRows, normalizeReplayMatch, extractReplayMatches, buildReplayMatchMaps, getSignalCandles, adverseEntryBps, feeBps, latencyDelta, resolveTelemetryQuality, finiteTelemetryQuality, countBy, toLatencyBucket, toSpreadBucket, buildSample, buildReplayOnlySample, hasTelemetry, hasFullTelemetry, buildGroupSummary, groupSamples, positiveMetricValues, buildRecommendation, buildExecutionCalibrationReport;
+var import_constants17, import_data8, import_trade3, roundMetric, asRecord3, asArray, finiteNumber2, finiteString, finiteDirection, metricValues, quantile, summarizeNumbers, getIntervalMs, getSignalKey, addSignalToMap, getRuntimePayload, extractRuntimeTradeRows, normalizeReplayMatch, extractReplayMatches, buildReplayMatchMaps, getSignalCandles, adverseEntryBps, feeBps, latencyDelta, resolveTelemetryQuality, finiteTelemetryQuality, countBy, toLatencyBucket, toSpreadBucket, buildSample, buildReplayOnlySample, hasTelemetry, hasFullTelemetry, buildGroupSummary, groupSamples, positiveMetricValues, buildRecommendation, buildExecutionCalibrationReport;
 var init_executionCalibration = __esm({
   "src/lib/executionCalibration.ts"() {
     "use strict";
     import_constants17 = require("@tradejs/core/constants");
-    import_data6 = require("@tradejs/core/data");
+    import_data8 = require("@tradejs/core/data");
     import_trade3 = require("@tradejs/core/trade");
     roundMetric = (value, decimals = 6) => typeof value === "number" && Number.isFinite(value) ? Number(value.toFixed(decimals)) : null;
     asRecord3 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -23567,7 +23713,7 @@ var init_executionCalibration = __esm({
         return null;
       }
       try {
-        return (0, import_data6.intervalToMs)(interval4);
+        return (0, import_data8.intervalToMs)(interval4);
       } catch {
         return null;
       }
@@ -24795,14 +24941,16 @@ const timer = setInterval(() => {
     if (result.exitCode !== 0) {
       let fd;
       try {
-        fd = fs.openSync(file + '.log', fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        const logId = result.logRequestId === undefined ? id : result.logRequestId;
+        if (typeof logId !== 'string' || !/^[a-f0-9]{64}$/.test(logId)) throw new Error('Invalid replay log identity');
+        fd = fs.openSync(path.join(root, logId) + '.log', fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
         const size = fs.fstatSync(fd).size;
         const tail = Buffer.alloc(Math.min(size, 65536));
         fs.readSync(fd, tail, 0, tail.length, Math.max(0, size - tail.length));
         // The worker redacts each line before persisting or returning it through MCP.
         for (const line of tail.toString('utf8').split(/[\\r\\n]+/).filter(Boolean).slice(-150)) console.error('Host replay: ' + line);
       } catch (error) {
-        console.error('Host replay log unavailable: ' + error.code);
+        console.error('Host replay: ' + result.message + '; log unavailable: ' + (error.code || error.message));
       } finally { if (fd !== undefined) fs.closeSync(fd); }
     }
     clearInterval(timer);
@@ -31438,6 +31586,10 @@ var init_specification = __esm({
       };
       if (!spec.budget || !spec.selection || !spec.diagnostics)
         throw new Error("Missing research budgets or criteria");
+      if (spec.featurePaths !== void 0 && (!Array.isArray(spec.featurePaths) || !spec.featurePaths.length || spec.featurePaths.length > 64 || new Set(spec.featurePaths).size !== spec.featurePaths.length || spec.featurePaths.some(
+        (path56) => typeof path56 !== "string" || !/^additionalIndicators\.[a-zA-Z0-9_.]+$/.test(path56) || classifyAiPocketFeaturePath(path56.split(".")) !== "eligible"
+      )))
+        throw new Error("Feature paths must be unique causal market features");
       positive(spec.budget.maxVariants, "maxVariants", 12);
       if (!Number.isInteger(spec.minQuality) || spec.minQuality < 1 || spec.minQuality > 5)
         throw new Error("minQuality must be 1 through 5");
@@ -33609,6 +33761,7 @@ var init_orchestrator2 = __esm({
               parentSpec.selection,
               parentSpec.portfolio,
               parentSpec.minQuality,
+              parentSpec.featurePaths,
               parentSpec.diagnostics
             ]) !== sha256Json([
               spec.core.variants.map((item) => item.resolvedConfig),
@@ -33617,6 +33770,7 @@ var init_orchestrator2 = __esm({
               spec.selection,
               spec.portfolio,
               spec.minQuality,
+              spec.featurePaths,
               spec.diagnostics
             ]) || parentState.lineage.runtimeSha256 !== state.lineage.runtimeSha256 || parentState.lineage.contextEnvironmentSha256 !== state.lineage.contextEnvironmentSha256)
               throw new Error(
@@ -34132,7 +34286,7 @@ ${conclusion.nextAction} Current-snapshot universe; no deployment authorization.
 });
 
 // src/lib/strategyResearch/native.ts
-var import_promises32, import_node_fs9, import_node_path29, import_node_os4, import_node_readline4, import_node_child_process8, import_node_module3, import_redis17, import_ai9, import_backtest7, import_registry5, import_connectors14, import_data7, import_coreResearch2, import_jev6, validateResearchJevTraining, nativeConfig, runResearchCommand, createNativeStrategyResearchBackend;
+var import_promises32, import_node_fs9, import_node_path29, import_node_os4, import_node_readline4, import_node_child_process8, import_node_module3, import_redis17, import_ai9, import_backtest7, import_registry5, import_connectors14, import_data9, import_coreResearch2, import_jev6, validateResearchJevTraining, nativeConfig, runResearchCommand, createNativeStrategyResearchBackend;
 var init_native = __esm({
   "src/lib/strategyResearch/native.ts"() {
     "use strict";
@@ -34157,7 +34311,7 @@ var init_native = __esm({
     init_io2();
     init_aiTrainResearch();
     init_events();
-    import_data7 = require("@tradejs/core/data");
+    import_data9 = require("@tradejs/core/data");
     import_coreResearch2 = require("@tradejs/infra/coreResearch");
     init_trace();
     import_jev6 = require("@tradejs/core/jev");
@@ -34325,9 +34479,10 @@ var init_native = __esm({
           throw new Error(
             "Tester workers are already active; research will resume when the host is free"
           );
-        if (import_node_os4.default.freemem() < spec.budget.minimumFreeMemoryMb * 1024 * 1024)
+        const availableBytes = import_node_os4.default.platform() === "darwin" ? process.availableMemory() : import_node_os4.default.freemem();
+        if (!Number.isFinite(availableBytes) || availableBytes < spec.budget.minimumFreeMemoryMb * 1024 * 1024)
           throw new Error(
-            "Insufficient free host memory for the frozen research budget"
+            "Insufficient available host memory for the frozen research budget"
           );
       };
       return {
@@ -34551,7 +34706,7 @@ var init_native = __esm({
               );
           }
           if (!coverage.some(
-            (item) => (item.last ?? 0) >= spec.core.window.end - 2 * (0, import_data7.intervalToMs)(spec.core.execution.interval)
+            (item) => (item.last ?? 0) >= spec.core.window.end - 2 * (0, import_data9.intervalToMs)(spec.core.execution.interval)
           ))
             throw new Error(
               "Cached market history ends before the requested window; choose a covered end or explicitly refresh history"
@@ -34780,9 +34935,14 @@ var init_native = __esm({
             throw new Error(
               `Native/export reconciliation is ${reconciliation.status}: ${reconciliation.reasons.join("; ")}`
             );
+          const researchSignalId = (symbol, signalId) => JSON.stringify([symbol, signalId]);
           const trades = loaded.trades.filter(
             (trade) => trade.signalTimestamp >= spec.core.window.start && trade.signalTimestamp < spec.core.window.end && trade.exitTimestamp < spec.core.window.end
-          );
+          ).map((trade) => ({
+            ...trade,
+            // Strategy-generated signal IDs need not be unique across symbols.
+            signalId: researchSignalId(trade.symbol, trade.signalId)
+          }));
           const tradeBySignal = new Map(
             trades.map((trade) => [trade.signalId, trade])
           );
@@ -34806,9 +34966,10 @@ var init_native = __esm({
               for await (const line of lines) {
                 if (!line.trim()) continue;
                 const row = JSON.parse(line);
-                const trade = tradeBySignal.get(row.signalId);
-                if (!trade || seen.has(row.signalId)) continue;
-                seen.add(row.signalId);
+                const signalId = researchSignalId(row.symbol, row.signalId);
+                const trade = tradeBySignal.get(signalId);
+                if (!trade || seen.has(signalId)) continue;
+                seen.add(signalId);
                 if (discoveryOnly && (row.timestamp >= spec.testSince || trade.exitTimestamp >= spec.testSince)) {
                   if (row.timestamp < spec.testSince) purgedLabels++;
                   continue;
@@ -34846,7 +35007,7 @@ var init_native = __esm({
                   featureProfile: "all"
                 });
                 for (const key of Object.keys(features))
-                  if (!key.startsWith("additionalIndicators.") || features[key] == null)
+                  if (!key.startsWith("additionalIndicators.") || features[key] == null || spec.featurePaths && !spec.featurePaths.includes(key))
                     delete features[key];
                 featureValues += Object.keys(features).length;
                 if (featureValues > 5e6)
@@ -34865,7 +35026,7 @@ var init_native = __esm({
                     pathCoverage[key]++;
                 }
                 rows.push({
-                  signalId: row.signalId,
+                  signalId,
                   symbol: row.symbol,
                   strategy: row.strategyName,
                   timestamp: row.timestamp,
@@ -34880,7 +35041,7 @@ var init_native = __esm({
                 });
                 if (discoveryOnly) {
                   eventInputs.push({
-                    signalId: row.signalId,
+                    signalId,
                     timestamp: row.timestamp,
                     symbol: row.symbol,
                     direction: row.direction,
@@ -34891,8 +35052,8 @@ var init_native = __esm({
                   });
                   const key = `${row.direction}:${trade.netProfit > 0}`;
                   const bucket = sampleBuckets.get(key) ?? [];
-                  bucket.push(row.signalId);
-                  sampleInputs.set(row.signalId, row);
+                  bucket.push(signalId);
+                  sampleInputs.set(signalId, row);
                   bucket.sort((a, b) => sha256Json(a).localeCompare(sha256Json(b)));
                   while (bucket.length > spec.diagnostics.samplePerSideAndOutcome)
                     sampleInputs.delete(bucket.pop());
@@ -34927,7 +35088,7 @@ var init_native = __esm({
               grouped.set(input.symbol, group);
             }
             for (const [symbol, events] of grouped) {
-              const intervalMs = (0, import_data7.intervalToMs)(
+              const intervalMs = (0, import_data9.intervalToMs)(
                 spec.core.execution.interval
               );
               const candles = await provider.kline({
@@ -34960,7 +35121,7 @@ var init_native = __esm({
                   const trade = tradeBySignal.get(row.signalId);
                   const original = sampleInputs.get(row.signalId);
                   if (!trade || !original) continue;
-                  const intervalMs = (0, import_data7.intervalToMs)(
+                  const intervalMs = (0, import_data9.intervalToMs)(
                     spec.core.execution.interval
                   );
                   const candles = await provider.kline({