@tradejs/cli 3.1.29-beta.265 → 3.1.29-beta.266

package/dist/cli.js

@@ -16947,18 +16947,43 @@ var init_chartSnapshot = __esm({
 });
 
 // src/lib/runtimeParity.ts
-var toFiniteNumberOrNull2, toGroupKey, toRuntimeDuplicateKey, getBacktestParityComparisonTimestamp, sortTradeParityEntries, buildPriceDeltaPct, toExitType, resolveBacktestExitType, extractBacktestEntryParityEntries, extractRuntimeParityEntries, findRuntimeDuplicateGroups, dedupeRuntimeParityEntries, compareTradeParityEntries, summarizeMatchedParity;
+var resolveTradeParityTimestampOffset, buildTradeParityTimestampOffset, toFiniteNumberOrNull2, toGroupKey, toRuntimeDuplicateKey, getBacktestParityComparisonTimestamp, sortTradeParityEntries, buildPriceDeltaPct, toExitType, resolveBacktestExitType, extractBacktestEntryParityEntries, extractRuntimeParityEntries, findRuntimeDuplicateGroups, dedupeRuntimeParityEntries, compareTradeParityEntries, summarizeMatchedParity;
 var init_runtimeParity = __esm({
   "src/lib/runtimeParity.ts"() {
     "use strict";
+    resolveTradeParityTimestampOffset = (strategy, offset) => typeof offset === "function" ? offset(strategy) : offset;
+    buildTradeParityTimestampOffset = (strategies) => {
+      const intervals = /* @__PURE__ */ new Map();
+      for (const { strategyName, interval: interval4 } of strategies) {
+        const minutes = Number(interval4);
+        if (!Number.isFinite(minutes) || minutes <= 0) {
+          throw new Error(`Invalid embedded replay interval for ${strategyName}`);
+        }
+        intervals.set(strategyName, minutes * 60 * 1e3);
+      }
+      return (strategy) => {
+        const offsetMs = intervals.get(strategy);
+        if (offsetMs == null) {
+          throw new Error(`Missing embedded replay interval for ${strategy}`);
+        }
+        return offsetMs;
+      };
+    };
     toFiniteNumberOrNull2 = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
     toGroupKey = (entry) => `${entry.strategy}::${entry.symbol}::${entry.direction}`;
     toRuntimeDuplicateKey = (entry) => `${toGroupKey(entry)}::${entry.timestamp}`;
     getBacktestParityComparisonTimestamp = (entry, timestampOffsetMs = 0) => {
-      if (timestampOffsetMs > 0 && entry.signalTimestamp != null && entry.timestamp >= entry.signalTimestamp + timestampOffsetMs) {
+      const offsetMs = resolveTradeParityTimestampOffset(
+        entry.strategy,
+        timestampOffsetMs
+      );
+      if (!Number.isFinite(offsetMs) || offsetMs < 0) {
+        throw new Error(`Invalid backtest timestamp offset for ${entry.strategy}`);
+      }
+      if (offsetMs > 0 && entry.signalTimestamp != null && entry.timestamp >= entry.signalTimestamp + offsetMs) {
         return entry.timestamp;
       }
-      return (entry.signalTimestamp ?? entry.timestamp) + timestampOffsetMs;
+      return (entry.signalTimestamp ?? entry.timestamp) + offsetMs;
     };
     sortTradeParityEntries = (left, right) => left.timestamp - right.timestamp || left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol) || left.direction.localeCompare(right.direction) || left.id.localeCompare(right.id);
     buildPriceDeltaPct = (leftPrice, rightPrice) => {
@@ -18014,9 +18039,13 @@ var init_runtimeParityDetails = __esm({
       totalFee: entry.totalFee ?? null
     });
     toBacktestParityDetail = (entry, timestampOffsetMs = 0) => {
+      const offsetMs = resolveTradeParityTimestampOffset(
+        entry.strategy,
+        timestampOffsetMs
+      );
       const comparisonTimestamp = getBacktestParityComparisonTimestamp(
         entry,
-        timestampOffsetMs
+        offsetMs
       );
       return {
         source: "backtest",
@@ -18026,7 +18055,7 @@ var init_runtimeParityDetails = __esm({
         qty: entry.qty ?? null,
         timestamp: entry.timestamp,
         signalTimestamp: entry.signalTimestamp ?? null,
-        comparisonTimestamp: timestampOffsetMs === 0 ? null : comparisonTimestamp,
+        comparisonTimestamp: offsetMs === 0 ? null : comparisonTimestamp,
         price: entry.price,
         exitType: entry.exitType ?? null,
         exitTimestamp: entry.exitTimestamp ?? null,
@@ -18485,25 +18514,29 @@ var init_runtimeParityDetails = __esm({
       let runtimeOnlyArtifactsIncluded = 0;
       let backtestOnlyArtifactsIncluded = 0;
       const runtimeOnlyDiagnostics = runtimeOnly.map((entry, index) => {
+        const entryOffsetMs = resolveTradeParityTimestampOffset(
+          getEntryStrategy(entry) ?? "",
+          backtestTimestampOffsetMs
+        );
         const includeArtifacts = index < artifactLimit;
         const nearestCandidate = nearestByEntry.get(entry);
         const nearestReplaySignal = findNearestSignal({
           entry,
           signals: replaySignals,
           toleranceMs,
-          timestampOffsetMs: backtestTimestampOffsetMs
+          timestampOffsetMs: entryOffsetMs
         });
         const nearestReplayEvaluation = findNearestEvaluation({
           entry,
           evaluations: replaySignalEvaluations,
           toleranceMs,
-          timestampOffsetMs: backtestTimestampOffsetMs
+          timestampOffsetMs: entryOffsetMs
         });
         const nearestReplayEvaluationOutcome = findNearestReplayEvaluationOutcome({
           entry,
           lineageScopes: replayLineageScopes,
           toleranceMs,
-          timestampOffsetMs: backtestTimestampOffsetMs
+          timestampOffsetMs: entryOffsetMs
         });
         const classification = nearestReplaySignal ? classifySignalDiagnostic(nearestReplaySignal.signal) : nearestReplayEvaluation ? classifyEvaluationDiagnostic(nearestReplayEvaluation.evaluation) : nearestReplayEvaluationOutcome ? {
           classification: "core_skipped",
@@ -19386,6 +19419,7 @@ var init_runtimeComparison = __esm({
     init_cliConfig2();
     init_runtimeEvidenceSource();
     init_support();
+    init_runtimeEvidenceDeployment();
     init_runtimeComparisonCalculations();
     init_runtimeComparisonReporting();
     init_runtimeComparisonCalculations();
@@ -19775,6 +19809,9 @@ var init_runtimeComparison = __esm({
         expectedUserName: replayUserName,
         expectedWindow: window
       }) : null;
+      const replayTimestampOffset = runtimeEvidence2 ? buildTradeParityTimestampOffset(
+        (0, runtimeEvidenceDeployment_exports.activeRuntimeEvidenceStrategies)(runtimeEvidence2.deployment)
+      ) : getReplayEntryTimestampCompareOffsetMs();
       const [
         rawRuntimeTrades,
         runtimeSignals,
@@ -19884,7 +19921,7 @@ var init_runtimeComparison = __esm({
         runtimeEntries: runtimeDedupe.entries,
         backtestEntries: comparableBacktestEntries,
         toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
-        backtestTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs()
+        backtestTimestampOffsetMs: replayTimestampOffset
       });
       const details = buildReplayRuntimeComparisonDetails({
         matched: comparison.matched,
@@ -19893,7 +19930,7 @@ var init_runtimeComparison = __esm({
         runtimeEntries: runtimeDedupe.entries,
         backtestEntries: comparableBacktestEntries,
         toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
-        backtestTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs(),
+        backtestTimestampOffsetMs: replayTimestampOffset,
         runtimeSignals: comparable.runtimeSignals,
         runtimeSignalEvaluations: comparable.runtimeSignalEvaluations,
         replaySignals,
@@ -31772,41 +31809,52 @@ var init_runtimeFeedbackReplay = __esm({
       interval: interval4,
       startTime,
       endTime
-    }) => [
-      [
-        cliPath,
-        "replay",
-        "--user",
-        userName3,
-        "--connector",
-        connectorName,
-        "--deployment",
-        deploymentId,
-        "--timeframe",
-        interval4,
-        "--startTime",
-        String(startTime),
-        "--endTime",
-        String(endTime),
-        "--runtimeEvidence",
-        runtimeEvidencePath,
-        "--cacheOnly"
-      ],
-      [
-        cliPath,
-        "replay-runtime-evidence",
-        "--user",
-        userName3,
-        "--runtimeEvidence",
-        runtimeEvidencePath,
-        "--startTime",
-        String(startTime),
-        "--endTime",
-        String(endTime),
-        "--out",
-        replayEvidencePath
-      ]
-    ];
+    }) => {
+      const intervals = interval4.split(",").map((value) => value.trim());
+      if (!intervals.length || intervals.some(
+        (value) => !value || !Number.isFinite(Number(value)) || Number(value) <= 0
+      )) {
+        throw new Error(`Invalid runtime feedback replay intervals: ${interval4}`);
+      }
+      const replayTimeframe = intervals.sort(
+        (left, right) => Number(left) - Number(right)
+      )[0];
+      return [
+        [
+          cliPath,
+          "replay",
+          "--user",
+          userName3,
+          "--connector",
+          connectorName,
+          "--deployment",
+          deploymentId,
+          "--timeframe",
+          replayTimeframe,
+          "--startTime",
+          String(startTime),
+          "--endTime",
+          String(endTime),
+          "--runtimeEvidence",
+          runtimeEvidencePath,
+          "--cacheOnly"
+        ],
+        [
+          cliPath,
+          "replay-runtime-evidence",
+          "--user",
+          userName3,
+          "--runtimeEvidence",
+          runtimeEvidencePath,
+          "--startTime",
+          String(startTime),
+          "--endTime",
+          String(endTime),
+          "--out",
+          replayEvidencePath
+        ]
+      ];
+    };
     runLoggedCommand = async ({
       executable,
       command,
@@ -31893,10 +31941,8 @@ $ ${[executable, ...command].join(" ")}
       const intervals = new Set(
         activeStrategies.map(({ interval: interval4 }) => String(interval4))
       );
-      if (intervals.size !== 1) {
-        throw new Error(
-          `Runtime feedback replay requires one interval, received ${[...intervals].join(",")}`
-        );
+      if (!intervals.size) {
+        throw new Error("Runtime feedback replay requires an active interval");
       }
       await import_promises28.default.mkdir(outDir, { recursive: true });
       const existing = await import_promises28.default.readdir(outDir);
@@ -31917,7 +31963,7 @@ $ ${[executable, ...command].join(" ")}
         userName: runtimeEvidenceBundle.manifest.userName,
         connectorName: deployment.connectorName,
         deploymentId: deployment.id,
-        interval: [...intervals][0],
+        interval: [...intervals].join(","),
         startTime: runtimeEvidenceBundle.manifest.window.startTime,
         endTime: runtimeEvidenceBundle.manifest.window.endTime
       });

package/dist/lib/runtimeFeedbackReplay.js

@@ -133,41 +133,52 @@ var buildRuntimeFeedbackReplayCommands = ({
   interval,
   startTime,
   endTime
-}) => [
-  [
-    cliPath,
-    "replay",
-    "--user",
-    userName,
-    "--connector",
-    connectorName,
-    "--deployment",
-    deploymentId,
-    "--timeframe",
-    interval,
-    "--startTime",
-    String(startTime),
-    "--endTime",
-    String(endTime),
-    "--runtimeEvidence",
-    runtimeEvidencePath,
-    "--cacheOnly"
-  ],
-  [
-    cliPath,
-    "replay-runtime-evidence",
-    "--user",
-    userName,
-    "--runtimeEvidence",
-    runtimeEvidencePath,
-    "--startTime",
-    String(startTime),
-    "--endTime",
-    String(endTime),
-    "--out",
-    replayEvidencePath
-  ]
-];
+}) => {
+  const intervals = interval.split(",").map((value) => value.trim());
+  if (!intervals.length || intervals.some(
+    (value) => !value || !Number.isFinite(Number(value)) || Number(value) <= 0
+  )) {
+    throw new Error(`Invalid runtime feedback replay intervals: ${interval}`);
+  }
+  const replayTimeframe = intervals.sort(
+    (left, right) => Number(left) - Number(right)
+  )[0];
+  return [
+    [
+      cliPath,
+      "replay",
+      "--user",
+      userName,
+      "--connector",
+      connectorName,
+      "--deployment",
+      deploymentId,
+      "--timeframe",
+      replayTimeframe,
+      "--startTime",
+      String(startTime),
+      "--endTime",
+      String(endTime),
+      "--runtimeEvidence",
+      runtimeEvidencePath,
+      "--cacheOnly"
+    ],
+    [
+      cliPath,
+      "replay-runtime-evidence",
+      "--user",
+      userName,
+      "--runtimeEvidence",
+      runtimeEvidencePath,
+      "--startTime",
+      String(startTime),
+      "--endTime",
+      String(endTime),
+      "--out",
+      replayEvidencePath
+    ]
+  ];
+};
 var runLoggedCommand = async ({
   executable,
   command,
@@ -254,10 +265,8 @@ var runRuntimeFeedbackReplay = async ({
   const intervals = new Set(
     activeStrategies.map(({ interval }) => String(interval))
   );
-  if (intervals.size !== 1) {
-    throw new Error(
-      `Runtime feedback replay requires one interval, received ${[...intervals].join(",")}`
-    );
+  if (!intervals.size) {
+    throw new Error("Runtime feedback replay requires an active interval");
   }
   await import_promises.default.mkdir(outDir, { recursive: true });
   const existing = await import_promises.default.readdir(outDir);
@@ -278,7 +287,7 @@ var runRuntimeFeedbackReplay = async ({
     userName: runtimeEvidenceBundle.manifest.userName,
     connectorName: deployment.connectorName,
     deploymentId: deployment.id,
-    interval: [...intervals][0],
+    interval: [...intervals].join(","),
     startTime: runtimeEvidenceBundle.manifest.window.startTime,
     endTime: runtimeEvidenceBundle.manifest.window.endTime
   });

package/dist/lib/runtimeParity.js

@@ -20,23 +20,50 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/lib/runtimeParity.ts
 var runtimeParity_exports = {};
 __export(runtimeParity_exports, {
+  buildTradeParityTimestampOffset: () => buildTradeParityTimestampOffset,
   compareTradeParityEntries: () => compareTradeParityEntries,
   dedupeRuntimeParityEntries: () => dedupeRuntimeParityEntries,
   extractBacktestEntryParityEntries: () => extractBacktestEntryParityEntries,
   extractRuntimeParityEntries: () => extractRuntimeParityEntries,
   findRuntimeDuplicateGroups: () => findRuntimeDuplicateGroups,
   getBacktestParityComparisonTimestamp: () => getBacktestParityComparisonTimestamp,
+  resolveTradeParityTimestampOffset: () => resolveTradeParityTimestampOffset,
   summarizeMatchedParity: () => summarizeMatchedParity
 });
 module.exports = __toCommonJS(runtimeParity_exports);
+var resolveTradeParityTimestampOffset = (strategy, offset) => typeof offset === "function" ? offset(strategy) : offset;
+var buildTradeParityTimestampOffset = (strategies) => {
+  const intervals = /* @__PURE__ */ new Map();
+  for (const { strategyName, interval } of strategies) {
+    const minutes = Number(interval);
+    if (!Number.isFinite(minutes) || minutes <= 0) {
+      throw new Error(`Invalid embedded replay interval for ${strategyName}`);
+    }
+    intervals.set(strategyName, minutes * 60 * 1e3);
+  }
+  return (strategy) => {
+    const offsetMs = intervals.get(strategy);
+    if (offsetMs == null) {
+      throw new Error(`Missing embedded replay interval for ${strategy}`);
+    }
+    return offsetMs;
+  };
+};
 var toFiniteNumberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
 var toGroupKey = (entry) => `${entry.strategy}::${entry.symbol}::${entry.direction}`;
 var toRuntimeDuplicateKey = (entry) => `${toGroupKey(entry)}::${entry.timestamp}`;
 var getBacktestParityComparisonTimestamp = (entry, timestampOffsetMs = 0) => {
-  if (timestampOffsetMs > 0 && entry.signalTimestamp != null && entry.timestamp >= entry.signalTimestamp + timestampOffsetMs) {
+  const offsetMs = resolveTradeParityTimestampOffset(
+    entry.strategy,
+    timestampOffsetMs
+  );
+  if (!Number.isFinite(offsetMs) || offsetMs < 0) {
+    throw new Error(`Invalid backtest timestamp offset for ${entry.strategy}`);
+  }
+  if (offsetMs > 0 && entry.signalTimestamp != null && entry.timestamp >= entry.signalTimestamp + offsetMs) {
     return entry.timestamp;
   }
-  return (entry.signalTimestamp ?? entry.timestamp) + timestampOffsetMs;
+  return (entry.signalTimestamp ?? entry.timestamp) + offsetMs;
 };
 var sortTradeParityEntries = (left, right) => left.timestamp - right.timestamp || left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol) || left.direction.localeCompare(right.direction) || left.id.localeCompare(right.id);
 var buildPriceDeltaPct = (leftPrice, rightPrice) => {
@@ -301,11 +328,13 @@ var summarizeMatchedParity = (matched) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  buildTradeParityTimestampOffset,
   compareTradeParityEntries,
   dedupeRuntimeParityEntries,
   extractBacktestEntryParityEntries,
   extractRuntimeParityEntries,
   findRuntimeDuplicateGroups,
   getBacktestParityComparisonTimestamp,
+  resolveTradeParityTimestampOffset,
   summarizeMatchedParity
 });

package/dist/lib/runtimeParityDetails.js

@@ -30,11 +30,19 @@ module.exports = __toCommonJS(runtimeParityDetails_exports);
 var import_trade = require("@tradejs/core/trade");
 
 // src/lib/runtimeParity.ts
+var resolveTradeParityTimestampOffset = (strategy, offset) => typeof offset === "function" ? offset(strategy) : offset;
 var getBacktestParityComparisonTimestamp = (entry, timestampOffsetMs = 0) => {
-  if (timestampOffsetMs > 0 && entry.signalTimestamp != null && entry.timestamp >= entry.signalTimestamp + timestampOffsetMs) {
+  const offsetMs = resolveTradeParityTimestampOffset(
+    entry.strategy,
+    timestampOffsetMs
+  );
+  if (!Number.isFinite(offsetMs) || offsetMs < 0) {
+    throw new Error(`Invalid backtest timestamp offset for ${entry.strategy}`);
+  }
+  if (offsetMs > 0 && entry.signalTimestamp != null && entry.timestamp >= entry.signalTimestamp + offsetMs) {
     return entry.timestamp;
   }
-  return (entry.signalTimestamp ?? entry.timestamp) + timestampOffsetMs;
+  return (entry.signalTimestamp ?? entry.timestamp) + offsetMs;
 };
 
 // src/lib/runtimeParityDetails.ts
@@ -78,9 +86,13 @@ var buildCostDetail = (entry) => ({
   totalFee: entry.totalFee ?? null
 });
 var toBacktestParityDetail = (entry, timestampOffsetMs = 0) => {
+  const offsetMs = resolveTradeParityTimestampOffset(
+    entry.strategy,
+    timestampOffsetMs
+  );
   const comparisonTimestamp = getBacktestParityComparisonTimestamp(
     entry,
-    timestampOffsetMs
+    offsetMs
   );
   return {
     source: "backtest",
@@ -90,7 +102,7 @@ var toBacktestParityDetail = (entry, timestampOffsetMs = 0) => {
     qty: entry.qty ?? null,
     timestamp: entry.timestamp,
     signalTimestamp: entry.signalTimestamp ?? null,
-    comparisonTimestamp: timestampOffsetMs === 0 ? null : comparisonTimestamp,
+    comparisonTimestamp: offsetMs === 0 ? null : comparisonTimestamp,
     price: entry.price,
     exitType: entry.exitType ?? null,
     exitTimestamp: entry.exitTimestamp ?? null,
@@ -549,25 +561,29 @@ var buildReplayMismatchDrilldown = ({
   let runtimeOnlyArtifactsIncluded = 0;
   let backtestOnlyArtifactsIncluded = 0;
   const runtimeOnlyDiagnostics = runtimeOnly.map((entry, index) => {
+    const entryOffsetMs = resolveTradeParityTimestampOffset(
+      getEntryStrategy(entry) ?? "",
+      backtestTimestampOffsetMs
+    );
     const includeArtifacts = index < artifactLimit;
     const nearestCandidate = nearestByEntry.get(entry);
     const nearestReplaySignal = findNearestSignal({
       entry,
       signals: replaySignals,
       toleranceMs,
-      timestampOffsetMs: backtestTimestampOffsetMs
+      timestampOffsetMs: entryOffsetMs
     });
     const nearestReplayEvaluation = findNearestEvaluation({
       entry,
       evaluations: replaySignalEvaluations,
       toleranceMs,
-      timestampOffsetMs: backtestTimestampOffsetMs
+      timestampOffsetMs: entryOffsetMs
     });
     const nearestReplayEvaluationOutcome = findNearestReplayEvaluationOutcome({
       entry,
       lineageScopes: replayLineageScopes,
       toleranceMs,
-      timestampOffsetMs: backtestTimestampOffsetMs
+      timestampOffsetMs: entryOffsetMs
     });
     const classification = nearestReplaySignal ? classifySignalDiagnostic(nearestReplaySignal.signal) : nearestReplayEvaluation ? classifyEvaluationDiagnostic(nearestReplayEvaluation.evaluation) : nearestReplayEvaluationOutcome ? {
       classification: "core_skipped",

package/dist/scripts/replay.js

@@ -6056,14 +6056,39 @@ var buildReplayChartSnapshot = (params) => {
 var import_chalk10 = __toESM(require("chalk"));
 
 // src/lib/runtimeParity.ts
+var resolveTradeParityTimestampOffset = (strategy, offset) => typeof offset === "function" ? offset(strategy) : offset;
+var buildTradeParityTimestampOffset = (strategies) => {
+  const intervals = /* @__PURE__ */ new Map();
+  for (const { strategyName, interval } of strategies) {
+    const minutes = Number(interval);
+    if (!Number.isFinite(minutes) || minutes <= 0) {
+      throw new Error(`Invalid embedded replay interval for ${strategyName}`);
+    }
+    intervals.set(strategyName, minutes * 60 * 1e3);
+  }
+  return (strategy) => {
+    const offsetMs = intervals.get(strategy);
+    if (offsetMs == null) {
+      throw new Error(`Missing embedded replay interval for ${strategy}`);
+    }
+    return offsetMs;
+  };
+};
 var toFiniteNumberOrNull2 = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
 var toGroupKey = (entry) => `${entry.strategy}::${entry.symbol}::${entry.direction}`;
 var toRuntimeDuplicateKey = (entry) => `${toGroupKey(entry)}::${entry.timestamp}`;
 var getBacktestParityComparisonTimestamp = (entry, timestampOffsetMs = 0) => {
-  if (timestampOffsetMs > 0 && entry.signalTimestamp != null && entry.timestamp >= entry.signalTimestamp + timestampOffsetMs) {
+  const offsetMs = resolveTradeParityTimestampOffset(
+    entry.strategy,
+    timestampOffsetMs
+  );
+  if (!Number.isFinite(offsetMs) || offsetMs < 0) {
+    throw new Error(`Invalid backtest timestamp offset for ${entry.strategy}`);
+  }
+  if (offsetMs > 0 && entry.signalTimestamp != null && entry.timestamp >= entry.signalTimestamp + offsetMs) {
     return entry.timestamp;
   }
-  return (entry.signalTimestamp ?? entry.timestamp) + timestampOffsetMs;
+  return (entry.signalTimestamp ?? entry.timestamp) + offsetMs;
 };
 var sortTradeParityEntries = (left, right) => left.timestamp - right.timestamp || left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol) || left.direction.localeCompare(right.direction) || left.id.localeCompare(right.id);
 var buildPriceDeltaPct = (leftPrice, rightPrice) => {
@@ -6869,9 +6894,13 @@ var buildCostDetail = (entry) => ({
   totalFee: entry.totalFee ?? null
 });
 var toBacktestParityDetail = (entry, timestampOffsetMs = 0) => {
+  const offsetMs = resolveTradeParityTimestampOffset(
+    entry.strategy,
+    timestampOffsetMs
+  );
   const comparisonTimestamp = getBacktestParityComparisonTimestamp(
     entry,
-    timestampOffsetMs
+    offsetMs
   );
   return {
     source: "backtest",
@@ -6881,7 +6910,7 @@ var toBacktestParityDetail = (entry, timestampOffsetMs = 0) => {
     qty: entry.qty ?? null,
     timestamp: entry.timestamp,
     signalTimestamp: entry.signalTimestamp ?? null,
-    comparisonTimestamp: timestampOffsetMs === 0 ? null : comparisonTimestamp,
+    comparisonTimestamp: offsetMs === 0 ? null : comparisonTimestamp,
     price: entry.price,
     exitType: entry.exitType ?? null,
     exitTimestamp: entry.exitTimestamp ?? null,
@@ -7340,25 +7369,29 @@ var buildReplayMismatchDrilldown = ({
   let runtimeOnlyArtifactsIncluded = 0;
   let backtestOnlyArtifactsIncluded = 0;
   const runtimeOnlyDiagnostics = runtimeOnly.map((entry, index) => {
+    const entryOffsetMs = resolveTradeParityTimestampOffset(
+      getEntryStrategy(entry) ?? "",
+      backtestTimestampOffsetMs
+    );
     const includeArtifacts = index < artifactLimit;
     const nearestCandidate = nearestByEntry.get(entry);
     const nearestReplaySignal = findNearestSignal({
       entry,
       signals: replaySignals,
       toleranceMs,
-      timestampOffsetMs: backtestTimestampOffsetMs
+      timestampOffsetMs: entryOffsetMs
     });
     const nearestReplayEvaluation = findNearestEvaluation({
       entry,
       evaluations: replaySignalEvaluations,
       toleranceMs,
-      timestampOffsetMs: backtestTimestampOffsetMs
+      timestampOffsetMs: entryOffsetMs
     });
     const nearestReplayEvaluationOutcome = findNearestReplayEvaluationOutcome({
       entry,
       lineageScopes: replayLineageScopes,
       toleranceMs,
-      timestampOffsetMs: backtestTimestampOffsetMs
+      timestampOffsetMs: entryOffsetMs
     });
     const classification = nearestReplaySignal ? classifySignalDiagnostic(nearestReplaySignal.signal) : nearestReplayEvaluation ? classifyEvaluationDiagnostic(nearestReplayEvaluation.evaluation) : nearestReplayEvaluationOutcome ? {
       classification: "core_skipped",
@@ -8593,6 +8626,9 @@ var saveAndPrintReplayRuntimeComparison = async ({
     expectedUserName: replayUserName,
     expectedWindow: window
   }) : null;
+  const replayTimestampOffset = runtimeEvidence ? buildTradeParityTimestampOffset(
+    (0, runtimeEvidenceDeployment_exports.activeRuntimeEvidenceStrategies)(runtimeEvidence.deployment)
+  ) : getReplayEntryTimestampCompareOffsetMs();
   const [
     rawRuntimeTrades,
     runtimeSignals,
@@ -8702,7 +8738,7 @@ var saveAndPrintReplayRuntimeComparison = async ({
     runtimeEntries: runtimeDedupe.entries,
     backtestEntries: comparableBacktestEntries,
     toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
-    backtestTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs()
+    backtestTimestampOffsetMs: replayTimestampOffset
   });
   const details = buildReplayRuntimeComparisonDetails({
     matched: comparison.matched,
@@ -8711,7 +8747,7 @@ var saveAndPrintReplayRuntimeComparison = async ({
     runtimeEntries: runtimeDedupe.entries,
     backtestEntries: comparableBacktestEntries,
     toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
-    backtestTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs(),
+    backtestTimestampOffsetMs: replayTimestampOffset,
     runtimeSignals: comparable.runtimeSignals,
     runtimeSignalEvaluations: comparable.runtimeSignalEvaluations,
     replaySignals,

package/dist/scripts/replayRunner.js

@@ -6059,14 +6059,39 @@ var buildReplayChartSnapshot = (params) => {
 var import_chalk10 = __toESM(require("chalk"));
 
 // src/lib/runtimeParity.ts
+var resolveTradeParityTimestampOffset = (strategy, offset) => typeof offset === "function" ? offset(strategy) : offset;
+var buildTradeParityTimestampOffset = (strategies) => {
+  const intervals = /* @__PURE__ */ new Map();
+  for (const { strategyName, interval } of strategies) {
+    const minutes = Number(interval);
+    if (!Number.isFinite(minutes) || minutes <= 0) {
+      throw new Error(`Invalid embedded replay interval for ${strategyName}`);
+    }
+    intervals.set(strategyName, minutes * 60 * 1e3);
+  }
+  return (strategy) => {
+    const offsetMs = intervals.get(strategy);
+    if (offsetMs == null) {
+      throw new Error(`Missing embedded replay interval for ${strategy}`);
+    }
+    return offsetMs;
+  };
+};
 var toFiniteNumberOrNull2 = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
 var toGroupKey = (entry) => `${entry.strategy}::${entry.symbol}::${entry.direction}`;
 var toRuntimeDuplicateKey = (entry) => `${toGroupKey(entry)}::${entry.timestamp}`;
 var getBacktestParityComparisonTimestamp = (entry, timestampOffsetMs = 0) => {
-  if (timestampOffsetMs > 0 && entry.signalTimestamp != null && entry.timestamp >= entry.signalTimestamp + timestampOffsetMs) {
+  const offsetMs = resolveTradeParityTimestampOffset(
+    entry.strategy,
+    timestampOffsetMs
+  );
+  if (!Number.isFinite(offsetMs) || offsetMs < 0) {
+    throw new Error(`Invalid backtest timestamp offset for ${entry.strategy}`);
+  }
+  if (offsetMs > 0 && entry.signalTimestamp != null && entry.timestamp >= entry.signalTimestamp + offsetMs) {
     return entry.timestamp;
   }
-  return (entry.signalTimestamp ?? entry.timestamp) + timestampOffsetMs;
+  return (entry.signalTimestamp ?? entry.timestamp) + offsetMs;
 };
 var sortTradeParityEntries = (left, right) => left.timestamp - right.timestamp || left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol) || left.direction.localeCompare(right.direction) || left.id.localeCompare(right.id);
 var buildPriceDeltaPct = (leftPrice, rightPrice) => {
@@ -6872,9 +6897,13 @@ var buildCostDetail = (entry) => ({
   totalFee: entry.totalFee ?? null
 });
 var toBacktestParityDetail = (entry, timestampOffsetMs = 0) => {
+  const offsetMs = resolveTradeParityTimestampOffset(
+    entry.strategy,
+    timestampOffsetMs
+  );
   const comparisonTimestamp = getBacktestParityComparisonTimestamp(
     entry,
-    timestampOffsetMs
+    offsetMs
   );
   return {
     source: "backtest",
@@ -6884,7 +6913,7 @@ var toBacktestParityDetail = (entry, timestampOffsetMs = 0) => {
     qty: entry.qty ?? null,
     timestamp: entry.timestamp,
     signalTimestamp: entry.signalTimestamp ?? null,
-    comparisonTimestamp: timestampOffsetMs === 0 ? null : comparisonTimestamp,
+    comparisonTimestamp: offsetMs === 0 ? null : comparisonTimestamp,
     price: entry.price,
     exitType: entry.exitType ?? null,
     exitTimestamp: entry.exitTimestamp ?? null,
@@ -7343,25 +7372,29 @@ var buildReplayMismatchDrilldown = ({
   let runtimeOnlyArtifactsIncluded = 0;
   let backtestOnlyArtifactsIncluded = 0;
   const runtimeOnlyDiagnostics = runtimeOnly.map((entry, index) => {
+    const entryOffsetMs = resolveTradeParityTimestampOffset(
+      getEntryStrategy(entry) ?? "",
+      backtestTimestampOffsetMs
+    );
     const includeArtifacts = index < artifactLimit;
     const nearestCandidate = nearestByEntry.get(entry);
     const nearestReplaySignal = findNearestSignal({
       entry,
       signals: replaySignals,
       toleranceMs,
-      timestampOffsetMs: backtestTimestampOffsetMs
+      timestampOffsetMs: entryOffsetMs
     });
     const nearestReplayEvaluation = findNearestEvaluation({
       entry,
       evaluations: replaySignalEvaluations,
       toleranceMs,
-      timestampOffsetMs: backtestTimestampOffsetMs
+      timestampOffsetMs: entryOffsetMs
     });
     const nearestReplayEvaluationOutcome = findNearestReplayEvaluationOutcome({
       entry,
       lineageScopes: replayLineageScopes,
       toleranceMs,
-      timestampOffsetMs: backtestTimestampOffsetMs
+      timestampOffsetMs: entryOffsetMs
     });
     const classification = nearestReplaySignal ? classifySignalDiagnostic(nearestReplaySignal.signal) : nearestReplayEvaluation ? classifyEvaluationDiagnostic(nearestReplayEvaluation.evaluation) : nearestReplayEvaluationOutcome ? {
       classification: "core_skipped",
@@ -8596,6 +8629,9 @@ var saveAndPrintReplayRuntimeComparison = async ({
     expectedUserName: replayUserName,
     expectedWindow: window
   }) : null;
+  const replayTimestampOffset = runtimeEvidence ? buildTradeParityTimestampOffset(
+    (0, runtimeEvidenceDeployment_exports.activeRuntimeEvidenceStrategies)(runtimeEvidence.deployment)
+  ) : getReplayEntryTimestampCompareOffsetMs();
   const [
     rawRuntimeTrades,
     runtimeSignals,
@@ -8705,7 +8741,7 @@ var saveAndPrintReplayRuntimeComparison = async ({
     runtimeEntries: runtimeDedupe.entries,
     backtestEntries: comparableBacktestEntries,
     toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
-    backtestTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs()
+    backtestTimestampOffsetMs: replayTimestampOffset
   });
   const details = buildReplayRuntimeComparisonDetails({
     matched: comparison.matched,
@@ -8714,7 +8750,7 @@ var saveAndPrintReplayRuntimeComparison = async ({
     runtimeEntries: runtimeDedupe.entries,
     backtestEntries: comparableBacktestEntries,
     toleranceMs: REPLAY_RUNTIME_COMPARE_TOLERANCE_MS,
-    backtestTimestampOffsetMs: getReplayEntryTimestampCompareOffsetMs(),
+    backtestTimestampOffsetMs: replayTimestampOffset,
     runtimeSignals: comparable.runtimeSignals,
     runtimeSignalEvaluations: comparable.runtimeSignalEvaluations,
     replaySignals,

package/dist/scripts/runtimeFeedbackReplay.js

@@ -137,41 +137,52 @@ var buildRuntimeFeedbackReplayCommands = ({
   interval,
   startTime,
   endTime
-}) => [
-  [
-    cliPath,
-    "replay",
-    "--user",
-    userName,
-    "--connector",
-    connectorName,
-    "--deployment",
-    deploymentId,
-    "--timeframe",
-    interval,
-    "--startTime",
-    String(startTime),
-    "--endTime",
-    String(endTime),
-    "--runtimeEvidence",
-    runtimeEvidencePath,
-    "--cacheOnly"
-  ],
-  [
-    cliPath,
-    "replay-runtime-evidence",
-    "--user",
-    userName,
-    "--runtimeEvidence",
-    runtimeEvidencePath,
-    "--startTime",
-    String(startTime),
-    "--endTime",
-    String(endTime),
-    "--out",
-    replayEvidencePath
-  ]
-];
+}) => {
+  const intervals = interval.split(",").map((value) => value.trim());
+  if (!intervals.length || intervals.some(
+    (value) => !value || !Number.isFinite(Number(value)) || Number(value) <= 0
+  )) {
+    throw new Error(`Invalid runtime feedback replay intervals: ${interval}`);
+  }
+  const replayTimeframe = intervals.sort(
+    (left, right) => Number(left) - Number(right)
+  )[0];
+  return [
+    [
+      cliPath,
+      "replay",
+      "--user",
+      userName,
+      "--connector",
+      connectorName,
+      "--deployment",
+      deploymentId,
+      "--timeframe",
+      replayTimeframe,
+      "--startTime",
+      String(startTime),
+      "--endTime",
+      String(endTime),
+      "--runtimeEvidence",
+      runtimeEvidencePath,
+      "--cacheOnly"
+    ],
+    [
+      cliPath,
+      "replay-runtime-evidence",
+      "--user",
+      userName,
+      "--runtimeEvidence",
+      runtimeEvidencePath,
+      "--startTime",
+      String(startTime),
+      "--endTime",
+      String(endTime),
+      "--out",
+      replayEvidencePath
+    ]
+  ];
+};
 var runLoggedCommand = async ({
   executable,
   command,
@@ -258,10 +269,8 @@ var runRuntimeFeedbackReplay = async ({
   const intervals = new Set(
     activeStrategies.map(({ interval }) => String(interval))
   );
-  if (intervals.size !== 1) {
-    throw new Error(
-      `Runtime feedback replay requires one interval, received ${[...intervals].join(",")}`
-    );
+  if (!intervals.size) {
+    throw new Error("Runtime feedback replay requires an active interval");
   }
   await import_promises.default.mkdir(outDir, { recursive: true });
   const existing = await import_promises.default.readdir(outDir);
@@ -282,7 +291,7 @@ var runRuntimeFeedbackReplay = async ({
     userName: runtimeEvidenceBundle.manifest.userName,
     connectorName: deployment.connectorName,
     deploymentId: deployment.id,
-    interval: [...intervals][0],
+    interval: [...intervals].join(","),
     startTime: runtimeEvidenceBundle.manifest.window.startTime,
     endTime: runtimeEvidenceBundle.manifest.window.endTime
   });

package/dist/scripts/runtimeParity.js

@@ -48,14 +48,22 @@ var import_backtest = require("@tradejs/node/backtest");
 var import_connectors5 = require("@tradejs/node/connectors");
 
 // src/lib/runtimeParity.ts
+var resolveTradeParityTimestampOffset = (strategy, offset) => typeof offset === "function" ? offset(strategy) : offset;
 var toFiniteNumberOrNull = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
 var toGroupKey = (entry) => `${entry.strategy}::${entry.symbol}::${entry.direction}`;
 var toRuntimeDuplicateKey = (entry) => `${toGroupKey(entry)}::${entry.timestamp}`;
 var getBacktestParityComparisonTimestamp = (entry, timestampOffsetMs = 0) => {
-  if (timestampOffsetMs > 0 && entry.signalTimestamp != null && entry.timestamp >= entry.signalTimestamp + timestampOffsetMs) {
+  const offsetMs = resolveTradeParityTimestampOffset(
+    entry.strategy,
+    timestampOffsetMs
+  );
+  if (!Number.isFinite(offsetMs) || offsetMs < 0) {
+    throw new Error(`Invalid backtest timestamp offset for ${entry.strategy}`);
+  }
+  if (offsetMs > 0 && entry.signalTimestamp != null && entry.timestamp >= entry.signalTimestamp + offsetMs) {
     return entry.timestamp;
   }
-  return (entry.signalTimestamp ?? entry.timestamp) + timestampOffsetMs;
+  return (entry.signalTimestamp ?? entry.timestamp) + offsetMs;
 };
 var sortTradeParityEntries = (left, right) => left.timestamp - right.timestamp || left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol) || left.direction.localeCompare(right.direction) || left.id.localeCompare(right.id);
 var buildPriceDeltaPct = (leftPrice, rightPrice) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tradejs/cli",
-  "version": "3.1.29-beta.265",
+  "version": "3.1.29-beta.266",
   "description": "Official CLI for the TradeJS TypeScript framework: infra setup, backtests, signals, bots, and ML workflows.",
   "keywords": [
     "tradejs",
@@ -37,13 +37,13 @@
     "tradejs": "dist/cli.js"
   },
   "dependencies": {
-    "@tradejs/connectors": "^3.1.29-beta.265",
-    "@tradejs/core": "^3.1.29-beta.265",
-    "@tradejs/indicators": "^3.1.29-beta.265",
-    "@tradejs/infra": "^3.1.29-beta.265",
-    "@tradejs/node": "^3.1.29-beta.265",
+    "@tradejs/connectors": "^3.1.29-beta.266",
+    "@tradejs/core": "^3.1.29-beta.266",
+    "@tradejs/indicators": "^3.1.29-beta.266",
+    "@tradejs/infra": "^3.1.29-beta.266",
+    "@tradejs/node": "^3.1.29-beta.266",
     "@tradejs/strategy-kit": "3.0.6",
-    "@tradejs/types": "^3.1.29-beta.265",
+    "@tradejs/types": "^3.1.29-beta.266",
     "args": "^5.0.3",
     "bcryptjs": "^2.4.3",
     "chalk": "4.1.2",