@tradejs/cli 2.0.16 → 2.0.18

package/dist/lib/hyperliquidWhaleBackfill.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/lib/hyperliquidWhaleBackfill.ts
@@ -24,6 +34,7 @@ __export(hyperliquidWhaleBackfill_exports, {
   fetchHyperliquidUserFillsByTime: () => fetchHyperliquidUserFillsByTime
 });
 module.exports = __toCommonJS(hyperliquidWhaleBackfill_exports);
+var import_progress = __toESM(require("progress"));
 var import_timescale = require("@tradejs/infra/timescale");
 var import_strategies = require("@tradejs/node/strategies");
 
@@ -398,11 +409,36 @@ var backfillHyperliquidWhaleContext = async (params) => {
     toMs,
     ...identity
   });
+  const totalCoverageBuckets = Math.ceil(
+    (toMs - fromMs) / HYPERLIQUID_WHALE_BUCKET_MS
+  );
+  const coverageBar = new import_progress.default(
+    "Hyperliquid coverage :current/:total [:bar][:percent] :eta(s) rows=:rows chunk=:chunk",
+    {
+      total: Math.max(1, totalCoverageBuckets),
+      width: 24
+    }
+  );
+  let displayedCoverageBuckets = 0;
   const coverageBuckets = await (0, import_timescale.rebuildHyperliquidWhaleCoverageRows)({
     fromMs,
     toMs,
     expectedWhales: whales.addresses.length,
-    ...identity
+    ...identity,
+    onProgress: (progress) => {
+      const next = Math.max(
+        displayedCoverageBuckets,
+        Math.min(progress.completedBuckets, coverageBar.total)
+      );
+      const delta = next - displayedCoverageBuckets;
+      if (delta > 0) {
+        coverageBar.tick(delta, {
+          rows: progress.rows,
+          chunk: `${progress.chunkIndex}/${progress.totalChunks}`
+        });
+        displayedCoverageBuckets = next;
+      }
+    }
   });
   const result = {
     cached: false,

package/dist/lib/marketContextPrepare.js

@@ -4501,6 +4501,7 @@ var timeOperation = async (label, operation, log = console.log) => {
 };
 
 // src/lib/hyperliquidWhaleBackfill.ts
+var import_progress3 = __toESM(require("progress"));
 var import_timescale4 = require("@tradejs/infra/timescale");
 var import_strategies2 = require("@tradejs/node/strategies");
 
@@ -4875,11 +4876,36 @@ var backfillHyperliquidWhaleContext = async (params) => {
     toMs,
     ...identity
   });
+  const totalCoverageBuckets = Math.ceil(
+    (toMs - fromMs) / HYPERLIQUID_WHALE_BUCKET_MS
+  );
+  const coverageBar = new import_progress3.default(
+    "Hyperliquid coverage :current/:total [:bar][:percent] :eta(s) rows=:rows chunk=:chunk",
+    {
+      total: Math.max(1, totalCoverageBuckets),
+      width: 24
+    }
+  );
+  let displayedCoverageBuckets = 0;
   const coverageBuckets = await (0, import_timescale4.rebuildHyperliquidWhaleCoverageRows)({
     fromMs,
     toMs,
     expectedWhales: whales.addresses.length,
-    ...identity
+    ...identity,
+    onProgress: (progress) => {
+      const next = Math.max(
+        displayedCoverageBuckets,
+        Math.min(progress.completedBuckets, coverageBar.total)
+      );
+      const delta = next - displayedCoverageBuckets;
+      if (delta > 0) {
+        coverageBar.tick(delta, {
+          rows: progress.rows,
+          chunk: `${progress.chunkIndex}/${progress.totalChunks}`
+        });
+        displayedCoverageBuckets = next;
+      }
+    }
   });
   const result = {
     cached: false,

package/dist/lib/runtimeEvidenceArtifacts.js

@@ -46,6 +46,17 @@ var RUNTIME_EVIDENCE_PAYLOAD_FILE = "runtime-evidence.json";
 var RUNTIME_EVIDENCE_COMPLETE_FILE = ".complete";
 var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
 var sha256 = (value) => (0, import_node_crypto.createHash)("sha256").update(value).digest("hex");
+var runtimeEvidenceIdentitySha256 = (artifact) => {
+  const identityArtifact = { ...artifact };
+  delete identityArtifact.generatedAt;
+  const runtime = asRecord(identityArtifact.runtime);
+  if (runtime) {
+    const identityRuntime = { ...runtime };
+    delete identityRuntime.generatedAt;
+    identityArtifact.runtime = identityRuntime;
+  }
+  return sha256(JSON.stringify(identityArtifact));
+};
 var isExistingDestinationError = (error) => {
   const code = error.code;
   return code === "EEXIST" || code === "ENOTEMPTY";
@@ -116,11 +127,12 @@ var publishRuntimeEvidenceBundle = async ({
   const payload = `${JSON.stringify(artifact, null, 2)}
 `;
   const payloadSha256 = sha256(payload);
+  const identitySha256 = runtimeEvidenceIdentitySha256(artifact);
   const safeDeploymentId = safeSegment(deploymentId, "default");
   const artifactId = [
     compactTimestamp(startTime),
     compactTimestamp(endTime),
-    payloadSha256.slice(0, 16)
+    identitySha256.slice(0, 16)
   ].join("_");
   const createdAt = Date.now();
   const manifest = {

package/dist/scripts/backtest.js

@@ -4542,6 +4542,7 @@ var backfillCoinMarketCapContextForReplay = backfillCoinMarketCapContext;
 var backfillCoinMarketCapContextForSignals = (params) => backfillCoinMarketCapContext({ ...params, refreshStaleFearGreed: true });
 
 // src/lib/hyperliquidWhaleBackfill.ts
+var import_progress3 = __toESM(require("progress"));
 var import_timescale4 = require("@tradejs/infra/timescale");
 var import_strategies2 = require("@tradejs/node/strategies");
 
@@ -4916,11 +4917,36 @@ var backfillHyperliquidWhaleContext = async (params) => {
     toMs,
     ...identity
   });
+  const totalCoverageBuckets = Math.ceil(
+    (toMs - fromMs) / HYPERLIQUID_WHALE_BUCKET_MS
+  );
+  const coverageBar = new import_progress3.default(
+    "Hyperliquid coverage :current/:total [:bar][:percent] :eta(s) rows=:rows chunk=:chunk",
+    {
+      total: Math.max(1, totalCoverageBuckets),
+      width: 24
+    }
+  );
+  let displayedCoverageBuckets = 0;
   const coverageBuckets = await (0, import_timescale4.rebuildHyperliquidWhaleCoverageRows)({
     fromMs,
     toMs,
     expectedWhales: whales.addresses.length,
-    ...identity
+    ...identity,
+    onProgress: (progress) => {
+      const next = Math.max(
+        displayedCoverageBuckets,
+        Math.min(progress.completedBuckets, coverageBar.total)
+      );
+      const delta = next - displayedCoverageBuckets;
+      if (delta > 0) {
+        coverageBar.tick(delta, {
+          rows: progress.rows,
+          chunk: `${progress.chunkIndex}/${progress.totalChunks}`
+        });
+        displayedCoverageBuckets = next;
+      }
+    }
   });
   const result = {
     cached: false,
@@ -6273,10 +6299,27 @@ var resetRunState = () => {
 };
 
 // src/lib/backtest/workerPool.ts
-var import_progress3 = __toESM(require("progress"));
+var import_progress4 = __toESM(require("progress"));
 var import_child_process = require("child_process");
 var import_chalk8 = __toESM(require("chalk"));
 var import_node_crypto2 = require("crypto");
+var DEFAULT_PG_POOL_MAX = 10;
+var FAST_AI_PG_CONNECTION_BUDGET = 18;
+var MIN_FAST_AI_WORKER_PG_POOL_MAX = 3;
+var resolveFastAiWorkerPgPoolMax = (testSuite, workerCount, configuredPoolMax) => {
+  if (configuredPoolMax?.trim() || workerCount <= 1 || testSuite.length === 0 || testSuite.some((test) => !test.fast || !test.ai)) {
+    return void 0;
+  }
+  return String(
+    Math.min(
+      DEFAULT_PG_POOL_MAX,
+      Math.max(
+        MIN_FAST_AI_WORKER_PG_POOL_MAX,
+        Math.floor(FAST_AI_PG_CONNECTION_BUDGET / workerCount)
+      )
+    )
+  );
+};
 var executeBacktestWorkerPool = async ({
   testSuite,
   userName: userName2,
@@ -6295,6 +6338,12 @@ var executeBacktestWorkerPool = async ({
   totalTests
 }) => {
   const chunks = chunkTestSuite(testSuite);
+  const fastAiWorkerPgPoolMax = resolveFastAiWorkerPgPoolMax(
+    testSuite,
+    chunks.length,
+    process.env.PG_POOL_MAX
+  );
+  const workerEnv = fastAiWorkerPgPoolMax ? { ...process.env, PG_POOL_MAX: fastAiWorkerPgPoolMax } : void 0;
   const totalExpectedTests = Math.max(
     testSuite.length,
     totalTests ?? testSuite.length,
@@ -6352,7 +6401,7 @@ var executeBacktestWorkerPool = async ({
     console.log(line);
   }
   console.log("");
-  const bar = new import_progress3.default(
+  const bar = new import_progress4.default(
     ":current/:total [:bar][:percent] avg :amount win :winRate trades :trades :eta(s)",
     {
       total: totalExpectedTests,
@@ -6380,6 +6429,7 @@ var executeBacktestWorkerPool = async ({
     const chunkId = runId ? `${runId}-${attemptId}` : attemptId;
     const chunkWithId = chunk.map((test) => ({ ...test, chunkId }));
     const tester = (0, import_child_process.fork)(testerWorkerPath, [], {
+      ...workerEnv ? { env: workerEnv } : {},
       execArgv: testerNeedsTsRuntime ? [
         `--max-old-space-size=${workerHeapMb2}`,
         "-r",

package/dist/scripts/hyperliquidWhaleBackfill.js

@@ -36,6 +36,7 @@ module.exports = __toCommonJS(hyperliquidWhaleBackfill_exports);
 var import_args = __toESM(require("args"));
 
 // src/lib/hyperliquidWhaleBackfill.ts
+var import_progress = __toESM(require("progress"));
 var import_timescale = require("@tradejs/infra/timescale");
 var import_strategies = require("@tradejs/node/strategies");
 
@@ -410,11 +411,36 @@ var backfillHyperliquidWhaleContext = async (params) => {
     toMs,
     ...identity
   });
+  const totalCoverageBuckets = Math.ceil(
+    (toMs - fromMs) / HYPERLIQUID_WHALE_BUCKET_MS
+  );
+  const coverageBar = new import_progress.default(
+    "Hyperliquid coverage :current/:total [:bar][:percent] :eta(s) rows=:rows chunk=:chunk",
+    {
+      total: Math.max(1, totalCoverageBuckets),
+      width: 24
+    }
+  );
+  let displayedCoverageBuckets = 0;
   const coverageBuckets = await (0, import_timescale.rebuildHyperliquidWhaleCoverageRows)({
     fromMs,
     toMs,
     expectedWhales: whales.addresses.length,
-    ...identity
+    ...identity,
+    onProgress: (progress) => {
+      const next = Math.max(
+        displayedCoverageBuckets,
+        Math.min(progress.completedBuckets, coverageBar.total)
+      );
+      const delta = next - displayedCoverageBuckets;
+      if (delta > 0) {
+        coverageBar.tick(delta, {
+          rows: progress.rows,
+          chunk: `${progress.chunkIndex}/${progress.totalChunks}`
+        });
+        displayedCoverageBuckets = next;
+      }
+    }
   });
   const result = {
     cached: false,

package/dist/scripts/hyperliquidWhalesUpdate.js

@@ -39,6 +39,7 @@ var import_node_crypto = require("crypto");
 var import_strategies2 = require("@tradejs/node/strategies");
 
 // src/lib/hyperliquidWhaleBackfill.ts
+var import_progress = __toESM(require("progress"));
 var import_timescale = require("@tradejs/infra/timescale");
 var import_strategies = require("@tradejs/node/strategies");
 

package/dist/scripts/replay.js

@@ -4349,27 +4349,27 @@ var createCoinMarketCapFetchStats = () => ({
   totalCredits: 0,
   byPath: /* @__PURE__ */ new Map()
 });
-var getCoinMarketCapPathLabel = (path3) => {
-  if (path3.includes("global-metrics")) return "global";
-  if (path3.includes("cryptocurrency/quotes")) return "reference";
-  if (path3.includes("exchange/quotes")) return "exchangeLiquidity";
-  if (path3.includes("fear-and-greed")) return "fearGreed";
-  if (path3.includes("cmc100")) return "cmc100";
-  if (path3.includes("cmc20")) return "cmc20";
-  return path3;
-};
-var recordCoinMarketCapFetchStats = (stats, path3, creditCount) => {
+var getCoinMarketCapPathLabel = (path4) => {
+  if (path4.includes("global-metrics")) return "global";
+  if (path4.includes("cryptocurrency/quotes")) return "reference";
+  if (path4.includes("exchange/quotes")) return "exchangeLiquidity";
+  if (path4.includes("fear-and-greed")) return "fearGreed";
+  if (path4.includes("cmc100")) return "cmc100";
+  if (path4.includes("cmc20")) return "cmc20";
+  return path4;
+};
+var recordCoinMarketCapFetchStats = (stats, path4, creditCount) => {
   if (!stats) return;
-  const existing = stats.byPath.get(path3) ?? { requests: 0, credits: 0 };
+  const existing = stats.byPath.get(path4) ?? { requests: 0, credits: 0 };
   existing.requests += 1;
   existing.credits += creditCount ?? 0;
   stats.requests += 1;
   stats.totalCredits += creditCount ?? 0;
-  stats.byPath.set(path3, existing);
+  stats.byPath.set(path4, existing);
 };
 var formatCoinMarketCapFetchStats = (stats) => {
   const byPath = [...stats.byPath.entries()].map(
-    ([path3, item]) => `${getCoinMarketCapPathLabel(path3)}=${item.requests}req/${item.credits}cr`
+    ([path4, item]) => `${getCoinMarketCapPathLabel(path4)}=${item.requests}req/${item.credits}cr`
   ).join(" ");
   return `apiRequests=${stats.requests} apiCredits=${stats.totalCredits}${byPath ? ` ${byPath}` : ""}`;
 };
@@ -5183,6 +5183,7 @@ var backfillCoinMarketCapContextForReplay = backfillCoinMarketCapContext;
 var backfillCoinMarketCapContextForSignals = (params) => backfillCoinMarketCapContext({ ...params, refreshStaleFearGreed: true });
 
 // src/lib/hyperliquidWhaleBackfill.ts
+var import_progress3 = __toESM(require("progress"));
 var import_timescale4 = require("@tradejs/infra/timescale");
 var import_strategies2 = require("@tradejs/node/strategies");
 
@@ -5557,11 +5558,36 @@ var backfillHyperliquidWhaleContext = async (params) => {
     toMs,
     ...identity
   });
+  const totalCoverageBuckets = Math.ceil(
+    (toMs - fromMs) / HYPERLIQUID_WHALE_BUCKET_MS
+  );
+  const coverageBar = new import_progress3.default(
+    "Hyperliquid coverage :current/:total [:bar][:percent] :eta(s) rows=:rows chunk=:chunk",
+    {
+      total: Math.max(1, totalCoverageBuckets),
+      width: 24
+    }
+  );
+  let displayedCoverageBuckets = 0;
   const coverageBuckets = await (0, import_timescale4.rebuildHyperliquidWhaleCoverageRows)({
     fromMs,
     toMs,
     expectedWhales: whales.addresses.length,
-    ...identity
+    ...identity,
+    onProgress: (progress) => {
+      const next = Math.max(
+        displayedCoverageBuckets,
+        Math.min(progress.completedBuckets, coverageBar.total)
+      );
+      const delta = next - displayedCoverageBuckets;
+      if (delta > 0) {
+        coverageBar.tick(delta, {
+          rows: progress.rows,
+          chunk: `${progress.chunkIndex}/${progress.totalChunks}`
+        });
+        displayedCoverageBuckets = next;
+      }
+    }
   });
   const result = {
     cached: false,
@@ -5923,6 +5949,10 @@ import_args.default.option(["f", "timeframe"], "Timeframe", 15);
 import_args.default.option(["d", "days"], "Run replay only for the last N days");
 import_args.default.option("startTime", "Explicit replay start timestamp (ms or seconds)");
 import_args.default.option("endTime", "Explicit replay end timestamp (ms or seconds)");
+import_args.default.option(
+  "runtimeEvidence",
+  "Immutable runtime evidence JSON used for offline runtime comparison"
+);
 import_args.default.option(["u", "updateOnly"], "Only update tickers history", false);
 import_args.default.option(["C", "cacheOnly"], "Do not update tickers history", false);
 import_args.default.option(
@@ -5948,6 +5978,7 @@ var replayFlags = import_args.default.parse(replayNormalizedArgv);
 var replayInterval = String(replayFlags.timeframe ?? 15);
 var replayUserName = String(replayFlags.user ?? "root");
 var replayProjectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+var replayRuntimeEvidencePath = typeof replayFlags.runtimeEvidence === "string" && replayFlags.runtimeEvidence.trim() ? replayFlags.runtimeEvidence.trim() : null;
 var isReplayUpdateOnlyRun = Boolean(replayFlags.updateOnly);
 
 // src/lib/replay/support.ts
@@ -6059,7 +6090,7 @@ var compactReplaySignal = (signal) => {
 
 // src/lib/replay/historicalSignalsReplay.ts
 var import_chalk9 = __toESM(require("chalk"));
-var import_progress3 = __toESM(require("progress"));
+var import_progress4 = __toESM(require("progress"));
 var import_backtest = require("@tradejs/core/backtest");
 var import_strategies4 = require("@tradejs/core/strategies");
 var import_time3 = require("@tradejs/core/time");
@@ -6943,7 +6974,7 @@ var runHistoricalSignalsReplay = async ({
   const sharedReplayKeyPrefixes = [];
   let preparedSymbols = 0;
   let skippedSymbols = 0;
-  const prepareBar = new import_progress3.default(
+  const prepareBar = new import_progress4.default(
     "prepare :current/:total [:bar][:percent] skipped=:skipped :etas(s) :symbol",
     {
       total: preparedRun.tickers.length,
@@ -7065,7 +7096,7 @@ var runHistoricalSignalsReplay = async ({
     interval
   });
   let abortedCycles = 0;
-  const cycleBar = new import_progress3.default(
+  const cycleBar = new import_progress4.default(
     "cycles  :current/:total [:bar][:percent] sig=:signals abort=:aborted :etas(s) :ts",
     {
       total: orderedTimestamps.length,
@@ -8780,6 +8811,114 @@ var buildReplayExchangeComparisonDetails = ({
   };
 };
 
+// src/lib/replay/runtimeEvidenceSource.ts
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path2 = __toESM(require("path"));
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+var asFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+var unwrapRows = (value, field) => (Array.isArray(value) ? value : []).map((item) => {
+  const row = asRecord(item);
+  return asRecord(row?.[field]) ?? row;
+}).filter((item) => item != null);
+var buildRuntimeEvidenceLineageScopes = ({
+  signals,
+  evaluations
+}) => {
+  const scopes = /* @__PURE__ */ new Map();
+  const add = ({
+    strategy,
+    symbol,
+    runtimeConfigId,
+    timestamp,
+    lineage
+  }) => {
+    if (!lineage || !Number.isFinite(timestamp)) {
+      return;
+    }
+    const key = `${strategy}::${symbol}::${runtimeLineageKey(lineage)}`;
+    const existing = scopes.get(key);
+    scopes.set(key, {
+      strategy,
+      symbol,
+      ...runtimeConfigId ? { runtimeConfigId } : {},
+      lineage,
+      firstTimestamp: existing ? Math.min(existing.firstTimestamp, timestamp) : timestamp,
+      lastTimestamp: existing ? Math.max(existing.lastTimestamp, timestamp) : timestamp
+    });
+  };
+  for (const signal of signals) {
+    add({
+      strategy: signal.strategy,
+      symbol: signal.symbol,
+      runtimeConfigId: signal.runtimeConfigId,
+      timestamp: signal.timestamp,
+      lineage: signal.runtimeLineage
+    });
+  }
+  for (const evaluation of evaluations) {
+    add({
+      strategy: evaluation.strategy,
+      symbol: evaluation.symbol,
+      runtimeConfigId: evaluation.runtimeConfigId,
+      timestamp: evaluation.timestamp,
+      lineage: evaluation.runtimeLineage
+    });
+  }
+  return [...scopes.values()].sort(
+    (left, right) => left.strategy.localeCompare(right.strategy) || left.symbol.localeCompare(right.symbol) || left.firstTimestamp - right.firstTimestamp
+  );
+};
+var loadReplayRuntimeEvidenceSource = async ({
+  filePath,
+  projectRoot,
+  expectedUserName,
+  expectedWindow
+}) => {
+  const resolvedPath = import_node_path2.default.resolve(projectRoot, filePath);
+  const root = asRecord(
+    JSON.parse(await import_promises2.default.readFile(resolvedPath, "utf8"))
+  );
+  const runtime = asRecord(root?.runtime) ?? root;
+  if (!root || !runtime) {
+    throw new Error(`Invalid runtime evidence JSON: ${resolvedPath}`);
+  }
+  const rootWindow = asRecord(root.window);
+  const runtimeWindow = asRecord(runtime.window);
+  const startTime = asFiniteNumber(rootWindow?.startTime) ?? asFiniteNumber(runtimeWindow?.startTime);
+  const endTime = asFiniteNumber(rootWindow?.endTime) ?? asFiniteNumber(runtimeWindow?.endTime);
+  const userName = String(root.userName ?? runtime.userName ?? "").trim();
+  if (!userName || userName !== expectedUserName) {
+    throw new Error(
+      `Runtime evidence user mismatch: expected=${expectedUserName}, actual=${userName || "missing"}`
+    );
+  }
+  const endTimeMatches = endTime === expectedWindow.end || endTime === expectedWindow.end + 1;
+  if (startTime !== expectedWindow.start || !endTimeMatches) {
+    throw new Error(
+      `Runtime evidence window mismatch: expected=${expectedWindow.start}..${expectedWindow.end}, actual=${startTime ?? "missing"}..${endTime ?? "missing"}`
+    );
+  }
+  const trades = unwrapRows(runtime.trades, "trade");
+  const signals = unwrapRows(runtime.signals, "signal");
+  const evaluations = unwrapRows(
+    runtime.evaluations,
+    "evaluation"
+  );
+  return {
+    path: resolvedPath,
+    userName,
+    startTime,
+    endTime,
+    trades,
+    signals,
+    evaluations,
+    lineageScopes: buildRuntimeEvidenceLineageScopes({
+      signals,
+      evaluations
+    })
+  };
+};
+
 // src/lib/replay/runtimeComparison.ts
 var getReplayEntryTimestampCompareOffsetMs = () => {
   const intervalMinutes = Number(replayInterval);
@@ -9549,7 +9688,8 @@ var saveAndPrintReplayRuntimeComparison = async ({
   liveStrategySummaries,
   backtestEntries,
   replaySignals,
-  replayLineages
+  replayLineages,
+  runtimeEvidencePath
 }) => {
   const { connector, connectorName, window: window2 } = getRuntimeCompareContext();
   if (!connector || !window2) {
@@ -9559,12 +9699,23 @@ var saveAndPrintReplayRuntimeComparison = async ({
     liveStrategySummaries.map((summary) => summary.strategyName)
   );
   const replaySignalEvaluations = buildReplaySignalEvaluations(replaySignals);
+  const runtimeEvidence = runtimeEvidencePath ? await loadReplayRuntimeEvidenceSource({
+    filePath: runtimeEvidencePath,
+    projectRoot: replayProjectRoot,
+    expectedUserName: replayUserName,
+    expectedWindow: window2
+  }) : null;
   const [
     rawRuntimeTrades,
     runtimeSignals,
     runtimeSignalEvaluations,
     runtimeLineageScopes
-  ] = await Promise.all([
+  ] = runtimeEvidence ? [
+    runtimeEvidence.trades,
+    runtimeEvidence.signals,
+    runtimeEvidence.evaluations,
+    runtimeEvidence.lineageScopes
+  ] : await Promise.all([
     loadRuntimeTrades(replayUserName, {
       startTime: window2.start,
       endTime: window2.end
@@ -9582,7 +9733,14 @@ var saveAndPrintReplayRuntimeComparison = async ({
       endTime: window2.end
     })
   ]);
-  const syncedRuntimeTrades = await syncRuntimeTrades({
+  if (runtimeEvidence) {
+    console.log(
+      import_chalk11.default.gray(
+        `runtime compare: using immutable evidence ${runtimeEvidence.path}`
+      )
+    );
+  }
+  const syncedRuntimeTrades = runtimeEvidence ? rawRuntimeTrades : await syncRuntimeTrades({
     userName: replayUserName,
     connector,
     trades: rawRuntimeTrades,
@@ -9633,7 +9791,7 @@ var saveAndPrintReplayRuntimeComparison = async ({
   const windowRuntimeTrades = comparable.runtimeTrades.filter(
     (trade) => trade.entryTimestamp >= window2.start && trade.entryTimestamp < window2.end && relevantStrategies.has(trade.strategy)
   );
-  if (!windowRuntimeTrades.length) {
+  if (!windowRuntimeTrades.length && !runtimeEvidence) {
     console.log("");
     console.log(
       import_chalk11.default.yellow(
@@ -9765,8 +9923,8 @@ var saveAndPrintReplayRuntimeComparison = async ({
 };
 
 // src/lib/replay/outputReport.ts
-var import_promises2 = __toESM(require("fs/promises"));
-var import_node_path2 = __toESM(require("path"));
+var import_promises3 = __toESM(require("fs/promises"));
+var import_node_path3 = __toESM(require("path"));
 var import_data = require("@tradejs/core/data");
 var formatMsk = (timestamp) => typeof timestamp === "number" && Number.isFinite(timestamp) ? new Intl.DateTimeFormat("ru-RU", {
   timeZone: "Europe/Moscow",
@@ -10070,8 +10228,8 @@ var writeReplayOutputReport = async ({
   strategySnapshot,
   runtimeComparison
 }) => {
-  const outputDir = import_node_path2.default.resolve(projectRoot, "data/replay/output");
-  await import_promises2.default.mkdir(outputDir, { recursive: true });
+  const outputDir = import_node_path3.default.resolve(projectRoot, "data/replay/output");
+  await import_promises3.default.mkdir(outputDir, { recursive: true });
   const perTradeAnalysis = buildPerTradeAnalysis(runtimeComparison);
   const report = {
     reportType: "replay-output",
@@ -10106,8 +10264,8 @@ var writeReplayOutputReport = async ({
     runtimeComparison,
     perTradeAnalysis
   };
-  const markdownPath = import_node_path2.default.join(outputDir, `${timestamp}-replay-report.md`);
-  const jsonPath = import_node_path2.default.join(outputDir, `${timestamp}-replay-report.json`);
+  const markdownPath = import_node_path3.default.join(outputDir, `${timestamp}-replay-report.md`);
+  const jsonPath = import_node_path3.default.join(outputDir, `${timestamp}-replay-report.json`);
   const lines = [
     "# Replay Report",
     "",
@@ -10173,8 +10331,8 @@ var writeReplayOutputReport = async ({
     ""
   ];
   await Promise.all([
-    import_promises2.default.writeFile(markdownPath, lines.join("\n"), "utf8"),
-    import_promises2.default.writeFile(jsonPath, `${(0, import_data.toJson)(report, true)}
+    import_promises3.default.writeFile(markdownPath, lines.join("\n"), "utf8"),
+    import_promises3.default.writeFile(jsonPath, `${(0, import_data.toJson)(report, true)}
 `, "utf8")
   ]);
   return {
@@ -10215,7 +10373,8 @@ var finishReplay = async ({
     liveStrategySummaries: replayStrategySnapshot.summaries,
     backtestEntries: replayStrategySnapshot.backtestEntries,
     replaySignals: replayResult.signals,
-    replayLineages: replayResult.runtimeLineages
+    replayLineages: replayResult.runtimeLineages,
+    runtimeEvidencePath: replayRuntimeEvidencePath
   });
   const finishedAt = /* @__PURE__ */ new Date();
   const durationSeconds = Number(