@tradejs/cli 3.1.29-beta.277 → 3.1.29-beta.278

package/dist/cli.js

@@ -24462,45 +24462,45 @@ var init_marketWsGateway = __esm({
           socket.destroy();
           return;
         }
-        wsServer.handleUpgrade(request, socket, head, (client) => {
-          wsServer.emit("connection", client, request);
+        wsServer.handleUpgrade(request, socket, head, (client2) => {
+          wsServer.emit("connection", client2, request);
         });
       });
-      wsServer.on("connection", (client) => {
-        subscriptions.set(client, /* @__PURE__ */ new Set());
-        alive.add(client);
-        client.on("pong", () => alive.add(client));
-        client.on("message", (raw) => {
+      wsServer.on("connection", (client2) => {
+        subscriptions.set(client2, /* @__PURE__ */ new Set());
+        alive.add(client2);
+        client2.on("pong", () => alive.add(client2));
+        client2.on("message", (raw) => {
           const command = parseSubscriptionCommand(raw.toString());
           if (!command) {
-            client.send(JSON.stringify({ type: "error", error: "bad_command" }));
+            client2.send(JSON.stringify({ type: "error", error: "bad_command" }));
             return;
           }
           subscriptions.set(
-            client,
+            client2,
             applySubscriptionCommand(
-              subscriptions.get(client) ?? /* @__PURE__ */ new Set(),
+              subscriptions.get(client2) ?? /* @__PURE__ */ new Set(),
               command
             )
           );
-          client.send(
+          client2.send(
             JSON.stringify({
               type: "subscribed",
-              topics: [...subscriptions.get(client) ?? []]
+              topics: [...subscriptions.get(client2) ?? []]
             })
           );
         });
-        client.on("close", () => subscriptions.delete(client));
+        client2.on("close", () => subscriptions.delete(client2));
       });
       const heartbeat = setInterval(() => {
-        for (const client of subscriptions.keys()) {
-          if (!alive.has(client)) {
-            client.terminate();
-            subscriptions.delete(client);
+        for (const client2 of subscriptions.keys()) {
+          if (!alive.has(client2)) {
+            client2.terminate();
+            subscriptions.delete(client2);
             continue;
           }
-          alive.delete(client);
-          client.ping();
+          alive.delete(client2);
+          client2.ping();
         }
       }, 3e4);
       subscriber.on("message", (channel, payload) => {
@@ -24509,9 +24509,9 @@ var init_marketWsGateway = __esm({
         if (!event) return;
         const topic = buildMarketKlineTopic(event);
         const message = JSON.stringify({ type: "kline", topic, event });
-        for (const [client, topics] of subscriptions) {
-          if (client.readyState === import_ws.WebSocket.OPEN && topics.has(topic)) {
-            client.send(message);
+        for (const [client2, topics] of subscriptions) {
+          if (client2.readyState === import_ws.WebSocket.OPEN && topics.has(topic)) {
+            client2.send(message);
           }
         }
       });
@@ -24527,7 +24527,7 @@ var init_marketWsGateway = __esm({
       return {
         close: async () => {
           clearInterval(heartbeat);
-          for (const client of subscriptions.keys()) client.close();
+          for (const client2 of subscriptions.keys()) client2.close();
           subscriptions.clear();
           await subscriber.unsubscribe(MARKET_KLINE_CHANNEL);
           subscriber.disconnect();
@@ -24567,15 +24567,6 @@ var init_marketWs = __esm({
   }
 });
 
-// src/lib/runtimeEvidenceProducer.ts
-var runtimeEvidenceProducer_exports = {};
-var init_runtimeEvidenceProducer = __esm({
-  "src/lib/runtimeEvidenceProducer.ts"() {
-    "use strict";
-    __reExport(runtimeEvidenceProducer_exports, require("@tradejs/node/diagnostics"));
-  }
-});
-
 // src/lib/runtimeEvidenceArtifacts.ts
 var runtimeEvidenceArtifacts_exports = {};
 var init_runtimeEvidenceArtifacts = __esm({
@@ -24586,13 +24577,32 @@ var init_runtimeEvidenceArtifacts = __esm({
 });
 
 // src/lib/mcpReplayProcess.ts
-var import_node_path14, buildMcpReplayProcess;
+var import_node_path14, import_node_crypto8, import_promises17, client, buildMcpReplayProcess;
 var init_mcpReplayProcess = __esm({
   "src/lib/mcpReplayProcess.ts"() {
     "use strict";
     import_node_path14 = __toESM(require("path"));
-    init_runtimeEvidenceProducer();
+    import_node_crypto8 = require("crypto");
+    import_promises17 = __toESM(require("fs/promises"));
     init_runtimeEvidenceArtifacts();
+    client = `
+const fs = require('node:fs');
+const path = require('node:path');
+const [root, id, request] = process.argv.slice(1);
+const file = path.join(root, id);
+fs.mkdirSync(root, {recursive:true});
+try { fs.writeFileSync(file + '.request', request, {flag:'wx'}); }
+catch (error) { if (error.code !== 'EEXIST') throw error; if (fs.readFileSync(file + '.request', 'utf8') !== request) throw new Error('Replay request identity conflict'); }
+process.on('SIGTERM', () => { fs.writeFileSync(file + '.cancel', 'cancel'); process.exit(143); });
+const timer = setInterval(() => {
+  try {
+    const result = JSON.parse(fs.readFileSync(file + '.result', 'utf8'));
+    console.log(result.message);
+    clearInterval(timer);
+    process.exit(result.exitCode === 0 ? 0 : 1);
+  } catch (error) { if (error.code !== 'ENOENT') throw error; }
+}, 1000);
+`;
     buildMcpReplayProcess = async ({
       evidencePath,
       outDir,
@@ -24600,79 +24610,34 @@ var init_mcpReplayProcess = __esm({
       projectRoot: projectRoot18,
       env
     }) => {
-      if (!/^[a-zA-Z0-9_-]{1,100}$/.test(runId))
-        throw new Error("Invalid replay container run id");
+      if (!/^[a-f0-9]{64}$/.test(runId))
+        throw new Error("Invalid replay request id");
       const bundle = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(import_node_path14.default.dirname(evidencePath));
       if (import_node_path14.default.resolve(evidencePath) !== import_node_path14.default.resolve(bundle.payloadPath))
         throw new Error("Replay requires the verified bundle payload");
-      const producer = (0, runtimeEvidenceProducer_exports.parseRuntimeEvidenceProducer)(bundle.artifact.producer);
-      if (!env.MCP_REPLAY_HOST_PROJECT_ROOT || !env.MCP_REPLAY_NETWORK || !env.MCP_REPLAY_IMAGE_REPOSITORY)
-        throw new Error(
-          "Image-bound replay requires MCP_REPLAY_HOST_PROJECT_ROOT MCP_REPLAY_NETWORK and MCP_REPLAY_IMAGE_REPOSITORY"
-        );
-      const hostPath = (file) => {
-        const relative = import_node_path14.default.relative(projectRoot18, file);
-        if (relative.startsWith("..") || import_node_path14.default.isAbsolute(relative))
-          throw new Error("Replay mounts must be inside the Project");
-        return import_node_path14.default.join(env.MCP_REPLAY_HOST_PROJECT_ROOT, relative);
-      };
-      const args39 = [
-        "run",
-        "--rm",
-        "--name",
-        `tradejs-replay-${runId}`,
-        "--memory=1536m",
-        "--cpus=1",
-        "--pids-limit=512",
-        "--read-only",
-        "--cap-drop=ALL",
-        "--security-opt=no-new-privileges",
-        "--network",
-        env.MCP_REPLAY_NETWORK,
-        "--tmpfs",
-        "/tmp",
-        "--tmpfs",
-        "/app/data",
-        "--entrypoint",
-        "/app/node_modules/.bin/tradejs",
-        "--mount",
-        `type=bind,src=${hostPath(import_node_path14.default.dirname(evidencePath))},dst=/evidence,readonly`,
-        "--mount",
-        `type=bind,src=${hostPath(outDir)},dst=/replay-output`
-      ];
-      const safeEnv = {
-        PROJECT_CWD: "/app",
-        DOTENV_CONFIG_PATH: "/dev/null",
-        TRADEJS_PROJECT_SHA: producer.projectSha,
-        TRADEJS_PROJECT_IMAGE_DIGEST: producer.imageDigest,
-        NODE_OPTIONS: "--max-old-space-size=1024",
-        MAKE_ORDERS: "false",
-        TRADEJS_EXTERNAL_ORDER_PLACEMENT: "false",
-        AI_ENABLED: "false",
-        ML_ENABLED: "false",
-        RUNTIME_FEEDBACK_ISOLATED_REDIS: "true",
-        REDIS_HOST: env.MCP_REPLAY_REDIS_HOST,
-        REDIS_PORT: "6379",
-        REDIS_DB: "0",
-        PGOPTIONS: "-c default_transaction_read_only=on",
-        TRADEJS_TIMESCALE_READ_ONLY: "true"
-      };
-      for (const name of ["PG_HOST", "PG_PORT", "PG_USER", "PG_DATABASE", "PG_DB"])
-        if (env[name]) safeEnv[name] = env[name];
-      for (const [name, value] of Object.entries(safeEnv))
-        if (value !== void 0) args39.push("--env", `${name}=${value}`);
-      if (env.PG_PASSWORD) args39.push("--env", "PG_PASSWORD");
-      args39.push(
-        `${env.MCP_REPLAY_IMAGE_REPOSITORY}@${producer.imageDigest}`,
-        "runtime-feedback-replay",
-        "--runtimeEvidence",
-        `/evidence/${import_node_path14.default.basename(evidencePath)}`,
-        "--outDir",
-        "/replay-output",
-        "--runId",
-        runId
-      );
-      return { executable: "docker", args: args39 };
+      const relative = import_node_path14.default.relative(import_node_path14.default.join(projectRoot18, "data"), evidencePath);
+      if (relative.startsWith("..") || import_node_path14.default.isAbsolute(relative))
+        throw new Error("Evidence must be inside Project data");
+      const root = env.MCP_REPLAY_REQUEST_ROOT || import_node_path14.default.join(projectRoot18, "data/mcp-replay-requests");
+      const heartbeat = JSON.parse(
+        await import_promises17.default.readFile(import_node_path14.default.join(root, "heartbeat.json"), "utf8")
+      );
+      if (!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_promises17.default.readFile(evidencePath);
+      const request = JSON.stringify({
+        schemaVersion: 1,
+        id: runId,
+        evidence: relative,
+        artifactId: bundle.manifest.artifactId,
+        deploymentId: bundle.manifest.deploymentId,
+        payloadSha256: (0, import_node_crypto8.createHash)("sha256").update(bytes).digest("hex")
+      });
+      void outDir;
+      return {
+        executable: process.execPath,
+        args: ["-e", client, root, runId, request]
+      };
     };
   }
 });
@@ -24682,13 +24647,13 @@ var mcpWorker_exports = {};
 __export(mcpWorker_exports, {
   main: () => main26
 });
-var import_node_child_process4, import_node_crypto8, import_promises17, import_redis15, import_mcp, pause, leaseKey, LEASE_SECONDS, JOB_TIMEOUT_MS, main26;
+var import_node_child_process4, import_node_crypto9, import_promises18, import_redis15, import_mcp, pause, leaseKey, LEASE_SECONDS, JOB_TIMEOUT_MS, main26;
 var init_mcpWorker = __esm({
   "src/scripts/mcpWorker.ts"() {
     "use strict";
     import_node_child_process4 = require("child_process");
-    import_node_crypto8 = require("crypto");
-    import_promises17 = require("fs/promises");
+    import_node_crypto9 = require("crypto");
+    import_promises18 = require("fs/promises");
     import_redis15 = require("@tradejs/infra/redis");
     import_mcp = require("@tradejs/node/mcp");
     init_mcpReplayProcess();
@@ -24697,7 +24662,7 @@ var init_mcpWorker = __esm({
     LEASE_SECONDS = 15;
     JOB_TIMEOUT_MS = 60 * 60 * 1e3;
     main26 = async (options = {}) => {
-      const owner = (0, import_node_crypto8.randomUUID)();
+      const owner = (0, import_node_crypto9.randomUUID)();
       if (!await import_redis15.mcpStorage.put(leaseKey, owner, LEASE_SECONDS, true))
         throw new Error("Another MCP worker owns this storage");
       let stopping = false;
@@ -24705,6 +24670,18 @@ var init_mcpWorker = __esm({
       let renewing = false;
       let leaseLost = false;
       let manifestHash = "";
+      let replayReady = false;
+      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_promises18.readFile)(`${root}/heartbeat.json`, "utf8")
+          );
+          replayReady = Number.isFinite(heartbeat2.observedAt) && Date.now() - heartbeat2.observedAt >= 0 && Date.now() - heartbeat2.observedAt < 12e4;
+        } catch {
+          replayReady = false;
+        }
+      };
       const signalChild = (signal) => {
         if (!child?.pid) return;
         try {
@@ -24718,9 +24695,7 @@ var init_mcpWorker = __esm({
       const heartbeatValue = () => ({
         observedAt: Date.now(),
         packageManifestSha256: manifestHash,
-        replayAvailable: Boolean(
-          process.env.MCP_REPLAY_REDIS_HOST && process.env.MCP_REPLAY_HOST_PROJECT_ROOT && process.env.MCP_REPLAY_NETWORK && process.env.MCP_REPLAY_IMAGE_REPOSITORY
-        )
+        replayAvailable: replayReady
       });
       const stop = () => {
         stopping = true;
@@ -24736,6 +24711,7 @@ var init_mcpWorker = __esm({
         try {
           if (!await import_redis15.mcpStorage.compare(leaseKey, owner, owner, LEASE_SECONDS))
             throw new Error("Worker lease lost");
+          await updateReplayReady();
           await import_redis15.mcpStorage.put("worker:heartbeat", heartbeatValue(), LEASE_SECONDS);
         } catch {
           leaseLost = true;
@@ -24746,6 +24722,7 @@ var init_mcpWorker = __esm({
       }, 2e3);
       try {
         manifestHash = await (0, import_mcp.mcpPackageManifestHash)();
+        await updateReplayReady();
         await import_redis15.mcpStorage.put("worker:heartbeat", heartbeatValue(), LEASE_SECONDS);
         let cursor = "0";
         do {
@@ -24810,7 +24787,7 @@ var init_mcpWorker = __esm({
             );
             continue;
           }
-          await (0, import_promises17.mkdir)((0, import_mcp.mcpJobDirectory)(started), { recursive: true });
+          await (0, import_promises18.mkdir)((0, import_mcp.mcpJobDirectory)(started), { recursive: true });
           if (started.kind === "backtest")
             await (0, import_redis15.setDataStrict)(
               import_redis15.redisKeys.backtestConfig(
@@ -24833,7 +24810,9 @@ var init_mcpWorker = __esm({
           };
           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))
+              if (/secret|password|token|api.?key|private.?key|cookie|credential/i.test(
+                name
+              ))
                 delete jobEnv[name];
             }
             Object.assign(jobEnv, {
@@ -24874,8 +24853,6 @@ var init_mcpWorker = __esm({
             );
             continue;
           }
-          if (started.kind === "runtime-feedback-replay" && process.env.PG_PASSWORD)
-            jobEnv.PG_PASSWORD = process.env.PG_PASSWORD;
           child = (0, import_node_child_process4.spawn)(command.executable, command.args, {
             cwd: process.env.PROJECT_CWD || process.cwd(),
             env: jobEnv,
@@ -24930,20 +24907,6 @@ var init_mcpWorker = __esm({
             );
             currentChild.once("exit", (code) => resolve({ code }));
           });
-          if (started.kind === "runtime-feedback-replay") {
-            await new Promise((resolve) => {
-              const cleanup = (0, import_node_child_process4.spawn)(
-                "docker",
-                ["rm", "--force", `tradejs-replay-${started.id}`],
-                {
-                  stdio: "ignore",
-                  timeout: 1e4
-                }
-              );
-              cleanup.once("error", () => resolve());
-              cleanup.once("close", () => resolve());
-            });
-          }
           clearTimeout(timeout);
           clearInterval(monitor);
           child = void 0;
@@ -25335,13 +25298,13 @@ var hyperliquidWhalesUpdate_exports = {};
 __export(hyperliquidWhalesUpdate_exports, {
   main: () => main29
 });
-var import_config8, import_args21, import_node_crypto9, import_strategies12, LEADERBOARD_URL, DAY_MS10, CANDIDATE_LIMIT, flags19, fingerprint, runConcurrent2, main29;
+var import_config8, import_args21, import_node_crypto10, import_strategies12, LEADERBOARD_URL, DAY_MS10, CANDIDATE_LIMIT, flags19, fingerprint, runConcurrent2, main29;
 var init_hyperliquidWhalesUpdate = __esm({
   "src/scripts/hyperliquidWhalesUpdate.ts"() {
     "use strict";
     import_config8 = require("dotenv/config");
     import_args21 = __toESM(require("args"));
-    import_node_crypto9 = require("crypto");
+    import_node_crypto10 = require("crypto");
     import_strategies12 = require("@tradejs/node/strategies");
     init_hyperliquidWhaleBackfill();
     init_hyperliquidRateLimiter();
@@ -25355,7 +25318,7 @@ var init_hyperliquidWhalesUpdate = __esm({
     );
     import_args21.default.option(["d", "days"], "Calibration window in days", 7);
     flags19 = import_args21.default.parse(process.argv);
-    fingerprint = (addresses) => (0, import_node_crypto9.createHash)("sha256").update(JSON.stringify(addresses)).digest("hex").slice(0, 16);
+    fingerprint = (addresses) => (0, import_node_crypto10.createHash)("sha256").update(JSON.stringify(addresses)).digest("hex").slice(0, 16);
     runConcurrent2 = async (params) => {
       let nextIndex = 0;
       await Promise.all(
@@ -25464,13 +25427,13 @@ var mlExport_exports = {};
 __export(mlExport_exports, {
   main: () => main30
 });
-var import_args22, import_chalk37, import_promises18, import_path8, import_ml, flags20, resolveRunScopedMlChunks, main30;
+var import_args22, import_chalk37, import_promises19, import_path8, import_ml, flags20, resolveRunScopedMlChunks, main30;
 var init_mlExport = __esm({
   "src/scripts/mlExport.ts"() {
     "use strict";
     import_args22 = __toESM(require("args"));
     import_chalk37 = __toESM(require("chalk"));
-    import_promises18 = __toESM(require("fs/promises"));
+    import_promises19 = __toESM(require("fs/promises"));
     import_path8 = __toESM(require("path"));
     import_ml = require("@tradejs/infra/ml");
     init_checkpoint();
@@ -25521,7 +25484,7 @@ var init_mlExport = __esm({
     };
     main30 = async () => {
       const outDir = String(flags20.outDir || "data/ml/export");
-      await import_promises18.default.mkdir(outDir, { recursive: true });
+      await import_promises19.default.mkdir(outDir, { recursive: true });
       const strategyName = await resolveExportStrategy({
         explicitStrategy: String(flags20.strategy || ""),
         outDir,
@@ -25566,7 +25529,7 @@ var init_mlExport = __esm({
       const shouldDeleteChunks = !Boolean(flags20.keepChunks);
       if (shouldDeleteChunks) {
         for (const filePath of chunkFiles) {
-          await import_promises18.default.rm(filePath, { force: true });
+          await import_promises19.default.rm(filePath, { force: true });
         }
       }
       console.log(import_chalk37.default.green(`Merged dataset saved: ${mergedPath}`));
@@ -25587,13 +25550,13 @@ var mlInspect_exports = {};
 __export(mlInspect_exports, {
   main: () => main31
 });
-var import_args23, import_chalk38, import_promises19, import_fs3, import_path9, import_readline2, import_child_process2, flags21, toMode, toInspectTool, selectInspectTool, asPositiveInt, readRowsHead, readRowsTail, readRowsSample, quantileSorted, mean2, std, findLatestDataset, buildNumericStats, formatNumber5, runQuickInspect, runYDataInspect, main31;
+var import_args23, import_chalk38, import_promises20, import_fs3, import_path9, import_readline2, import_child_process2, flags21, toMode, toInspectTool, selectInspectTool, asPositiveInt, readRowsHead, readRowsTail, readRowsSample, quantileSorted, mean2, std, findLatestDataset, buildNumericStats, formatNumber5, runQuickInspect, runYDataInspect, main31;
 var init_mlInspect = __esm({
   "src/scripts/mlInspect.ts"() {
     "use strict";
     import_args23 = __toESM(require("args"));
     import_chalk38 = __toESM(require("chalk"));
-    import_promises19 = __toESM(require("fs/promises"));
+    import_promises20 = __toESM(require("fs/promises"));
     import_fs3 = require("fs");
     import_path9 = __toESM(require("path"));
     import_readline2 = __toESM(require("readline"));
@@ -25770,7 +25733,7 @@ var init_mlInspect = __esm({
     };
     findLatestDataset = async (params) => {
       const { dir, strategy } = params;
-      const entries = await import_promises19.default.readdir(dir, { withFileTypes: true });
+      const entries = await import_promises20.default.readdir(dir, { withFileTypes: true });
       const strategyToken = strategy.trim().toLowerCase();
       const files = entries.filter((entry) => entry.isFile()).map((entry) => entry.name).filter((name) => name.endsWith(".jsonl")).filter(
         (name) => !name.includes(".train.") && !name.includes(".test.")
@@ -25782,7 +25745,7 @@ var init_mlInspect = __esm({
       }
       const withMtime = await Promise.all(
         files.map(async (name) => {
-          const stat = await import_promises19.default.stat(import_path9.default.join(dir, name));
+          const stat = await import_promises20.default.stat(import_path9.default.join(dir, name));
           return { name, mtime: stat.mtimeMs };
         })
       );
@@ -26027,7 +25990,7 @@ var init_mlInspect = __esm({
       const relToData = import_path9.default.relative(dataRoot, absDatasetPath);
       const inputInContainer = `/app/data/${relToData}`;
       const reportDir = import_path9.default.dirname(absDatasetPath);
-      await import_promises19.default.mkdir(reportDir, { recursive: true });
+      await import_promises20.default.mkdir(reportDir, { recursive: true });
       const reportPath = import_path9.default.join(
         reportDir,
         `${import_path9.default.basename(datasetPath, import_path9.default.extname(datasetPath))}.profile.html`
@@ -26123,12 +26086,12 @@ var mlTrainLatestSelect_exports = {};
 __export(mlTrainLatestSelect_exports, {
   main: () => main32
 });
-var import_path10, import_promises20, import_fs4, import_crypto2, import_child_process3, import_events, import_readline3, import_args24, import_chalk39, import_ml2, toFileToken6, asBool, asInt7, asNonNegativeInt, formatBytes, getMlContainerMemUsage, MODEL_TYPES, STRATEGIES, flags22, parseStrategy, parseModelType, selectModelType, listDatasetFiles, concatFiles, pipeNormalized, DAY_MS11, SPLIT_PROGRESS_EVERY, parseTimestampMs, scanMaxLabeledTimestampMs, scanMaxTrainTimestampMs, hashFileNameSha1, prepareTrainWindowFiles, main32;
+var import_path10, import_promises21, import_fs4, import_crypto2, import_child_process3, import_events, import_readline3, import_args24, import_chalk39, import_ml2, toFileToken6, asBool, asInt7, asNonNegativeInt, formatBytes, getMlContainerMemUsage, MODEL_TYPES, STRATEGIES, flags22, parseStrategy, parseModelType, selectModelType, listDatasetFiles, concatFiles, pipeNormalized, DAY_MS11, SPLIT_PROGRESS_EVERY, parseTimestampMs, scanMaxLabeledTimestampMs, scanMaxTrainTimestampMs, hashFileNameSha1, prepareTrainWindowFiles, main32;
 var init_mlTrainLatestSelect = __esm({
   "src/scripts/mlTrainLatestSelect.ts"() {
     "use strict";
     import_path10 = __toESM(require("path"));
-    import_promises20 = __toESM(require("fs/promises"));
+    import_promises21 = __toESM(require("fs/promises"));
     import_fs4 = require("fs");
     import_crypto2 = require("crypto");
     import_child_process3 = require("child_process");
@@ -26257,7 +26220,7 @@ var init_mlTrainLatestSelect = __esm({
       return defaultModel;
     };
     listDatasetFiles = async (dir, strategyName) => {
-      const entries = await import_promises20.default.readdir(dir, { withFileTypes: true });
+      const entries = await import_promises21.default.readdir(dir, { withFileTypes: true });
       const prefix = `ml-dataset-${toFileToken6(strategyName)}-`;
       const legacyPrefix = "ml-dataset-";
       const fileNames = entries.filter((entry) => entry.isFile()).map((entry) => entry.name);
@@ -26268,7 +26231,7 @@ var init_mlTrainLatestSelect = __esm({
       ).filter((name) => !name.includes(".train.") && !name.includes(".test.")).filter((name) => !name.includes(".holdout-train.")).filter((name) => !name.includes(".holdout-test.")).filter((name) => !name.includes(".walk-forward.")).filter((name) => !name.includes(".prod."));
       const withMtime = await Promise.all(
         jsonlFiles.map(async (name) => {
-          const stat = await import_promises20.default.stat(import_path10.default.join(dir, name));
+          const stat = await import_promises21.default.stat(import_path10.default.join(dir, name));
           return { name, mtime: stat.mtimeMs };
         })
       );
@@ -26444,13 +26407,13 @@ var init_mlTrainLatestSelect = __esm({
       const metaPath = import_path10.default.join(dir, `${parsed.name}.windows.${key}.meta.json`);
       try {
         const [metaRaw] = await Promise.all([
-          import_promises20.default.readFile(metaPath, "utf8"),
-          import_promises20.default.access(holdoutTrainPath),
-          import_promises20.default.access(holdoutTestPath),
-          import_promises20.default.access(prodPath),
+          import_promises21.default.readFile(metaPath, "utf8"),
+          import_promises21.default.access(holdoutTrainPath),
+          import_promises21.default.access(holdoutTestPath),
+          import_promises21.default.access(prodPath),
           ...walkForwardFoldDefs.flatMap((entry) => [
-            import_promises20.default.access(entry.trainPath),
-            import_promises20.default.access(entry.testPath)
+            import_promises21.default.access(entry.trainPath),
+            import_promises21.default.access(entry.testPath)
           ])
         ]);
         const meta2 = JSON.parse(metaRaw);
@@ -26817,7 +26780,7 @@ var init_mlTrainLatestSelect = __esm({
         },
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
-      await import_promises20.default.writeFile(metaPath, `${JSON.stringify(meta, null, 2)}
+      await import_promises21.default.writeFile(metaPath, `${JSON.stringify(meta, null, 2)}
 `, "utf8");
       return {
         holdoutTrainPath,
@@ -26875,7 +26838,7 @@ var init_mlTrainLatestSelect = __esm({
         process.exit(1);
       }
       try {
-        const inputStat = await import_promises20.default.stat(inputPath);
+        const inputStat = await import_promises21.default.stat(inputPath);
         const totalInputBytes = inputStat.size;
         const autoIncrementalThresholdGb = asInt7(
           process.env.ML_TRAIN_INCREMENTAL_THRESHOLD_GB,
@@ -27064,7 +27027,7 @@ var init_mlTrainLatestSelect = __esm({
           const modelDir = import_path10.default.join(modelDirRoot, "models");
           let savedModels = [];
           try {
-            const entries = await import_promises20.default.readdir(modelDir, { withFileTypes: true });
+            const entries = await import_promises21.default.readdir(modelDir, { withFileTypes: true });
             savedModels = entries.filter((entry) => entry.isFile()).map((entry) => entry.name).filter(
               (name) => name === `${selected}.joblib` || /^.+\.model\d+\.joblib$/.test(name)
             ).filter((name) => name.startsWith(`${selected}.`)).sort();
@@ -27086,7 +27049,7 @@ var init_mlTrainLatestSelect = __esm({
         process.exitCode = finalCode;
       } finally {
         for (const file of cleanupFiles) {
-          await import_promises20.default.rm(file, { force: true });
+          await import_promises21.default.rm(file, { force: true });
         }
       }
       process.exit(process.exitCode ?? 1);
@@ -27118,14 +27081,14 @@ __export(researchAuto_exports, {
   toStrategyConfigGrid: () => toStrategyConfigGrid2,
   trimTextTail: () => trimTextTail2
 });
-var import_args25, import_chalk40, import_node_child_process5, import_promises21, import_node_os2, import_node_path15, import_constants18, import_ai8, import_logger6, import_redis16, import_registry4, flags23, projectRoot8, dotenvPath, getResearchAutoLockPath, readResearchAutoLock, isProcessAlive, acquireResearchAutoLock, releaseResearchAutoLock, resolvePositiveInteger, resolveHeapMbFromEnv, buildNodeOptions, RESEARCH_AUTO_PARENT_HEAP_MB, RESEARCH_AUTO_BACKTEST_PARENT_HEAP_MB, RESEARCH_AUTO_AI_TRAIN_PARENT_HEAP_MB, RESEARCH_AUTO_AGENT_PARENT_HEAP_MB, trimTextTail2, escapeHtml3, createEmptySteps, saveRun, listMergedFiles3, getBacktestResultsPrefix, listRuntimeStrategyNames, toStrategyConfigGrid2, formatMskDateTime, buildTelegramReport, runCliCommand, resolveTarget, parseJsonOutput, logResearch, executeNonBlockingStep, main33;
+var import_args25, import_chalk40, import_node_child_process5, import_promises22, import_node_os2, import_node_path15, import_constants18, import_ai8, import_logger6, import_redis16, import_registry4, flags23, projectRoot8, dotenvPath, getResearchAutoLockPath, readResearchAutoLock, isProcessAlive, acquireResearchAutoLock, releaseResearchAutoLock, resolvePositiveInteger, resolveHeapMbFromEnv, buildNodeOptions, RESEARCH_AUTO_PARENT_HEAP_MB, RESEARCH_AUTO_BACKTEST_PARENT_HEAP_MB, RESEARCH_AUTO_AI_TRAIN_PARENT_HEAP_MB, RESEARCH_AUTO_AGENT_PARENT_HEAP_MB, trimTextTail2, escapeHtml3, createEmptySteps, saveRun, listMergedFiles3, getBacktestResultsPrefix, listRuntimeStrategyNames, toStrategyConfigGrid2, formatMskDateTime, buildTelegramReport, runCliCommand, resolveTarget, parseJsonOutput, logResearch, executeNonBlockingStep, main33;
 var init_researchAuto = __esm({
   "src/scripts/researchAuto.ts"() {
     "use strict";
     import_args25 = __toESM(require("args"));
     import_chalk40 = __toESM(require("chalk"));
     import_node_child_process5 = require("child_process");
-    import_promises21 = __toESM(require("fs/promises"));
+    import_promises22 = __toESM(require("fs/promises"));
     import_node_os2 = __toESM(require("os"));
     import_node_path15 = __toESM(require("path"));
     import_constants18 = require("@tradejs/core/constants");
@@ -27172,7 +27135,7 @@ var init_researchAuto = __esm({
     );
     readResearchAutoLock = async (lockPath) => {
       try {
-        const raw = await import_promises21.default.readFile(lockPath, "utf8");
+        const raw = await import_promises22.default.readFile(lockPath, "utf8");
         return JSON.parse(raw);
       } catch {
         return null;
@@ -27207,9 +27170,9 @@ var init_researchAuto = __esm({
         startedAt,
         argv: [...process.argv]
       };
-      await import_promises21.default.mkdir(import_node_path15.default.dirname(lockPath), { recursive: true });
+      await import_promises22.default.mkdir(import_node_path15.default.dirname(lockPath), { recursive: true });
       const writeLock = async () => {
-        await import_promises21.default.writeFile(lockPath, JSON.stringify(nextLock, null, 2), {
+        await import_promises22.default.writeFile(lockPath, JSON.stringify(nextLock, null, 2), {
           flag: "wx"
         });
       };
@@ -27228,7 +27191,7 @@ var init_researchAuto = __esm({
           `research:auto is already running for user ${userName3} (runId=${existingLock.runId}, strategy=${existingLock.strategy}, pid=${existingLock.pid}, ppid=${existingLock.ppid}, startedAt=${existingLock.startedAt}, host=${existingLock.hostname})`
         );
       }
-      await import_promises21.default.unlink(lockPath).catch(() => void 0);
+      await import_promises22.default.unlink(lockPath).catch(() => void 0);
       await writeLock();
       return lockPath;
     };
@@ -27240,7 +27203,7 @@ var init_researchAuto = __esm({
       if (existingLock && existingLock.pid !== process.pid) {
         return;
       }
-      await import_promises21.default.unlink(lockPath).catch(() => void 0);
+      await import_promises22.default.unlink(lockPath).catch(() => void 0);
     };
     resolvePositiveInteger = (value, fallback) => {
       const parsed = Number.parseInt(String(value ?? ""), 10);
@@ -27342,7 +27305,7 @@ var init_researchAuto = __esm({
     };
     listMergedFiles3 = async (outDir, strategyName) => {
       try {
-        const entries = await import_promises21.default.readdir(outDir);
+        const entries = await import_promises22.default.readdir(outDir);
         const prefix = `ai-dataset-${(0, import_ai8.toFileToken)(strategyName)}-merged-`;
         return entries.filter((name) => name.startsWith(prefix) && name.endsWith(".jsonl")).sort().map((name) => import_node_path15.default.join(outDir, name));
       } catch {
@@ -28010,13 +27973,13 @@ var init_types = __esm({
 function assert(condition, message) {
   if (!condition) throw new Error(`Invalid core research spec: ${message}`);
 }
-var import_node_crypto10, import_node_fs3, import_promises22, import_backtest5, import_node_path16, RESEARCH_ID_RE, SHA256_RE, canonicalJson, sha256Text, sha256Json, sha256File, assertFinite, validateCoreResearchSpec, loadCoreResearchSpec, resolveCoreResearchPaths, writeJsonAtomic, buildLedgerRecordHash, readCoreResearchLedger, verifyCoreResearchLedger, appendCoreResearchLedger, validateCoreResearchParentLineage, prepareCoreResearch, verifyCoreResearchArtifacts, scanCoreResearchStages, writeCoreResearchStageIndex;
+var import_node_crypto11, import_node_fs3, import_promises23, import_backtest5, import_node_path16, RESEARCH_ID_RE, SHA256_RE, canonicalJson, sha256Text, sha256Json, sha256File, assertFinite, validateCoreResearchSpec, loadCoreResearchSpec, resolveCoreResearchPaths, writeJsonAtomic, buildLedgerRecordHash, readCoreResearchLedger, verifyCoreResearchLedger, appendCoreResearchLedger, validateCoreResearchParentLineage, prepareCoreResearch, verifyCoreResearchArtifacts, scanCoreResearchStages, writeCoreResearchStageIndex;
 var init_io = __esm({
   "src/lib/coreResearch/io.ts"() {
     "use strict";
-    import_node_crypto10 = require("crypto");
+    import_node_crypto11 = require("crypto");
     import_node_fs3 = require("fs");
-    import_promises22 = __toESM(require("fs/promises"));
+    import_promises23 = __toESM(require("fs/promises"));
     import_backtest5 = require("@tradejs/core/backtest");
     import_node_path16 = __toESM(require("path"));
     init_types();
@@ -28034,10 +27997,10 @@ var init_io = __esm({
       };
       return JSON.stringify(normalize(value));
     };
-    sha256Text = (value) => (0, import_node_crypto10.createHash)("sha256").update(value).digest("hex");
+    sha256Text = (value) => (0, import_node_crypto11.createHash)("sha256").update(value).digest("hex");
     sha256Json = (value) => sha256Text(canonicalJson(value));
     sha256File = async (filePath) => {
-      const hash = (0, import_node_crypto10.createHash)("sha256");
+      const hash = (0, import_node_crypto11.createHash)("sha256");
       const input = (0, import_node_fs3.createReadStream)(filePath);
       for await (const chunk of input) hash.update(chunk);
       return hash.digest("hex");
@@ -28278,7 +28241,7 @@ var init_io = __esm({
     };
     loadCoreResearchSpec = async (specPath) => {
       const resolvedPath = import_node_path16.default.resolve(specPath);
-      const parsed = JSON.parse(await import_promises22.default.readFile(resolvedPath, "utf8"));
+      const parsed = JSON.parse(await import_promises23.default.readFile(resolvedPath, "utf8"));
       const spec = validateCoreResearchSpec(parsed);
       return { resolvedPath, spec, specSha256: sha256Json(spec) };
     };
@@ -28300,17 +28263,17 @@ var init_io = __esm({
       };
     };
     writeJsonAtomic = async (filePath, value) => {
-      await import_promises22.default.mkdir(import_node_path16.default.dirname(filePath), { recursive: true });
+      await import_promises23.default.mkdir(import_node_path16.default.dirname(filePath), { recursive: true });
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-      await import_promises22.default.writeFile(temporaryPath, `${canonicalJson(value)}
+      await import_promises23.default.writeFile(temporaryPath, `${canonicalJson(value)}
 `, "utf8");
-      await import_promises22.default.rename(temporaryPath, filePath);
+      await import_promises23.default.rename(temporaryPath, filePath);
     };
     buildLedgerRecordHash = (record) => sha256Json(record);
     readCoreResearchLedger = async (ledgerPath) => {
       let text = "";
       try {
-        text = await import_promises22.default.readFile(ledgerPath, "utf8");
+        text = await import_promises23.default.readFile(ledgerPath, "utf8");
       } catch (error) {
         if (error.code === "ENOENT") return [];
         throw error;
@@ -28347,11 +28310,11 @@ var init_io = __esm({
     };
     appendCoreResearchLedger = async (params) => {
       const { ledgerPath } = params;
-      await import_promises22.default.mkdir(import_node_path16.default.dirname(ledgerPath), { recursive: true });
+      await import_promises23.default.mkdir(import_node_path16.default.dirname(ledgerPath), { recursive: true });
       const lockPath = `${ledgerPath}.lock`;
       let lock = null;
       try {
-        lock = await import_promises22.default.open(lockPath, "wx");
+        lock = await import_promises23.default.open(lockPath, "wx");
         const records = await readCoreResearchLedger(ledgerPath);
         const verified = verifyCoreResearchLedger(records);
         const payload = {
@@ -28370,7 +28333,7 @@ var init_io = __esm({
           ...payload,
           recordHash: buildLedgerRecordHash(payload)
         };
-        await import_promises22.default.appendFile(ledgerPath, `${canonicalJson(record)}
+        await import_promises23.default.appendFile(ledgerPath, `${canonicalJson(record)}
 `, "utf8");
         return record;
       } catch (error) {
@@ -28380,7 +28343,7 @@ var init_io = __esm({
         throw error;
       } finally {
         await lock?.close();
-        await import_promises22.default.rm(lockPath, { force: true });
+        await import_promises23.default.rm(lockPath, { force: true });
       }
     };
     validateCoreResearchParentLineage = async (spec) => {
@@ -28391,9 +28354,9 @@ var init_io = __esm({
       for (const parentResearchId of spec.parentResearchIds ?? []) {
         const parentDir = import_node_path16.default.join(rootDir, parentResearchId);
         const [parentSpec, parentManifest, parentResult] = await Promise.all([
-          import_promises22.default.readFile(import_node_path16.default.join(parentDir, "spec.json"), "utf8").then((text) => JSON.parse(text)),
-          import_promises22.default.readFile(import_node_path16.default.join(parentDir, "manifest.json"), "utf8").then((text) => JSON.parse(text)),
-          import_promises22.default.readFile(import_node_path16.default.join(parentDir, "result.json"), "utf8").then((text) => JSON.parse(text))
+          import_promises23.default.readFile(import_node_path16.default.join(parentDir, "spec.json"), "utf8").then((text) => JSON.parse(text)),
+          import_promises23.default.readFile(import_node_path16.default.join(parentDir, "manifest.json"), "utf8").then((text) => JSON.parse(text)),
+          import_promises23.default.readFile(import_node_path16.default.join(parentDir, "result.json"), "utf8").then((text) => JSON.parse(text))
         ]);
         validateCoreResearchSpec(parentSpec);
         if (parentManifest.status !== "completed") {
@@ -28440,12 +28403,12 @@ var init_io = __esm({
       await validateCoreResearchParentLineage(spec);
       const specSha256 = sha256Json(spec);
       const paths = resolveCoreResearchPaths(spec);
-      await import_promises22.default.mkdir(paths.researchDir, { recursive: true });
+      await import_promises23.default.mkdir(paths.researchDir, { recursive: true });
       let existing = null;
       let existingManifest = null;
       try {
         existing = JSON.parse(
-          await import_promises22.default.readFile(paths.specPath, "utf8")
+          await import_promises23.default.readFile(paths.specPath, "utf8")
         );
       } catch (error) {
         if (error.code !== "ENOENT") throw error;
@@ -28458,7 +28421,7 @@ var init_io = __esm({
       if (existing) {
         try {
           existingManifest = JSON.parse(
-            await import_promises22.default.readFile(paths.manifestPath, "utf8")
+            await import_promises23.default.readFile(paths.manifestPath, "utf8")
           );
         } catch (error) {
           if (error.code !== "ENOENT") throw error;
@@ -28497,7 +28460,7 @@ var init_io = __esm({
     verifyCoreResearchArtifacts = async (spec) => {
       const paths = resolveCoreResearchPaths(spec);
       const manifest = JSON.parse(
-        await import_promises22.default.readFile(paths.manifestPath, "utf8")
+        await import_promises23.default.readFile(paths.manifestPath, "utf8")
       );
       if (manifest.specSha256 !== sha256Json(spec)) {
         throw new Error("Manifest spec hash does not match the supplied spec");
@@ -28525,7 +28488,7 @@ var init_io = __esm({
       const resolvedRoot = import_node_path16.default.resolve(rootDir);
       let entries = [];
       try {
-        entries = await import_promises22.default.readdir(resolvedRoot);
+        entries = await import_promises23.default.readdir(resolvedRoot);
       } catch (error) {
         if (error.code === "ENOENT") {
           return {
@@ -28541,14 +28504,14 @@ var init_io = __esm({
         (left, right) => left < right ? -1 : left > right ? 1 : 0
       )) {
         const researchDir = import_node_path16.default.join(resolvedRoot, entry);
-        const stats = await import_promises22.default.stat(researchDir);
+        const stats = await import_promises23.default.stat(researchDir);
         if (!stats.isDirectory()) continue;
         let spec;
         let manifest;
         try {
           [spec, manifest] = await Promise.all([
-            import_promises22.default.readFile(import_node_path16.default.join(researchDir, "spec.json"), "utf8").then((text) => JSON.parse(text)),
-            import_promises22.default.readFile(import_node_path16.default.join(researchDir, "manifest.json"), "utf8").then((text) => JSON.parse(text))
+            import_promises23.default.readFile(import_node_path16.default.join(researchDir, "spec.json"), "utf8").then((text) => JSON.parse(text)),
+            import_promises23.default.readFile(import_node_path16.default.join(researchDir, "manifest.json"), "utf8").then((text) => JSON.parse(text))
           ]);
         } catch (error) {
           if (error.code === "ENOENT") continue;
@@ -28558,7 +28521,7 @@ var init_io = __esm({
         if (manifest.specSha256 !== sha256Json(spec)) {
           throw new Error(`Stage index found a spec hash mismatch for ${entry}`);
         }
-        const result = manifest.status === "completed" ? await import_promises22.default.readFile(import_node_path16.default.join(researchDir, "result.json"), "utf8").then((text) => JSON.parse(text)) : null;
+        const result = manifest.status === "completed" ? await import_promises23.default.readFile(import_node_path16.default.join(researchDir, "result.json"), "utf8").then((text) => JSON.parse(text)) : null;
         familyByResearch.set(spec.researchId, spec.hypothesis.family);
         experiments.push({
           researchId: spec.researchId,
@@ -28613,13 +28576,13 @@ var init_io = __esm({
 });
 
 // src/lib/coreResearch/artifacts.ts
-var import_node_fs4, import_node_events, import_promises23, import_node_path17, csv, writeLine, closeOutput, writeCoreResearchMatches, writeCoreResearchTrades;
+var import_node_fs4, import_node_events, import_promises24, import_node_path17, csv, writeLine, closeOutput, writeCoreResearchMatches, writeCoreResearchTrades;
 var init_artifacts = __esm({
   "src/lib/coreResearch/artifacts.ts"() {
     "use strict";
     import_node_fs4 = require("fs");
     import_node_events = require("events");
-    import_promises23 = __toESM(require("fs/promises"));
+    import_promises24 = __toESM(require("fs/promises"));
     import_node_path17 = __toESM(require("path"));
     init_io();
     csv = (value) => {
@@ -28634,7 +28597,7 @@ var init_artifacts = __esm({
       await (0, import_node_events.once)(output, "close");
     };
     writeCoreResearchMatches = async (params) => {
-      await import_promises23.default.mkdir(import_node_path17.default.dirname(params.filePath), { recursive: true });
+      await import_promises24.default.mkdir(import_node_path17.default.dirname(params.filePath), { recursive: true });
       const output = (0, import_node_fs4.createWriteStream)(params.filePath, { encoding: "utf8" });
       await writeLine(
         output,
@@ -28685,7 +28648,7 @@ var init_artifacts = __esm({
       await closeOutput(output);
     };
     writeCoreResearchTrades = async (params) => {
-      await import_promises23.default.mkdir(import_node_path17.default.dirname(params.filePath), { recursive: true });
+      await import_promises24.default.mkdir(import_node_path17.default.dirname(params.filePath), { recursive: true });
       const output = (0, import_node_fs4.createWriteStream)(params.filePath, { encoding: "utf8" });
       for (const variant of params.variants) {
         for (const trade of variant.trades) {
@@ -28925,14 +28888,14 @@ var init_rules = __esm({
 });
 
 // src/lib/coreResearch/statistics.ts
-var import_node_crypto11, createSeededRandom, percentile, calendarClusterBootstrap, applyHolmCorrection, inverseNormalCdf, erf, normalCdf, deflatedSharpeDiagnostic, combinations, probabilityOfBacktestOverfitting;
+var import_node_crypto12, createSeededRandom, percentile, calendarClusterBootstrap, applyHolmCorrection, inverseNormalCdf, erf, normalCdf, deflatedSharpeDiagnostic, combinations, probabilityOfBacktestOverfitting;
 var init_statistics = __esm({
   "src/lib/coreResearch/statistics.ts"() {
     "use strict";
-    import_node_crypto11 = require("crypto");
+    import_node_crypto12 = require("crypto");
     init_metrics();
     createSeededRandom = (seedText) => {
-      const digest = (0, import_node_crypto11.createHash)("sha256").update(seedText).digest();
+      const digest = (0, import_node_crypto12.createHash)("sha256").update(seedText).digest();
       let state = digest.readUInt32LE(0) || 1;
       return () => {
         state ^= state << 13;
@@ -29399,11 +29362,11 @@ var init_comparison = __esm({
 });
 
 // src/lib/coreResearch/dataset.ts
-var import_node_crypto12, import_node_fs5, import_node_path18, import_node_readline2, asRecord4, finiteNumber4, normalizeDirection, findStrategySetupIdentity, classifyBreadth, classifyDerivatives, resolveCoreResearchRegime, normalizeCompletedTrade, completedTradeIdentity, positionCycleIdentity, sumBy, weightedPrice, aggregatePositionCycles, compareText, compareTrades, readCoreResearchVariant;
+var import_node_crypto13, import_node_fs5, import_node_path18, import_node_readline2, asRecord4, finiteNumber4, normalizeDirection, findStrategySetupIdentity, classifyBreadth, classifyDerivatives, resolveCoreResearchRegime, normalizeCompletedTrade, completedTradeIdentity, positionCycleIdentity, sumBy, weightedPrice, aggregatePositionCycles, compareText, compareTrades, readCoreResearchVariant;
 var init_dataset2 = __esm({
   "src/lib/coreResearch/dataset.ts"() {
     "use strict";
-    import_node_crypto12 = require("crypto");
+    import_node_crypto13 = require("crypto");
     import_node_fs5 = require("fs");
     import_node_path18 = __toESM(require("path"));
     import_node_readline2 = __toESM(require("readline"));
@@ -29618,7 +29581,7 @@ var init_dataset2 = __esm({
       for (const inputPath of variant.files) {
         const filePath = import_node_path18.default.resolve(inputPath);
         const input = (0, import_node_fs5.createReadStream)(filePath);
-        const hash = (0, import_node_crypto12.createHash)("sha256");
+        const hash = (0, import_node_crypto13.createHash)("sha256");
         input.on("data", (chunk) => hash.update(chunk));
         const lines = import_node_readline2.default.createInterface({ input, crlfDelay: Infinity });
         const fileTrades = [];
@@ -30108,11 +30071,11 @@ var init_selection = __esm({
 });
 
 // src/lib/coreResearch/trace.ts
-var import_promises24, import_node_path19, summarizeCoreResearchTrace;
+var import_promises25, import_node_path19, summarizeCoreResearchTrace;
 var init_trace = __esm({
   "src/lib/coreResearch/trace.ts"() {
     "use strict";
-    import_promises24 = __toESM(require("fs/promises"));
+    import_promises25 = __toESM(require("fs/promises"));
     import_node_path19 = __toESM(require("path"));
     summarizeCoreResearchTrace = async (filePaths = []) => {
       const events = /* @__PURE__ */ Object.create(null);
@@ -30120,7 +30083,7 @@ var init_trace = __esm({
       const exitCodes = /* @__PURE__ */ Object.create(null);
       for (const inputPath of filePaths) {
         const filePath = import_node_path19.default.resolve(inputPath);
-        const text = await import_promises24.default.readFile(filePath, "utf8");
+        const text = await import_promises25.default.readFile(filePath, "utf8");
         for (const [index, line] of text.split("\n").entries()) {
           if (!line.trim()) continue;
           let event;
@@ -30160,14 +30123,14 @@ var init_trace = __esm({
 });
 
 // src/lib/coreResearch/orchestrator.ts
-var import_promises25, import_node_path20, import_node_child_process6, import_node_crypto13, import_coreResearch, summarizeSupplementalFiles, analyzeCoreResearchPrepared, analyzeCoreResearch, createCoreResearchSpecTemplate, runCommand2, commandValue, commandHas, validateCoreResearchRunCommand, runCoreResearch;
+var import_promises26, import_node_path20, import_node_child_process6, import_node_crypto14, import_coreResearch, summarizeSupplementalFiles, analyzeCoreResearchPrepared, analyzeCoreResearch, createCoreResearchSpecTemplate, runCommand2, commandValue, commandHas, validateCoreResearchRunCommand, runCoreResearch;
 var init_orchestrator = __esm({
   "src/lib/coreResearch/orchestrator.ts"() {
     "use strict";
-    import_promises25 = __toESM(require("fs/promises"));
+    import_promises26 = __toESM(require("fs/promises"));
     import_node_path20 = __toESM(require("path"));
     import_node_child_process6 = require("child_process");
-    import_node_crypto13 = require("crypto");
+    import_node_crypto14 = require("crypto");
     import_coreResearch = require("@tradejs/infra/coreResearch");
     init_artifacts();
     init_io();
@@ -30456,7 +30419,7 @@ var init_orchestrator = __esm({
       const tradesByVariant = new Map(
         windowed.map((entry) => [entry.variant.id, entry.trades])
       );
-      await import_promises25.default.writeFile(
+      await import_promises26.default.writeFile(
         paths.reportPath,
         buildCoreResearchHtml({ spec, result, tradesByVariant }),
         "utf8"
@@ -30476,7 +30439,7 @@ var init_orchestrator = __esm({
         if (error.code !== "ENOENT") throw error;
       }
       try {
-        for (const name of await import_promises25.default.readdir(paths.runLogDir)) {
+        for (const name of await import_promises26.default.readdir(paths.runLogDir)) {
           if (!name.endsWith(".log")) continue;
           artifactHashes[`runs/${name}`] = await sha256File(
             import_node_path20.default.join(paths.runLogDir, name)
@@ -30569,7 +30532,7 @@ var init_orchestrator = __esm({
             gitSha,
             ...sourceRepository ? { sourceRepository } : {},
             ...dirtyDiff ? {
-              dirtyDiffSha256: (0, import_node_crypto13.createHash)("sha256").update(dirtyDiff).digest("hex")
+              dirtyDiffSha256: (0, import_node_crypto14.createHash)("sha256").update(dirtyDiff).digest("hex")
             } : {}
           };
         } catch {
@@ -30676,7 +30639,7 @@ var init_orchestrator = __esm({
     };
     runCommand2 = async (params) => {
       if (!params.command.length) throw new Error("Cannot run an empty command");
-      await import_promises25.default.mkdir(import_node_path20.default.dirname(params.logPath), { recursive: true });
+      await import_promises26.default.mkdir(import_node_path20.default.dirname(params.logPath), { recursive: true });
       const chunks = [];
       const child = (0, import_node_child_process6.spawn)(params.command[0], params.command.slice(1), {
         cwd: params.cwd,
@@ -30696,7 +30659,7 @@ var init_orchestrator = __esm({
         child.once("close", (code) => resolve(code ?? 1));
       });
       const output = chunks.join("");
-      await import_promises25.default.writeFile(params.logPath, output, "utf8");
+      await import_promises26.default.writeFile(params.logPath, output, "utf8");
       if (exitCode !== 0) {
         throw new Error(
           `Command failed with exit ${exitCode}: ${params.command.join(" ")}`
@@ -30901,11 +30864,11 @@ var coreResearch_exports = {};
 __export(coreResearch_exports, {
   main: () => main34
 });
-var import_promises26, import_node_path21, import_chalk41, valueAfter, required, parseTimestamp, readSymbols, printUsage, main34;
+var import_promises27, import_node_path21, import_chalk41, valueAfter, required, parseTimestamp, readSymbols, printUsage, main34;
 var init_coreResearch = __esm({
   "src/scripts/coreResearch.ts"() {
     "use strict";
-    import_promises26 = __toESM(require("fs/promises"));
+    import_promises27 = __toESM(require("fs/promises"));
     import_node_path21 = __toESM(require("path"));
     import_chalk41 = __toESM(require("chalk"));
     init_io();
@@ -30930,7 +30893,7 @@ var init_coreResearch = __esm({
       const symbolsFile = valueAfter(argv2, "--symbolsFile");
       if (symbolsFile) {
         const parsed = JSON.parse(
-          await import_promises26.default.readFile(import_node_path21.default.resolve(projectRoot18, symbolsFile), "utf8")
+          await import_promises27.default.readFile(import_node_path21.default.resolve(projectRoot18, symbolsFile), "utf8")
         );
         if (!Array.isArray(parsed) || parsed.some((symbol) => typeof symbol !== "string")) {
           throw new Error("--symbolsFile must contain a JSON string array");
@@ -31655,11 +31618,11 @@ __export(replayRuntimeEvidence_exports, {
   replayRuntimeEvidence: () => replayRuntimeEvidence,
   summarizeReplayComparison: () => summarizeReplayComparison
 });
-var import_promises27, import_node_path22, import_args27, import_chalk43, import_redis19, toEpochMs2, resolveWindow, parseStrategyFilter, asRecord5, asArray2, sum, groupCount, compactMatched, resolveItemStrategy, summarizeReplayComparison, loadReplayResult, getReplayStrategies, loadRuntimePayload, replayRuntimeEvidence, main36;
+var import_promises28, import_node_path22, import_args27, import_chalk43, import_redis19, toEpochMs2, resolveWindow, parseStrategyFilter, asRecord5, asArray2, sum, groupCount, compactMatched, resolveItemStrategy, summarizeReplayComparison, loadReplayResult, getReplayStrategies, loadRuntimePayload, replayRuntimeEvidence, main36;
 var init_replayRuntimeEvidence = __esm({
   "src/scripts/replayRuntimeEvidence.ts"() {
     "use strict";
-    import_promises27 = __toESM(require("fs/promises"));
+    import_promises28 = __toESM(require("fs/promises"));
     import_node_path22 = __toESM(require("path"));
     import_args27 = __toESM(require("args"));
     import_chalk43 = __toESM(require("chalk"));
@@ -31922,7 +31885,7 @@ var init_replayRuntimeEvidence = __esm({
       const runtimeEvidencePath = typeof runtimeEvidenceFile === "string" && runtimeEvidenceFile.trim() ? import_node_path22.default.resolve(projectRoot18, runtimeEvidenceFile.trim()) : null;
       if (runtimeEvidencePath) {
         const artifact = JSON.parse(
-          await import_promises27.default.readFile(runtimeEvidencePath, "utf8")
+          await import_promises28.default.readFile(runtimeEvidencePath, "utf8")
         );
         return {
           source: "file",
@@ -32009,8 +31972,8 @@ var init_replayRuntimeEvidence = __esm({
         runtime: runtime.payload
       };
       const outPath = import_node_path22.default.resolve(projectRoot18, String(flags35.out));
-      await import_promises27.default.mkdir(import_node_path22.default.dirname(outPath), { recursive: true });
-      await import_promises27.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
+      await import_promises28.default.mkdir(import_node_path22.default.dirname(outPath), { recursive: true });
+      await import_promises28.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
 `, "utf8");
       console.log(import_chalk43.default.green(`Wrote ${outPath}`));
       console.log(
@@ -32032,6 +31995,15 @@ var init_replayRuntimeEvidence = __esm({
   }
 });
 
+// src/lib/runtimeEvidenceProducer.ts
+var runtimeEvidenceProducer_exports = {};
+var init_runtimeEvidenceProducer = __esm({
+  "src/lib/runtimeEvidenceProducer.ts"() {
+    "use strict";
+    __reExport(runtimeEvidenceProducer_exports, require("@tradejs/node/diagnostics"));
+  }
+});
+
 // src/lib/runtimeFeedbackArtifacts.ts
 var runtimeFeedbackArtifacts_exports = {};
 var init_runtimeFeedbackArtifacts = __esm({
@@ -32042,12 +32014,12 @@ var init_runtimeFeedbackArtifacts = __esm({
 });
 
 // src/lib/runtimeFeedbackReplay.ts
-var import_node_child_process7, import_promises28, import_node_path23, REQUIRED_ENV, FORBIDDEN_SECRET_ENV, unsafeRedisHosts, safeSegment, assertRuntimeFeedbackReplaySafety, buildRuntimeFeedbackReplayCommands, runLoggedCommand, runRuntimeFeedbackReplay;
+var import_node_child_process7, import_promises29, import_node_path23, REQUIRED_ENV, FORBIDDEN_SECRET_ENV, unsafeRedisHosts, safeSegment, assertRuntimeFeedbackReplaySafety, buildRuntimeFeedbackReplayCommands, runLoggedCommand, runRuntimeFeedbackReplay;
 var init_runtimeFeedbackReplay = __esm({
   "src/lib/runtimeFeedbackReplay.ts"() {
     "use strict";
     import_node_child_process7 = require("child_process");
-    import_promises28 = __toESM(require("fs/promises"));
+    import_promises29 = __toESM(require("fs/promises"));
     import_node_path23 = __toESM(require("path"));
     init_runtimeEvidenceDeployment();
     init_runtimeEvidenceArtifacts();
@@ -32264,15 +32236,15 @@ $ ${[executable, ...command].join(" ")}
       if (!intervals.size) {
         throw new Error("Runtime feedback replay requires an active interval");
       }
-      await import_promises28.default.mkdir(outDir, { recursive: true });
-      const existing = await import_promises28.default.readdir(outDir);
+      await import_promises29.default.mkdir(outDir, { recursive: true });
+      const existing = await import_promises29.default.readdir(outDir);
       if (existing.length) {
         throw new Error(
           `Runtime feedback output directory must be empty: ${outDir}`
         );
       }
       const replayEvidencePath = import_node_path23.default.join(outDir, runtimeFeedbackArtifacts_exports.RUNTIME_FEEDBACK_REPLAY_FILE);
-      const logHandle = await import_promises28.default.open(
+      const logHandle = await import_promises29.default.open(
         import_node_path23.default.join(outDir, runtimeFeedbackArtifacts_exports.RUNTIME_FEEDBACK_LOG_FILE),
         "wx"
       );
@@ -32530,12 +32502,12 @@ var init_runtimeFeedbackNotify = __esm({
 });
 
 // src/lib/runtimeEvidenceSync.ts
-var import_node_child_process8, import_promises29, import_node_path26, import_node_util, execFileAsync, isExistingDestinationError, safeSegment2, withTrailingSlash, dateParts, buildRuntimeEvidenceRsyncArgs, receiptPath, compareBundles, listPendingRuntimeEvidenceBundles, markRuntimeEvidenceBundleProcessed, syncRuntimeEvidenceBundles;
+var import_node_child_process8, import_promises30, import_node_path26, import_node_util, execFileAsync, isExistingDestinationError, safeSegment2, withTrailingSlash, dateParts, buildRuntimeEvidenceRsyncArgs, receiptPath, compareBundles, listPendingRuntimeEvidenceBundles, markRuntimeEvidenceBundleProcessed, syncRuntimeEvidenceBundles;
 var init_runtimeEvidenceSync = __esm({
   "src/lib/runtimeEvidenceSync.ts"() {
     "use strict";
     import_node_child_process8 = require("child_process");
-    import_promises29 = __toESM(require("fs/promises"));
+    import_promises30 = __toESM(require("fs/promises"));
     import_node_path26 = __toESM(require("path"));
     import_node_util = require("util");
     init_runtimeEvidenceArtifacts();
@@ -32586,7 +32558,7 @@ var init_runtimeEvidenceSync = __esm({
         if (verified.manifest.deploymentId !== safeDeploymentId) continue;
         (0, runtimeEvidenceDeployment_exports.assertCurrentRuntimeEvidenceArtifact)(verified.artifact);
         try {
-          await import_promises29.default.access(receiptPath(receiptsRoot, verified.manifest.artifactId));
+          await import_promises30.default.access(receiptPath(receiptsRoot, verified.manifest.artifactId));
           continue;
         } catch (error) {
           if (error.code !== "ENOENT") throw error;
@@ -32623,14 +32595,14 @@ var init_runtimeEvidenceSync = __esm({
           replayEvidenceSha256: runtimeFeedback.replayEvidenceSha256
         } : {}
       };
-      await import_promises29.default.mkdir(receiptsRoot, { recursive: true });
-      await import_promises29.default.writeFile(
+      await import_promises30.default.mkdir(receiptsRoot, { recursive: true });
+      await import_promises30.default.writeFile(
         temporaryPath,
         `${JSON.stringify(receipt, null, 2)}
 `,
         "utf8"
       );
-      await import_promises29.default.rename(temporaryPath, finalPath);
+      await import_promises30.default.rename(temporaryPath, finalPath);
       return finalPath;
     };
     syncRuntimeEvidenceBundles = async ({
@@ -32648,8 +32620,8 @@ var init_runtimeEvidenceSync = __esm({
       const inboxRoot = import_node_path26.default.join(evidenceRoot, "inbox", safeDeploymentId);
       const artifactsRoot = import_node_path26.default.join(evidenceRoot, "artifacts", safeDeploymentId);
       await Promise.all([
-        import_promises29.default.mkdir(inboxRoot, { recursive: true }),
-        import_promises29.default.mkdir(artifactsRoot, { recursive: true })
+        import_promises30.default.mkdir(inboxRoot, { recursive: true }),
+        import_promises30.default.mkdir(artifactsRoot, { recursive: true })
       ]);
       const rsyncArgs = buildRuntimeEvidenceRsyncArgs({
         source,
@@ -32671,9 +32643,9 @@ var init_runtimeEvidenceSync = __esm({
           ...dateParts(verified.manifest.window.endTime),
           safeSegment2(verified.manifest.artifactId, "artifact")
         );
-        await import_promises29.default.mkdir(import_node_path26.default.dirname(destinationDir), { recursive: true });
+        await import_promises30.default.mkdir(import_node_path26.default.dirname(destinationDir), { recursive: true });
         try {
-          await import_promises29.default.rename(bundleDir, destinationDir);
+          await import_promises30.default.rename(bundleDir, destinationDir);
         } catch (error) {
           if (!isExistingDestinationError(error)) throw error;
           const existing = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(destinationDir);
@@ -32682,7 +32654,7 @@ var init_runtimeEvidenceSync = __esm({
               `Conflicting runtime evidence artifact ${verified.manifest.artifactId}`
             );
           }
-          await import_promises29.default.rm(bundleDir, { recursive: true, force: true });
+          await import_promises30.default.rm(bundleDir, { recursive: true, force: true });
         }
         received.push(await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(destinationDir));
       }
@@ -32702,12 +32674,12 @@ var init_runtimeEvidenceSync = __esm({
 });
 
 // src/lib/runtimeFeedbackSync.ts
-var import_node_child_process9, import_promises30, import_node_path27, import_node_util2, execFileAsync2, isExistingDestinationError2, safeSegment3, dateParts2, syncRuntimeFeedbackReplayBundles;
+var import_node_child_process9, import_promises31, import_node_path27, import_node_util2, execFileAsync2, isExistingDestinationError2, safeSegment3, dateParts2, syncRuntimeFeedbackReplayBundles;
 var init_runtimeFeedbackSync = __esm({
   "src/lib/runtimeFeedbackSync.ts"() {
     "use strict";
     import_node_child_process9 = require("child_process");
-    import_promises30 = __toESM(require("fs/promises"));
+    import_promises31 = __toESM(require("fs/promises"));
     import_node_path27 = __toESM(require("path"));
     import_node_util2 = require("util");
     init_runtimeFeedbackArtifacts();
@@ -32744,8 +32716,8 @@ var init_runtimeFeedbackSync = __esm({
       const inboxRoot = import_node_path27.default.join(feedbackRoot, "inbox", safeDeploymentId);
       const artifactsRoot = import_node_path27.default.join(feedbackRoot, "artifacts", safeDeploymentId);
       await Promise.all([
-        import_promises30.default.mkdir(inboxRoot, { recursive: true }),
-        import_promises30.default.mkdir(artifactsRoot, { recursive: true })
+        import_promises31.default.mkdir(inboxRoot, { recursive: true }),
+        import_promises31.default.mkdir(artifactsRoot, { recursive: true })
       ]);
       const rsyncArgs = buildRuntimeEvidenceRsyncArgs({
         source,
@@ -32767,9 +32739,9 @@ var init_runtimeFeedbackSync = __esm({
           safeSegment3(verified.manifest.runtimeEvidence.artifactId, "artifact"),
           safeSegment3(verified.manifest.runId, "run")
         );
-        await import_promises30.default.mkdir(import_node_path27.default.dirname(destinationDir), { recursive: true });
+        await import_promises31.default.mkdir(import_node_path27.default.dirname(destinationDir), { recursive: true });
         try {
-          await import_promises30.default.rename(bundleDir, destinationDir);
+          await import_promises31.default.rename(bundleDir, destinationDir);
         } catch (error) {
           if (!isExistingDestinationError2(error)) throw error;
           const existing = await (0, runtimeFeedbackArtifacts_exports.verifyRuntimeFeedbackReplayBundle)(destinationDir);
@@ -32778,7 +32750,7 @@ var init_runtimeFeedbackSync = __esm({
               `Conflicting runtime feedback replay ${verified.manifest.artifactId}`
             );
           }
-          await import_promises30.default.rm(bundleDir, { recursive: true, force: true });
+          await import_promises31.default.rm(bundleDir, { recursive: true, force: true });
         }
         received.push(await (0, runtimeFeedbackArtifacts_exports.verifyRuntimeFeedbackReplayBundle)(destinationDir));
       }
@@ -32862,12 +32834,12 @@ var init_runtimeFeedbackSync2 = __esm({
 });
 
 // src/lib/runtimeEvidenceCompositionSnapshots.ts
-var import_node_crypto14, import_promises31, import_node_path29, SNAPSHOT_FILE, MANIFEST_FILE, COMPLETE_FILE, createRuntimeEvidenceCompositionSnapshotRecorder, isRecord2, sha256, safeSegment4, isExistingDestinationError3, parseManifest, verifyRuntimeEvidenceCompositionSnapshot, sameSnapshot, publishRuntimeEvidenceCompositionSnapshot, captureRuntimeEvidenceCompositionSnapshot, discoverRuntimeEvidenceCompositionSnapshots;
+var import_node_crypto15, import_promises32, import_node_path29, SNAPSHOT_FILE, MANIFEST_FILE, COMPLETE_FILE, createRuntimeEvidenceCompositionSnapshotRecorder, isRecord2, sha256, safeSegment4, isExistingDestinationError3, parseManifest, verifyRuntimeEvidenceCompositionSnapshot, sameSnapshot, publishRuntimeEvidenceCompositionSnapshot, captureRuntimeEvidenceCompositionSnapshot, discoverRuntimeEvidenceCompositionSnapshots;
 var init_runtimeEvidenceCompositionSnapshots = __esm({
   "src/lib/runtimeEvidenceCompositionSnapshots.ts"() {
     "use strict";
-    import_node_crypto14 = require("crypto");
-    import_promises31 = __toESM(require("fs/promises"));
+    import_node_crypto15 = require("crypto");
+    import_promises32 = __toESM(require("fs/promises"));
     import_node_path29 = __toESM(require("path"));
     init_runtimeEvidenceDeployment();
     init_runtimeEvidenceProducer();
@@ -32889,7 +32861,7 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
       };
     };
     isRecord2 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
-    sha256 = (value) => (0, import_node_crypto14.createHash)("sha256").update(value).digest("hex");
+    sha256 = (value) => (0, import_node_crypto15.createHash)("sha256").update(value).digest("hex");
     safeSegment4 = (value, label) => {
       const normalized = value.trim();
       if (!normalized || !/^[a-zA-Z0-9._:-]+$/.test(normalized)) {
@@ -32911,9 +32883,9 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
     };
     verifyRuntimeEvidenceCompositionSnapshot = async (bundleDir) => {
       const [manifestText, payload, completeText] = await Promise.all([
-        import_promises31.default.readFile(import_node_path29.default.join(bundleDir, MANIFEST_FILE), "utf8"),
-        import_promises31.default.readFile(import_node_path29.default.join(bundleDir, SNAPSHOT_FILE)),
-        import_promises31.default.readFile(import_node_path29.default.join(bundleDir, COMPLETE_FILE), "utf8")
+        import_promises32.default.readFile(import_node_path29.default.join(bundleDir, MANIFEST_FILE), "utf8"),
+        import_promises32.default.readFile(import_node_path29.default.join(bundleDir, SNAPSHOT_FILE)),
+        import_promises32.default.readFile(import_node_path29.default.join(bundleDir, COMPLETE_FILE), "utf8")
       ]);
       const manifest = parseManifest(JSON.parse(manifestText));
       if (completeText.trim() !== manifest.deploymentCompositionId) {
@@ -32981,34 +32953,34 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
       const temporaryDir = import_node_path29.default.join(
         evidenceRoot,
         "incoming",
-        `snapshot-${compositionId}.tmp-${(0, import_node_crypto14.randomUUID)()}`
+        `snapshot-${compositionId}.tmp-${(0, import_node_crypto15.randomUUID)()}`
       );
-      await import_promises31.default.mkdir(temporaryDir, { recursive: true });
+      await import_promises32.default.mkdir(temporaryDir, { recursive: true });
       try {
         await Promise.all([
-          import_promises31.default.writeFile(import_node_path29.default.join(temporaryDir, SNAPSHOT_FILE), payload, "utf8"),
-          import_promises31.default.writeFile(
+          import_promises32.default.writeFile(import_node_path29.default.join(temporaryDir, SNAPSHOT_FILE), payload, "utf8"),
+          import_promises32.default.writeFile(
             import_node_path29.default.join(temporaryDir, MANIFEST_FILE),
             `${JSON.stringify(manifest, null, 2)}
 `,
             "utf8"
           )
         ]);
-        await import_promises31.default.writeFile(
+        await import_promises32.default.writeFile(
           import_node_path29.default.join(temporaryDir, COMPLETE_FILE),
           `${compositionId}
 `,
           "utf8"
         );
-        await import_promises31.default.mkdir(snapshotsRoot, { recursive: true });
+        await import_promises32.default.mkdir(snapshotsRoot, { recursive: true });
         try {
-          await import_promises31.default.rename(temporaryDir, bundleDir);
+          await import_promises32.default.rename(temporaryDir, bundleDir);
         } catch (error) {
           if (!isExistingDestinationError3(error)) throw error;
-          await import_promises31.default.rm(temporaryDir, { recursive: true, force: true });
+          await import_promises32.default.rm(temporaryDir, { recursive: true, force: true });
         }
       } catch (error) {
-        await import_promises31.default.rm(temporaryDir, { recursive: true, force: true });
+        await import_promises32.default.rm(temporaryDir, { recursive: true, force: true });
         throw error;
       }
       const verified = await verifyRuntimeEvidenceCompositionSnapshot(bundleDir);
@@ -33053,14 +33025,14 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
       const bundleDirs = [];
       let deployments;
       try {
-        deployments = await import_promises31.default.readdir(rootDir, { withFileTypes: true });
+        deployments = await import_promises32.default.readdir(rootDir, { withFileTypes: true });
       } catch (error) {
         if (error.code === "ENOENT") return [];
         throw error;
       }
       for (const deployment of deployments.filter((entry) => entry.isDirectory())) {
         const deploymentDir = import_node_path29.default.join(rootDir, deployment.name);
-        const compositions = await import_promises31.default.readdir(deploymentDir, {
+        const compositions = await import_promises32.default.readdir(deploymentDir, {
           withFileTypes: true
         });
         bundleDirs.push(
@@ -33245,11 +33217,11 @@ __export(runtimeEvidence_exports, {
   main: () => main40,
   runtimeEvidence: () => runtimeEvidence
 });
-var import_promises32, import_node_path30, import_args31, import_chalk47, flags28, projectRoot12, toEpochMs3, resolveWindow2, parseStrategyFilter2, runtimeEvidence, main40;
+var import_promises33, import_node_path30, import_args31, import_chalk47, flags28, projectRoot12, toEpochMs3, resolveWindow2, parseStrategyFilter2, runtimeEvidence, main40;
 var init_runtimeEvidence = __esm({
   "src/scripts/runtimeEvidence.ts"() {
     "use strict";
-    import_promises32 = __toESM(require("fs/promises"));
+    import_promises33 = __toESM(require("fs/promises"));
     import_node_path30 = __toESM(require("path"));
     import_args31 = __toESM(require("args"));
     import_chalk47 = __toESM(require("chalk"));
@@ -33432,8 +33404,8 @@ var init_runtimeEvidence = __esm({
       }
       const artifact = current.artifact;
       const outPath = import_node_path30.default.resolve(projectRoot12, String(flags28.out));
-      await import_promises32.default.mkdir(import_node_path30.default.dirname(outPath), { recursive: true });
-      await import_promises32.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
+      await import_promises33.default.mkdir(import_node_path30.default.dirname(outPath), { recursive: true });
+      await import_promises33.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
 `, "utf8");
       const published = publishDir ? await Promise.all(
         artifacts.map(
@@ -34620,7 +34592,7 @@ async function collectReleaseEvidenceReferences(references) {
       let artifact;
       try {
         const parsed = JSON.parse(
-          await import_promises33.default.readFile(reference.path, "utf8")
+          await import_promises34.default.readFile(reference.path, "utf8")
         );
         assert3(
           parsed != null && typeof parsed === "object" && !Array.isArray(parsed),
@@ -34767,12 +34739,12 @@ async function collectReleaseEvidenceReferences(references) {
     })
   );
 }
-var import_node_crypto15, import_promises33, import_node_path32, import_types9, import_strategyReleaseEvidence2, SHA256_RE2, LINEAGE_FINGERPRINT_RE, STRATEGY_REVISION_RE, DEPLOYMENT_COMPOSITION_ID_RE, REQUIRED_LONG_WINDOWS, REQUIRED_DIAGNOSTIC_TERMINAL_WINDOWS, MIN_RECENT_DIRECTION_REPAIR_EVENTS, safeSegment5, compactTimestamp, verifyFullPeriodChartArtifact, readVerifiedJsonArtifact, verifyResearchDecisionLineage, hasExactRuntimeTarget, deriveStrategyReleaseResearchDecision, canonicalStrategyReleaseJson, strategyReleaseSha256, assertFingerprint, assertLineageFingerprint, releaseReasons, deriveReleaseGates, verifyEvidenceComposition, createStrategyReleaseManifest, createStrategyReleaseEnvelope, verifyStrategyReleaseEnvelope, verifyStrategyEvidenceMarkerEnvelope, releaseMarkers, writeJsonAtomic2, publishStrategyRelease, publishStrategyLiveDiagnosis, finiteString3, finiteNumber7, finiteDirectionPolicy, uniqueStrings, incompleteEvidenceLineage, extractEvidenceLineage, verifyCompletedCoreResearchBundle;
+var import_node_crypto16, import_promises34, import_node_path32, import_types9, import_strategyReleaseEvidence2, SHA256_RE2, LINEAGE_FINGERPRINT_RE, STRATEGY_REVISION_RE, DEPLOYMENT_COMPOSITION_ID_RE, REQUIRED_LONG_WINDOWS, REQUIRED_DIAGNOSTIC_TERMINAL_WINDOWS, MIN_RECENT_DIRECTION_REPAIR_EVENTS, safeSegment5, compactTimestamp, verifyFullPeriodChartArtifact, readVerifiedJsonArtifact, verifyResearchDecisionLineage, hasExactRuntimeTarget, deriveStrategyReleaseResearchDecision, canonicalStrategyReleaseJson, strategyReleaseSha256, assertFingerprint, assertLineageFingerprint, releaseReasons, deriveReleaseGates, verifyEvidenceComposition, createStrategyReleaseManifest, createStrategyReleaseEnvelope, verifyStrategyReleaseEnvelope, verifyStrategyEvidenceMarkerEnvelope, releaseMarkers, writeJsonAtomic2, publishStrategyRelease, publishStrategyLiveDiagnosis, finiteString3, finiteNumber7, finiteDirectionPolicy, uniqueStrings, incompleteEvidenceLineage, extractEvidenceLineage, verifyCompletedCoreResearchBundle;
 var init_strategyRelease = __esm({
   "src/lib/strategyRelease.ts"() {
     "use strict";
-    import_node_crypto15 = require("crypto");
-    import_promises33 = __toESM(require("fs/promises"));
+    import_node_crypto16 = require("crypto");
+    import_promises34 = __toESM(require("fs/promises"));
     import_node_path32 = __toESM(require("path"));
     import_types9 = require("@tradejs/types");
     import_strategyReleaseEvidence2 = require("@tradejs/infra/strategyReleaseEvidence");
@@ -34796,7 +34768,7 @@ var init_strategyRelease = __esm({
         if (await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(artifactPath) !== artifact.sha256) {
           return false;
         }
-        const report = JSON.parse(await import_promises33.default.readFile(artifactPath, "utf8"));
+        const report = JSON.parse(await import_promises34.default.readFile(artifactPath, "utf8"));
         return Boolean(
           report.chart?.persisted === true && report.chart.cardIds?.length && report.errors?.failed === 0 && report.run?.strategy === input.strategy && report.run.mode === "local-deterministic" && report.run.recent === 0 && report.run.since == null && report.run.until == null && Number(report.run.sourceRows) > 0
         );
@@ -34811,7 +34783,7 @@ var init_strategyRelease = __esm({
         if (await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(artifactPath) !== artifact.sha256) {
           return null;
         }
-        return JSON.parse(await import_promises33.default.readFile(artifactPath, "utf8"));
+        return JSON.parse(await import_promises34.default.readFile(artifactPath, "utf8"));
       } catch {
         return null;
       }
@@ -35357,7 +35329,7 @@ var init_strategyRelease = __esm({
       manifest
     });
     verifyStrategyReleaseEnvelope = async (valueOrPath) => {
-      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises33.default.readFile(valueOrPath, "utf8")) : valueOrPath;
+      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises34.default.readFile(valueOrPath, "utf8")) : valueOrPath;
       const envelope = value;
       assert3(
         envelope?.schema === "tradejs-strategy-release-envelope/v1",
@@ -35408,7 +35380,7 @@ var init_strategyRelease = __esm({
       return envelope;
     };
     verifyStrategyEvidenceMarkerEnvelope = async (valueOrPath) => {
-      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises33.default.readFile(valueOrPath, "utf8")) : valueOrPath;
+      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises34.default.readFile(valueOrPath, "utf8")) : valueOrPath;
       return (0, import_strategyReleaseEvidence2.verifyStrategyEvidenceMarkerEnvelope)(value);
     };
     releaseMarkers = (manifest) => {
@@ -35470,14 +35442,14 @@ var init_strategyRelease = __esm({
     };
     writeJsonAtomic2 = async (filePath, value) => {
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-      await import_promises33.default.mkdir(import_node_path32.default.dirname(filePath), { recursive: true });
-      await import_promises33.default.writeFile(
+      await import_promises34.default.mkdir(import_node_path32.default.dirname(filePath), { recursive: true });
+      await import_promises34.default.writeFile(
         temporaryPath,
         `${canonicalStrategyReleaseJson(value)}
 `,
         "utf8"
       );
-      await import_promises33.default.rename(temporaryPath, filePath);
+      await import_promises34.default.rename(temporaryPath, filePath);
     };
     publishStrategyRelease = async ({
       rootDir,
@@ -35779,8 +35751,8 @@ var init_strategyRelease = __esm({
       const researchDir = import_node_path32.default.dirname(resultPath);
       const manifestPath = import_node_path32.default.join(researchDir, "manifest.json");
       const specPath = import_node_path32.default.join(researchDir, "spec.json");
-      const manifestBytes = await import_promises33.default.readFile(manifestPath).catch(() => null);
-      const specBytes = await import_promises33.default.readFile(specPath).catch(() => null);
+      const manifestBytes = await import_promises34.default.readFile(manifestPath).catch(() => null);
+      const specBytes = await import_promises34.default.readFile(specPath).catch(() => null);
       assert3(
         manifestBytes != null && specBytes != null,
         "core result must belong to a completed core research bundle"
@@ -35789,7 +35761,7 @@ var init_strategyRelease = __esm({
       const artifactHashes = manifest.artifactHashes != null && typeof manifest.artifactHashes === "object" && !Array.isArray(manifest.artifactHashes) ? manifest.artifactHashes : null;
       const parsedSpec = JSON.parse(specBytes.toString("utf8"));
       assert3(
-        manifest.schema === "tradejs-core-research-manifest/v1" && manifest.status === "completed" && manifest.researchId === researchId && manifest.specSha256 === specSha256 && artifactHashes?.["result.json"] === resultSha256 && (0, import_node_crypto15.createHash)("sha256").update(canonicalStrategyReleaseJson(parsedSpec)).digest("hex") === specSha256,
+        manifest.schema === "tradejs-core-research-manifest/v1" && manifest.status === "completed" && manifest.researchId === researchId && manifest.specSha256 === specSha256 && artifactHashes?.["result.json"] === resultSha256 && (0, import_node_crypto16.createHash)("sha256").update(canonicalStrategyReleaseJson(parsedSpec)).digest("hex") === specSha256,
         "core result is not bound by its completed core research manifest"
       );
       for (const [relativePath, expectedSha256] of Object.entries(
@@ -35821,12 +35793,12 @@ __export(runtimeScorecard_exports, {
   main: () => main42,
   runtimeScorecard: () => runtimeScorecard
 });
-var import_promises34, import_node_crypto16, import_node_path33, import_args33, import_chalk49, flags30, projectRoot14, resolveOptionalPath, readJson, assertReportType, sha256File2, loadHistoryArtifacts, runtimeScorecard, main42;
+var import_promises35, import_node_crypto17, import_node_path33, import_args33, import_chalk49, flags30, projectRoot14, resolveOptionalPath, readJson, assertReportType, sha256File2, loadHistoryArtifacts, runtimeScorecard, main42;
 var init_runtimeScorecard2 = __esm({
   "src/scripts/runtimeScorecard.ts"() {
     "use strict";
-    import_promises34 = __toESM(require("fs/promises"));
-    import_node_crypto16 = require("crypto");
+    import_promises35 = __toESM(require("fs/promises"));
+    import_node_crypto17 = require("crypto");
     import_node_path33 = __toESM(require("path"));
     import_args33 = __toESM(require("args"));
     import_chalk49 = __toESM(require("chalk"));
@@ -35899,13 +35871,13 @@ var init_runtimeScorecard2 = __esm({
       const raw = String(value ?? "").trim();
       return raw ? import_node_path33.default.resolve(projectRoot14, raw) : null;
     };
-    readJson = async (filePath) => filePath ? JSON.parse(await import_promises34.default.readFile(filePath, "utf8")) : void 0;
+    readJson = async (filePath) => filePath ? JSON.parse(await import_promises35.default.readFile(filePath, "utf8")) : void 0;
     assertReportType = (artifact, expected, label) => {
       if (artifact != null && (!artifact || typeof artifact !== "object" || Array.isArray(artifact) || artifact.reportType !== expected)) {
         throw new Error(`${label} must be a ${expected} artifact`);
       }
     };
-    sha256File2 = async (filePath) => (0, import_node_crypto16.createHash)("sha256").update(await import_promises34.default.readFile(filePath)).digest("hex");
+    sha256File2 = async (filePath) => (0, import_node_crypto17.createHash)("sha256").update(await import_promises35.default.readFile(filePath)).digest("hex");
     loadHistoryArtifacts = async (historyDir) => {
       if (!historyDir) return [];
       const bundleDirs = await (0, runtimeEvidenceArtifacts_exports.discoverRuntimeEvidenceBundles)(historyDir);
@@ -35978,11 +35950,11 @@ var init_runtimeScorecard2 = __esm({
       });
       const outPath = import_node_path33.default.resolve(projectRoot14, String(flags30.out));
       const markdownPath = outPath.replace(/\.json$/i, "") + ".md";
-      await import_promises34.default.mkdir(import_node_path33.default.dirname(outPath), { recursive: true });
+      await import_promises35.default.mkdir(import_node_path33.default.dirname(outPath), { recursive: true });
       await Promise.all([
-        import_promises34.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
+        import_promises35.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
 `, "utf8"),
-        import_promises34.default.writeFile(
+        import_promises35.default.writeFile(
           markdownPath,
           formatRuntimeScorecardMarkdown(scorecard),
           "utf8"
@@ -35996,7 +35968,7 @@ var init_runtimeScorecard2 = __esm({
       const diagnosisPath = diagnosis ? outPath.replace(/\.json$/i, "") + ".diagnosis.json" : null;
       const strategyReleaseRoot = resolveOptionalPath(flags30.strategyReleaseRoot);
       if (diagnosis && diagnosisPath) {
-        await import_promises34.default.writeFile(
+        await import_promises35.default.writeFile(
           diagnosisPath,
           `${JSON.stringify(diagnosis, null, 2)}
 `,
@@ -36369,13 +36341,13 @@ print(json.dumps(sorted(opened)))
 });
 
 // src/lib/strategyRelease/researchRetention.ts
-var import_promises35, import_node_path35, import_node_crypto17, import_strategyReleaseEvidence3, SHA256_RE3, mapFiles, fileSha256, inside, applyResearchRetention;
+var import_promises36, import_node_path35, import_node_crypto18, import_strategyReleaseEvidence3, SHA256_RE3, mapFiles, fileSha256, inside, applyResearchRetention;
 var init_researchRetention = __esm({
   "src/lib/strategyRelease/researchRetention.ts"() {
     "use strict";
-    import_promises35 = __toESM(require("fs/promises"));
+    import_promises36 = __toESM(require("fs/promises"));
     import_node_path35 = __toESM(require("path"));
-    import_node_crypto17 = require("crypto");
+    import_node_crypto18 = require("crypto");
     import_strategyReleaseEvidence3 = require("@tradejs/infra/strategyReleaseEvidence");
     init_researchFileConsumers();
     init_evidenceRetention();
@@ -36395,13 +36367,13 @@ var init_researchRetention = __esm({
         if (worker.status === "rejected") throw worker.reason;
       return results2;
     };
-    fileSha256 = async (file, bytes) => bytes <= 1024 * 1024 ? (0, import_node_crypto17.createHash)("sha256").update(await import_promises35.default.readFile(file)).digest("hex") : (0, import_strategyReleaseEvidence3.strategyEvidenceFileSha256)(file);
+    fileSha256 = async (file, bytes) => bytes <= 1024 * 1024 ? (0, import_node_crypto18.createHash)("sha256").update(await import_promises36.default.readFile(file)).digest("hex") : (0, import_strategyReleaseEvidence3.strategyEvidenceFileSha256)(file);
     inside = (root, file) => {
       const relative = import_node_path35.default.relative(root, file);
       return relative !== "" && !relative.startsWith(`..${import_node_path35.default.sep}`) && relative !== ".." && !import_node_path35.default.isAbsolute(relative);
     };
     applyResearchRetention = async (options) => {
-      const projectRoot18 = await import_promises35.default.realpath(options.projectRoot);
+      const projectRoot18 = await import_promises36.default.realpath(options.projectRoot);
       const dataRoot = import_node_path35.default.join(projectRoot18, "data");
       const resolve = (file) => import_node_path35.default.resolve(projectRoot18, file);
       const receiptPath2 = resolve(options.receiptPath);
@@ -36428,13 +36400,13 @@ var init_researchRetention = __esm({
       }
       await mapFiles(options.research.permanentArtifacts, async (artifact) => {
         const file = resolve(artifact.path);
-        if (!inside(projectRoot18, await import_promises35.default.realpath(file)) || !SHA256_RE3.test(artifact.sha256) || await fileSha256(file, (await import_promises35.default.stat(file)).size) !== artifact.sha256) {
+        if (!inside(projectRoot18, await import_promises36.default.realpath(file)) || !SHA256_RE3.test(artifact.sha256) || await fileSha256(file, (await import_promises36.default.stat(file)).size) !== artifact.sha256) {
           throw new Error(
             `Permanent research artifact checksum/path mismatch: ${file}`
           );
         }
         if (artifact.role === "note") {
-          const handle = await import_promises35.default.open(file, "r");
+          const handle = await import_promises36.default.open(file, "r");
           try {
             const header = Buffer.alloc(4096);
             const { bytesRead } = await handle.read(header, 0, header.length, 0);
@@ -36460,9 +36432,9 @@ var init_researchRetention = __esm({
         if (checkedPaths.has(file))
           throw new Error(`Duplicate cleanup path: ${file}`);
         checkedPaths.add(file);
-        if (await import_promises35.default.realpath(file) !== file)
+        if (await import_promises36.default.realpath(file) !== file)
           throw new Error(`Research cleanup refuses symlinks: ${file}`);
-        const stat = await import_promises35.default.lstat(file);
+        const stat = await import_promises36.default.lstat(file);
         if (!stat.isFile() || stat.size !== entry.bytes || await fileSha256(file, stat.size) !== entry.sha256) {
           throw new Error(
             `Disposable research file checksum/size mismatch: ${file}`
@@ -36488,29 +36460,29 @@ var init_researchRetention = __esm({
         }))
       };
       if (!options.apply) return receipt;
-      await import_promises35.default.mkdir(import_node_path35.default.dirname(receiptPath2), { recursive: true });
-      if (await import_promises35.default.realpath(import_node_path35.default.dirname(receiptPath2)) !== import_node_path35.default.dirname(receiptPath2)) {
+      await import_promises36.default.mkdir(import_node_path35.default.dirname(receiptPath2), { recursive: true });
+      if (await import_promises36.default.realpath(import_node_path35.default.dirname(receiptPath2)) !== import_node_path35.default.dirname(receiptPath2)) {
         throw new Error("Cleanup receipt refuses symlinked directories");
       }
-      const lock = await import_promises35.default.open(`${receiptPath2}.lock`, "wx");
+      const lock = await import_promises36.default.open(`${receiptPath2}.lock`, "wx");
       let journal;
       const writeReceipt = async () => {
         const temp = `${receiptPath2}.${process.pid}.tmp`;
-        await import_promises35.default.writeFile(temp, `${JSON.stringify(receipt, null, 2)}
+        await import_promises36.default.writeFile(temp, `${JSON.stringify(receipt, null, 2)}
 `, "utf8");
-        await import_promises35.default.rename(temp, receiptPath2);
+        await import_promises36.default.rename(temp, receiptPath2);
       };
       try {
-        journal = await import_promises35.default.open(journalPath, "wx");
+        journal = await import_promises36.default.open(journalPath, "wx");
         receipt.status = "applying";
         await writeReceipt();
         for (let index = 0; index < checked.length; index += 1) {
           const { file, entry, ino, mtimeMs } = checked[index];
-          const stat = await import_promises35.default.lstat(file);
+          const stat = await import_promises36.default.lstat(file);
           if (!stat.isFile() || stat.ino !== ino || stat.mtimeMs !== mtimeMs || stat.size !== entry.bytes) {
             throw new Error(`Research file changed during cleanup: ${file}`);
           }
-          await import_promises35.default.unlink(file);
+          await import_promises36.default.unlink(file);
           receipt.files[index].removed = true;
           await journal.write(`${JSON.stringify(receipt.files[index])}
 `);
@@ -36524,7 +36496,7 @@ var init_researchRetention = __esm({
       } finally {
         await journal?.close();
         await lock.close();
-        await import_promises35.default.unlink(`${receiptPath2}.lock`);
+        await import_promises36.default.unlink(`${receiptPath2}.lock`);
       }
     };
   }
@@ -36536,11 +36508,11 @@ __export(strategyRelease_exports, {
   main: () => main44,
   runStrategyReleaseCommand: () => runStrategyReleaseCommand
 });
-var import_promises36, import_node_fs6, import_node_readline3, import_node_path36, import_chalk50, valueAfter2, required3, writeJsonAtomic3, runStrategyReleaseCommand, printUsage2, main44;
+var import_promises37, import_node_fs6, import_node_readline3, import_node_path36, import_chalk50, valueAfter2, required3, writeJsonAtomic3, runStrategyReleaseCommand, printUsage2, main44;
 var init_strategyRelease2 = __esm({
   "src/scripts/strategyRelease.ts"() {
     "use strict";
-    import_promises36 = __toESM(require("fs/promises"));
+    import_promises37 = __toESM(require("fs/promises"));
     import_node_fs6 = require("fs");
     import_node_readline3 = require("readline");
     import_node_path36 = __toESM(require("path"));
@@ -36557,14 +36529,14 @@ var init_strategyRelease2 = __esm({
     };
     writeJsonAtomic3 = async (filePath, value) => {
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-      await import_promises36.default.mkdir(import_node_path36.default.dirname(filePath), { recursive: true });
-      await import_promises36.default.writeFile(
+      await import_promises37.default.mkdir(import_node_path36.default.dirname(filePath), { recursive: true });
+      await import_promises37.default.writeFile(
         temporaryPath,
         `${JSON.stringify(value, null, 2)}
 `,
         "utf8"
       );
-      await import_promises36.default.rename(temporaryPath, filePath);
+      await import_promises37.default.rename(temporaryPath, filePath);
     };
     runStrategyReleaseCommand = async (options) => {
       const inputPath = import_node_path36.default.resolve(options.inputPath);
@@ -36616,7 +36588,7 @@ var init_strategyRelease2 = __esm({
           profile
         };
       }
-      const input = JSON.parse(await import_promises36.default.readFile(inputPath, "utf8"));
+      const input = JSON.parse(await import_promises37.default.readFile(inputPath, "utf8"));
       if (options.command === "decide") {
         const decision = await deriveStrategyReleaseResearchDecision(input);
         if (options.outputPath) {
@@ -36649,7 +36621,7 @@ var init_strategyRelease2 = __esm({
             protectedPaths: [inputPath]
           });
         } else if (options.apply) {
-          await Promise.all(plan.delete.map((entry) => import_promises36.default.rm(entry.path)));
+          await Promise.all(plan.delete.map((entry) => import_promises37.default.rm(entry.path)));
         }
         return {
           kind: "retention",
@@ -38553,12 +38525,12 @@ __export(runtimeParity_exports, {
   main: () => main46,
   runtimeParity: () => runtimeParity
 });
-var import_config11, import_node_crypto18, import_args35, import_chalk52, import_constants19, import_time13, import_logger7, import_redis21, import_cli12, import_backtest7, import_connectors15, flags31, interval3, projectRoot16, DEFAULT_LOOKBACK_DAYS, DETAIL_LIMIT2, DEFAULT_REPLAY_ENV, resolveParityConnectorName, createConnector, buildReplayAiAnalyses, formatReplayEnvSummary, buildReplayConfig, warmReplayHistory, runtimeParity, main46;
+var import_config11, import_node_crypto19, import_args35, import_chalk52, import_constants19, import_time13, import_logger7, import_redis21, import_cli12, import_backtest7, import_connectors15, flags31, interval3, projectRoot16, DEFAULT_LOOKBACK_DAYS, DETAIL_LIMIT2, DEFAULT_REPLAY_ENV, resolveParityConnectorName, createConnector, buildReplayAiAnalyses, formatReplayEnvSummary, buildReplayConfig, warmReplayHistory, runtimeParity, main46;
 var init_runtimeParity2 = __esm({
   "src/scripts/runtimeParity.ts"() {
     "use strict";
     import_config11 = require("dotenv/config");
-    import_node_crypto18 = require("crypto");
+    import_node_crypto19 = require("crypto");
     import_args35 = __toESM(require("args"));
     import_chalk52 = __toESM(require("chalk"));
     import_constants19 = require("@tradejs/core/constants");
@@ -38941,9 +38913,9 @@ var init_runtimeParity2 = __esm({
                 start: window.start,
                 end: window.end
               },
-              name: `${target.symbol}_${target.strategy}_${(0, import_node_crypto18.randomUUID)().slice(0, 8)}`,
-              testId: (0, import_node_crypto18.randomUUID)().slice(0, 8),
-              testSuiteId: (0, import_node_crypto18.randomUUID)().slice(0, 8),
+              name: `${target.symbol}_${target.strategy}_${(0, import_node_crypto19.randomUUID)().slice(0, 8)}`,
+              testId: (0, import_node_crypto19.randomUUID)().slice(0, 8),
+              testSuiteId: (0, import_node_crypto19.randomUUID)().slice(0, 8),
               strategyName: target.strategy,
               strategyConfig: replayConfig,
               connectorName,