@tradejs/cli 3.1.29-beta.291 → 3.1.29-beta.296

package/dist/scripts/replay.js

@@ -11,9 +11,9 @@ var __export = (target, all) => {
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
   }
   return to;
 };
@@ -591,9 +591,9 @@ var loadRuntimeTrades = async (userName, {
   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)
+    (key2) => !key2.startsWith(bucketPrefix)
   );
-  const trades = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
+  const trades = await Promise.all(keys.map((key2) => (0, import_redis.getData)(key2, null)));
   return trades.filter(isRuntimeTradeRecord).filter(filterByWindow).sort((left, right) => left.entryTimestamp - right.entryTimestamp);
 };
 
@@ -1515,13 +1515,12 @@ var getReferenceSymbols = () => {
 };
 var intervalToMarketFeatureInterval = (interval) => {
   const normalized = String(interval).trim().toLowerCase();
-  if (normalized === "1" || normalized === "1m") return "1m";
+  if (normalized === "1" || normalized === "1m") return null;
   if (normalized === "5" || normalized === "5m") return "5m";
   if (normalized === "60" || normalized === "1h") return "1h";
   return "15m";
 };
 var marketIntervalToConnectorInterval = (interval) => {
-  if (interval === "1m") return "1";
   if (interval === "5m") return "5";
   if (interval === "1h") return "60";
   return "15";
@@ -1686,6 +1685,7 @@ var backfillBinanceMarketContext = async (params, enabled) => {
     return skippedBackfillResult();
   }
   const interval = intervalToMarketFeatureInterval(params.interval);
+  if (interval === null) return skippedBackfillResult();
   const intervalMs = MARKET_FEATURE_INTERVAL_MS[interval];
   const { breadthStartMs, tradeFlowStartMs, endMs } = resolveBinanceMarketContextBackfillWindow(params);
   if (endMs <= Math.min(breadthStartMs, tradeFlowStartMs)) {
@@ -1880,8 +1880,8 @@ var backfillBinanceMarketContext = async (params, enabled) => {
       })
     );
     const missingChunks = chunks.filter((chunk) => {
-      const key = `${chunk.startMs}:${chunk.endMs}`;
-      return plans.some((plan) => plan.missingChunkKeys.has(key));
+      const key2 = `${chunk.startMs}:${chunk.endMs}`;
+      return plans.some((plan) => plan.missingChunkKeys.has(key2));
     });
     const bar = new import_progress.default(
       "breadth :current/:total [:bar][:percent] :etas(s) candles=:candles skip=:skip chunk=:chunk :symbol",
@@ -2237,13 +2237,13 @@ var networkErrorCodes = /* @__PURE__ */ new Set([
   "EAI_AGAIN",
   "EHOSTUNREACH"
 ]);
-var getNestedErrorValue = (error, key) => {
+var getNestedErrorValue = (error, key2) => {
   let current = error;
   const seen = /* @__PURE__ */ new Set();
   while (current && typeof current === "object" && !seen.has(current)) {
     seen.add(current);
     const record = current;
-    const value = record[key];
+    const value = record[key2];
     if (typeof value === "string" && value.trim()) {
       return value.trim();
     }
@@ -2376,11 +2376,11 @@ var selectBestMarket = (candidates, exchangePriority) => {
 var buildMatches = (tickers, markets, exchangePriority) => {
   const marketByTicker = /* @__PURE__ */ new Map();
   for (const market of markets) {
-    const key = String(market.symbol_on_exchange || "").trim().toUpperCase();
-    if (!key) continue;
-    const list = marketByTicker.get(key) ?? [];
+    const key2 = String(market.symbol_on_exchange || "").trim().toUpperCase();
+    if (!key2) continue;
+    const list = marketByTicker.get(key2) ?? [];
     list.push(market);
-    marketByTicker.set(key, list);
+    marketByTicker.set(key2, list);
   }
   const matches = [];
   const unmatched = [];
@@ -2712,7 +2712,7 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
       while (cursor < window.toMs) {
         const toMs = Math.min(window.toMs, cursor + batchMs);
         const missingRanges = batch.map((item) => {
-          const key = coverageKey({
+          const key2 = coverageKey({
             symbol: item.symbol,
             interval,
             fromMs: cursor,
@@ -2727,7 +2727,7 @@ var backfillDerivativesContext = async (params, enabled, mode) => {
               fromMs: cursor,
               toMs,
               nowMs: coverageNowMs,
-              dataCoverageKeyExists: coverageKeys.has(key),
+              dataCoverageKeyExists: coverageKeys.has(key2),
               dataCoverageRanges: coverageRangesBySymbol.get(normalizedSymbol),
               liquidationCoverageRanges: liquidationCoverageRangesBySymbol.get(normalizedSymbol),
               edges: edgesBySymbol.get(normalizedSymbol)
@@ -3026,7 +3026,7 @@ var toIntOrNull = (value) => {
   return numeric == null ? null : Math.trunc(numeric);
 };
 var getRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
-var getNestedRecord = (value, key) => getRecord(value[key]);
+var getNestedRecord = (value, key2) => getRecord(value[key2]);
 var safeDivide2 = (numerator, denominator) => numerator != null && denominator != null && denominator > 0 ? numerator / denominator : null;
 var sumFinite = (values) => values.reduce((sum, value) => sum + (value ?? 0), 0);
 var toExchangeLiquidityRegime = ({
@@ -3133,7 +3133,7 @@ var coverageRowsToKeySet = (rows) => new Set(
 );
 var hasBackfillCoverage = (coverageKeys, params) => coverageKeys.has(coverageKey2(params));
 var hasRecentBackfillCoverage = (rows, params) => {
-  const key = coverageKey2(params);
+  const key2 = coverageKey2(params);
   return rows.some((row) => {
     if (!isMarketContextBackfillCoverageDataBearing(row)) return false;
     if (coverageKey2({
@@ -3142,7 +3142,7 @@ var hasRecentBackfillCoverage = (rows, params) => {
       interval: row.interval,
       fromMs: row.fromMs,
       toMs: row.toMs
-    }) !== key) {
+    }) !== key2) {
       return false;
     }
     const checkedAtMs = Number(row.checkedAtMs);
@@ -3179,27 +3179,27 @@ var createCoinMarketCapFetchStats = () => ({
   totalCredits: 0,
   byPath: /* @__PURE__ */ new Map()
 });
-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) => {
+var getCoinMarketCapPathLabel = (path9) => {
+  if (path9.includes("global-metrics")) return "global";
+  if (path9.includes("cryptocurrency/quotes")) return "reference";
+  if (path9.includes("exchange/quotes")) return "exchangeLiquidity";
+  if (path9.includes("fear-and-greed")) return "fearGreed";
+  if (path9.includes("cmc100")) return "cmc100";
+  if (path9.includes("cmc20")) return "cmc20";
+  return path9;
+};
+var recordCoinMarketCapFetchStats = (stats, path9, creditCount) => {
   if (!stats) return;
-  const existing = stats.byPath.get(path7) ?? { requests: 0, credits: 0 };
+  const existing = stats.byPath.get(path9) ?? { requests: 0, credits: 0 };
   existing.requests += 1;
   existing.credits += creditCount ?? 0;
   stats.requests += 1;
   stats.totalCredits += creditCount ?? 0;
-  stats.byPath.set(path7, existing);
+  stats.byPath.set(path9, existing);
 };
 var formatCoinMarketCapFetchStats = (stats) => {
   const byPath = [...stats.byPath.entries()].map(
-    ([path7, item]) => `${getCoinMarketCapPathLabel(path7)}=${item.requests}req/${item.credits}cr`
+    ([path9, item]) => `${getCoinMarketCapPathLabel(path9)}=${item.requests}req/${item.credits}cr`
   ).join(" ");
   return `apiRequests=${stats.requests} apiCredits=${stats.totalCredits}${byPath ? ` ${byPath}` : ""}`;
 };
@@ -3221,8 +3221,8 @@ var logBackfillSourceDone = (params) => {
 var markBackfillCoverage = (rows) => (0, import_marketContext2.upsertMarketContextBackfillCoverage)(rows);
 var coinMarketCapFetch = async (params) => {
   const url = new URL(`${getBaseUrl()}${params.path}`);
-  for (const [key, value] of Object.entries(params.searchParams)) {
-    url.searchParams.set(key, value);
+  for (const [key2, value] of Object.entries(params.searchParams)) {
+    url.searchParams.set(key2, value);
   }
   for (let attempt = 0; attempt <= getMaxRetries(); attempt += 1) {
     const waitMs = Math.max(
@@ -3266,7 +3266,7 @@ var coinMarketCapFetch = async (params) => {
 };
 var fetchCoinMarketCapIndexRows = async (params) => {
   const rows = [];
-  const maxChunkDays = 9;
+  const maxChunkDays = 4;
   const totalChunks = Math.max(
     1,
     Math.ceil(
@@ -3403,10 +3403,10 @@ var coinMarketCapExchangeQuotesPayloadToLiquidityRows = (payload, interval = "1d
       const ts = typeof tsRaw === "string" ? new Date(tsRaw) : null;
       if (!ts || Number.isNaN(ts.getTime())) continue;
       const volumeUsd = toFiniteNumberOrNull(usd.volume_24h) ?? toFiniteNumberOrNull(usd.volume_24h_adjusted) ?? toFiniteNumberOrNull(usd.spot_volume_usd) ?? toFiniteNumberOrNull(usd.reported_volume_24h);
-      const key = ts.getTime();
-      const rows = rowsByTs.get(key) ?? [];
+      const key2 = ts.getTime();
+      const rows = rowsByTs.get(key2) ?? [];
       rows.push({ slug, name, volumeUsd });
-      rowsByTs.set(key, rows);
+      rowsByTs.set(key2, rows);
     }
   }
   return [...rowsByTs.entries()].sort(([left], [right]) => left - right).map(([ts, exchanges]) => {
@@ -4809,6 +4809,10 @@ import_args.default.option(
   "Write aggregate portfolio metrics and SVG charts; skip runtime/exchange comparison",
   false
 );
+import_args.default.option(
+  "portfolioCompareTo",
+  "Compare a full shared replay with a prior portfolio report JSON"
+);
 import_args.default.option(
   ["B", "portfolioBatchSize"],
   "Maximum number of symbols held in memory by one portfolio replay batch",
@@ -4854,7 +4858,7 @@ var normalizeForStableJson = (value) => {
   }
   if (value && typeof value === "object") {
     return Object.fromEntries(
-      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, normalizeForStableJson(entry)])
+      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key2, entry]) => [key2, normalizeForStableJson(entry)])
     );
   }
   return value;
@@ -5012,9 +5016,9 @@ var buildRuntimeEvidenceLineageScopes = ({
     if (!lineage || !Number.isFinite(timestamp)) {
       return;
     }
-    const key = `${deploymentId ?? "default"}::${accountId ?? "default"}::${strategy}::${symbol}::${runtimeLineageKey(lineage)}`;
-    const existing = scopes.get(key);
-    scopes.set(key, {
+    const key2 = `${deploymentId ?? "default"}::${accountId ?? "default"}::${strategy}::${symbol}::${runtimeLineageKey(lineage)}`;
+    const existing = scopes.get(key2);
+    scopes.set(key2, {
       strategy,
       symbol,
       ...deploymentId ? { deploymentId } : {},
@@ -5177,12 +5181,13 @@ var getPositionPnlSnapshot = ({
     direction: position.direction
   };
 };
-var createPortfolioReplayConnector = (connector) => {
+var createPortfolioReplayConnector = (connector, observeEquity = false) => {
   let state = {};
   let amount = import_constants3.INITIAL_BACKTEST_AMOUNT;
   let executionTimestamp = null;
   const positionsBySymbol = /* @__PURE__ */ new Map();
   const currentPriceBySymbol = /* @__PURE__ */ new Map();
+  const equityMarks = observeEquity ? /* @__PURE__ */ new Map() : void 0;
   const markedAtBySymbol = /* @__PURE__ */ new Map();
   const entryFacts = /* @__PURE__ */ new Map();
   let portfolioObserved = false;
@@ -5603,11 +5608,25 @@ var createPortfolioReplayConnector = (connector) => {
     advanceMarket: async ({ symbol, candle }) => {
       executionTimestamp = candle.timestamp;
       markedAtBySymbol.set(symbol, candle.timestamp);
+      equityMarks?.set(symbol, candle.close);
       currentPriceBySymbol.set(symbol, candle.close);
       await checkSl({ symbol, candle });
       await checkTp({ symbol, candle });
       currentPriceBySymbol.set(symbol, candle.close);
     },
+    getMarkedEquity: () => {
+      if (!equityMarks) return null;
+      let equity = amount - import_constants3.INITIAL_BACKTEST_AMOUNT;
+      for (const { position } of positionsBySymbol.values()) {
+        const mark = equityMarks.get(position.symbol);
+        if (mark == null || !Number.isFinite(mark)) return null;
+        equity += getPositionPnlSnapshot({
+          position,
+          currentPrice: mark
+        }).unrealizedPnl;
+      }
+      return (0, import_math.round)(equity);
+    },
     getReplayArtifacts: () => ({
       orderLog,
       positionLog,
@@ -5821,6 +5840,21 @@ var executeHistoricalReplay = async (context, adapters) => {
     context.collectSkipEvidence
   );
   const decisionTrace = createReplayDecisionTrace(context.decisionTraceTargets);
+  const portfolioDiagnostics = context.collectPortfolioDiagnostics ? { markedMaxDrawdown: 0, unpricedCycles: 0, admissions: [] } : void 0;
+  let equityPeak = 0;
+  const observeEquity = () => {
+    if (!portfolioDiagnostics) return;
+    const equity = context.connector.getMarkedEquity();
+    if (equity === null) {
+      portfolioDiagnostics.unpricedCycles++;
+      return;
+    }
+    equityPeak = Math.max(equityPeak, equity);
+    portfolioDiagnostics.markedMaxDrawdown = Math.max(
+      portfolioDiagnostics.markedMaxDrawdown ?? 0,
+      equityPeak - equity
+    );
+  };
   const reportProgress = (timestamp) => {
     if (adapters.progress.enabled === false) return;
     adapters.progress.tick({
@@ -5864,6 +5898,7 @@ var executeHistoricalReplay = async (context, adapters) => {
           }
         }
         advanceAbortedCycle(cycleSymbols, timestamp);
+        observeEquity();
         reportProgress(timestamp);
         continue;
       }
@@ -5907,6 +5942,21 @@ var executeHistoricalReplay = async (context, adapters) => {
             result
           });
           if (result && typeof result !== "string") {
+            if (portfolioDiagnostics) {
+              const status = result.orderFailureReason === "PORTFOLIO_POSITION_LIMIT" ? "capacity-rejected" : result.orderStatus === "completed" ? "filled" : void 0;
+              if (status)
+                portfolioDiagnostics.admissions.push({
+                  strategy: strategyRuntime.strategyName,
+                  status,
+                  key: JSON.stringify([
+                    strategyRuntime.strategyName,
+                    result.symbol,
+                    result.direction,
+                    result.timestamp,
+                    result.signalId
+                  ])
+                });
+            }
             result.runtimeLineage = strategyRuntime.runtimeLineage;
             await adapters.enrichSignal(result);
             cycleSignals.push(result);
@@ -5921,12 +5971,16 @@ var executeHistoricalReplay = async (context, adapters) => {
         status: "completed",
         durationMs: adapters.clock.now() - cycleStartedAt
       });
+      observeEquity();
       reportProgress(timestamp);
     }
   } finally {
     releaseHistoricalReplayCaches(context.plan, adapters);
   }
+  if (portfolioDiagnostics?.unpricedCycles)
+    portfolioDiagnostics.markedMaxDrawdown = null;
   return {
+    ...portfolioDiagnostics ? { portfolioDiagnostics } : {},
     signals,
     abortedCycles,
     replayLineageScopes: skipEvidence.values(),
@@ -5982,6 +6036,7 @@ var collectHistoricalReplayResult = (context) => ({
   abortedCycles: context.abortedCycles,
   runtimeLineages: context.runtimeLineages,
   replayLineageScopes: context.replayLineageScopes,
+  ...context.portfolioDiagnostics ? { portfolioDiagnostics: context.portfolioDiagnostics } : {},
   ...context.replayDecisionTraces?.length ? { replayDecisionTraces: context.replayDecisionTraces } : {}
 });
 var compactHistoricalReplayResultForPortfolio = (result) => ({
@@ -6183,6 +6238,7 @@ var runHistoricalSignalsReplay = async ({
   showProgress = true,
   collectSkipEvidence = true,
   collectSignals = true,
+  collectPortfolioDiagnostics = false,
   decisionTraceTargets
 }) => {
   const memory = createReplayMemoryProfile();
@@ -6192,7 +6248,8 @@ var runHistoricalSignalsReplay = async ({
   const projectHooks = projectConfig.hooks;
   const loadedStrategies = await loadRuntimeStrategies(runtimeStrategies);
   const replayConnector = createPortfolioReplayConnector(
-    preparedRun.marketConnector
+    preparedRun.marketConnector,
+    collectPortfolioDiagnostics
   );
   const connectorName = getConnectorName(preparedRun.marketConnector);
   const referenceData = references ?? await loadHistoricalReplayReferences({ preparedRun, interval });
@@ -6270,6 +6327,7 @@ var runHistoricalSignalsReplay = async ({
       connector: replayConnector,
       collectSkipEvidence,
       collectSignals,
+      collectPortfolioDiagnostics,
       decisionTraceTargets,
       hooks: projectHooks,
       hookContext
@@ -6308,7 +6366,8 @@ var runHistoricalSignalsReplay = async ({
     abortedCycles: execution.abortedCycles,
     runtimeLineages: plan.runtimeLineages,
     replayLineageScopes: execution.replayLineageScopes,
-    replayDecisionTraces: execution.replayDecisionTraces
+    replayDecisionTraces: execution.replayDecisionTraces,
+    portfolioDiagnostics: execution.portfolioDiagnostics
   });
   memory?.("result:collected");
   return result;
@@ -6555,16 +6614,16 @@ var findRuntimeDuplicateGroups = (entries) => {
     if (entry.source !== "runtime") {
       continue;
     }
-    const key = toRuntimeDuplicateKey(entry);
-    const bucket = groups.get(key) ?? [];
+    const key2 = toRuntimeDuplicateKey(entry);
+    const bucket = groups.get(key2) ?? [];
     bucket.push(entry);
-    groups.set(key, bucket);
+    groups.set(key2, bucket);
   }
-  return [...groups.entries()].filter(([, group]) => group.length > 1).map(([key, group]) => {
+  return [...groups.entries()].filter(([, group]) => group.length > 1).map(([key2, group]) => {
     const sortedGroup = [...group].sort(sortTradeParityEntries);
     const first = sortedGroup[0];
     return {
-      key,
+      key: key2,
       strategy: first.strategy,
       symbol: first.symbol,
       direction: first.direction,
@@ -6603,26 +6662,26 @@ var compareTradeParityEntries = ({
   const groupedRuntime = /* @__PURE__ */ new Map();
   const groupedBacktest = /* @__PURE__ */ new Map();
   for (const entry of runtimeEntries) {
-    const key = toGroupKey(entry);
-    const bucket = groupedRuntime.get(key) ?? [];
+    const key2 = toGroupKey(entry);
+    const bucket = groupedRuntime.get(key2) ?? [];
     bucket.push(entry);
-    groupedRuntime.set(key, bucket);
+    groupedRuntime.set(key2, bucket);
   }
   for (const entry of backtestEntries) {
-    const key = toGroupKey(entry);
-    const bucket = groupedBacktest.get(key) ?? [];
+    const key2 = toGroupKey(entry);
+    const bucket = groupedBacktest.get(key2) ?? [];
     bucket.push(entry);
-    groupedBacktest.set(key, bucket);
+    groupedBacktest.set(key2, bucket);
   }
   const groupKeys = /* @__PURE__ */ new Set([
     ...groupedRuntime.keys(),
     ...groupedBacktest.keys()
   ]);
-  for (const key of groupKeys) {
-    const runtimeGroup = [...groupedRuntime.get(key) ?? []].sort(
+  for (const key2 of groupKeys) {
+    const runtimeGroup = [...groupedRuntime.get(key2) ?? []].sort(
       (left, right) => left.timestamp - right.timestamp
     );
-    const backtestGroup = [...groupedBacktest.get(key) ?? []].sort(
+    const backtestGroup = [...groupedBacktest.get(key2) ?? []].sort(
       (left, right) => left.timestamp - right.timestamp
     );
     const unmatchedBacktest = backtestGroup.map((entry) => ({
@@ -6863,8 +6922,8 @@ var filterBucketKeysByWindow = (bucketKeys, prefix, startTime, endTime) => {
   if (!allowedDayKeys.size) {
     return [];
   }
-  return bucketKeys.filter((key) => {
-    const suffix = key.slice(prefix.length);
+  return bucketKeys.filter((key2) => {
+    const suffix = key2.slice(prefix.length);
     const firstColon = suffix.indexOf(":");
     if (firstColon <= 0) {
       return false;
@@ -6883,7 +6942,7 @@ var loadRuntimeSignals = async (userName, {
     startTime,
     endTime
   );
-  const refs = (await Promise.all(bucketKeys.map((key) => (0, import_redis4.getHashJsonValues)(key)))).flat().filter(isRuntimeSignalBucketRef);
+  const refs = (await Promise.all(bucketKeys.map((key2) => (0, import_redis4.getHashJsonValues)(key2)))).flat().filter(isRuntimeSignalBucketRef);
   const seen = /* @__PURE__ */ new Set();
   const payloads = await Promise.all(
     refs.map(async (ref) => {
@@ -6912,7 +6971,7 @@ var loadRuntimeSignalEvaluations = async (userName, {
     startTime,
     endTime
   );
-  const evaluations = (await Promise.all(bucketKeys.map((key) => (0, import_redis4.getHashJsonValues)(key)))).flat().filter(isRuntimeSignalEvaluationRecord);
+  const evaluations = (await Promise.all(bucketKeys.map((key2) => (0, import_redis4.getHashJsonValues)(key2)))).flat().filter(isRuntimeSignalEvaluationRecord);
   const deduped = /* @__PURE__ */ new Map();
   for (const evaluation of evaluations) {
     deduped.set(evaluation.evaluationId, evaluation);
@@ -7082,10 +7141,10 @@ var syncRuntimeTrades = async ({
     )
   ];
   await Promise.all(
-    activeTradeKeys.map(async (key) => {
-      const activeRef = await (0, import_redis5.getData)(key, null);
+    activeTradeKeys.map(async (key2) => {
+      const activeRef = await (0, import_redis5.getData)(key2, null);
       activeOrderIdByKey.set(
-        key,
+        key2,
         typeof activeRef?.orderId === "string" ? activeRef.orderId : null
       );
     })
@@ -8152,9 +8211,9 @@ var filterReplayComparisonByLineage = ({
   );
   const deploymentWindows = /* @__PURE__ */ new Map();
   for (const scope of comparableRuntimeLineageScopes) {
-    const key = lineageScopeKey(scope);
-    const existing = deploymentWindows.get(key);
-    deploymentWindows.set(key, {
+    const key2 = lineageScopeKey(scope);
+    const existing = deploymentWindows.get(key2);
+    deploymentWindows.set(key2, {
       firstTimestamp: existing == null ? scope.firstTimestamp : Math.min(existing.firstTimestamp, scope.firstTimestamp),
       lastTimestamp: existing == null ? scope.lastTimestamp : Math.max(existing.lastTimestamp, scope.lastTimestamp)
     });
@@ -8190,9 +8249,9 @@ var filterReplayComparisonByLineage = ({
     ...comparableRuntimeSignals,
     ...comparableRuntimeEvaluations
   ]) {
-    const key = lineageScopeKey(artifact);
-    const existing = deploymentWindows.get(key);
-    deploymentWindows.set(key, {
+    const key2 = lineageScopeKey(artifact);
+    const existing = deploymentWindows.get(key2);
+    deploymentWindows.set(key2, {
       firstTimestamp: existing == null ? artifact.timestamp : Math.min(existing.firstTimestamp, artifact.timestamp),
       lastTimestamp: existing == null ? artifact.timestamp : Math.max(existing.lastTimestamp, artifact.timestamp)
     });
@@ -8277,16 +8336,16 @@ var compareExchangeEntriesToBacktest = ({
   const groupedExchange = /* @__PURE__ */ new Map();
   const groupedBacktest = /* @__PURE__ */ new Map();
   for (const entry of exchangeEntries) {
-    const key = `${entry.symbol}::${entry.direction}`;
-    const bucket = groupedExchange.get(key) ?? [];
+    const key2 = `${entry.symbol}::${entry.direction}`;
+    const bucket = groupedExchange.get(key2) ?? [];
     bucket.push(entry);
-    groupedExchange.set(key, bucket);
+    groupedExchange.set(key2, bucket);
   }
   for (const entry of backtestEntries) {
-    const key = `${entry.symbol}::${entry.direction}`;
-    const bucket = groupedBacktest.get(key) ?? [];
+    const key2 = `${entry.symbol}::${entry.direction}`;
+    const bucket = groupedBacktest.get(key2) ?? [];
     bucket.push(entry);
-    groupedBacktest.set(key, bucket);
+    groupedBacktest.set(key2, bucket);
   }
   const matched = [];
   const exchangeOnly = [];
@@ -8296,11 +8355,11 @@ var compareExchangeEntriesToBacktest = ({
     ...groupedExchange.keys(),
     ...groupedBacktest.keys()
   ]);
-  for (const key of groupKeys) {
-    const exchangeGroup = [...groupedExchange.get(key) ?? []].sort(
+  for (const key2 of groupKeys) {
+    const exchangeGroup = [...groupedExchange.get(key2) ?? []].sort(
       (left, right) => left.entryTimestamp - right.entryTimestamp
     );
-    const unmatchedBacktest = [...groupedBacktest.get(key) ?? []].sort((left, right) => left.timestamp - right.timestamp).map((entry) => ({ entry, used: false }));
+    const unmatchedBacktest = [...groupedBacktest.get(key2) ?? []].sort((left, right) => left.timestamp - right.timestamp).map((entry) => ({ entry, used: false }));
     for (const exchangeEntry of exchangeGroup) {
       let bestIndex = -1;
       let bestDiff = Number.POSITIVE_INFINITY;
@@ -8721,14 +8780,14 @@ var mergeExchangeEntryExecutions = (rows) => {
   const mergedRows = [];
   const groups = /* @__PURE__ */ new Map();
   for (const row of rows) {
-    const key = getExchangeExecutionMergeKey(row);
-    if (!key) {
+    const key2 = getExchangeExecutionMergeKey(row);
+    if (!key2) {
       mergedRows.push(row);
       continue;
     }
-    const group = groups.get(key) ?? [];
+    const group = groups.get(key2) ?? [];
     group.push(row);
-    groups.set(key, group);
+    groups.set(key2, group);
   }
   for (const group of groups.values()) {
     mergedRows.push(
@@ -9219,13 +9278,13 @@ function* jsonParts(value, ancestors = /* @__PURE__ */ new Set()) {
         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);
+      for (const key2 of Object.keys(value)) {
+        const field = Reflect.get(value, key2);
         if (field === void 0 || typeof field === "function" || typeof field === "symbol")
           continue;
         if (!first) yield ",";
         first = false;
-        yield JSON.stringify(key) + ":";
+        yield JSON.stringify(key2) + ":";
         yield* jsonParts(field, ancestors);
       }
       yield "}";
@@ -9687,10 +9746,276 @@ var writeReplayOutputReport = async ({
 };
 
 // src/lib/replay/portfolioReport.ts
+var import_promises5 = __toESM(require("fs/promises"));
+var import_node_path8 = __toESM(require("path"));
+var import_node_crypto6 = require("crypto");
+
+// src/lib/replay/portfolioComparison.ts
+var import_node_crypto5 = require("crypto");
+
+// src/lib/coreResearch/io.ts
+var import_node_crypto3 = require("crypto");
+var import_node_fs4 = require("fs");
 var import_promises4 = __toESM(require("fs/promises"));
+var import_backtest2 = require("@tradejs/core/backtest");
+var import_node_path7 = __toESM(require("path"));
+
+// src/lib/coreResearch/trace.ts
+var import_node_fs3 = require("fs");
+var import_node_readline = __toESM(require("readline"));
 var import_node_path6 = __toESM(require("path"));
-var import_node_crypto3 = require("crypto");
-var DAY_MS4 = 864e5;
+
+// src/lib/coreResearch/io.ts
+var canonicalJson = (value) => {
+  const normalize = (current) => {
+    if (Array.isArray(current)) return current.map(normalize);
+    if (current && typeof current === "object") {
+      return Object.fromEntries(
+        Object.entries(current).filter(([, entry]) => entry !== void 0).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([key2, entry]) => [key2, normalize(entry)])
+      );
+    }
+    return current;
+  };
+  return JSON.stringify(normalize(value));
+};
+
+// src/lib/coreResearch/statistics.ts
+var import_node_crypto4 = require("crypto");
+
+// src/lib/coreResearch/metrics.ts
+var DAY_MS4 = 24 * 60 * 60 * 1e3;
+
+// src/lib/coreResearch/statistics.ts
+var createSeededRandom = (seedText) => {
+  const digest = (0, import_node_crypto4.createHash)("sha256").update(seedText).digest();
+  let state = digest.readUInt32LE(0) || 1;
+  return () => {
+    state ^= state << 13;
+    state ^= state >>> 17;
+    state ^= state << 5;
+    return (state >>> 0) / 4294967296;
+  };
+};
+var percentile = (sorted, probability) => {
+  if (!sorted.length) return Number.NaN;
+  const index = Math.min(
+    sorted.length - 1,
+    Math.max(0, Math.floor(probability * sorted.length))
+  );
+  return sorted[index];
+};
+var calendarClusterBootstrap = (params) => {
+  const clusterMs = params.clusterDays * DAY_MS4;
+  const buckets = /* @__PURE__ */ new Map();
+  if (params.start != null && params.end != null && params.end > params.start) {
+    const first = Math.floor(params.start / clusterMs);
+    const last = Math.ceil(params.end / clusterMs);
+    for (let bucket = first; bucket < last; bucket += 1) {
+      buckets.set(bucket, { control: 0, candidate: 0 });
+    }
+  }
+  const add = (trades, field) => {
+    for (const trade of trades) {
+      const bucket = Math.floor(trade.exitTimestamp / clusterMs);
+      const current = buckets.get(bucket) ?? { control: 0, candidate: 0 };
+      current[field] += trade.netProfit;
+      buckets.set(bucket, current);
+    }
+  };
+  add(params.control, "control");
+  add(params.candidate, "candidate");
+  const deltas = [...buckets.entries()].sort(([left], [right]) => left - right).map(([, value]) => value.candidate - value.control);
+  if (!deltas.length) {
+    return {
+      method: "calendar-cluster-bootstrap",
+      clusterDays: params.clusterDays,
+      iterations: params.iterations,
+      confidenceLevel: params.confidenceLevel,
+      observedMeanPnlDelta: null,
+      confidenceInterval: null,
+      probabilityPositive: null,
+      oneSidedPValue: null,
+      holmAdjustedPValue: null
+    };
+  }
+  const random = createSeededRandom(params.seed);
+  const samples = [];
+  for (let iteration = 0; iteration < params.iterations; iteration += 1) {
+    let sum = 0;
+    for (let index = 0; index < deltas.length; index += 1) {
+      sum += deltas[Math.floor(random() * deltas.length)];
+    }
+    samples.push(sum / deltas.length);
+  }
+  samples.sort((left, right) => left - right);
+  const alpha = 1 - params.confidenceLevel;
+  const positive = samples.filter((value) => value > 0).length;
+  const probabilityPositive = positive / samples.length;
+  const observed = deltas.reduce((sum, value) => sum + value, 0) / deltas.length;
+  const oneSidedPValue = (1 + samples.filter((value) => value - observed >= observed - 1e-12).length) / (samples.length + 1);
+  return {
+    method: "calendar-cluster-bootstrap",
+    clusterDays: params.clusterDays,
+    iterations: params.iterations,
+    confidenceLevel: params.confidenceLevel,
+    observedMeanPnlDelta: deltas.reduce((sum, value) => sum + value, 0) / deltas.length,
+    confidenceInterval: [
+      percentile(samples, alpha / 2),
+      percentile(samples, 1 - alpha / 2)
+    ],
+    probabilityPositive,
+    oneSidedPValue,
+    holmAdjustedPValue: null
+  };
+};
+
+// src/lib/replay/portfolioComparison.ts
+var key = (value) => canonicalJson(value);
+function longestRecovery(points) {
+  let start;
+  let lastPeak;
+  let longestMs = 0;
+  for (const point of points) {
+    if (point.value === 0) {
+      if (start !== void 0)
+        longestMs = Math.max(longestMs, point.timestamp - start);
+      start = void 0;
+      lastPeak = point.timestamp;
+    } else if (start === void 0) start = lastPeak ?? point.timestamp;
+  }
+  return { longestCompletedMs: longestMs, unresolvedSince: start ?? null };
+}
+function compareCapacityAdmissions(before, after, changed) {
+  const count = (filled, rejected) => {
+    const keys = new Set(
+      filled.admissions.filter(
+        (event) => event.strategy !== changed && event.status === "filled"
+      ).map((event) => event.key)
+    );
+    return new Set(
+      rejected.admissions.filter(
+        (event) => event.status === "capacity-rejected" && keys.has(event.key)
+      ).map((event) => event.key)
+    ).size;
+  };
+  return { displaced: count(before, after), restored: count(after, before) };
+}
+function comparePortfolioReports(input, candidate) {
+  if (!input || typeof input !== "object" || !("checksum" in input)) {
+    throw new Error("Expected a checksum-bound portfolio report");
+  }
+  const { checksum, ...payload } = input;
+  if (checksum !== (0, import_node_crypto5.createHash)("sha256").update(JSON.stringify(payload)).digest("hex") || payload.schema !== "tradejs-portfolio-backtest/v1") {
+    throw new Error("Control portfolio report checksum or schema mismatch");
+  }
+  const control = payload;
+  if (control.lineage?.batchCount !== 1 || candidate.lineage.batchCount !== 1 || control.lineage.cacheOnly !== true || candidate.lineage.cacheOnly !== true) {
+    throw new Error(
+      "Portfolio comparison requires two cache-only reports from a single shared batch"
+    );
+  }
+  for (const field of [
+    "connector",
+    "interval",
+    "tickers",
+    "candleCoverage",
+    "binanceMarketContextRows",
+    "maxLossValue"
+  ]) {
+    if (candidate.lineage[field] === void 0 || key(control.lineage[field]) !== key(candidate.lineage[field])) {
+      throw new Error(`Portfolio comparison scope mismatch: ${field}`);
+    }
+  }
+  if (key(control.window) !== key(candidate.window))
+    throw new Error("Portfolio comparison window mismatch");
+  const before = control.lineage.strategies;
+  const after = candidate.lineage.strategies;
+  if (!Array.isArray(before) || !Array.isArray(after) || key(before.map((s) => s.strategyName)) !== key(after.map((s) => s.strategyName))) {
+    throw new Error(
+      "Portfolio comparison requires the same ordered strategies"
+    );
+  }
+  const changed = after.filter((s, index) => key(s) !== key(before[index]));
+  if (changed.length > 1)
+    throw new Error(
+      "Portfolio comparison allows at most one strategy replacement"
+    );
+  if (after.some(
+    (s, index) => s.maxLossValue !== before[index].maxLossValue || key(s.effectiveConfig.PORTFOLIO_POLICY) !== key(before[index].effectiveConfig.PORTFOLIO_POLICY)
+  )) {
+    throw new Error(
+      "Portfolio comparison requires unchanged risk and portfolio policies"
+    );
+  }
+  const all = (report) => {
+    const row = report.metrics.portfolio.find(
+      (r) => r.window === "full" && r.cohort === "ALL"
+    );
+    if (!row) throw new Error("Missing full ALL portfolio metrics");
+    return row;
+  };
+  const a = all(control), b = all(candidate);
+  const toPnl = (report) => report.trades.map((trade) => ({
+    exitTimestamp: trade.exitedAt,
+    netProfit: trade.pnl
+  }));
+  const strategyDelta = candidate.metrics.strategies.filter((row) => row.window === "full").map((row) => {
+    const previous = control.metrics.strategies.find(
+      (r) => r.window === row.window && r.scope === row.scope && r.cohort === row.cohort
+    );
+    return {
+      strategy: row.scope,
+      cohort: row.cohort,
+      trades: previous ? row.n - previous.n : null,
+      pnl: previous ? row.pnl - previous.pnl : null
+    };
+  });
+  const markBefore = control.portfolioDiagnostics?.markedMaxDrawdown ?? null;
+  const markAfter = candidate.portfolioDiagnostics?.markedMaxDrawdown ?? null;
+  const displacement = control.portfolioDiagnostics && candidate.portfolioDiagnostics ? compareCapacityAdmissions(
+    control.portfolioDiagnostics,
+    candidate.portfolioDiagnostics,
+    changed[0]?.strategyName
+  ) : null;
+  return {
+    controlChecksum: checksum,
+    markedDrawdown: {
+      control: markBefore,
+      candidate: markAfter,
+      delta: markBefore === null || markAfter === null ? null : markAfter - markBefore
+    },
+    capacityDisplacement: displacement,
+    changedStrategy: changed[0]?.strategyName ?? null,
+    delta: {
+      pnl: b.pnl - a.pnl,
+      trades: b.n - a.n,
+      realizedMaxDrawdown: b.realizedMaxDrawdown - a.realizedMaxDrawdown
+    },
+    recovery: {
+      control: longestRecovery(control.curves.portfolioDrawdown),
+      candidate: longestRecovery(candidate.curves.portfolioDrawdown)
+    },
+    strategyDelta,
+    bootstrap: calendarClusterBootstrap({
+      control: toPnl(control),
+      candidate: toPnl(candidate),
+      clusterDays: 7,
+      iterations: 1e3,
+      confidenceLevel: 0.95,
+      seed: String(checksum),
+      start: candidate.window.start,
+      end: candidate.window.end
+    }),
+    limitations: [
+      "Scope and recorded coverage match. Report lineage does not prove equality of every historical source byte.",
+      "Marked drawdown uses last observed candle closes at replay cycle boundaries. It does not measure intra-candle excursions.",
+      "Capacity displacement counts only identical signals of unchanged strategies filled in one run and explicitly rejected by the position cap in the other."
+    ]
+  };
+}
+
+// src/lib/replay/portfolioReport.ts
+var DAY_MS5 = 864e5;
 var WINDOWS = [365, 180, 90, 30, 7];
 var COLORS = [
   "#2563eb",
@@ -9770,7 +10095,7 @@ var calculatePortfolioMetricRow = ({
   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);
+  const days = Math.max(1, (end - start) / DAY_MS5);
   return {
     window,
     scope,
@@ -9790,7 +10115,7 @@ var windowBounds = (start, end) => [
   { label: "full", start, end },
   ...WINDOWS.map((days) => ({
     label: `${days}d`,
-    start: Math.max(start, end - days * DAY_MS4),
+    start: Math.max(start, end - days * DAY_MS5),
     end
   }))
 ];
@@ -9865,10 +10190,11 @@ var writePortfolioReport = async ({
   replayResult,
   window,
   lineage,
-  command
+  command,
+  compareTo
 }) => {
-  const outputDir = import_node_path6.default.resolve(projectRoot, "data/replay/output");
-  await import_promises4.default.mkdir(outputDir, { recursive: true });
+  const outputDir = import_node_path8.default.resolve(projectRoot, "data/replay/output");
+  await import_promises5.default.mkdir(outputDir, { recursive: true });
   const trades = replayResult.strategies.flatMap(
     (strategy) => tradesFromPositionLog(strategy.strategyName, strategy.positionLog)
   );
@@ -9940,13 +10266,13 @@ var writePortfolioReport = async ({
   });
   const prefix = `${timestamp}-portfolio-backtest`;
   const paths = {
-    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`)
+    markdown: import_node_path8.default.join(outputDir, `${prefix}.md`),
+    json: import_node_path8.default.join(outputDir, `${prefix}.json`),
+    equitySvg: import_node_path8.default.join(outputDir, `${prefix}-equity.svg`),
+    drawdownSvg: import_node_path8.default.join(outputDir, `${prefix}-drawdown.svg`),
+    html: import_node_path8.default.join(outputDir, `${prefix}.html`)
   };
-  const report = {
+  const baseReport = {
     schema: "tradejs-portfolio-backtest/v1",
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     command,
@@ -9968,9 +10294,17 @@ var writePortfolioReport = async ({
       portfolioDrawdown: drawdownCurve(portfolioEquity),
       strategies: strategySeries.map(({ name, points }) => ({ name, points }))
     },
-    trades
+    trades,
+    ...replayResult.portfolioDiagnostics ? { portfolioDiagnostics: replayResult.portfolioDiagnostics } : {}
   };
-  const checksum = (0, import_node_crypto3.createHash)("sha256").update(JSON.stringify(report)).digest("hex");
+  const comparison = compareTo ? comparePortfolioReports(
+    JSON.parse(
+      await import_promises5.default.readFile(import_node_path8.default.resolve(projectRoot, compareTo), "utf8")
+    ),
+    baseReport
+  ) : void 0;
+  const report = { ...baseReport, ...comparison ? { comparison } : {} };
+  const checksum = (0, import_node_crypto6.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
 
@@ -9982,9 +10316,9 @@ var writePortfolioReport = async ({
 - Report checksum: \`${checksum}\`
 - Command: \`${command}\`
 
-![Strategy PnL overlay](./${import_node_path6.default.basename(paths.equitySvg)})
+![Strategy PnL overlay](./${import_node_path8.default.basename(paths.equitySvg)})
 
-![Portfolio drawdown](./${import_node_path6.default.basename(paths.drawdownSvg)})
+![Portfolio drawdown](./${import_node_path8.default.basename(paths.drawdownSvg)})
 
 ## Portfolio metrics
 
@@ -9995,17 +10329,33 @@ ${markdownTable(portfolioRows)}
 ${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>`;
+  const comparisonMarkdown = comparison ? `
+## Paired portfolio comparison
+
+- Net PnL delta: ${display(comparison.delta.pnl)}
+- Closed trades delta: ${comparison.delta.trades}
+- Realized MaxDD delta: ${display(comparison.delta.realizedMaxDrawdown)}
+
+${comparison.limitations.join(" ")}
+` : "";
   await Promise.all([
-    import_promises4.default.writeFile(paths.markdown, markdown, "utf8"),
-    import_promises4.default.writeFile(
+    import_promises5.default.writeFile(paths.markdown, markdown + comparisonMarkdown, "utf8"),
+    import_promises5.default.writeFile(
       paths.json,
       `${JSON.stringify({ ...report, checksum }, null, 2)}
 `,
       "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")
+    import_promises5.default.writeFile(paths.equitySvg, equitySvg, "utf8"),
+    import_promises5.default.writeFile(paths.drawdownSvg, drawdownSvg, "utf8"),
+    import_promises5.default.writeFile(
+      paths.html,
+      comparison ? html.replace(
+        "</body>",
+        `<h2>Paired portfolio comparison</h2><pre>${escapeHtml(JSON.stringify(comparison, null, 2))}</pre></body>`
+      ) : html,
+      "utf8"
+    )
   ]);
   return { ...paths, checksum };
 };
@@ -10048,8 +10398,8 @@ var cachedTickerSymbols = async ({
     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);
+  for (const key2 of [...new Set(keys)]) {
+    const cached = await (0, import_redis6.getData)(key2, null);
     const symbols = (cached?.tickers ?? []).map(
       (ticker) => String(ticker.symbol ?? "").trim().toUpperCase()
     ).filter(Boolean);
@@ -10118,7 +10468,8 @@ var finishReplay = async ({
     replayResult,
     window,
     lineage: portfolioLineage ?? {},
-    command: process.argv.join(" ")
+    command: process.argv.join(" "),
+    compareTo: replayFlags.portfolioCompareTo
   }) : null;
   if (portfolioReport) {
     console.log(import_chalk13.default.green(`Portfolio report: ${portfolioReport.html}`));
@@ -10402,6 +10753,18 @@ var replayBacktest = async () => {
       `Invalid --portfolioBatchSize: ${String(replayFlags.portfolioBatchSize)}`
     );
   }
+  if (replayFlags.portfolioCompareTo && (!replayFlags.portfolioReport || !replayFlags.cacheOnly)) {
+    throw new Error(
+      "--portfolioCompareTo requires --portfolioReport and --cacheOnly"
+    );
+  }
+  if (replayFlags.portfolioReport && preparedRun.tickers.length > portfolioBatchSize && (replayFlags.portfolioCompareTo || replayStrategies.some(
+    ({ strategyConfig }) => Boolean(strategyConfig.PORTFOLIO_POLICY)
+  ))) {
+    throw new Error(
+      "Portfolio policies and comparisons require a single shared batch; set --portfolioBatchSize to at least the number of tickers"
+    );
+  }
   const runtimeStrategies = replayFlags.tickers && !replayFlags.portfolioReport ? replayStrategies.map(
     ({ selection: _selection, ...strategy }) => strategy
   ) : replayStrategies;
@@ -10425,6 +10788,9 @@ var replayBacktest = async () => {
       showProgress: !replayFlags.portfolioReport,
       collectSkipEvidence: !replayFlags.portfolioReport,
       collectSignals: !replayFlags.portfolioReport,
+      collectPortfolioDiagnostics: Boolean(
+        replayFlags.portfolioReport && tickerBatches.length === 1
+      ),
       decisionTraceTargets: replayFlags.portfolioReport ? void 0 : evidenceMetadata?.decisionTraceTargets
     });
     return replayFlags.portfolioReport ? compactHistoricalReplayResultForPortfolio(result) : result;
@@ -10462,6 +10828,9 @@ var replayBacktest = async () => {
       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,
+      batchCount: tickerBatches.length,
+      connector: preparedRun.connectorName,
+      interval: replayInterval,
       tickers: preparedRun.tickers,
       candleCoverage: candleCoverage ?? null,
       binanceMarketContextRows: portfolioMarketContextRows ?? null,