@tradejs/cli 3.1.27-beta.250 → 3.1.28-beta.251

package/dist/scripts/replay.js

@@ -36,10 +36,13 @@ module.exports = __toCommonJS(replay_exports);
 
 // src/scripts/replayRunner.ts
 var import_chalk13 = __toESM(require("chalk"));
-var import_constants6 = require("@tradejs/core/constants");
+var import_constants7 = require("@tradejs/core/constants");
 var import_data4 = 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");
+var import_runtimeStrategies4 = require("@tradejs/node/runtimeStrategies");
+var import_strategies5 = require("@tradejs/node/strategies");
 
 // src/lib/runFormatting.ts
 var import_date_fns = require("date-fns");
@@ -887,8 +890,8 @@ var buildMarketBreadthRows = ({
     let altTurnover24h = 0;
     let previousAltTurnover24h = 0;
     for (const indexed of indexedSymbols) {
-      const { candles, byTimestamp, turnoverPrefix, closePrefix } = indexed;
-      const index = byTimestamp.get(timestamp);
+      const { candles, byTimestamp: byTimestamp2, turnoverPrefix, closePrefix } = indexed;
+      const index = byTimestamp2.get(timestamp);
       if (index == null) continue;
       const candle = candles[index];
       const previous = candles[index - 1];
@@ -2704,27 +2707,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 = (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) => {
   if (!stats) return;
-  const existing = stats.byPath.get(path3) ?? { requests: 0, credits: 0 };
+  const existing = stats.byPath.get(path5) ?? { 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(path5, existing);
 };
 var formatCoinMarketCapFetchStats = (stats) => {
   const byPath = [...stats.byPath.entries()].map(
-    ([path3, item]) => `${getCoinMarketCapPathLabel(path3)}=${item.requests}req/${item.credits}cr`
+    ([path5, item]) => `${getCoinMarketCapPathLabel(path5)}=${item.requests}req/${item.credits}cr`
   ).join(" ");
   return `apiRequests=${stats.requests} apiCredits=${stats.totalCredits}${byPath ? ` ${byPath}` : ""}`;
 };
@@ -4320,6 +4323,29 @@ import_args.default.option(
   "Save compact replay chart data for the strategies UI",
   false
 );
+import_args.default.option(
+  "allData",
+  "Use the complete cached candle range for the selected provider, interval, and symbols",
+  false
+);
+import_args.default.option(
+  "maxLossValue",
+  "Override MAX_LOSS_VALUE for every selected runtime strategy without changing its declaration"
+);
+import_args.default.option(
+  "portfolioReport",
+  "Write aggregate portfolio metrics and SVG charts; skip runtime/exchange comparison",
+  false
+);
+import_args.default.option(
+  ["B", "portfolioBatchSize"],
+  "Maximum number of symbols held in memory by one portfolio replay batch",
+  4
+);
+import_args.default.option(
+  ["X", "portfolioOutputSuffix"],
+  "Optional safe suffix for parallel portfolio report shards"
+);
 import_args.default.option(["L", "showTickersList"], "Just show only ticker list", false);
 import_args.default.option(["U", "user"], "Use user config", "root");
 import_args.default.option(
@@ -4951,6 +4977,8 @@ var compactReplaySignal = (signal) => {
 // 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_module = require("module");
 var import_strategies3 = require("@tradejs/core/strategies");
 var import_time3 = require("@tradejs/core/time");
 var import_logger = require("@tradejs/infra/logger");
@@ -5034,7 +5062,8 @@ var createPortfolioReplayConnector = (connector) => {
       close: {
         timestamp,
         amount: (0, import_math.round)(amount)
-      }
+      },
+      netProfit: (0, import_math.round)(positionState.currentProfit)
     };
     positionLog.push(nextPositionLog);
     appendStrategyPositionLog(
@@ -5484,7 +5513,8 @@ var prepareHistoricalReplay = async (context, adapters) => {
     strategies,
     references
   } = context;
-  const cycleSymbolsByTimestamp = /* @__PURE__ */ new Map();
+  const symbolRuntimes = [];
+  const orderedTimestamps = /* @__PURE__ */ new Set();
   const sharedReplayKeyPrefixes = [];
   const runtimeLineages = [];
   let skippedSymbols = 0;
@@ -5591,19 +5621,18 @@ var prepareHistoricalReplay = async (context, adapters) => {
       currentIndex: 0,
       strategies: strategiesForSymbol
     };
+    symbolRuntimes.push(symbolRuntime);
     adapters.progress.tick({
       skipped: adapters.display.skipped(skippedSymbols),
       symbol: adapters.display.symbol(symbol)
     });
     for (const candle of preparedData.replayData) {
-      const bucket = cycleSymbolsByTimestamp.get(candle.timestamp) ?? [];
-      bucket.push(symbolRuntime);
-      cycleSymbolsByTimestamp.set(candle.timestamp, bucket);
+      orderedTimestamps.add(candle.timestamp);
     }
   }
   return {
-    cycleSymbolsByTimestamp,
-    orderedTimestamps: [...cycleSymbolsByTimestamp.keys()].sort(
+    symbolRuntimes,
+    orderedTimestamps: [...orderedTimestamps].sort(
       (left, right) => left - right
     ),
     sharedReplayKeyPrefixes,
@@ -5636,7 +5665,13 @@ var appendReplaySignalEvaluationRun = ({
     }
   ];
 };
-var createHistoricalReplaySkipEvidence = (runtimeLineages) => {
+var createHistoricalReplaySkipEvidence = (runtimeLineages, enabled = true) => {
+  if (!enabled) {
+    return {
+      record: () => void 0,
+      values: () => []
+    };
+  }
   const lineageByStrategySymbol = new Map(
     runtimeLineages.map((record2) => [
       replayScopeKey(record2.strategy, record2.symbol),
@@ -5685,7 +5720,9 @@ var createHistoricalReplaySkipEvidence = (runtimeLineages) => {
 
 // src/lib/replay/historicalSignalsReplayExecution.ts
 var advanceCycleMarket = async (plan, connector, timestamp) => {
-  const cycleSymbols = plan.cycleSymbolsByTimestamp.get(timestamp) ?? [];
+  const cycleSymbols = plan.symbolRuntimes.filter(
+    (symbolRuntime) => symbolRuntime.replayData[symbolRuntime.currentIndex]?.timestamp === timestamp
+  );
   for (const symbolRuntime of cycleSymbols) {
     const candle = symbolRuntime.replayData[symbolRuntime.currentIndex];
     if (candle?.timestamp === timestamp) {
@@ -5709,8 +5746,17 @@ var executeHistoricalReplay = async (context, adapters) => {
   const signals = [];
   let abortedCycles = 0;
   const skipEvidence = createHistoricalReplaySkipEvidence(
-    context.plan.runtimeLineages
+    context.plan.runtimeLineages,
+    context.collectSkipEvidence
   );
+  const reportProgress = (timestamp) => {
+    if (adapters.progress.enabled === false) return;
+    adapters.progress.tick({
+      signals: adapters.display.signals(signals.length),
+      aborted: adapters.display.aborted(abortedCycles),
+      ts: adapters.display.timestamp(timestamp)
+    });
+  };
   try {
     for (const timestamp of context.plan.orderedTimestamps) {
       const cycleStartedAt = adapters.clock.now();
@@ -5732,11 +5778,7 @@ var executeHistoricalReplay = async (context, adapters) => {
           durationMs: adapters.clock.now() - cycleStartedAt
         });
         advanceAbortedCycle(cycleSymbols, timestamp);
-        adapters.progress.tick({
-          signals: adapters.display.signals(signals.length),
-          aborted: adapters.display.aborted(abortedCycles),
-          ts: adapters.display.timestamp(timestamp)
-        });
+        reportProgress(timestamp);
         continue;
       }
       const cycleSignals = [];
@@ -5765,7 +5807,7 @@ var executeHistoricalReplay = async (context, adapters) => {
             result.runtimeLineage = strategyRuntime.runtimeLineage;
             await adapters.enrichSignal(result);
             cycleSignals.push(result);
-            signals.push(result);
+            if (context.collectSignals !== false) signals.push(result);
           }
         }
         symbolRuntime.currentIndex += 1;
@@ -5776,11 +5818,7 @@ var executeHistoricalReplay = async (context, adapters) => {
         status: "completed",
         durationMs: adapters.clock.now() - cycleStartedAt
       });
-      adapters.progress.tick({
-        signals: adapters.display.signals(signals.length),
-        aborted: adapters.display.aborted(abortedCycles),
-        ts: adapters.display.timestamp(timestamp)
-      });
+      reportProgress(timestamp);
     }
   } finally {
     for (const keyPrefix of context.plan.sharedReplayKeyPrefixes) {
@@ -5797,6 +5835,7 @@ var executeHistoricalReplay = async (context, adapters) => {
 
 // src/lib/replay/historicalSignalsReplayResults.ts
 var import_backtest = require("@tradejs/core/backtest");
+var import_constants4 = require("@tradejs/core/constants");
 var emptyStat = () => ({
   orders: 0,
   wins: 0,
@@ -5804,6 +5843,25 @@ var emptyStat = () => ({
   netProfit: 0,
   amount: 0
 });
+var positionLogForStats = (positionLog) => {
+  let amount = import_constants4.INITIAL_BACKTEST_AMOUNT;
+  return [...positionLog].sort(
+    (left, right) => left.close.timestamp - right.close.timestamp || left.open.timestamp - right.open.timestamp
+  ).map((position) => {
+    const pnl = Number.isFinite(position.netProfit) ? Number(position.netProfit) : position.close.amount - position.open.amount;
+    const next = {
+      ...position,
+      open: { ...position.open, amount },
+      close: { ...position.close, amount: amount + pnl },
+      netProfit: pnl
+    };
+    amount += pnl;
+    return next;
+  });
+};
+var calculateReplayStat = (positionLog) => positionLog.length ? (0, import_backtest.calculateStatsFull)(positionLogForStats(positionLog)) : emptyStat();
+var byTimestamp = (left, right) => left.timestamp - right.timestamp;
+var byPositionClose = (left, right) => left.close.timestamp - right.close.timestamp;
 var collectHistoricalReplayResult = (context) => ({
   strategies: context.strategies.map(({ strategyName, strategyConfig }) => {
     const orderLog = context.artifacts.orderLogByStrategy.get(strategyName) ?? [];
@@ -5813,7 +5871,7 @@ var collectHistoricalReplayResult = (context) => ({
       strategyConfig,
       orderLog,
       positionLog,
-      stat: positionLog.length ? (0, import_backtest.calculateStatsFull)(positionLog) : emptyStat()
+      stat: calculateReplayStat(positionLog)
     };
   }),
   signals: context.signals,
@@ -5824,8 +5882,78 @@ var collectHistoricalReplayResult = (context) => ({
   runtimeLineages: context.runtimeLineages,
   replayLineageScopes: context.replayLineageScopes
 });
+var compactHistoricalReplayResultForPortfolio = (result) => ({
+  ...result,
+  strategies: result.strategies.map((strategy) => ({
+    ...strategy,
+    orderLog: []
+  })),
+  signals: [],
+  orderLog: [],
+  replayLineageScopes: []
+});
+var mergeHistoricalReplayResults = (parts) => {
+  if (!parts.length) {
+    throw new Error("Cannot merge an empty historical replay result list");
+  }
+  const strategyNames = parts[0].strategies.map(
+    (strategy) => strategy.strategyName
+  );
+  const strategies = strategyNames.map((strategyName) => {
+    const entries = parts.map((part) => {
+      const entry = part.strategies.find(
+        (strategy) => strategy.strategyName === strategyName
+      );
+      if (!entry) {
+        throw new Error(`Replay batch is missing strategy ${strategyName}`);
+      }
+      return entry;
+    });
+    const positionLog = entries.flatMap((entry) => entry.positionLog).sort(byPositionClose);
+    return {
+      strategyName,
+      strategyConfig: entries[0].strategyConfig,
+      orderLog: entries.flatMap((entry) => entry.orderLog).sort(byTimestamp),
+      positionLog,
+      stat: calculateReplayStat(positionLog)
+    };
+  });
+  return {
+    strategies,
+    signals: parts.flatMap((part) => part.signals).sort(byTimestamp),
+    orderLog: parts.flatMap((part) => part.orderLog).sort(byTimestamp),
+    positionLog: parts.flatMap((part) => part.positionLog).sort(byPositionClose),
+    cycleCount: parts.reduce((sum, part) => sum + part.cycleCount, 0),
+    abortedCycles: parts.reduce((sum, part) => sum + part.abortedCycles, 0),
+    runtimeLineages: parts.flatMap((part) => part.runtimeLineages),
+    replayLineageScopes: parts.flatMap((part) => part.replayLineageScopes)
+  };
+};
 
 // src/lib/replay/historicalSignalsReplay.ts
+var projectReplayCacheReleasers;
+var getProjectReplayCacheReleasers = () => {
+  if (projectReplayCacheReleasers !== void 0) {
+    return projectReplayCacheReleasers;
+  }
+  try {
+    const requireFromProject = (0, import_node_module.createRequire)(
+      import_node_path2.default.join(replayProjectRoot, "package.json")
+    );
+    projectReplayCacheReleasers = requireFromProject(
+      "@tradejs/core/strategies"
+    );
+  } catch {
+    projectReplayCacheReleasers = null;
+  }
+  return projectReplayCacheReleasers;
+};
+var releaseReplayCacheCopies = (keyPrefix, localRelease, projectRelease) => {
+  localRelease(keyPrefix);
+  if (projectRelease && projectRelease !== localRelease) {
+    projectRelease(keyPrefix);
+  }
+};
 var loadRuntimeStrategies = async (runtimeStrategies) => {
   const strategies = await Promise.all(
     runtimeStrategies.map(async (runtimeStrategy) => {
@@ -5840,16 +5968,19 @@ var loadRuntimeStrategies = async (runtimeStrategies) => {
         strategyConfig,
         selection
       } = runtimeStrategy;
+      const strategyModule = strategyPackage.startsWith("@tradejs/strategy-") ? strategyPackage : void 0;
       const strategyCreator = await (0, import_strategies4.getStrategyCreator)(
         strategyName,
-        replayProjectRoot
+        replayProjectRoot,
+        strategyModule
       );
       if (!strategyCreator) {
         throw new Error(`Unknown strategy: ${strategyName}`);
       }
       const installed = await (0, import_runtimeStrategies3.getRuntimeStrategyPackageMetadata)({
         strategyName,
-        projectRoot: replayProjectRoot
+        projectRoot: replayProjectRoot,
+        strategyModule
       });
       if (installed.strategyPackage !== strategyPackage || installed.strategyPackageVersion !== strategyPackageVersion || JSON.stringify(installed.strategyDependencyVersions) !== JSON.stringify(strategyDependencyVersions) || installed.runtimePackageVersion !== runtimePackageVersion) {
         throw new Error(
@@ -5912,10 +6043,41 @@ var getConnectorName = (connector) => {
   const name = "name" in connector ? connector.name : void 0;
   return String(name || import_connectors6.DEFAULT_CONNECTOR_NAME).trim() || import_connectors6.DEFAULT_CONNECTOR_NAME;
 };
+var loadHistoricalReplayReferences = async ({
+  preparedRun,
+  interval
+}) => {
+  const connectorName = getConnectorName(preparedRun.marketConnector);
+  const binanceConnector = connectorName.toLowerCase() === import_connectors6.DEFAULT_CONNECTOR_NAME.toLowerCase() ? await loadReferenceConnector("Binance") : preparedRun.marketConnector;
+  const coinbaseConnector = connectorName.toLowerCase() === import_connectors6.DEFAULT_CONNECTOR_NAME.toLowerCase() ? await loadReferenceConnector("Coinbase") : preparedRun.marketConnector;
+  const request = {
+    symbol: "BTCUSDT",
+    start: preparedRun.preloadStart,
+    end: preparedRun.window.end,
+    cacheOnly: true,
+    interval
+  };
+  const [btcBinanceData, btcCoinbaseData, btcMarketData, ethMarketData] = await Promise.all([
+    binanceConnector.kline(request),
+    coinbaseConnector.kline(request),
+    preparedRun.marketConnector.kline(request),
+    preparedRun.marketConnector.kline({ ...request, symbol: "ETHUSDT" })
+  ]);
+  return {
+    btcMarketData,
+    ethMarketData,
+    btcBinanceData,
+    btcCoinbaseData
+  };
+};
 var runHistoricalSignalsReplay = async ({
   preparedRun,
   interval,
-  runtimeStrategies
+  runtimeStrategies,
+  references,
+  showProgress = true,
+  collectSkipEvidence = true,
+  collectSignals = true
 }) => {
   const startedAt = Date.now();
   const projectConfig = await (0, import_cli4.loadTradejsConfig)(replayProjectRoot);
@@ -5925,38 +6087,7 @@ var runHistoricalSignalsReplay = async ({
     preparedRun.marketConnector
   );
   const connectorName = getConnectorName(preparedRun.marketConnector);
-  const binanceConnector = connectorName.toLowerCase() === import_connectors6.DEFAULT_CONNECTOR_NAME.toLowerCase() ? await loadReferenceConnector("Binance") : preparedRun.marketConnector;
-  const coinbaseConnector = connectorName.toLowerCase() === import_connectors6.DEFAULT_CONNECTOR_NAME.toLowerCase() ? await loadReferenceConnector("Coinbase") : preparedRun.marketConnector;
-  const [btcBinanceData, btcCoinbaseData] = await Promise.all([
-    binanceConnector.kline({
-      symbol: "BTCUSDT",
-      start: preparedRun.preloadStart,
-      end: preparedRun.window.end,
-      cacheOnly: true,
-      interval
-    }),
-    coinbaseConnector.kline({
-      symbol: "BTCUSDT",
-      start: preparedRun.preloadStart,
-      end: preparedRun.window.end,
-      cacheOnly: true,
-      interval
-    })
-  ]);
-  const btcMarketData = await preparedRun.marketConnector.kline({
-    symbol: "BTCUSDT",
-    start: preparedRun.preloadStart,
-    end: preparedRun.window.end,
-    cacheOnly: true,
-    interval
-  });
-  const ethMarketData = await preparedRun.marketConnector.kline({
-    symbol: "ETHUSDT",
-    start: preparedRun.preloadStart,
-    end: preparedRun.window.end,
-    cacheOnly: true,
-    interval
-  });
+  const referenceData = references ?? await loadHistoricalReplayReferences({ preparedRun, interval });
   const prepareBar = new import_progress4.default(
     "prepare :current/:total [:bar][:percent] skipped=:skipped :etas(s) :symbol",
     {
@@ -5974,10 +6105,10 @@ var runHistoricalSignalsReplay = async ({
       replayConnector,
       strategies: loadedStrategies,
       references: {
-        btcMarketData,
-        ethMarketData,
-        btcBinanceData,
-        btcCoinbaseData
+        btcMarketData: referenceData.btcMarketData,
+        ethMarketData: referenceData.ethMarketData,
+        btcBinanceData: referenceData.btcBinanceData,
+        btcCoinbaseData: referenceData.btcCoinbaseData
       }
     },
     {
@@ -6009,12 +6140,15 @@ var runHistoricalSignalsReplay = async ({
     {
       plan,
       connector: replayConnector,
+      collectSkipEvidence,
+      collectSignals,
       hooks: projectHooks,
       hookContext
     },
     {
       clock: { now: Date.now },
       progress: {
+        enabled: showProgress,
         tick: (tokens) => cycleBar.tick(1, tokens)
       },
       display: {
@@ -6025,8 +6159,16 @@ var runHistoricalSignalsReplay = async ({
       invokeBeforeSignals: invokeBeforeSignalsHooks,
       invokeAfterSignals: invokeAfterSignalsHooks,
       enrichSignal: (signal) => (0, import_strategies4.enrichSignalWithBinanceMarketContext)({ signal, env: "PARITY" }),
-      releaseIndicatorsCache: import_strategies3.releaseStrategyIndicatorsReplayCache,
-      releaseReplayCache: import_strategies3.releaseStrategyReplayCache
+      releaseIndicatorsCache: (keyPrefix) => releaseReplayCacheCopies(
+        keyPrefix,
+        import_strategies3.releaseStrategyIndicatorsReplayCache,
+        getProjectReplayCacheReleasers()?.releaseStrategyIndicatorsReplayCache
+      ),
+      releaseReplayCache: (keyPrefix) => releaseReplayCacheCopies(
+        keyPrefix,
+        import_strategies3.releaseStrategyReplayCache,
+        getProjectReplayCacheReleasers()?.releaseStrategyReplayCache
+      )
     }
   );
   const artifacts = replayConnector.getReplayArtifacts();
@@ -6397,11 +6539,16 @@ var saveAndPrintReplayResultsByStrategy = async ({
   const backtestEntries = replayResult.strategies.flatMap(
     ({ orderLog }) => extractBacktestEntryParityEntries(orderLog)
   );
-  const summaries = replayResult.strategies.map(({ strategyName, strategyConfig, stat }) => {
-    const orders = stat?.orders ?? 0;
-    const wins = stat?.wins ?? 0;
-    const losses = stat?.losses ?? 0;
-    const netProfit = Number((stat?.netProfit ?? 0).toFixed(2));
+  const summaries = replayResult.strategies.map(({ strategyName, strategyConfig, positionLog }) => {
+    const realizedPnl = positionLog.map(
+      (position) => Number.isFinite(position.netProfit) ? Number(position.netProfit) : position.close.amount - position.open.amount
+    );
+    const orders = realizedPnl.length;
+    const wins = realizedPnl.filter((pnl) => pnl > 0).length;
+    const losses = realizedPnl.filter((pnl) => pnl <= 0).length;
+    const netProfit = Number(
+      realizedPnl.reduce((sum, pnl) => sum + pnl, 0).toFixed(2)
+    );
     const winRate = orders > 0 ? Number((wins / orders * 100).toFixed(2)) : 0;
     const avgTradeProfit = orders > 0 ? Number((netProfit / orders).toFixed(2)) : 0;
     const tradedSymbols = new Set(
@@ -6528,7 +6675,7 @@ var summarizeTradeParityByStrategy = ({
 var import_redis4 = require("@tradejs/infra/redis");
 
 // src/lib/runtimeSignalsStorage.ts
-var import_constants4 = require("@tradejs/core/constants");
+var import_constants5 = require("@tradejs/core/constants");
 var import_data2 = require("@tradejs/core/data");
 var import_time4 = require("@tradejs/core/time");
 var isRuntimeSignalBucketRef = (value) => {
@@ -6638,7 +6785,7 @@ var loadRuntimeLineageScopes = async (userName, {
 };
 
 // src/lib/runtimeTradeSync.ts
-var import_constants5 = require("@tradejs/core/constants");
+var import_constants6 = require("@tradejs/core/constants");
 var import_time5 = require("@tradejs/core/time");
 var import_redis5 = require("@tradejs/infra/redis");
 var CLOSED_PNL_LIMIT = 100;
@@ -6879,7 +7026,7 @@ var syncRuntimeTrades = async ({
     };
     await Promise.all([
       (0, import_redis5.setData)(import_redis5.redisKeys.runtimeTrade(userName, trade.orderId), nextTrade, {
-        expire: import_constants5.TTL_1M
+        expire: import_constants6.TTL_1M
       }),
       (0, import_redis5.setHashJsonField)(
         import_redis5.redisKeys.runtimeTradeBucket(
@@ -6888,7 +7035,7 @@ var syncRuntimeTrades = async ({
         ),
         trade.orderId,
         nextTrade,
-        { expire: import_constants5.TTL_1M }
+        { expire: import_constants6.TTL_1M }
       ),
       (0, import_redis5.setHashJsonField)(
         import_redis5.redisKeys.runtimeClosedTradeBucket(
@@ -6897,7 +7044,7 @@ var syncRuntimeTrades = async ({
         ),
         trade.orderId,
         nextTrade,
-        { expire: import_constants5.TTL_1M }
+        { expire: import_constants6.TTL_1M }
       ),
       ...isCurrentActiveTrade ? [(0, import_redis5.delKey)(activeTradeKey)] : []
     ]);
@@ -8838,7 +8985,7 @@ var saveAndPrintReplayRuntimeComparison = async ({
 
 // src/lib/replay/outputReport.ts
 var import_promises2 = __toESM(require("fs/promises"));
-var import_node_path2 = __toESM(require("path"));
+var import_node_path3 = __toESM(require("path"));
 var import_data3 = require("@tradejs/core/data");
 var formatMsk = (timestamp) => typeof timestamp === "number" && Number.isFinite(timestamp) ? new Intl.DateTimeFormat("ru-RU", {
   timeZone: "Europe/Moscow",
@@ -9142,7 +9289,7 @@ var writeReplayOutputReport = async ({
   strategySnapshot,
   runtimeComparison
 }) => {
-  const outputDir = import_node_path2.default.resolve(projectRoot, "data/replay/output");
+  const outputDir = import_node_path3.default.resolve(projectRoot, "data/replay/output");
   await import_promises2.default.mkdir(outputDir, { recursive: true });
   const perTradeAnalysis = buildPerTradeAnalysis(runtimeComparison);
   const report = {
@@ -9178,8 +9325,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",
     "",
@@ -9255,6 +9402,330 @@ 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 DAY_MS4 = 864e5;
+var WINDOWS = [365, 180, 90, 30, 7];
+var COLORS = [
+  "#2563eb",
+  "#dc2626",
+  "#059669",
+  "#7c3aed",
+  "#ea580c",
+  "#0891b2",
+  "#c026d3",
+  "#4d7c0f",
+  "#be123c",
+  "#4338ca",
+  "#0f766e"
+];
+var finite = (value, fallback = 0) => {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : fallback;
+};
+var round2 = (value, digits = 8) => Number(value.toFixed(digits));
+var tradesFromPositionLog = (strategyName, positionLog) => positionLog.map((position) => ({
+  strategyName,
+  direction: position.direction,
+  openedAt: position.open.timestamp,
+  exitedAt: position.close.timestamp,
+  pnl: finite(
+    position.netProfit,
+    finite(position.close.amount) - finite(position.open.amount)
+  )
+}));
+var curveForTrades = (trades, start, end) => {
+  let value = 0;
+  const realized = [...trades].sort(
+    (left, right) => left.exitedAt - right.exitedAt || left.strategyName.localeCompare(right.strategyName)
+  ).map((trade) => ({
+    timestamp: trade.exitedAt,
+    value: value = round2(value + trade.pnl)
+  }));
+  return [
+    { timestamp: start, value: 0 },
+    ...realized,
+    { timestamp: end, value }
+  ];
+};
+var drawdownCurve = (equity) => {
+  let peak = 0;
+  return equity.map((point) => {
+    peak = Math.max(peak, point.value);
+    return { timestamp: point.timestamp, value: round2(point.value - peak) };
+  });
+};
+var maxDrawdown = (trades) => {
+  let equity = 0;
+  let peak = 0;
+  let worst = 0;
+  for (const trade of [...trades].sort((a, b) => a.exitedAt - b.exitedAt)) {
+    equity += trade.pnl;
+    peak = Math.max(peak, equity);
+    worst = Math.max(worst, peak - equity);
+  }
+  return worst;
+};
+var calculatePortfolioMetricRow = ({
+  trades,
+  window,
+  scope,
+  cohort,
+  start,
+  end
+}) => {
+  const selected = trades.filter(
+    (trade) => trade.exitedAt >= start && trade.exitedAt < end && (cohort === "ALL" || trade.direction === cohort)
+  );
+  const grossProfit = selected.filter((trade) => trade.pnl > 0).reduce((sum, trade) => sum + trade.pnl, 0);
+  const grossLoss = Math.abs(
+    selected.filter((trade) => trade.pnl < 0).reduce((sum, trade) => sum + trade.pnl, 0)
+  );
+  const pnl = selected.reduce((sum, trade) => sum + trade.pnl, 0);
+  const wins = selected.filter((trade) => trade.pnl > 0).length;
+  const losses = selected.filter((trade) => trade.pnl <= 0).length;
+  const days = Math.max(1, (end - start) / DAY_MS4);
+  return {
+    window,
+    scope,
+    cohort,
+    n: selected.length,
+    wins,
+    losses,
+    pnl: round2(pnl),
+    pnlPerTrade: selected.length ? round2(pnl / selected.length) : null,
+    profitFactor: grossLoss > 0 ? round2(grossProfit / grossLoss) : null,
+    winRate: selected.length ? round2(wins / selected.length * 100) : null,
+    realizedMaxDrawdown: round2(maxDrawdown(selected)),
+    cadencePerDay: round2(selected.length / days)
+  };
+};
+var windowBounds = (start, end) => [
+  { label: "full", start, end },
+  ...WINDOWS.map((days) => ({
+    label: `${days}d`,
+    start: Math.max(start, end - days * DAY_MS4),
+    end
+  }))
+];
+var escapeHtml = (value) => String(value ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var display = (value, digits = 2) => value == null || !Number.isFinite(value) ? "n/a" : value.toFixed(digits);
+var displayPercent = (value) => value == null || !Number.isFinite(value) ? "n/a" : `${value.toFixed(1)}%`;
+var downsample = (points, limit = 2e3) => {
+  if (points.length <= limit) return points;
+  const result = [];
+  const step = (points.length - 1) / (limit - 1);
+  for (let index = 0; index < limit; index += 1) {
+    result.push(points[Math.round(index * step)]);
+  }
+  return result;
+};
+var renderSvg = ({
+  title,
+  series,
+  start,
+  end
+}) => {
+  const width = 1280;
+  const legendColumns = 3;
+  const legendRows = Math.max(1, Math.ceil(series.length / legendColumns));
+  const height = 640 + legendRows * 20;
+  const left = 78;
+  const right = 24;
+  const top = 58;
+  const bottom = 90 + legendRows * 20;
+  const allValues = series.flatMap(
+    ({ points }) => points.map(({ value }) => value)
+  );
+  const min = Math.min(0, ...allValues);
+  const max = Math.max(0, ...allValues);
+  const span = Math.max(1, max - min);
+  const timeSpan = Math.max(1, end - start);
+  const x = (timestamp) => left + (timestamp - start) / timeSpan * (width - left - right);
+  const y = (value) => top + (max - value) / span * (height - top - bottom);
+  const grid = Array.from({ length: 6 }, (_, index) => {
+    const value = max - span * index / 5;
+    const py = y(value);
+    return `<line x1="${left}" y1="${py}" x2="${width - right}" y2="${py}" stroke="#e5e7eb"/><text x="${left - 10}" y="${py + 4}" text-anchor="end" font-size="12" fill="#64748b">${value.toFixed(1)}</text>`;
+  }).join("");
+  const paths = series.map(({ name, color, points, strokeWidth = 2 }) => {
+    const sampled = downsample(points);
+    const d = sampled.map(
+      (point, index) => `${index ? "L" : "M"}${x(point.timestamp).toFixed(2)},${y(point.value).toFixed(2)}`
+    ).join(" ");
+    return `<path d="${d}" fill="none" stroke="${color}" stroke-width="${strokeWidth}"/><title>${escapeHtml(name)}</title>`;
+  }).join("");
+  const legend = series.map(
+    ({ name, color }, index) => `<g transform="translate(${left + index % legendColumns * 390},${height - 20 - (legendRows - 1 - Math.floor(index / legendColumns)) * 20})"><line x1="0" y1="-4" x2="20" y2="-4" stroke="${color}" stroke-width="3"/><text x="26" y="0" font-size="12" fill="#334155">${escapeHtml(name)}</text></g>`
+  ).join("");
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}"><rect width="100%" height="100%" fill="white"/><text x="${left}" y="32" font-size="22" font-family="sans-serif" fill="#0f172a">${escapeHtml(title)}</text><g font-family="sans-serif">${grid}<line x1="${left}" y1="${y(0)}" x2="${width - right}" y2="${y(0)}" stroke="#94a3b8"/>${paths}<text x="${left}" y="${height - bottom + 26}" font-size="12" fill="#64748b">${new Date(start).toISOString().slice(0, 10)}</text><text x="${width - right}" y="${height - bottom + 26}" text-anchor="end" font-size="12" fill="#64748b">${new Date(end).toISOString().slice(0, 10)}</text>${legend}</g></svg>`;
+};
+var metricTable = (rows) => {
+  const body = rows.map(
+    (row) => `<tr><td>${escapeHtml(row.window)}</td><td>${escapeHtml(row.scope)}</td><td>${row.cohort}</td><td>${row.n}</td><td>${display(row.pnl)}</td><td>${display(row.pnlPerTrade)}</td><td>${display(row.profitFactor)}</td><td>${displayPercent(row.winRate)}</td><td>${display(row.realizedMaxDrawdown)}</td><td>${display(row.cadencePerDay, 3)}</td></tr>`
+  ).join("");
+  return `<table><thead><tr><th>Window</th><th>Scope</th><th>Cohort</th><th>N</th><th>PnL</th><th>PnL/trade</th><th>PF</th><th>WR</th><th>Realized MaxDD</th><th>Cadence/day</th></tr></thead><tbody>${body}</tbody></table>`;
+};
+var markdownTable = (rows) => [
+  "| Window | Scope | Cohort | N | PnL | PnL/trade | PF | WR | Realized MaxDD | Cadence/day |",
+  "| --- | --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |",
+  ...rows.map(
+    (row) => `| ${row.window} | ${row.scope} | ${row.cohort} | ${row.n} | ${display(row.pnl)} | ${display(row.pnlPerTrade)} | ${display(row.profitFactor)} | ${displayPercent(row.winRate)} | ${display(row.realizedMaxDrawdown)} | ${display(row.cadencePerDay, 3)} |`
+  )
+].join("\n");
+var writePortfolioReport = async ({
+  projectRoot,
+  timestamp,
+  replayResult,
+  window,
+  lineage,
+  command
+}) => {
+  const outputDir = import_node_path4.default.resolve(projectRoot, "data/replay/output");
+  await import_promises3.default.mkdir(outputDir, { recursive: true });
+  const trades = replayResult.strategies.flatMap(
+    (strategy) => tradesFromPositionLog(strategy.strategyName, strategy.positionLog)
+  );
+  const bounds = windowBounds(window.start, window.end);
+  const portfolioRows = bounds.flatMap(
+    (bound) => ["ALL", "LONG", "SHORT"].map(
+      (cohort) => calculatePortfolioMetricRow({
+        trades,
+        window: bound.label,
+        scope: "PORTFOLIO",
+        cohort,
+        start: bound.start,
+        end: bound.end
+      })
+    )
+  );
+  const strategyRows = bounds.flatMap(
+    (bound) => replayResult.strategies.map(
+      (strategy) => calculatePortfolioMetricRow({
+        trades: trades.filter(
+          (trade) => trade.strategyName === strategy.strategyName
+        ),
+        window: bound.label,
+        scope: strategy.strategyName,
+        cohort: "ALL",
+        start: bound.start,
+        end: bound.end
+      })
+    )
+  );
+  const portfolioEquity = curveForTrades(trades, window.start, window.end);
+  const strategySeries = replayResult.strategies.flatMap((strategy, index) => {
+    const strategyTrades = trades.filter(
+      (trade) => trade.strategyName === strategy.strategyName
+    );
+    return strategyTrades.length ? [
+      {
+        name: strategy.strategyName,
+        color: COLORS[index % COLORS.length],
+        points: curveForTrades(strategyTrades, window.start, window.end)
+      }
+    ] : [];
+  });
+  const equitySvg = renderSvg({
+    title: "Portfolio and strategy realized PnL overlay",
+    series: [
+      {
+        name: "PORTFOLIO",
+        color: "#111827",
+        points: portfolioEquity,
+        strokeWidth: 3
+      },
+      ...strategySeries
+    ],
+    start: window.start,
+    end: window.end
+  });
+  const drawdownSvg = renderSvg({
+    title: "Aggregate portfolio realized drawdown",
+    series: [
+      {
+        name: "PORTFOLIO",
+        color: "#111827",
+        points: drawdownCurve(portfolioEquity)
+      }
+    ],
+    start: window.start,
+    end: window.end
+  });
+  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`)
+  };
+  const report = {
+    schema: "tradejs-portfolio-backtest/v1",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    command,
+    window: {
+      start: window.start,
+      end: window.end,
+      startIso: new Date(window.start).toISOString(),
+      endIso: new Date(window.end).toISOString()
+    },
+    lineage,
+    counts: {
+      strategies: replayResult.strategies.length,
+      signals: replayResult.signals.length,
+      completedTrades: trades.length
+    },
+    metrics: { portfolio: portfolioRows, strategies: strategyRows },
+    curves: {
+      portfolioEquity,
+      portfolioDrawdown: drawdownCurve(portfolioEquity),
+      strategies: strategySeries.map(({ name, points }) => ({ name, points }))
+    },
+    trades
+  };
+  const checksum = (0, import_node_crypto2.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
+
+- Window: ${report.window.startIso} .. ${report.window.endIso}
+- Strategies: ${report.counts.strategies}
+- Signals: ${report.counts.signals}
+- Completed trades: ${report.counts.completedTrades}
+- Portfolio semantics: ${semantics}
+- Report checksum: \`${checksum}\`
+- Command: \`${command}\`
+
+![Strategy PnL overlay](./${import_node_path4.default.basename(paths.equitySvg)})
+
+![Portfolio drawdown](./${import_node_path4.default.basename(paths.drawdownSvg)})
+
+## Portfolio metrics
+
+${markdownTable(portfolioRows)}
+
+## Strategy metrics
+
+${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(
+      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")
+  ]);
+  return { ...paths, checksum };
+};
+
 // src/scripts/replayRunner.ts
 var prepareReplayBinanceMarketContext = async (preparedRun) => {
   await prepareMarketContextForRun({
@@ -9273,17 +9744,47 @@ var prepareReplayBinanceMarketContext = async (preparedRun) => {
     log: (message) => console.log(import_chalk13.default.gray(message))
   });
 };
+var replayMarketContextInterval = () => {
+  if (replayInterval === "1") return "1m";
+  if (replayInterval === "5") return "5m";
+  if (replayInterval === "60") return "1h";
+  return "15m";
+};
+var cachedTickerSymbols = async ({
+  connectorName,
+  universe,
+  accountId
+}) => {
+  const connectorNames = [
+    connectorName,
+    ...connectorName.toLowerCase() === "bybit" ? ["ByBit"] : []
+  ];
+  const keys = connectorNames.flatMap((name) => [
+    import_redis6.redisKeys.tickerUniverse(replayUserName, name, universe, accountId),
+    import_redis6.redisKeys.tickerUniverse(replayUserName, name, universe, "default"),
+    import_redis6.redisKeys.tickerUniverse(replayUserName, name)
+  ]);
+  for (const key of [...new Set(keys)]) {
+    const cached = await (0, import_redis6.getData)(key, null);
+    const symbols = (cached?.tickers ?? []).map(
+      (ticker) => String(ticker.symbol ?? "").trim().toUpperCase()
+    ).filter(Boolean);
+    if (symbols.length) return [...new Set(symbols)];
+  }
+  return [];
+};
 var finishReplay = async ({
   replayResult,
   tickers,
   connectorName,
-  window
+  window,
+  portfolioLineage
 }) => {
   const replayStrategySnapshot = await saveAndPrintReplayResultsByStrategy({
     replayResult,
     tickers
   });
-  const replayRuntimeComparison = await saveAndPrintReplayRuntimeComparison({
+  const replayRuntimeComparison = replayFlags.portfolioReport ? null : await saveAndPrintReplayRuntimeComparison({
     liveStrategySummaries: replayStrategySnapshot.summaries,
     backtestEntries: replayStrategySnapshot.backtestEntries,
     replaySignals: replayResult.signals,
@@ -9326,6 +9827,18 @@ var finishReplay = async ({
   });
   console.log(import_chalk13.default.green(`Replay report: ${outputReport.markdownPath}`));
   console.log(import_chalk13.default.green(`Replay report JSON: ${outputReport.jsonPath}`));
+  const portfolioReport = replayFlags.portfolioReport ? await writePortfolioReport({
+    projectRoot: replayProjectRoot,
+    timestamp: `${timestamp}${replayFlags.portfolioOutputSuffix ? `-${String(replayFlags.portfolioOutputSuffix).replace(/[^a-zA-Z0-9_-]/g, "")}` : ""}`,
+    replayResult,
+    window,
+    lineage: portfolioLineage ?? {},
+    command: process.argv.join(" ")
+  }) : null;
+  if (portfolioReport) {
+    console.log(import_chalk13.default.green(`Portfolio report: ${portfolioReport.html}`));
+    console.log(import_chalk13.default.green(`Portfolio report JSON: ${portfolioReport.json}`));
+  }
   await (0, import_redis6.setData)(
     replayKey,
     {
@@ -9349,10 +9862,11 @@ var finishReplay = async ({
       signalsCount: replayResult.signals.length,
       replayLineage: replayResult.runtimeLineages,
       strategyCharts: replayChartSnapshot,
-      outputReport
+      outputReport,
+      ...portfolioReport ? { portfolioReport } : {}
     },
     {
-      expire: import_constants6.TTL_1M
+      expire: import_constants7.TTL_1M
     }
   );
   if (replayChartSnapshot) {
@@ -9362,7 +9876,7 @@ var finishReplay = async ({
           import_redis6.redisKeys.strategyChartCard(replayUserName, "replay", card.cardId),
           card,
           {
-            expire: import_constants6.TTL_1M
+            expire: import_constants7.TTL_1M
           }
         )
       )
@@ -9412,7 +9926,57 @@ var replayBacktest = async () => {
     projectRoot: replayProjectRoot,
     deploymentId: replayDeploymentId
   });
-  const { deployment, strategies: replayStrategies } = replayComposition;
+  const { deployment } = replayComposition;
+  const maxLossValue = (() => {
+    if (replayFlags.maxLossValue == null || replayFlags.maxLossValue === "") {
+      return null;
+    }
+    const value = Number(replayFlags.maxLossValue);
+    if (!Number.isFinite(value) || value <= 0) {
+      throw new Error(
+        `Invalid --maxLossValue: ${String(replayFlags.maxLossValue)}`
+      );
+    }
+    return value;
+  })();
+  const sourceDeploymentCompositionId = replayComposition.strategies[0]?.deploymentCompositionId ?? deployment.deploymentCompositionId;
+  let replayStrategies = replayComposition.strategies.map((strategy) => {
+    if (maxLossValue == null) return strategy;
+    const strategyConfig = {
+      ...strategy.strategyConfig,
+      MAX_LOSS_VALUE: maxLossValue
+    };
+    return {
+      ...strategy,
+      strategyConfig,
+      strategyRevision: (0, import_runtimeStrategies4.computeStrategyRevision)({
+        strategyName: strategy.strategyName,
+        strategyPackage: strategy.strategyPackage,
+        strategyPackageVersion: strategy.strategyPackageVersion,
+        strategyDependencyVersions: strategy.strategyDependencyVersions,
+        runtimePackageVersion: strategy.runtimePackageVersion,
+        strategyConfig
+      })
+    };
+  });
+  const researchDeploymentCompositionId = (0, import_runtimeStrategies4.computeDeploymentCompositionId)({
+    deploymentId: deployment.id,
+    connectorName: deployment.connectorName,
+    provider: deployment.provider,
+    accountId: deployment.accountId,
+    enabled: deployment.enabled,
+    ...deployment.assetClasses ? { assetClasses: deployment.assetClasses } : {},
+    strategies: replayStrategies.map((strategy) => ({
+      strategyName: strategy.strategyName,
+      strategyRevision: strategy.strategyRevision,
+      enabled: true,
+      ...strategy.selection ? { selection: strategy.selection } : {}
+    }))
+  });
+  replayStrategies = replayStrategies.map((strategy) => ({
+    ...strategy,
+    deploymentCompositionId: researchDeploymentCompositionId
+  }));
   if (!replayStrategies.length) {
     throw new Error(`No enabled strategies in deployment ${deployment.id}`);
   }
@@ -9437,10 +10001,26 @@ var replayBacktest = async () => {
     );
   }
   const replaySelection = mergeRuntimeStrategySelections(replayStrategies);
+  const useAllData = Boolean(replayFlags.allData) && replayFlags.days == null && replayFlags.startTime == null && replayFlags.endTime == null;
+  let candleCoverage;
+  let portfolioMarketContextRows;
+  let allDataTickers;
+  if (useAllData && !replayFlags.tickers) {
+    allDataTickers = await cachedTickerSymbols({
+      connectorName: deployment.connectorName,
+      universe: [...strategyUniverses][0],
+      accountId: deployment.accountId
+    });
+    if (!allDataTickers.length) {
+      throw new Error(
+        `No cached ticker universe found for ${deployment.connectorName}. Pass --tickers explicitly or refresh the ticker cache first.`
+      );
+    }
+  }
   const preparedRun = await prepareRunEnvironment({
     connector: deployment.connectorName,
     userName: replayUserName,
-    tickers: replayFlags.tickers ?? replaySelection?.tickers?.join(",") ?? deployment.tickers?.join(","),
+    tickers: replayFlags.tickers ?? allDataTickers?.join(",") ?? replaySelection?.tickers?.join(",") ?? deployment.tickers?.join(","),
     exclude: replayFlags.exclude,
     tickersLimit: replayFlags.tickersLimit,
     showTickersList: replayFlags.showTickersList,
@@ -9460,6 +10040,45 @@ var replayBacktest = async () => {
   if (!preparedRun || isReplayUpdateOnlyRun) {
     return;
   }
+  if (useAllData) {
+    const intervalMs = (0, import_data4.intervalToMs)(replayInterval);
+    const edges = await (0, import_candles.getDataEdgesForSymbols)(
+      deployment.provider,
+      preparedRun.tickers,
+      Number(replayInterval)
+    );
+    const available = [...edges.values()].filter(
+      (edge) => Number.isFinite(edge.min) && Number.isFinite(edge.max)
+    );
+    if (!available.length) {
+      throw new Error(
+        `No cached candles found for provider=${deployment.provider}, interval=${replayInterval}`
+      );
+    }
+    const start = Math.min(...available.map((edge) => edge.min));
+    const lastClosedEnd = Math.floor(Date.now() / intervalMs) * intervalMs - 1;
+    const max = Math.min(
+      Math.max(...available.map((edge) => edge.max)),
+      lastClosedEnd
+    );
+    preparedRun.window = {
+      start,
+      end: max + intervalMs - 1,
+      source: "explicit"
+    };
+    preparedRun.preloadStart = (0, import_time7.getBacktestPreloadStart)(start);
+    candleCoverage = {
+      symbolsRequested: preparedRun.tickers.length,
+      symbolsWithData: available.length,
+      min: start,
+      max
+    };
+    console.log(
+      import_chalk13.default.gray(
+        `cached candle coverage: ${new Date(start).toISOString()} -> ${new Date(max).toISOString()} (${available.length}/${preparedRun.tickers.length} symbols)`
+      )
+    );
+  }
   setRuntimeCompareContext({
     connector: preparedRun.marketConnector,
     connectorName: preparedRun.connectorName,
@@ -9468,16 +10087,29 @@ var replayBacktest = async () => {
       end: preparedRun.window.end
     }
   });
+  const aiEnabled = replayStrategies.some(
+    ({ strategyConfig }) => Boolean(strategyConfig.AI_ENABLED)
+  );
   await prepareReplayBinanceMarketContext({
     ...preparedRun,
-    aiEnabled: replayStrategies.some(
-      ({ strategyConfig }) => Boolean(strategyConfig.AI_ENABLED)
-    ),
+    aiEnabled,
     mlEnabled: replayStrategies.some(
       ({ strategyConfig }) => Boolean(strategyConfig.ML_ENABLED)
     ),
     strategyNames: replayStrategies.map(({ strategyName }) => strategyName)
   });
+  if (replayFlags.portfolioReport && replayFlags.allData && aiEnabled) {
+    portfolioMarketContextRows = await (0, import_strategies5.preloadBinanceMarketContextForWindow)({
+      startMs: preparedRun.window.start,
+      endMs: preparedRun.window.end,
+      interval: replayMarketContextInterval()
+    });
+    console.log(
+      import_chalk13.default.gray(
+        `preloaded Binance market context: ${portfolioMarketContextRows.tradeFlowRows} trade-flow rows, ${portfolioMarketContextRows.breadthRows} breadth rows`
+      )
+    );
+  }
   console.log(import_chalk13.default.yellow(`tickers: ${preparedRun.tickers.length}`));
   console.log(
     import_chalk13.default.gray(
@@ -9485,13 +10117,54 @@ var replayBacktest = async () => {
     )
   );
   markTestsStarted();
-  const replayResult = await runHistoricalSignalsReplay({
+  const portfolioBatchSize = Number(replayFlags.portfolioBatchSize ?? 4);
+  if (replayFlags.portfolioReport && (!Number.isSafeInteger(portfolioBatchSize) || portfolioBatchSize <= 0)) {
+    throw new Error(
+      `Invalid --portfolioBatchSize: ${String(replayFlags.portfolioBatchSize)}`
+    );
+  }
+  const runtimeStrategies = replayFlags.tickers && !replayFlags.portfolioReport ? replayStrategies.map(
+    ({ selection: _selection, ...strategy }) => strategy
+  ) : replayStrategies;
+  const historicalReplayReferences = replayFlags.portfolioReport ? await loadHistoricalReplayReferences({
     preparedRun,
-    interval: replayInterval,
-    runtimeStrategies: replayFlags.tickers ? replayStrategies.map(
-      ({ selection: _selection, ...strategy }) => strategy
-    ) : replayStrategies
-  });
+    interval: replayInterval
+  }) : void 0;
+  const tickerBatches = replayFlags.portfolioReport ? Array.from(
+    { length: Math.ceil(preparedRun.tickers.length / portfolioBatchSize) },
+    (_, index) => preparedRun.tickers.slice(
+      index * portfolioBatchSize,
+      (index + 1) * portfolioBatchSize
+    )
+  ) : [preparedRun.tickers];
+  const runReplayBatch = async (batchTickers) => {
+    const result = await runHistoricalSignalsReplay({
+      preparedRun: { ...preparedRun, tickers: batchTickers },
+      interval: replayInterval,
+      runtimeStrategies,
+      references: historicalReplayReferences,
+      showProgress: !replayFlags.portfolioReport,
+      collectSkipEvidence: !replayFlags.portfolioReport,
+      collectSignals: !replayFlags.portfolioReport
+    });
+    return replayFlags.portfolioReport ? compactHistoricalReplayResultForPortfolio(result) : result;
+  };
+  const batchResults = [];
+  for (const [index, batchTickers] of tickerBatches.entries()) {
+    if (tickerBatches.length > 1) {
+      console.log(
+        import_chalk13.default.gray(
+          `portfolio batch ${index + 1}/${tickerBatches.length}: ${batchTickers.length} symbols`
+        )
+      );
+    }
+    batchResults.push(await runReplayBatch(batchTickers));
+    if (replayFlags.portfolioReport) {
+      await new Promise((resolve) => setImmediate(resolve));
+      globalThis.gc?.();
+    }
+  }
+  const replayResult = batchResults.length === 1 ? batchResults[0] : mergeHistoricalReplayResults(batchResults);
   for (const _strategy of replayResult.strategies) {
     incrementSuccessTests();
   }
@@ -9499,7 +10172,32 @@ var replayBacktest = async () => {
     replayResult,
     tickers: preparedRun.tickers,
     connectorName: preparedRun.connectorName,
-    window: preparedRun.window
+    window: preparedRun.window,
+    portfolioLineage: replayFlags.portfolioReport ? {
+      sourceDeploymentId: deployment.id,
+      sourceDeploymentCompositionId,
+      researchDeploymentCompositionId,
+      maxLossValue,
+      aiMode: "strategy runtime declaration",
+      cacheOnly: Boolean(replayFlags.cacheOnly),
+      portfolioSemantics: "production strategy order and one concurrent position per symbol; fixed-risk symbol batches are merged by canonical realized PnL",
+      portfolioBatchSize,
+      tickers: preparedRun.tickers,
+      candleCoverage: candleCoverage ?? null,
+      binanceMarketContextRows: portfolioMarketContextRows ?? null,
+      strategies: replayStrategies.map((strategy) => ({
+        strategyName: strategy.strategyName,
+        strategyRevision: strategy.strategyRevision,
+        strategyPackage: strategy.strategyPackage,
+        strategyPackageVersion: strategy.strategyPackageVersion,
+        aiEnabled: Boolean(strategy.strategyConfig.AI_ENABLED),
+        minAiQuality: strategy.strategyConfig.MIN_AI_QUALITY ?? null,
+        aiMode: strategy.strategyConfig.AI_MODE ?? null,
+        maxLossValue: strategy.strategyConfig.MAX_LOSS_VALUE ?? null,
+        selection: strategy.selection ?? null,
+        effectiveConfig: strategy.strategyConfig
+      }))
+    } : void 0
   });
 };