@tradejs/cli 3.1.29-beta.281 → 3.1.29-beta.283

package/dist/scripts/replayRunner.js

@@ -41,7 +41,7 @@ __export(replayRunner_exports, {
 module.exports = __toCommonJS(replayRunner_exports);
 var import_chalk13 = __toESM(require("chalk"));
 var import_constants7 = require("@tradejs/core/constants");
-var import_data4 = require("@tradejs/core/data");
+var import_data3 = require("@tradejs/core/data");
 var import_time7 = require("@tradejs/core/time");
 var import_redis6 = require("@tradejs/infra/redis");
 var import_candles = require("@tradejs/infra/timescale/candles");
@@ -2711,27 +2711,27 @@ var createCoinMarketCapFetchStats = () => ({
   totalCredits: 0,
   byPath: /* @__PURE__ */ new Map()
 });
-var getCoinMarketCapPathLabel = (path5) => {
-  if (path5.includes("global-metrics")) return "global";
-  if (path5.includes("cryptocurrency/quotes")) return "reference";
-  if (path5.includes("exchange/quotes")) return "exchangeLiquidity";
-  if (path5.includes("fear-and-greed")) return "fearGreed";
-  if (path5.includes("cmc100")) return "cmc100";
-  if (path5.includes("cmc20")) return "cmc20";
-  return path5;
-};
-var recordCoinMarketCapFetchStats = (stats, path5, creditCount) => {
+var getCoinMarketCapPathLabel = (path7) => {
+  if (path7.includes("global-metrics")) return "global";
+  if (path7.includes("cryptocurrency/quotes")) return "reference";
+  if (path7.includes("exchange/quotes")) return "exchangeLiquidity";
+  if (path7.includes("fear-and-greed")) return "fearGreed";
+  if (path7.includes("cmc100")) return "cmc100";
+  if (path7.includes("cmc20")) return "cmc20";
+  return path7;
+};
+var recordCoinMarketCapFetchStats = (stats, path7, creditCount) => {
   if (!stats) return;
-  const existing = stats.byPath.get(path5) ?? { requests: 0, credits: 0 };
+  const existing = stats.byPath.get(path7) ?? { requests: 0, credits: 0 };
   existing.requests += 1;
   existing.credits += creditCount ?? 0;
   stats.requests += 1;
   stats.totalCredits += creditCount ?? 0;
-  stats.byPath.set(path5, existing);
+  stats.byPath.set(path7, existing);
 };
 var formatCoinMarketCapFetchStats = (stats) => {
   const byPath = [...stats.byPath.entries()].map(
-    ([path5, item]) => `${getCoinMarketCapPathLabel(path5)}=${item.requests}req/${item.credits}cr`
+    ([path7, item]) => `${getCoinMarketCapPathLabel(path7)}=${item.requests}req/${item.credits}cr`
   ).join(" ");
   return `apiRequests=${stats.requests} apiCredits=${stats.totalCredits}${byPath ? ` ${byPath}` : ""}`;
 };
@@ -4751,10 +4751,32 @@ var compactReplaySignal = (signal) => {
   };
 };
 
+// src/lib/replay/memoryProfile.ts
+var import_node_fs = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+var createReplayMemoryProfile = (file = process.env.TRADEJS_REPLAY_MEMORY_PROFILE) => {
+  if (!file) return void 0;
+  import_node_fs.default.mkdirSync(import_node_path2.default.dirname(file), { recursive: true });
+  return (phase, counts = {}) => {
+    import_node_fs.default.appendFileSync(
+      file,
+      JSON.stringify({
+        schemaVersion: 1,
+        observedAt: Date.now(),
+        pid: process.pid,
+        phase,
+        counts,
+        ...process.memoryUsage(),
+        maxRssKiB: process.resourceUsage().maxRSS
+      }) + "\n"
+    );
+  };
+};
+
 // src/lib/replay/historicalSignalsReplay.ts
 var import_chalk9 = __toESM(require("chalk"));
 var import_progress4 = __toESM(require("progress"));
-var import_node_path2 = __toESM(require("path"));
+var import_node_path3 = __toESM(require("path"));
 var import_node_module = require("module");
 var import_strategies3 = require("@tradejs/core/strategies");
 var import_time3 = require("@tradejs/core/time");
@@ -5303,6 +5325,11 @@ var prepareHistoricalReplay = async (context, adapters) => {
       cacheOnly: true,
       interval
     });
+    if (symbolRuntimes.length % 50 === 0)
+      adapters.sampleMemory?.("history:loaded", {
+        symbols: symbolRuntimes.length + 1,
+        candles: data.length
+      });
     const preparedData = buildPreparedData({
       data,
       btcData: references.btcMarketData,
@@ -5399,6 +5426,11 @@ var prepareHistoricalReplay = async (context, adapters) => {
       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)
@@ -5416,6 +5448,10 @@ var prepareHistoricalReplay = async (context, adapters) => {
     runtimeLineages
   };
 };
+var releaseHistoricalReplayPlan = (plan) => {
+  plan.symbolRuntimes.length = 0;
+  plan.sharedReplayKeyPrefixes.length = 0;
+};
 
 // src/lib/replay/historicalSignalsReplaySkipEvidence.ts
 var import_data = require("@tradejs/core/data");
@@ -5715,7 +5751,7 @@ var getProjectReplayCacheReleasers = () => {
   }
   try {
     const requireFromProject = (0, import_node_module.createRequire)(
-      import_node_path2.default.join(replayProjectRoot, "package.json")
+      import_node_path3.default.join(replayProjectRoot, "package.json")
     );
     projectReplayCacheReleasers = requireFromProject(
       "@tradejs/core/strategies"
@@ -5856,6 +5892,8 @@ var runHistoricalSignalsReplay = async ({
   collectSkipEvidence = true,
   collectSignals = true
 }) => {
+  const memory = createReplayMemoryProfile();
+  memory?.("prepare:start");
   const startedAt = Date.now();
   const projectConfig = await (0, import_cli4.loadTradejsConfig)(replayProjectRoot);
   const projectHooks = projectConfig.hooks;
@@ -5872,6 +5910,7 @@ var runHistoricalSignalsReplay = async ({
       width: 30
     }
   );
+  memory?.("references:loaded");
   const plan = await prepareHistoricalReplay(
     {
       userName: replayUserName,
@@ -5896,9 +5935,11 @@ var runHistoricalSignalsReplay = async ({
         skipped: (value) => import_chalk9.default.yellow(value),
         symbol: (value) => import_chalk9.default.gray(value)
       },
-      buildLineage: buildRuntimeLineage
+      buildLineage: buildRuntimeLineage,
+      sampleMemory: memory
     }
   );
+  memory?.("strategies:prepared", { symbols: plan.symbolRuntimes.length });
   const hookContext = buildAfterSignalsContext({
     connector: replayConnector,
     connectorName: preparedRun.connectorName,
@@ -5948,13 +5989,16 @@ var runHistoricalSignalsReplay = async ({
       )
     }
   );
+  memory?.("execution:complete", { signals: execution.signals.length });
+  releaseHistoricalReplayPlan(plan);
+  memory?.("execution:released");
   const artifacts = replayConnector.getReplayArtifacts();
   import_logger.logger.info(
     import_chalk9.default.gray(
       `signals replay historical cycles: ${plan.orderedTimestamps.length} (aborted=${execution.abortedCycles}) done in ${((Date.now() - startedAt) / 1e3).toFixed(1)}s`
     )
   );
-  return collectHistoricalReplayResult({
+  const result = collectHistoricalReplayResult({
     strategies: loadedStrategies,
     artifacts,
     signals: execution.signals,
@@ -5963,6 +6007,8 @@ var runHistoricalSignalsReplay = async ({
     runtimeLineages: plan.runtimeLineages,
     replayLineageScopes: execution.replayLineageScopes
   });
+  memory?.("result:collected");
+  return result;
 };
 
 // src/lib/replay/chartSnapshot.ts
@@ -8797,9 +8843,87 @@ var saveAndPrintReplayRuntimeComparison = async ({
 };
 
 // src/lib/replay/outputReport.ts
+var import_promises3 = __toESM(require("fs/promises"));
+var import_node_path5 = __toESM(require("path"));
+
+// src/lib/replay/jsonFile.ts
+var import_node_fs2 = __toESM(require("fs"));
 var import_promises2 = __toESM(require("fs/promises"));
-var import_node_path3 = __toESM(require("path"));
-var import_data3 = require("@tradejs/core/data");
+var import_node_path4 = __toESM(require("path"));
+var import_node_events = require("events");
+var import_node_crypto2 = require("crypto");
+function* jsonParts(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value !== "object") {
+    yield JSON.stringify(value) ?? "null";
+    return;
+  }
+  if (ancestors.has(value)) throw new TypeError("Circular JSON evidence");
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) {
+      yield "[";
+      for (let index = 0; index < value.length; index++) {
+        if (index) yield ",";
+        yield* jsonParts(value[index], ancestors);
+      }
+      yield "]";
+    } else {
+      if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+        throw new TypeError("JSON evidence requires plain records");
+      if ("toJSON" in value && typeof value.toJSON === "function")
+        throw new TypeError("JSON evidence cannot contain toJSON hooks");
+      yield "{";
+      let first = true;
+      for (const key of Object.keys(value)) {
+        const field = Reflect.get(value, key);
+        if (field === void 0 || typeof field === "function" || typeof field === "symbol")
+          continue;
+        if (!first) yield ",";
+        first = false;
+        yield JSON.stringify(key) + ":";
+        yield* jsonParts(field, ancestors);
+      }
+      yield "}";
+    }
+  } finally {
+    ancestors.delete(value);
+  }
+}
+var writeReplayJsonFile = async (file, value) => {
+  await import_promises2.default.mkdir(import_node_path4.default.dirname(file), { recursive: true });
+  const temporary = file + ".tmp-" + (0, import_node_crypto2.randomUUID)();
+  const stream = import_node_fs2.default.createWriteStream(temporary, {
+    flags: "wx",
+    highWaterMark: 65536
+  });
+  let failure;
+  stream.on("error", (error) => {
+    failure = error;
+  });
+  try {
+    let buffer = "";
+    for (const part of jsonParts(value)) {
+      buffer += part;
+      if (buffer.length >= 65536) {
+        if (failure) throw failure;
+        if (!stream.write(buffer)) await (0, import_node_events.once)(stream, "drain");
+        buffer = "";
+      }
+    }
+    if (failure) throw failure;
+    stream.end(buffer + "\n");
+    await (0, import_node_events.once)(stream, "close");
+    if (failure) throw failure;
+    await import_promises2.default.rename(temporary, file);
+  } catch (error) {
+    stream.destroy();
+    if (!stream.closed) await (0, import_node_events.once)(stream, "close").catch(() => void 0);
+    await import_promises2.default.rm(temporary, { force: true });
+    throw error;
+  }
+};
+
+// src/lib/replay/outputReport.ts
 var formatMsk = (timestamp) => typeof timestamp === "number" && Number.isFinite(timestamp) ? new Intl.DateTimeFormat("ru-RU", {
   timeZone: "Europe/Moscow",
   dateStyle: "short",
@@ -9102,8 +9226,8 @@ var writeReplayOutputReport = async ({
   strategySnapshot,
   runtimeComparison
 }) => {
-  const outputDir = import_node_path3.default.resolve(projectRoot, "data/replay/output");
-  await import_promises2.default.mkdir(outputDir, { recursive: true });
+  const outputDir = import_node_path5.default.resolve(projectRoot, "data/replay/output");
+  await import_promises3.default.mkdir(outputDir, { recursive: true });
   const perTradeAnalysis = buildPerTradeAnalysis(runtimeComparison);
   const report = {
     reportType: "replay-output",
@@ -9138,8 +9262,8 @@ var writeReplayOutputReport = async ({
     runtimeComparison,
     perTradeAnalysis
   };
-  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 markdownPath = import_node_path5.default.join(outputDir, `${timestamp}-replay-report.md`);
+  const jsonPath = import_node_path5.default.join(outputDir, `${timestamp}-replay-report.json`);
   const lines = [
     "# Replay Report",
     "",
@@ -9204,11 +9328,13 @@ var writeReplayOutputReport = async ({
     "Full machine-readable details are stored in the JSON sidecar.",
     ""
   ];
+  const memory = createReplayMemoryProfile();
+  memory?.("report:write:start");
   await Promise.all([
-    import_promises2.default.writeFile(markdownPath, lines.join("\n"), "utf8"),
-    import_promises2.default.writeFile(jsonPath, `${(0, import_data3.toJson)(report, true)}
-`, "utf8")
+    import_promises3.default.writeFile(markdownPath, lines.join("\n"), "utf8"),
+    writeReplayJsonFile(jsonPath, report)
   ]);
+  memory?.("report:write:complete");
   return {
     markdownPath,
     jsonPath
@@ -9216,9 +9342,9 @@ var writeReplayOutputReport = async ({
 };
 
 // src/lib/replay/portfolioReport.ts
-var import_promises3 = __toESM(require("fs/promises"));
-var import_node_path4 = __toESM(require("path"));
-var import_node_crypto2 = require("crypto");
+var import_promises4 = __toESM(require("fs/promises"));
+var import_node_path6 = __toESM(require("path"));
+var import_node_crypto3 = require("crypto");
 var DAY_MS4 = 864e5;
 var WINDOWS = [365, 180, 90, 30, 7];
 var COLORS = [
@@ -9396,8 +9522,8 @@ var writePortfolioReport = async ({
   lineage,
   command
 }) => {
-  const outputDir = import_node_path4.default.resolve(projectRoot, "data/replay/output");
-  await import_promises3.default.mkdir(outputDir, { recursive: true });
+  const outputDir = import_node_path6.default.resolve(projectRoot, "data/replay/output");
+  await import_promises4.default.mkdir(outputDir, { recursive: true });
   const trades = replayResult.strategies.flatMap(
     (strategy) => tradesFromPositionLog(strategy.strategyName, strategy.positionLog)
   );
@@ -9469,11 +9595,11 @@ var writePortfolioReport = async ({
   });
   const prefix = `${timestamp}-portfolio-backtest`;
   const paths = {
-    markdown: import_node_path4.default.join(outputDir, `${prefix}.md`),
-    json: import_node_path4.default.join(outputDir, `${prefix}.json`),
-    equitySvg: import_node_path4.default.join(outputDir, `${prefix}-equity.svg`),
-    drawdownSvg: import_node_path4.default.join(outputDir, `${prefix}-drawdown.svg`),
-    html: import_node_path4.default.join(outputDir, `${prefix}.html`)
+    markdown: import_node_path6.default.join(outputDir, `${prefix}.md`),
+    json: import_node_path6.default.join(outputDir, `${prefix}.json`),
+    equitySvg: import_node_path6.default.join(outputDir, `${prefix}-equity.svg`),
+    drawdownSvg: import_node_path6.default.join(outputDir, `${prefix}-drawdown.svg`),
+    html: import_node_path6.default.join(outputDir, `${prefix}.html`)
   };
   const report = {
     schema: "tradejs-portfolio-backtest/v1",
@@ -9499,7 +9625,7 @@ var writePortfolioReport = async ({
     },
     trades
   };
-  const checksum = (0, import_node_crypto2.createHash)("sha256").update(JSON.stringify(report)).digest("hex");
+  const checksum = (0, import_node_crypto3.createHash)("sha256").update(JSON.stringify(report)).digest("hex");
   const semantics = "Production strategy order, at most one open position per symbol, and fixed-risk symbol batches merged by canonical realized PnL.";
   const markdown = `# Portfolio Backtest
 
@@ -9511,9 +9637,9 @@ var writePortfolioReport = async ({
 - Report checksum: \`${checksum}\`
 - Command: \`${command}\`
 
-![Strategy PnL overlay](./${import_node_path4.default.basename(paths.equitySvg)})
+![Strategy PnL overlay](./${import_node_path6.default.basename(paths.equitySvg)})
 
-![Portfolio drawdown](./${import_node_path4.default.basename(paths.drawdownSvg)})
+![Portfolio drawdown](./${import_node_path6.default.basename(paths.drawdownSvg)})
 
 ## Portfolio metrics
 
@@ -9525,16 +9651,16 @@ ${markdownTable(strategyRows)}
 `;
   const html = `<!doctype html><html><head><meta charset="utf-8"><title>Portfolio Backtest</title><style>body{font-family:Inter,system-ui,sans-serif;margin:32px;color:#0f172a}h1,h2{margin-top:32px}.meta{color:#475569}table{border-collapse:collapse;width:100%;font-size:13px}th,td{padding:8px;border:1px solid #e2e8f0;text-align:right}th:nth-child(-n+3),td:nth-child(-n+3){text-align:left}.chart{overflow:auto;border:1px solid #e2e8f0;margin:16px 0}</style></head><body><h1>Portfolio Backtest</h1><p class="meta">${escapeHtml(report.window.startIso)} .. ${escapeHtml(report.window.endIso)} \xB7 ${report.counts.strategies} strategies \xB7 ${trades.length} completed trades \xB7 MAX_LOSS_VALUE=${escapeHtml(String(lineage.maxLossValue))}</p><p class="meta">${escapeHtml(semantics)}</p><div class="chart">${equitySvg}</div><div class="chart">${drawdownSvg}</div><h2>Portfolio metrics</h2>${metricTable(portfolioRows)}<h2>Strategy metrics</h2>${metricTable(strategyRows)}<h2>Lineage</h2><pre>${escapeHtml(JSON.stringify(lineage, null, 2))}</pre></body></html>`;
   await Promise.all([
-    import_promises3.default.writeFile(paths.markdown, markdown, "utf8"),
-    import_promises3.default.writeFile(
+    import_promises4.default.writeFile(paths.markdown, markdown, "utf8"),
+    import_promises4.default.writeFile(
       paths.json,
       `${JSON.stringify({ ...report, checksum }, null, 2)}
 `,
       "utf8"
     ),
-    import_promises3.default.writeFile(paths.equitySvg, equitySvg, "utf8"),
-    import_promises3.default.writeFile(paths.drawdownSvg, drawdownSvg, "utf8"),
-    import_promises3.default.writeFile(paths.html, html, "utf8")
+    import_promises4.default.writeFile(paths.equitySvg, equitySvg, "utf8"),
+    import_promises4.default.writeFile(paths.drawdownSvg, drawdownSvg, "utf8"),
+    import_promises4.default.writeFile(paths.html, html, "utf8")
   ]);
   return { ...paths, checksum };
 };
@@ -9848,13 +9974,13 @@ var replayBacktest = async () => {
     deploymentId: deployment.id,
     assetClasses: deployment.assetClasses,
     deployment,
-    closedIntervalMs: (0, import_data4.intervalToMs)(replayInterval)
+    closedIntervalMs: (0, import_data3.intervalToMs)(replayInterval)
   });
   if (!preparedRun || isReplayUpdateOnlyRun) {
     return;
   }
   if (useAllData) {
-    const intervalMs = (0, import_data4.intervalToMs)(replayInterval);
+    const intervalMs = (0, import_data3.intervalToMs)(replayInterval);
     const edges = await (0, import_candles.getDataEdgesForSymbols)(
       deployment.provider,
       preparedRun.tickers,

package/dist/scripts/replayRuntimeEvidence.js

@@ -35,8 +35,109 @@ __export(replayRuntimeEvidence_exports, {
   summarizeReplayComparison: () => summarizeReplayComparison
 });
 module.exports = __toCommonJS(replayRuntimeEvidence_exports);
+
+// src/lib/replay/jsonFile.ts
+var import_node_fs = __toESM(require("fs"));
 var import_promises = __toESM(require("fs/promises"));
 var import_node_path = __toESM(require("path"));
+var import_node_events = require("events");
+var import_node_crypto = require("crypto");
+function* jsonParts(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value !== "object") {
+    yield JSON.stringify(value) ?? "null";
+    return;
+  }
+  if (ancestors.has(value)) throw new TypeError("Circular JSON evidence");
+  ancestors.add(value);
+  try {
+    if (Array.isArray(value)) {
+      yield "[";
+      for (let index = 0; index < value.length; index++) {
+        if (index) yield ",";
+        yield* jsonParts(value[index], ancestors);
+      }
+      yield "]";
+    } else {
+      if (Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+        throw new TypeError("JSON evidence requires plain records");
+      if ("toJSON" in value && typeof value.toJSON === "function")
+        throw new TypeError("JSON evidence cannot contain toJSON hooks");
+      yield "{";
+      let first = true;
+      for (const key of Object.keys(value)) {
+        const field = Reflect.get(value, key);
+        if (field === void 0 || typeof field === "function" || typeof field === "symbol")
+          continue;
+        if (!first) yield ",";
+        first = false;
+        yield JSON.stringify(key) + ":";
+        yield* jsonParts(field, ancestors);
+      }
+      yield "}";
+    }
+  } finally {
+    ancestors.delete(value);
+  }
+}
+var writeReplayJsonFile = async (file, value) => {
+  await import_promises.default.mkdir(import_node_path.default.dirname(file), { recursive: true });
+  const temporary = file + ".tmp-" + (0, import_node_crypto.randomUUID)();
+  const stream = import_node_fs.default.createWriteStream(temporary, {
+    flags: "wx",
+    highWaterMark: 65536
+  });
+  let failure;
+  stream.on("error", (error) => {
+    failure = error;
+  });
+  try {
+    let buffer = "";
+    for (const part of jsonParts(value)) {
+      buffer += part;
+      if (buffer.length >= 65536) {
+        if (failure) throw failure;
+        if (!stream.write(buffer)) await (0, import_node_events.once)(stream, "drain");
+        buffer = "";
+      }
+    }
+    if (failure) throw failure;
+    stream.end(buffer + "\n");
+    await (0, import_node_events.once)(stream, "close");
+    if (failure) throw failure;
+    await import_promises.default.rename(temporary, file);
+  } catch (error) {
+    stream.destroy();
+    if (!stream.closed) await (0, import_node_events.once)(stream, "close").catch(() => void 0);
+    await import_promises.default.rm(temporary, { force: true });
+    throw error;
+  }
+};
+
+// src/lib/replay/memoryProfile.ts
+var import_node_fs2 = __toESM(require("fs"));
+var import_node_path2 = __toESM(require("path"));
+var createReplayMemoryProfile = (file = process.env.TRADEJS_REPLAY_MEMORY_PROFILE) => {
+  if (!file) return void 0;
+  import_node_fs2.default.mkdirSync(import_node_path2.default.dirname(file), { recursive: true });
+  return (phase, counts = {}) => {
+    import_node_fs2.default.appendFileSync(
+      file,
+      JSON.stringify({
+        schemaVersion: 1,
+        observedAt: Date.now(),
+        pid: process.pid,
+        phase,
+        counts,
+        ...process.memoryUsage(),
+        maxRssKiB: process.resourceUsage().maxRSS
+      }) + "\n"
+    );
+  };
+};
+
+// src/scripts/replayRuntimeEvidence.ts
+var import_promises2 = __toESM(require("fs/promises"));
+var import_node_path3 = __toESM(require("path"));
 var import_args = __toESM(require("args"));
 var import_chalk2 = __toESM(require("chalk"));
 var import_redis4 = require("@tradejs/infra/redis");
@@ -55,39 +156,6 @@ var isRuntimeTradeRecord = (value) => {
   const record = value;
   return typeof record.orderId === "string" && typeof record.strategy === "string" && typeof record.symbol === "string" && typeof record.entryTimestamp === "number" && typeof record.entryPrice === "number" && typeof record.qty === "number" && (record.direction === "LONG" || record.direction === "SHORT");
 };
-var loadRuntimeTrades = async (userName, {
-  startTime,
-  endTime
-} = {}) => {
-  const hasWindow = Number.isFinite(startTime) && Number.isFinite(endTime) && startTime != null && endTime != null;
-  const filterByWindow = (trade) => !hasWindow || trade.entryTimestamp >= startTime && trade.entryTimestamp <= endTime;
-  if (hasWindow) {
-    const dayKeys = (0, import_time.getRuntimeStorageDayKeys)(startTime, endTime);
-    const bucketTrades = (await Promise.all(
-      dayKeys.map(
-        (dayKey) => (0, import_redis.getHashJsonValues)(
-          import_redis.redisKeys.runtimeTradeBucket(userName, dayKey)
-        )
-      )
-    )).flat();
-    const dedupedBucketTrades = /* @__PURE__ */ new Map();
-    for (const trade of bucketTrades) {
-      if (!isRuntimeTradeRecord(trade)) {
-        continue;
-      }
-      dedupedBucketTrades.set(trade.orderId, trade);
-    }
-    const windowedTrades = [...dedupedBucketTrades.values()].filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
-    return windowedTrades;
-  }
-  const tradePrefix = import_redis.redisKeys.runtimeTrades(userName);
-  const bucketPrefix = import_redis.redisKeys.runtimeTradeBuckets(userName);
-  const keys = (await (0, import_redis.getKeys)(tradePrefix)).filter(
-    (key) => !key.startsWith(bucketPrefix)
-  );
-  const trades = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
-  return trades.filter(isRuntimeTradeRecord).filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
-};
 var loadRuntimeClosedTrades = async (userName, {
   startTime,
   endTime
@@ -111,6 +179,49 @@ var loadRuntimeClosedTrades = async (userName, {
     (left, right) => left.exitTimestamp - right.exitTimestamp
   );
 };
+var loadRuntimeEvidenceTrades = async (userName, { startTime, endTime }) => {
+  const prefix = import_redis.redisKeys.runtimeTradeBuckets(userName);
+  const lastDay = (0, import_time.getRuntimeStorageDayKey)(endTime - 1);
+  const keys = (await (0, import_redis.getKeys)(prefix)).filter((key) => {
+    const day = key.slice(prefix.length);
+    return key.startsWith(prefix) && /^\d{4}-\d{2}-\d{2}$/.test(day) && day <= lastDay;
+  });
+  const retained = /* @__PURE__ */ new Map();
+  for (let offset = 0; offset < keys.length; offset += 16) {
+    const buckets = await Promise.all(
+      keys.slice(offset, offset + 16).map((key) => (0, import_redis.getHashJsonValues)(key))
+    );
+    for (const row of buckets.flat())
+      if (isRuntimeTradeRecord(row)) retained.set(row.orderId, row);
+  }
+  for (const row of await loadRuntimeClosedTrades(userName, {
+    startTime,
+    endTime
+  }))
+    retained.set(row.orderId, row);
+  return [...retained.values()].filter(
+    (row) => row.entryTimestamp < endTime && (row.status === "active" || Number.isFinite(row.exitTimestamp) && row.exitTimestamp >= startTime)
+  ).map((row) => {
+    const closesAfterCutoff = row.status === "closed" && row.exitTimestamp >= endTime;
+    if (!closesAfterCutoff && !(row.status === "active" && row.lastSyncedAt >= endTime))
+      return row;
+    return {
+      ...row,
+      status: "active",
+      currentPrice: null,
+      currentPnl: null,
+      closedPnl: null,
+      exitPrice: null,
+      actualExitPrice: null,
+      exitTimestamp: null,
+      exitType: null,
+      closeFee: null,
+      fundingFee: null,
+      totalFee: null,
+      lastSyncedAt: void 0
+    };
+  }).sort((a, b) => a.entryTimestamp - b.entryTimestamp);
+};
 
 // src/lib/runtimeSignalsLoader.ts
 var import_redis2 = require("@tradejs/infra/redis");
@@ -313,30 +424,13 @@ var collectRuntimeDebugEvidence = async ({
 }) => {
   const dayKeys = (0, import_time2.getRuntimeStorageDayKeys)(startTime, endTime);
   const dayKeySet = new Set(dayKeys);
-  const [
-    entryTrades,
-    closedTrades,
-    signals,
-    evaluations,
-    evaluationStatsBuckets,
-    lineageScopes
-  ] = await Promise.all([
-    loadRuntimeTrades(userName, { startTime, endTime }),
-    loadRuntimeClosedTrades(userName, { startTime, endTime }),
+  const [trades, signals, evaluations, evaluationStatsBuckets, lineageScopes] = await Promise.all([
+    loadRuntimeEvidenceTrades(userName, { startTime, endTime }),
     loadRuntimeSignals(userName, { startTime, endTime }),
     loadRuntimeSignalEvaluations(userName, { startTime, endTime }),
     loadRuntimeSignalEvaluationStatsBuckets(userName),
     loadRuntimeLineageScopes(userName, { startTime, endTime })
   ]);
-  const tradesByOrderId = new Map(
-    entryTrades.map((trade) => [trade.orderId, trade])
-  );
-  for (const trade of closedTrades) {
-    tradesByOrderId.set(trade.orderId, trade);
-  }
-  const trades = [...tradesByOrderId.values()].sort(
-    (left, right) => left.entryTimestamp - right.entryTimestamp
-  );
   const filteredStats = evaluationStatsBuckets.filter(
     (entry) => dayKeySet.has(entry.dayKey) && (!deploymentId || entry.deploymentId === deploymentId) && (!strategies?.length || strategies.includes(entry.strategy))
   );
@@ -666,10 +760,10 @@ var loadRuntimePayload = async ({
   runtimeEvidenceFile,
   projectRoot
 }) => {
-  const runtimeEvidencePath = typeof runtimeEvidenceFile === "string" && runtimeEvidenceFile.trim() ? import_node_path.default.resolve(projectRoot, runtimeEvidenceFile.trim()) : null;
+  const runtimeEvidencePath = typeof runtimeEvidenceFile === "string" && runtimeEvidenceFile.trim() ? import_node_path3.default.resolve(projectRoot, runtimeEvidenceFile.trim()) : null;
   if (runtimeEvidencePath) {
     const artifact = JSON.parse(
-      await import_promises.default.readFile(runtimeEvidencePath, "utf8")
+      await import_promises2.default.readFile(runtimeEvidencePath, "utf8")
     );
     return {
       source: "file",
@@ -755,10 +849,12 @@ var replayRuntimeEvidence = async () => {
     },
     runtime: runtime.payload
   };
-  const outPath = import_node_path.default.resolve(projectRoot, String(flags.out));
-  await import_promises.default.mkdir(import_node_path.default.dirname(outPath), { recursive: true });
-  await import_promises.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
-`, "utf8");
+  const outPath = import_node_path3.default.resolve(projectRoot, String(flags.out));
+  await import_promises2.default.mkdir(import_node_path3.default.dirname(outPath), { recursive: true });
+  const memory = createReplayMemoryProfile();
+  memory?.("evidence:write:start");
+  await writeReplayJsonFile(outPath, artifact);
+  memory?.("evidence:write:complete");
   console.log(import_chalk2.default.green(`Wrote ${outPath}`));
   console.log(
     JSON.stringify(