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

package/dist/lib/runtimeRedis.js

@@ -26,6 +26,7 @@ __export(runtimeRedis_exports, {
   loadRuntimeActiveTradeOrderIds: () => loadRuntimeActiveTradeOrderIds,
   loadRuntimeActiveTrades: () => loadRuntimeActiveTrades,
   loadRuntimeClosedTrades: () => loadRuntimeClosedTrades,
+  loadRuntimeEvidenceTrades: () => loadRuntimeEvidenceTrades,
   loadRuntimeStrategyConfigs: () => import_runtimeStrategyConfigs.loadRuntimeStrategyConfigs,
   loadRuntimeStrategyNames: () => import_runtimeStrategyConfigs.loadRuntimeStrategyNames,
   loadRuntimeTrades: () => loadRuntimeTrades,
@@ -104,6 +105,49 @@ var loadRuntimeClosedTrades = async (userName, {
     (left, right) => left.exitTimestamp - right.exitTimestamp
   );
 };
+var loadRuntimeEvidenceTrades = async (userName, { startTime, endTime }) => {
+  const prefix = import_redis.redisKeys.runtimeTradeBuckets(userName);
+  const lastDay = (0, import_time.getRuntimeStorageDayKey)(endTime - 1);
+  const keys = (await (0, import_redis.getKeys)(prefix)).filter((key) => {
+    const day = key.slice(prefix.length);
+    return key.startsWith(prefix) && /^\d{4}-\d{2}-\d{2}$/.test(day) && day <= lastDay;
+  });
+  const retained = /* @__PURE__ */ new Map();
+  for (let offset = 0; offset < keys.length; offset += 16) {
+    const buckets = await Promise.all(
+      keys.slice(offset, offset + 16).map((key) => (0, import_redis.getHashJsonValues)(key))
+    );
+    for (const row of buckets.flat())
+      if (isRuntimeTradeRecord(row)) retained.set(row.orderId, row);
+  }
+  for (const row of await loadRuntimeClosedTrades(userName, {
+    startTime,
+    endTime
+  }))
+    retained.set(row.orderId, row);
+  return [...retained.values()].filter(
+    (row) => row.entryTimestamp < endTime && (row.status === "active" || Number.isFinite(row.exitTimestamp) && row.exitTimestamp >= startTime)
+  ).map((row) => {
+    const closesAfterCutoff = row.status === "closed" && row.exitTimestamp >= endTime;
+    if (!closesAfterCutoff && !(row.status === "active" && row.lastSyncedAt >= endTime))
+      return row;
+    return {
+      ...row,
+      status: "active",
+      currentPrice: null,
+      currentPnl: null,
+      closedPnl: null,
+      exitPrice: null,
+      actualExitPrice: null,
+      exitTimestamp: null,
+      exitType: null,
+      closeFee: null,
+      fundingFee: null,
+      totalFee: null,
+      lastSyncedAt: void 0
+    };
+  }).sort((a, b) => a.entryTimestamp - b.entryTimestamp);
+};
 var loadRuntimeActiveTradeOrderIds = async (userName) => {
   const keys = await (0, import_redis.getKeys)(import_redis.redisKeys.runtimeActiveTrades(userName));
   const refs = await Promise.all(keys.map((key) => (0, import_redis.getData)(key, null)));
@@ -144,6 +188,7 @@ var loadStrategyResultSymbols = async ({
   loadRuntimeActiveTradeOrderIds,
   loadRuntimeActiveTrades,
   loadRuntimeClosedTrades,
+  loadRuntimeEvidenceTrades,
   loadRuntimeStrategyConfigs,
   loadRuntimeStrategyNames,
   loadRuntimeTrades,

package/dist/scripts/mcpWorker.js

@@ -66,8 +66,21 @@ const timer = setInterval(() => {
   try {
     const result = JSON.parse(fs.readFileSync(file + '.result', 'utf8'));
     console.log(result.message);
+    if (result.exitCode !== 0) {
+      let fd;
+      try {
+        fd = fs.openSync(file + '.log', fs.constants.O_RDONLY | fs.constants.O_NOFOLLOW);
+        const size = fs.fstatSync(fd).size;
+        const tail = Buffer.alloc(Math.min(size, 65536));
+        fs.readSync(fd, tail, 0, tail.length, Math.max(0, size - tail.length));
+        // The worker redacts each line before persisting or returning it through MCP.
+        for (const line of tail.toString('utf8').split(/[\\r\\n]+/).filter(Boolean).slice(-150)) console.error('Host replay: ' + line);
+      } catch (error) {
+        console.error('Host replay log unavailable: ' + error.code);
+      } finally { if (fd !== undefined) fs.closeSync(fd); }
+    }
     clearInterval(timer);
-    process.exit(result.exitCode === 0 ? 0 : 1);
+    process.exitCode = result.exitCode === 0 ? 0 : 1;
   } catch (error) { if (error.code !== 'ENOENT') throw error; }
 }, 1000);
 `;
@@ -90,7 +103,7 @@ var buildMcpReplayProcess = async ({
   const heartbeat = JSON.parse(
     await import_promises.default.readFile(import_node_path.default.join(root, "heartbeat.json"), "utf8")
   );
-  if (!Number.isFinite(heartbeat.observedAt) || Date.now() - heartbeat.observedAt < 0 || Date.now() - heartbeat.observedAt > 12e4)
+  if (heartbeat.protocolVersion !== 2 || !Number.isFinite(heartbeat.observedAt) || Date.now() - heartbeat.observedAt < 0 || Date.now() - heartbeat.observedAt > 12e4)
     throw new Error("Host replay runner heartbeat is stale");
   const bytes = await import_promises.default.readFile(evidencePath);
   const request = JSON.stringify({
@@ -123,14 +136,17 @@ var main = async (options = {}) => {
   let leaseLost = false;
   let manifestHash = "";
   let replayReady = false;
+  let replayReadiness = "unknown";
   const updateReplayReady = async () => {
     try {
       const root = process.env.MCP_REPLAY_REQUEST_ROOT || `${process.env.PROJECT_CWD || process.cwd()}/data/mcp-replay-requests`;
       const heartbeat2 = JSON.parse(
         await (0, import_promises2.readFile)(`${root}/heartbeat.json`, "utf8")
       );
-      replayReady = Number.isFinite(heartbeat2.observedAt) && Date.now() - heartbeat2.observedAt >= 0 && Date.now() - heartbeat2.observedAt < 12e4;
+      replayReadiness = heartbeat2.readiness === "ready" || heartbeat2.readiness === "waiting_resources" ? heartbeat2.readiness : "unknown";
+      replayReady = heartbeat2.protocolVersion === 2 && Number.isFinite(heartbeat2.observedAt) && Date.now() - heartbeat2.observedAt >= 0 && Date.now() - heartbeat2.observedAt < 12e4;
     } catch {
+      replayReadiness = "unknown";
       replayReady = false;
     }
   };
@@ -147,7 +163,8 @@ var main = async (options = {}) => {
   const heartbeatValue = () => ({
     observedAt: Date.now(),
     packageManifestSha256: manifestHash,
-    replayAvailable: replayReady
+    replayAvailable: replayReady,
+    replayReadiness
   });
   const stop = () => {
     stopping = true;
@@ -208,7 +225,9 @@ var main = async (options = {}) => {
         cursor = page.cursor;
         for (const key of page.ids) {
           const job = await import_redis.mcpStorage.get(key);
-          if (job?.status === "queued" && (!queued || job.createdAt < queued.createdAt))
+          if (job && ["queued", "waiting_resources", "waiting_executor"].includes(
+            job.status
+          ) && (!queued || job.createdAt < queued.createdAt))
             queued = job;
         }
       } while (cursor !== "0" && !stopping);
@@ -219,13 +238,13 @@ var main = async (options = {}) => {
       const jobKey = (0, import_mcp.mcpJobStorageId)(queued.userName, queued.id);
       const started = {
         ...queued,
-        status: "running",
-        startedAt: Date.now(),
+        status: queued.kind === "runtime-feedback-replay" ? "waiting_executor" : "running",
+        ...queued.kind === "runtime-feedback-replay" ? {} : { startedAt: Date.now() },
         updatedAt: Date.now()
       };
       if (!await import_redis.mcpStorage.compare(jobKey, queued, started, import_mcp.MCP_JOB_TTL))
         continue;
-      if (started.packageManifestSha256 !== manifestHash) {
+      if (started.kind !== "runtime-feedback-replay" && started.packageManifestSha256 !== manifestHash) {
         await import_redis.mcpStorage.compare(
           jobKey,
           started,
@@ -299,7 +318,7 @@ var main = async (options = {}) => {
             status: "failed",
             finishedAt: Date.now(),
             updatedAt: Date.now(),
-            error: error instanceof Error ? error.message : "Replay preparation failed"
+            error: error instanceof Error ? (0, import_mcp.redactMcpJobLog)(error.message) : "Replay preparation failed"
           },
           import_mcp.MCP_JOB_TTL
         );
@@ -313,21 +332,15 @@ var main = async (options = {}) => {
       });
       const currentChild = child;
       let timedOut = false;
-      const timeout = setTimeout(() => {
+      let replayStartedAt;
+      const timeout = started.kind === "runtime-feedback-replay" ? void 0 : setTimeout(() => {
         timedOut = true;
         signalChild("SIGTERM");
       }, JOB_TIMEOUT_MS);
       const logs = [];
       const log = (chunk) => {
         const lines = chunk.toString().replace(/\u001b\[[0-9;]*m/g, "").split(/[\r\n]+/).filter(Boolean);
-        logs.push(
-          ...lines.map(
-            (line) => line.slice(0, 1e3).replace(
-              /((?:secret|password|api.?key|token|authorization)\s*[:=]\s*)\S+/gi,
-              "$1[redacted]"
-            )
-          )
-        );
+        logs.push(...lines.map(import_mcp.redactMcpJobLog));
         if (logs.length > 150) logs.splice(0, logs.length - 150);
       };
       currentChild.stdout?.on("data", log);
@@ -340,11 +353,38 @@ var main = async (options = {}) => {
             killAt ??= Date.now();
             signalChild(Date.now() - killAt > 8e3 ? "SIGKILL" : "SIGTERM");
           }
+          let replayStatus;
+          if (latest?.kind === "runtime-feedback-replay") {
+            try {
+              const root = process.env.MCP_REPLAY_REQUEST_ROOT || `${process.env.PROJECT_CWD || process.cwd()}/data/mcp-replay-requests`;
+              const state = JSON.parse(
+                await (0, import_promises2.readFile)(`${root}/${latest.id}.state`, "utf8")
+              );
+              if (state && typeof state === "object" && "status" in state && (state.status === "waiting_resources" || state.status === "waiting_executor" || state.status === "running"))
+                replayStatus = state.status;
+            } catch {
+            }
+          }
+          if (replayStatus === "running") {
+            replayStartedAt ??= latest?.startedAt ?? Date.now();
+            if (Date.now() - replayStartedAt > JOB_TIMEOUT_MS) {
+              timedOut = true;
+              signalChild("SIGTERM");
+            }
+          }
           if (latest && !leaseLost)
             await import_redis.mcpStorage.compare(
               jobKey,
               latest,
-              { ...latest, logs: [...logs], updatedAt: Date.now() },
+              {
+                ...latest,
+                ...replayStatus && !latest.cancelRequested ? {
+                  status: replayStatus,
+                  ...replayStatus === "running" && !latest.startedAt ? { startedAt: Date.now() } : {}
+                } : {},
+                logs: [...logs],
+                updatedAt: Date.now()
+              },
               import_mcp.MCP_JOB_TTL
             );
         } catch {
@@ -357,7 +397,7 @@ var main = async (options = {}) => {
           "error",
           () => resolve({ code: null, error: "Unable to start research process" })
         );
-        currentChild.once("exit", (code) => resolve({ code }));
+        currentChild.once("close", (code) => resolve({ code }));
       });
       clearTimeout(timeout);
       clearInterval(monitor);
@@ -374,7 +414,11 @@ var main = async (options = {}) => {
             exitCode: outcome.code,
             updatedAt: Date.now(),
             finishedAt: Date.now(),
-            ...cancelled ? {} : timedOut ? { error: "Job exceeded one hour" } : stopping ? { error: "Worker stopped; this job was not replayed" } : outcome.code !== 0 ? { error: outcome.error || "Research process failed" } : {}
+            ...cancelled ? {} : timedOut ? { error: "Job exceeded one hour" } : stopping ? { error: "Worker stopped; this job was not replayed" } : outcome.code !== 0 ? {
+              error: outcome.error || (started.kind === "runtime-feedback-replay" ? logs.find(
+                (line) => line.startsWith("Host replay: ")
+              ) || logs.at(-1) : void 0) || "Research process failed"
+            } : {}
           };
           if (await import_redis.mcpStorage.compare(jobKey, latest, next, import_mcp.MCP_JOB_TTL))
             break;

package/dist/scripts/replay.js

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