@tradejs/cli 3.1.29-beta.262 → 3.1.29-beta.264

package/dist/scripts/mcpWorker.js

@@ -0,0 +1,273 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scripts/mcpWorker.ts
+var mcpWorker_exports = {};
+__export(mcpWorker_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(mcpWorker_exports);
+var import_node_child_process = require("child_process");
+var import_node_crypto = require("crypto");
+var import_promises = require("fs/promises");
+var import_redis = require("@tradejs/infra/redis");
+var import_mcp = require("@tradejs/node/mcp");
+var pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var leaseKey = "worker:lease";
+var LEASE_SECONDS = 15;
+var JOB_TIMEOUT_MS = 60 * 60 * 1e3;
+var main = async (options = {}) => {
+  const owner = (0, import_node_crypto.randomUUID)();
+  if (!await import_redis.mcpStorage.put(leaseKey, owner, LEASE_SECONDS, true))
+    throw new Error("Another MCP worker owns this storage");
+  let stopping = false;
+  let child;
+  let renewing = false;
+  let leaseLost = false;
+  let manifestHash = "";
+  const signalChild = (signal) => {
+    if (!child?.pid) return;
+    try {
+      process.kill(
+        process.platform === "win32" ? child.pid : -child.pid,
+        signal
+      );
+    } catch {
+    }
+  };
+  const heartbeatValue = () => ({
+    observedAt: Date.now(),
+    packageManifestSha256: manifestHash,
+    replayAvailable: Boolean(process.env.MCP_REPLAY_REDIS_HOST)
+  });
+  const stop = () => {
+    stopping = true;
+    signalChild("SIGTERM");
+  };
+  options.signal?.addEventListener("abort", stop, { once: true });
+  if (options.signal?.aborted) stop();
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  const heartbeat = setInterval(async () => {
+    if (renewing || leaseLost) return;
+    renewing = true;
+    try {
+      if (!await import_redis.mcpStorage.compare(leaseKey, owner, owner, LEASE_SECONDS))
+        throw new Error("Worker lease lost");
+      await import_redis.mcpStorage.put("worker:heartbeat", heartbeatValue(), LEASE_SECONDS);
+    } catch {
+      leaseLost = true;
+      stop();
+    } finally {
+      renewing = false;
+    }
+  }, 2e3);
+  try {
+    manifestHash = await (0, import_mcp.mcpPackageManifestHash)();
+    await import_redis.mcpStorage.put("worker:heartbeat", heartbeatValue(), LEASE_SECONDS);
+    let cursor = "0";
+    do {
+      const page = await import_redis.mcpStorage.scan("jobs:", cursor);
+      cursor = page.cursor;
+      for (const key of page.ids) {
+        const job = await import_redis.mcpStorage.get(key);
+        if (job?.status === "running")
+          await import_redis.mcpStorage.compare(
+            key,
+            job,
+            {
+              ...job,
+              status: "failed",
+              error: "Worker restarted; this job was not replayed",
+              finishedAt: Date.now(),
+              updatedAt: Date.now()
+            },
+            import_mcp.MCP_JOB_TTL
+          );
+      }
+    } while (cursor !== "0" && !stopping);
+    console.log(
+      "MCP worker ready (one job at a time, cached history, no live order commands)"
+    );
+    while (!stopping) {
+      let queued;
+      cursor = "0";
+      do {
+        const page = await import_redis.mcpStorage.scan("jobs:", cursor);
+        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))
+            queued = job;
+        }
+      } while (cursor !== "0" && !stopping);
+      if (!queued) {
+        await pause(1e3);
+        continue;
+      }
+      const jobKey = (0, import_mcp.mcpJobStorageId)(queued.userName, queued.id);
+      const started = {
+        ...queued,
+        status: "running",
+        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) {
+        await import_redis.mcpStorage.compare(
+          jobKey,
+          started,
+          {
+            ...started,
+            status: "failed",
+            error: "Package composition changed since submission",
+            finishedAt: Date.now()
+          },
+          import_mcp.MCP_JOB_TTL
+        );
+        continue;
+      }
+      await (0, import_promises.mkdir)((0, import_mcp.mcpJobDirectory)(started), { recursive: true });
+      if (started.kind === "backtest")
+        await (0, import_redis.setDataStrict)(
+          import_redis.redisKeys.backtestConfig(
+            started.userName,
+            String(started.request.frozenConfigId)
+          ),
+          started.request.resolvedConfig,
+          { expire: import_mcp.MCP_JOB_TTL }
+        );
+      const jobEnv = {
+        ...process.env,
+        NODE_OPTIONS: "--max-old-space-size=1024",
+        MCP_WORKER: "true",
+        BACKTEST_WORKER_HEAP_MB: "768",
+        BACKTEST_MAX_PARALLEL: "1",
+        AI_ENABLED: "false",
+        ML_ENABLED: "false",
+        MAKE_ORDERS: "false",
+        TRADEJS_EXTERNAL_ORDER_PLACEMENT: "false"
+      };
+      if (started.kind === "runtime-feedback-replay") {
+        for (const name of Object.keys(jobEnv)) {
+          if (/secret|token|api.?key|private.?key|cookie|credential/i.test(name))
+            delete jobEnv[name];
+        }
+        Object.assign(jobEnv, {
+          DOTENV_CONFIG_PATH: "/dev/null",
+          REDIS_HOST: process.env.MCP_REPLAY_REDIS_HOST,
+          REDIS_PORT: "6379",
+          REDIS_DB: "0",
+          RUNTIME_FEEDBACK_ISOLATED_REDIS: "true",
+          PGOPTIONS: "-c default_transaction_read_only=on",
+          TRADEJS_TIMESCALE_READ_ONLY: "true"
+        });
+      }
+      child = (0, import_node_child_process.spawn)(process.execPath, [process.argv[1], ...started.args], {
+        cwd: process.env.PROJECT_CWD || process.cwd(),
+        env: jobEnv,
+        detached: process.platform !== "win32",
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const currentChild = child;
+      let timedOut = false;
+      const timeout = 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]"
+            )
+          )
+        );
+        if (logs.length > 150) logs.splice(0, logs.length - 150);
+      };
+      currentChild.stdout?.on("data", log);
+      currentChild.stderr?.on("data", log);
+      let killAt;
+      const monitor = setInterval(async () => {
+        try {
+          const latest = await import_redis.mcpStorage.get(jobKey);
+          if (!latest || latest.cancelRequested || stopping || timedOut) {
+            killAt ??= Date.now();
+            signalChild(Date.now() - killAt > 8e3 ? "SIGKILL" : "SIGTERM");
+          }
+          if (latest && !leaseLost)
+            await import_redis.mcpStorage.compare(
+              jobKey,
+              latest,
+              { ...latest, logs: [...logs], updatedAt: Date.now() },
+              import_mcp.MCP_JOB_TTL
+            );
+        } catch {
+          leaseLost = true;
+          stop();
+        }
+      }, 1e3);
+      const outcome = await new Promise((resolve) => {
+        currentChild.once(
+          "error",
+          () => resolve({ code: null, error: "Unable to start research process" })
+        );
+        currentChild.once("exit", (code) => resolve({ code }));
+      });
+      clearTimeout(timeout);
+      clearInterval(monitor);
+      child = void 0;
+      if (!leaseLost) {
+        for (let attempt = 0; attempt < 4; attempt++) {
+          const latest = await import_redis.mcpStorage.get(jobKey);
+          if (!latest) break;
+          const cancelled = latest.cancelRequested;
+          const next = {
+            ...latest,
+            logs,
+            status: cancelled ? "cancelled" : outcome.code === 0 && !timedOut && !stopping ? "completed" : "failed",
+            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" } : {}
+          };
+          if (await import_redis.mcpStorage.compare(jobKey, latest, next, import_mcp.MCP_JOB_TTL))
+            break;
+        }
+      }
+    }
+  } finally {
+    clearInterval(heartbeat);
+    options.signal?.removeEventListener("abort", stop);
+    process.removeListener("SIGINT", stop);
+    process.removeListener("SIGTERM", stop);
+    if (await import_redis.mcpStorage.release(leaseKey, owner))
+      await import_redis.mcpStorage.remove("worker:heartbeat");
+  }
+  if (leaseLost)
+    throw new Error("Worker lease lost; active computation was stopped");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});

package/dist/scripts/replay.js

@@ -17,6 +17,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
@@ -41,7 +42,7 @@ 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_runtimeStrategies3 = require("@tradejs/node/runtimeStrategies");
 var import_strategies5 = require("@tradejs/node/strategies");
 
 // src/lib/runFormatting.ts
@@ -4447,245 +4448,8 @@ var runtimeLineagesMatch = (left, right) => left != null && right != null && run
 var runtimeLineagesComparable = (left, right) => runtimeLineagesMatch(left, right) && typeof left?.maxLossValue === "number" && Number.isFinite(left.maxLossValue) && typeof right?.maxLossValue === "number" && Number.isFinite(right.maxLossValue) && left.maxLossValue === right.maxLossValue;
 
 // src/lib/runtimeEvidenceDeployment.ts
-var import_runtimeStrategies2 = require("@tradejs/node/runtimeStrategies");
-var isRecord = (value) => value != null && typeof value === "object" && !Array.isArray(value);
-var isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
-var isPackageVersionMap = (value) => isRecord(value) && Object.keys(value).length > 0 && Object.entries(value).every(
-  ([name, version]) => name.startsWith("@tradejs/") && isNonEmptyString(version)
-);
-var INTERVALS = /* @__PURE__ */ new Set([
-  "1",
-  "3",
-  "5",
-  "15",
-  "30",
-  "60",
-  "120",
-  "240",
-  "360",
-  "720",
-  "D",
-  "W",
-  "M"
-]);
-var UNIVERSES = /* @__PURE__ */ new Set(["crypto", "tradfi"]);
-var isRuntimeStrategySelection = (value) => value === void 0 || isRecord(value) && Object.keys(value).length === 1 && Object.keys(value).every((key) => key === "tickers") && Array.isArray(value.tickers) && value.tickers.length > 0 && value.tickers.every((ticker) => isNonEmptyString(ticker));
-var samePackageVersions = (left, right) => {
-  if (!left || !right) return false;
-  const leftEntries = Object.entries(left).sort(
-    ([a], [b]) => a.localeCompare(b)
-  );
-  const rightEntries = Object.entries(right).sort(
-    ([a], [b]) => a.localeCompare(b)
-  );
-  return JSON.stringify(leftEntries) === JSON.stringify(rightEntries);
-};
-var runtimeLineageMatchesStrategySnapshot = ({
-  lineage,
-  deployment,
-  strategy
-}) => lineage?.schemaVersion === 3 && lineage.strategyRevision === strategy.strategyRevision && lineage.deploymentCompositionId === deployment.deploymentCompositionId && lineage.strategyPackageVersion === strategy.strategyPackageVersion && lineage.runtimePackageVersion === strategy.runtimePackageVersion && samePackageVersions(
-  lineage.strategyDependencyVersions,
-  strategy.strategyDependencyVersions
-);
-var parseRuntimeEvidenceDeploymentSnapshot = (value) => {
-  if (!isRecord(value) || value.schemaVersion !== 2 || !isNonEmptyString(value.id) || !isNonEmptyString(value.deploymentCompositionId) || !/^dc1:[a-f0-9]{16}$/.test(value.deploymentCompositionId) || !isNonEmptyString(value.label) || !isNonEmptyString(value.connectorName) || !isNonEmptyString(value.provider) || !isNonEmptyString(value.accountId) || typeof value.enabled !== "boolean" || !Array.isArray(value.strategies)) {
-    throw new Error(
-      "Runtime evidence deployment snapshot is missing or invalid"
-    );
-  }
-  const strategies = value.strategies.map((candidate) => {
-    if (!isRecord(candidate) || !isNonEmptyString(candidate.strategyName) || !isNonEmptyString(candidate.strategyRevision) || !/^sr1:[a-f0-9]{16}$/.test(candidate.strategyRevision) || typeof candidate.enabled !== "boolean" || !["active", "entries_paused"].includes(String(candidate.controlState)) || !INTERVALS.has(String(candidate.interval)) || !UNIVERSES.has(String(candidate.universe)) || !isNonEmptyString(candidate.strategyPackage) || !isNonEmptyString(candidate.strategyPackageVersion) || !isPackageVersionMap(candidate.strategyDependencyVersions) || !isNonEmptyString(candidate.runtimePackageVersion) || !isRecord(candidate.strategyConfig) || !isRuntimeStrategySelection(candidate.selection)) {
-      throw new Error(
-        "Runtime evidence deployment strategy snapshot is invalid"
-      );
-    }
-    if (String(candidate.strategyConfig.INTERVAL) !== String(candidate.interval) || String(candidate.strategyConfig.UNIVERSE) !== String(candidate.universe)) {
-      throw new Error(
-        `Runtime evidence strategy config does not match its scope: ${candidate.strategyName}`
-      );
-    }
-    if (candidate.accountId != null && (!isNonEmptyString(candidate.accountId) || candidate.accountId !== value.accountId)) {
-      throw new Error(
-        `Runtime evidence strategy account does not match deployment: ${candidate.strategyName}`
-      );
-    }
-    return candidate;
-  });
-  const identities = /* @__PURE__ */ new Set();
-  for (const strategy of strategies) {
-    if (identities.has(strategy.strategyName)) {
-      throw new Error(
-        `Duplicate runtime evidence strategy: ${strategy.strategyName}`
-      );
-    }
-    identities.add(strategy.strategyName);
-  }
-  return {
-    ...value,
-    strategies
-  };
-};
-var activeRuntimeEvidenceStrategies = (deployment) => deployment.enabled ? deployment.strategies.filter((strategy) => strategy.enabled) : [];
-var unwrapRuntimeEvidenceRows = (value, field) => (Array.isArray(value) ? value : []).map((candidate) => {
-  const record = isRecord(candidate) ? candidate : null;
-  const nested = record && isRecord(record[field]) ? record[field] : null;
-  return nested ?? record;
-}).filter((record) => record != null);
-var assertCurrentRuntimeEvidenceArtifact = (artifact) => {
-  if (!isRecord(artifact) || artifact.reportType !== "runtime-evidence") {
-    throw new Error("Invalid runtime evidence artifact");
-  }
-  const deployment = parseRuntimeEvidenceDeploymentSnapshot(
-    artifact.deployment
-  );
-  const activeStrategies = activeRuntimeEvidenceStrategies(deployment);
-  if (activeStrategies.length === 0) {
-    throw new Error("Runtime evidence deployment has no enabled strategies");
-  }
-  const runtime = isRecord(artifact.runtime) ? artifact.runtime : null;
-  if (!runtime) {
-    throw new Error("Runtime evidence payload is missing");
-  }
-  if ("strategyConfigs" in runtime) {
-    throw new Error(
-      "Runtime evidence payload contains removed strategyConfigs data"
-    );
-  }
-  if ("evaluationStatsBuckets" in runtime) {
-    throw new Error(
-      "Runtime evidence payload contains removed lineage-less evaluationStatsBuckets data"
-    );
-  }
-  const rowFields = [
-    "trades",
-    "signals",
-    "evaluations",
-    "lineageScopes"
-  ];
-  for (const field of rowFields) {
-    if (!Array.isArray(runtime[field])) {
-      throw new Error(`Runtime evidence payload ${field} must be an array`);
-    }
-  }
-  const snapshots = new Map(
-    activeStrategies.map((strategy) => [strategy.strategyName, strategy])
-  );
-  const assertRows = (label, rows, lineageField) => {
-    for (const row of rows) {
-      const strategyName = String(row.strategy ?? "").trim();
-      const strategy = snapshots.get(strategyName);
-      if (!strategy || row.deploymentId !== deployment.id || row.accountId !== deployment.accountId || !runtimeLineageMatchesStrategySnapshot({
-        lineage: isRecord(row[lineageField]) ? row[lineageField] : void 0,
-        deployment,
-        strategy
-      })) {
-        throw new Error(
-          `Runtime evidence ${label} row is outside the current embedded deployment lineage`
-        );
-      }
-    }
-  };
-  assertRows(
-    "trade",
-    unwrapRuntimeEvidenceRows(runtime.trades, "trade"),
-    "runtimeLineage"
-  );
-  assertRows(
-    "signal",
-    unwrapRuntimeEvidenceRows(runtime.signals, "signal"),
-    "runtimeLineage"
-  );
-  assertRows(
-    "evaluation",
-    unwrapRuntimeEvidenceRows(runtime.evaluations, "evaluation"),
-    "runtimeLineage"
-  );
-  assertRows(
-    "lineage scope",
-    unwrapRuntimeEvidenceRows(runtime.lineageScopes, "lineageScope"),
-    "lineage"
-  );
-  return deployment;
-};
-var resolveRuntimeEvidenceTickerUniverse = ({
-  deployment,
-  lineageScopes,
-  fallbackTickers
-}) => {
-  const declaredTickers = deployment.tickers?.filter(isNonEmptyString) ?? [];
-  if (declaredTickers.length > 0) {
-    return {
-      ...deployment,
-      tickers: [
-        ...new Set(declaredTickers.map((ticker) => ticker.trim()))
-      ].sort()
-    };
-  }
-  const activeStrategies = activeRuntimeEvidenceStrategies(deployment);
-  if (activeStrategies.length > 0 && activeStrategies.every((strategy) => strategy.selection?.tickers?.length)) {
-    return {
-      ...deployment,
-      tickers: [
-        ...new Set(
-          activeStrategies.flatMap(
-            (strategy) => strategy.selection?.tickers ?? []
-          )
-        )
-      ].sort()
-    };
-  }
-  const strategiesByName = new Map(
-    activeStrategies.map((strategy) => [strategy.strategyName, strategy])
-  );
-  const tickers = /* @__PURE__ */ new Set();
-  for (const scope of lineageScopes) {
-    const strategy = strategiesByName.get(scope.strategy);
-    if (!strategy || scope.deploymentId !== deployment.id || scope.accountId !== deployment.accountId || !isNonEmptyString(scope.symbol) || !runtimeLineageMatchesStrategySnapshot({
-      lineage: scope.lineage,
-      deployment,
-      strategy
-    })) {
-      continue;
-    }
-    tickers.add(scope.symbol.trim());
-  }
-  if (tickers.size === 0) {
-    const verifiedFallbackTickers = fallbackTickers?.filter(isNonEmptyString) ?? [];
-    if (verifiedFallbackTickers.length > 0) {
-      return {
-        ...deployment,
-        tickers: [
-          ...new Set(verifiedFallbackTickers.map((ticker) => ticker.trim()))
-        ].sort()
-      };
-    }
-    throw new Error(
-      "Runtime evidence has no immutable ticker universe for the embedded deployment composition"
-    );
-  }
-  return { ...deployment, tickers: [...tickers].sort() };
-};
-var runtimeDeploymentFromEvidence = (deployment) => ({
-  id: deployment.id,
-  deploymentCompositionId: deployment.deploymentCompositionId,
-  label: deployment.label,
-  connectorName: deployment.connectorName,
-  provider: deployment.provider,
-  accountId: deployment.accountId,
-  enabled: deployment.enabled,
-  strategies: deployment.strategies.map(
-    ({ strategyName, strategyRevision, enabled, controlState, selection }) => ({
-      strategyName,
-      strategyRevision,
-      enabled,
-      controlState,
-      ...selection ? { selection } : {}
-    })
-  ),
-  ...deployment.assetClasses ? { assetClasses: [...deployment.assetClasses] } : {},
-  ...deployment.tickers ? { tickers: [...deployment.tickers] } : {}
-});
+var runtimeEvidenceDeployment_exports = {};
+__reExport(runtimeEvidenceDeployment_exports, require("@tradejs/node/diagnostics"));
 
 // src/lib/replay/runtimeEvidenceSource.ts
 var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
@@ -4700,7 +4464,7 @@ var assertRuntimeRowsMatchDeployment = ({
   deployment
 }) => {
   const activeStrategies = new Set(
-    activeRuntimeEvidenceStrategies(deployment).map(
+    (0, runtimeEvidenceDeployment_exports.activeRuntimeEvidenceStrategies)(deployment).map(
       ({ strategyName }) => strategyName
     )
   );
@@ -4724,7 +4488,7 @@ var readRuntimeEvidenceArtifact = async ({
   if (!root || !runtime) {
     throw new Error(`Invalid runtime evidence JSON: ${resolvedPath}`);
   }
-  assertCurrentRuntimeEvidenceArtifact(root);
+  (0, runtimeEvidenceDeployment_exports.assertCurrentRuntimeEvidenceArtifact)(root);
   const rootWindow = asRecord(root.window);
   const runtimeWindow = asRecord(runtime.window);
   return {
@@ -4734,8 +4498,8 @@ var readRuntimeEvidenceArtifact = async ({
     userName: String(root.userName ?? runtime.userName ?? "").trim(),
     startTime: asFiniteNumber(rootWindow?.startTime) ?? asFiniteNumber(runtimeWindow?.startTime),
     endTime: asFiniteNumber(rootWindow?.endTime) ?? asFiniteNumber(runtimeWindow?.endTime),
-    deployment: resolveRuntimeEvidenceTickerUniverse({
-      deployment: parseRuntimeEvidenceDeploymentSnapshot(root.deployment),
+    deployment: (0, runtimeEvidenceDeployment_exports.resolveRuntimeEvidenceTickerUniverse)({
+      deployment: (0, runtimeEvidenceDeployment_exports.parseRuntimeEvidenceDeploymentSnapshot)(root.deployment),
       lineageScopes: unwrapRows(
         runtime.lineageScopes,
         "lineageScope"
@@ -4996,7 +4760,7 @@ var import_redis3 = require("@tradejs/infra/redis");
 var import_connectors6 = require("@tradejs/node/connectors");
 var import_cli4 = require("@tradejs/node/cli");
 var import_strategies4 = require("@tradejs/node/strategies");
-var import_runtimeStrategies3 = require("@tradejs/node/runtimeStrategies");
+var import_runtimeStrategies2 = require("@tradejs/node/runtimeStrategies");
 
 // src/lib/replay/portfolioReplayConnector.ts
 var import_constants3 = require("@tradejs/core/constants");
@@ -5987,7 +5751,7 @@ var loadRuntimeStrategies = async (runtimeStrategies) => {
       if (!strategyCreator) {
         throw new Error(`Unknown strategy: ${strategyName}`);
       }
-      const installed = await (0, import_runtimeStrategies3.getRuntimeStrategyPackageMetadata)({
+      const installed = await (0, import_runtimeStrategies2.getRuntimeStrategyPackageMetadata)({
         strategyName,
         projectRoot: replayProjectRoot,
         strategyModule
@@ -9906,8 +9670,8 @@ var replayBacktest = async () => {
     );
   }
   const replayComposition = evidenceMetadata ? {
-    deployment: runtimeDeploymentFromEvidence(evidenceMetadata.deployment),
-    strategies: activeRuntimeEvidenceStrategies(
+    deployment: (0, runtimeEvidenceDeployment_exports.runtimeDeploymentFromEvidence)(evidenceMetadata.deployment),
+    strategies: (0, runtimeEvidenceDeployment_exports.activeRuntimeEvidenceStrategies)(
       evidenceMetadata.deployment
     ).map(
       ({
@@ -9959,7 +9723,7 @@ var replayBacktest = async () => {
     return {
       ...strategy,
       strategyConfig,
-      strategyRevision: (0, import_runtimeStrategies4.computeStrategyRevision)({
+      strategyRevision: (0, import_runtimeStrategies3.computeStrategyRevision)({
         strategyName: strategy.strategyName,
         strategyPackage: strategy.strategyPackage,
         strategyPackageVersion: strategy.strategyPackageVersion,
@@ -9969,7 +9733,7 @@ var replayBacktest = async () => {
       })
     };
   });
-  const researchDeploymentCompositionId = (0, import_runtimeStrategies4.computeDeploymentCompositionId)({
+  const researchDeploymentCompositionId = (0, import_runtimeStrategies3.computeDeploymentCompositionId)({
     deploymentId: deployment.id,
     connectorName: deployment.connectorName,
     provider: deployment.provider,