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

package/dist/cli.js

@@ -2278,9 +2278,9 @@ var init_features = __esm({
       "targetsymbol",
       "universe"
     ]);
-    normalizeFeaturePath = (path44) => (Array.isArray(path44) ? path44 : path44.split(".")).filter(Boolean).map((segment) => segment.toLowerCase());
-    classifyAiPocketCoverageFeaturePath = (path44) => {
-      const segments = normalizeFeaturePath(path44);
+    normalizeFeaturePath = (path47) => (Array.isArray(path47) ? path47 : path47.split(".")).filter(Boolean).map((segment) => segment.toLowerCase());
+    classifyAiPocketCoverageFeaturePath = (path47) => {
+      const segments = normalizeFeaturePath(path47);
       const normalizedPath = segments.join(".");
       if (segments.some(
         (segment) => segment.includes("cmc") || segment.includes("coinmarketcap")
@@ -2454,8 +2454,8 @@ var init_features = __esm({
       "volumeusd",
       "vwap"
     ]);
-    classifyAiPocketFeaturePath = (path44) => {
-      const segments = (Array.isArray(path44) ? path44 : path44.split(".")).filter(
+    classifyAiPocketFeaturePath = (path47) => {
+      const segments = (Array.isArray(path47) ? path47 : path47.split(".")).filter(
         Boolean
       );
       const normalized = segments.map((segment) => segment.toLowerCase());
@@ -2772,11 +2772,11 @@ var init_features = __esm({
         excludeFeaturePattern.source,
         excludeFeaturePattern.flags.replace(/[gy]/g, "")
       ) : void 0;
-      const isOperatorExcluded = (path44) => {
-        if (!exclusion?.test(path44)) {
+      const isOperatorExcluded = (path47) => {
+        if (!exclusion?.test(path47)) {
           return false;
         }
-        onFeatureExcluded?.({ path: path44, classification: "operator-excluded" });
+        onFeatureExcluded?.({ path: path47, classification: "operator-excluded" });
         return true;
       };
       const signal = payload.signal ?? {};
@@ -11317,27 +11317,27 @@ var init_coinMarketCapContextBackfill = __esm({
       totalCredits: 0,
       byPath: /* @__PURE__ */ new Map()
     });
-    getCoinMarketCapPathLabel = (path44) => {
-      if (path44.includes("global-metrics")) return "global";
-      if (path44.includes("cryptocurrency/quotes")) return "reference";
-      if (path44.includes("exchange/quotes")) return "exchangeLiquidity";
-      if (path44.includes("fear-and-greed")) return "fearGreed";
-      if (path44.includes("cmc100")) return "cmc100";
-      if (path44.includes("cmc20")) return "cmc20";
-      return path44;
-    };
-    recordCoinMarketCapFetchStats = (stats, path44, creditCount) => {
+    getCoinMarketCapPathLabel = (path47) => {
+      if (path47.includes("global-metrics")) return "global";
+      if (path47.includes("cryptocurrency/quotes")) return "reference";
+      if (path47.includes("exchange/quotes")) return "exchangeLiquidity";
+      if (path47.includes("fear-and-greed")) return "fearGreed";
+      if (path47.includes("cmc100")) return "cmc100";
+      if (path47.includes("cmc20")) return "cmc20";
+      return path47;
+    };
+    recordCoinMarketCapFetchStats = (stats, path47, creditCount) => {
       if (!stats) return;
-      const existing = stats.byPath.get(path44) ?? { requests: 0, credits: 0 };
+      const existing = stats.byPath.get(path47) ?? { requests: 0, credits: 0 };
       existing.requests += 1;
       existing.credits += creditCount ?? 0;
       stats.requests += 1;
       stats.totalCredits += creditCount ?? 0;
-      stats.byPath.set(path44, existing);
+      stats.byPath.set(path47, existing);
     };
     formatCoinMarketCapFetchStats = (stats) => {
       const byPath = [...stats.byPath.entries()].map(
-        ([path44, item]) => `${getCoinMarketCapPathLabel(path44)}=${item.requests}req/${item.credits}cr`
+        ([path47, item]) => `${getCoinMarketCapPathLabel(path47)}=${item.requests}req/${item.credits}cr`
       ).join(" ");
       return `apiRequests=${stats.requests} apiCredits=${stats.totalCredits}${byPath ? ` ${byPath}` : ""}`;
     };
@@ -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,26 +24567,102 @@ var init_marketWs = __esm({
   }
 });
 
+// src/lib/runtimeEvidenceArtifacts.ts
+var runtimeEvidenceArtifacts_exports = {};
+var init_runtimeEvidenceArtifacts = __esm({
+  "src/lib/runtimeEvidenceArtifacts.ts"() {
+    "use strict";
+    __reExport(runtimeEvidenceArtifacts_exports, require("@tradejs/node/diagnostics"));
+  }
+});
+
+// src/lib/mcpReplayProcess.ts
+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"));
+    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,
+      runId,
+      projectRoot: projectRoot18,
+      env
+    }) => {
+      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 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]
+      };
+    };
+  }
+});
+
 // src/scripts/mcpWorker.ts
 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();
     pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
     leaseKey = "worker:lease";
     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;
@@ -24594,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 {
@@ -24607,7 +24695,7 @@ var init_mcpWorker = __esm({
       const heartbeatValue = () => ({
         observedAt: Date.now(),
         packageManifestSha256: manifestHash,
-        replayAvailable: Boolean(process.env.MCP_REPLAY_REDIS_HOST)
+        replayAvailable: replayReady
       });
       const stop = () => {
         stopping = true;
@@ -24623,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;
@@ -24633,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 {
@@ -24697,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(
@@ -24720,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, {
@@ -24733,7 +24825,35 @@ var init_mcpWorker = __esm({
               TRADEJS_TIMESCALE_READ_ONLY: "true"
             });
           }
-          child = (0, import_node_child_process4.spawn)(process.execPath, [process.argv[1], ...started.args], {
+          let command = {
+            executable: process.execPath,
+            args: [process.argv[1], ...started.args]
+          };
+          try {
+            if (started.kind === "runtime-feedback-replay")
+              command = await buildMcpReplayProcess({
+                evidencePath: String(started.request.verifiedEvidencePath),
+                outDir: (0, import_mcp.mcpJobDirectory)(started),
+                runId: started.id,
+                projectRoot: process.env.PROJECT_CWD || process.cwd(),
+                env: process.env
+              });
+          } catch (error) {
+            await import_redis15.mcpStorage.compare(
+              jobKey,
+              started,
+              {
+                ...started,
+                status: "failed",
+                finishedAt: Date.now(),
+                updatedAt: Date.now(),
+                error: error instanceof Error ? error.message : "Replay preparation failed"
+              },
+              import_mcp.MCP_JOB_TTL
+            );
+            continue;
+          }
+          child = (0, import_node_child_process4.spawn)(command.executable, command.args, {
             cwd: process.env.PROJECT_CWD || process.cwd(),
             env: jobEnv,
             detached: process.platform !== "win32",
@@ -25178,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();
@@ -25198,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(
@@ -25307,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();
@@ -25364,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,
@@ -25409,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}`));
@@ -25430,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"));
@@ -25613,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.")
@@ -25625,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 };
         })
       );
@@ -25870,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`
@@ -25966,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");
@@ -26100,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);
@@ -26111,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 };
         })
       );
@@ -26287,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);
@@ -26660,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,
@@ -26718,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,
@@ -26907,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();
@@ -26929,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);
@@ -26961,16 +27081,16 @@ __export(researchAuto_exports, {
   toStrategyConfigGrid: () => toStrategyConfigGrid2,
   trimTextTail: () => trimTextTail2
 });
-var import_args25, import_chalk40, import_node_child_process5, import_promises21, import_node_os2, import_node_path14, 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_path14 = __toESM(require("path"));
+    import_node_path15 = __toESM(require("path"));
     import_constants18 = require("@tradejs/core/constants");
     import_ai8 = require("@tradejs/infra/ai");
     import_logger6 = require("@tradejs/infra/logger");
@@ -27004,9 +27124,9 @@ var init_researchAuto = __esm({
     flags23 = import_args25.default.parse(process.argv);
     ({ projectRoot: projectRoot8 } = resolveResearchRoots());
     dotenvPath = String(
-      process.env.DOTENV_CONFIG_PATH || import_node_path14.default.join(projectRoot8, ".env")
-    ).trim() || import_node_path14.default.join(projectRoot8, ".env");
-    getResearchAutoLockPath = (userName3) => import_node_path14.default.join(
+      process.env.DOTENV_CONFIG_PATH || import_node_path15.default.join(projectRoot8, ".env")
+    ).trim() || import_node_path15.default.join(projectRoot8, ".env");
+    getResearchAutoLockPath = (userName3) => import_node_path15.default.join(
       projectRoot8,
       "data",
       "cache",
@@ -27015,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;
@@ -27050,9 +27170,9 @@ var init_researchAuto = __esm({
         startedAt,
         argv: [...process.argv]
       };
-      await import_promises21.default.mkdir(import_node_path14.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"
         });
       };
@@ -27071,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;
     };
@@ -27083,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);
@@ -27185,9 +27305,9 @@ 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_path14.default.join(outDir, name));
+        return entries.filter((name) => name.startsWith(prefix) && name.endsWith(".jsonl")).sort().map((name) => import_node_path15.default.join(outDir, name));
       } catch {
         return [];
       }
@@ -27321,7 +27441,7 @@ var init_researchAuto = __esm({
       return new Promise((resolve, reject) => {
         const child = (0, import_node_child_process5.spawn)(
           process.execPath,
-          [import_node_path14.default.resolve(process.argv[1]), params.command, ...params.args],
+          [import_node_path15.default.resolve(process.argv[1]), params.command, ...params.args],
           {
             cwd: projectRoot8,
             env,
@@ -27504,8 +27624,8 @@ var init_researchAuto = __esm({
       const jsonOutput = Boolean(flags23.json);
       const skipAgent = Boolean(flags23.skipAgent);
       const outDirArg = String(flags23.outDir || "data/ai/export").trim() || "data/ai/export";
-      const outDir = import_node_path14.default.resolve(projectRoot8, outDirArg);
-      const cleanDirArg = import_node_path14.default.relative(import_node_path14.default.join(projectRoot8, "data"), outDir).replace(/\\/g, "/");
+      const outDir = import_node_path15.default.resolve(projectRoot8, outDirArg);
+      const cleanDirArg = import_node_path15.default.relative(import_node_path15.default.join(projectRoot8, "data"), outDir).replace(/\\/g, "/");
       const target = await resolveTarget();
       const runId = `${Date.now()}-${(0, import_ai8.toFileToken)(target.strategy)}`;
       const run = {
@@ -27853,15 +27973,15 @@ 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_path15, 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_path15 = __toESM(require("path"));
+    import_node_path16 = __toESM(require("path"));
     init_types();
     RESEARCH_ID_RE = /^[a-z0-9][a-z0-9._-]{2,120}$/;
     SHA256_RE = /^[a-f0-9]{64}$/;
@@ -27877,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");
@@ -28120,40 +28240,40 @@ var init_io = __esm({
       return spec;
     };
     loadCoreResearchSpec = async (specPath) => {
-      const resolvedPath = import_node_path15.default.resolve(specPath);
-      const parsed = JSON.parse(await import_promises22.default.readFile(resolvedPath, "utf8"));
+      const resolvedPath = import_node_path16.default.resolve(specPath);
+      const parsed = JSON.parse(await import_promises23.default.readFile(resolvedPath, "utf8"));
       const spec = validateCoreResearchSpec(parsed);
       return { resolvedPath, spec, specSha256: sha256Json(spec) };
     };
     resolveCoreResearchPaths = (spec) => {
-      const rootDir = import_node_path15.default.resolve(spec.artifacts.rootDir);
-      const researchDir = import_node_path15.default.join(rootDir, spec.researchId);
+      const rootDir = import_node_path16.default.resolve(spec.artifacts.rootDir);
+      const researchDir = import_node_path16.default.join(rootDir, spec.researchId);
       return {
         rootDir,
         researchDir,
-        ledgerPath: import_node_path15.default.resolve(spec.artifacts.ledgerPath),
-        specPath: import_node_path15.default.join(researchDir, "spec.json"),
-        manifestPath: import_node_path15.default.join(researchDir, "manifest.json"),
-        resultPath: import_node_path15.default.join(researchDir, "result.json"),
-        comparisonPath: import_node_path15.default.join(researchDir, "comparison.json"),
-        matchesPath: import_node_path15.default.join(researchDir, "matches.csv"),
-        tradesPath: import_node_path15.default.join(researchDir, "trades.jsonl"),
-        reportPath: import_node_path15.default.join(researchDir, "report.html"),
-        runLogDir: import_node_path15.default.join(researchDir, "runs")
+        ledgerPath: import_node_path16.default.resolve(spec.artifacts.ledgerPath),
+        specPath: import_node_path16.default.join(researchDir, "spec.json"),
+        manifestPath: import_node_path16.default.join(researchDir, "manifest.json"),
+        resultPath: import_node_path16.default.join(researchDir, "result.json"),
+        comparisonPath: import_node_path16.default.join(researchDir, "comparison.json"),
+        matchesPath: import_node_path16.default.join(researchDir, "matches.csv"),
+        tradesPath: import_node_path16.default.join(researchDir, "trades.jsonl"),
+        reportPath: import_node_path16.default.join(researchDir, "report.html"),
+        runLogDir: import_node_path16.default.join(researchDir, "runs")
       };
     };
     writeJsonAtomic = async (filePath, value) => {
-      await import_promises22.default.mkdir(import_node_path15.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;
@@ -28190,11 +28310,11 @@ var init_io = __esm({
     };
     appendCoreResearchLedger = async (params) => {
       const { ledgerPath } = params;
-      await import_promises22.default.mkdir(import_node_path15.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 = {
@@ -28213,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) {
@@ -28223,20 +28343,20 @@ 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) => {
       if (spec.stage === "screen") return;
       const expectedParentStage = spec.stage === "isolated_long" ? "screen" : "isolated_long";
-      const rootDir = import_node_path15.default.resolve(spec.artifacts.rootDir);
+      const rootDir = import_node_path16.default.resolve(spec.artifacts.rootDir);
       const passedParentCandidateConfigShas = /* @__PURE__ */ new Set();
       for (const parentResearchId of spec.parentResearchIds ?? []) {
-        const parentDir = import_node_path15.default.join(rootDir, parentResearchId);
+        const parentDir = import_node_path16.default.join(rootDir, parentResearchId);
         const [parentSpec, parentManifest, parentResult] = await Promise.all([
-          import_promises22.default.readFile(import_node_path15.default.join(parentDir, "spec.json"), "utf8").then((text) => JSON.parse(text)),
-          import_promises22.default.readFile(import_node_path15.default.join(parentDir, "manifest.json"), "utf8").then((text) => JSON.parse(text)),
-          import_promises22.default.readFile(import_node_path15.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") {
@@ -28283,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;
@@ -28301,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;
@@ -28340,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");
@@ -28349,7 +28469,7 @@ var init_io = __esm({
         manifest.artifactHashes
       )) {
         const actualHash = await sha256File(
-          import_node_path15.default.join(paths.researchDir, relativePath)
+          import_node_path16.default.join(paths.researchDir, relativePath)
         );
         if (actualHash !== expectedHash) {
           throw new Error(`Artifact hash mismatch: ${relativePath}`);
@@ -28365,10 +28485,10 @@ var init_io = __esm({
       };
     };
     scanCoreResearchStages = async (rootDir) => {
-      const resolvedRoot = import_node_path15.default.resolve(rootDir);
+      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 {
@@ -28383,15 +28503,15 @@ var init_io = __esm({
       for (const entry of entries.sort(
         (left, right) => left < right ? -1 : left > right ? 1 : 0
       )) {
-        const researchDir = import_node_path15.default.join(resolvedRoot, entry);
-        const stats = await import_promises22.default.stat(researchDir);
+        const researchDir = import_node_path16.default.join(resolvedRoot, entry);
+        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_path15.default.join(researchDir, "spec.json"), "utf8").then((text) => JSON.parse(text)),
-            import_promises22.default.readFile(import_node_path15.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;
@@ -28401,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_path15.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,
@@ -28432,7 +28552,7 @@ var init_io = __esm({
       return { experiments, familyByResearch };
     };
     writeCoreResearchStageIndex = async (rootDir) => {
-      const resolvedRoot = import_node_path15.default.resolve(rootDir);
+      const resolvedRoot = import_node_path16.default.resolve(rootDir);
       const { experiments, familyByResearch } = await scanCoreResearchStages(resolvedRoot);
       const grouped = /* @__PURE__ */ new Map();
       for (const experiment of experiments) {
@@ -28449,21 +28569,21 @@ var init_io = __esm({
         generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
         families: [...grouped.entries()].sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0).map(([family, experiments2]) => ({ family, experiments: experiments2 }))
       };
-      await writeJsonAtomic(import_node_path15.default.join(resolvedRoot, "index.json"), index);
+      await writeJsonAtomic(import_node_path16.default.join(resolvedRoot, "index.json"), index);
       return index;
     };
   }
 });
 
 // src/lib/coreResearch/artifacts.ts
-var import_node_fs4, import_node_events, import_promises23, import_node_path16, 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_node_path16 = __toESM(require("path"));
+    import_promises24 = __toESM(require("fs/promises"));
+    import_node_path17 = __toESM(require("path"));
     init_io();
     csv = (value) => {
       const text = String(value ?? "");
@@ -28477,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_path16.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,
@@ -28528,7 +28648,7 @@ var init_artifacts = __esm({
       await closeOutput(output);
     };
     writeCoreResearchTrades = async (params) => {
-      await import_promises23.default.mkdir(import_node_path16.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) {
@@ -28768,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;
@@ -29242,13 +29362,13 @@ var init_comparison = __esm({
 });
 
 // src/lib/coreResearch/dataset.ts
-var import_node_crypto12, import_node_fs5, import_node_path17, 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_path17 = __toESM(require("path"));
+    import_node_path18 = __toESM(require("path"));
     import_node_readline2 = __toESM(require("readline"));
     asRecord4 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
     finiteNumber4 = (value, field) => {
@@ -29344,7 +29464,7 @@ var init_dataset2 = __esm({
       };
     };
     normalizeCompletedTrade = (params) => {
-      const { filePath, fileSha256, lineNumber, row } = params;
+      const { filePath, fileSha256: fileSha2562, lineNumber, row } = params;
       const result = row.tradeResult;
       if (!result) return null;
       const signalTimestamp = finiteNumber4(row.timestamp, "row.timestamp");
@@ -29359,7 +29479,7 @@ var init_dataset2 = __esm({
       return {
         sourceFile: filePath,
         sourceLine: lineNumber,
-        sourceSha256: fileSha256,
+        sourceSha256: fileSha2562,
         runId: row.backtestRunId ?? null,
         configId: row.configId?.trim() || "<missing-config-id>",
         signalId,
@@ -29459,9 +29579,9 @@ var init_dataset2 = __esm({
       const seen = /* @__PURE__ */ new Map();
       let duplicateRowsDropped = 0;
       for (const inputPath of variant.files) {
-        const filePath = import_node_path17.default.resolve(inputPath);
+        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 = [];
@@ -29512,11 +29632,11 @@ var init_dataset2 = __esm({
           trades.push(trade);
           fileTrades.push(trade);
         }
-        const fileSha256 = hash.digest("hex");
-        for (const trade of fileTrades) trade.sourceSha256 = fileSha256;
+        const fileSha2562 = hash.digest("hex");
+        for (const trade of fileTrades) trade.sourceSha256 = fileSha2562;
         sources.push({
           path: filePath,
-          sha256: fileSha256,
+          sha256: fileSha2562,
           rows,
           selectedTrades,
           rowsForDifferentRun,
@@ -29951,19 +30071,19 @@ var init_selection = __esm({
 });
 
 // src/lib/coreResearch/trace.ts
-var import_promises24, import_node_path18, 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_node_path18 = __toESM(require("path"));
+    import_promises25 = __toESM(require("fs/promises"));
+    import_node_path19 = __toESM(require("path"));
     summarizeCoreResearchTrace = async (filePaths = []) => {
       const events = /* @__PURE__ */ Object.create(null);
       const skipCounts = /* @__PURE__ */ Object.create(null);
       const exitCodes = /* @__PURE__ */ Object.create(null);
       for (const inputPath of filePaths) {
-        const filePath = import_node_path18.default.resolve(inputPath);
-        const text = await import_promises24.default.readFile(filePath, "utf8");
+        const filePath = import_node_path19.default.resolve(inputPath);
+        const text = await import_promises25.default.readFile(filePath, "utf8");
         for (const [index, line] of text.split("\n").entries()) {
           if (!line.trim()) continue;
           let event;
@@ -30003,14 +30123,14 @@ var init_trace = __esm({
 });
 
 // src/lib/coreResearch/orchestrator.ts
-var import_promises25, import_node_path19, 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_node_path19 = __toESM(require("path"));
+    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();
@@ -30215,7 +30335,7 @@ var init_orchestrator = __esm({
       const primarySourceHashes = Object.fromEntries(
         analyses.flatMap(
           (analysis) => analysis.files.map((file) => [
-            import_node_path19.default.relative(paths.researchDir, file.path),
+            import_node_path20.default.relative(paths.researchDir, file.path),
             file.sha256
           ])
         )
@@ -30234,8 +30354,8 @@ var init_orchestrator = __esm({
       const supplementalSourceHashes = Object.fromEntries(
         await Promise.all(
           supplementalSourcePaths.map(async (filePath) => [
-            import_node_path19.default.relative(paths.researchDir, import_node_path19.default.resolve(filePath)),
-            await sha256File(import_node_path19.default.resolve(filePath))
+            import_node_path20.default.relative(paths.researchDir, import_node_path20.default.resolve(filePath)),
+            await sha256File(import_node_path20.default.resolve(filePath))
           ])
         )
       );
@@ -30299,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"
@@ -30312,17 +30432,17 @@ var init_orchestrator = __esm({
         "trades.jsonl": await sha256File(paths.tradesPath),
         "report.html": await sha256File(paths.reportPath)
       };
-      const resolvedRunsPath = import_node_path19.default.join(paths.researchDir, "resolved-runs.json");
+      const resolvedRunsPath = import_node_path20.default.join(paths.researchDir, "resolved-runs.json");
       try {
         artifactHashes["resolved-runs.json"] = await sha256File(resolvedRunsPath);
       } catch (error) {
         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_path19.default.join(paths.runLogDir, name)
+            import_node_path20.default.join(paths.runLogDir, name)
           );
         }
       } catch (error) {
@@ -30379,9 +30499,9 @@ var init_orchestrator = __esm({
       }
     };
     createCoreResearchSpecTemplate = (params) => {
-      const rootDir = import_node_path19.default.relative(
-        import_node_path19.default.resolve(params.projectRoot),
-        import_node_path19.default.join(import_node_path19.default.resolve(params.projectRoot), "data", "research", "core")
+      const rootDir = import_node_path20.default.relative(
+        import_node_path20.default.resolve(params.projectRoot),
+        import_node_path20.default.join(import_node_path20.default.resolve(params.projectRoot), "data", "research", "core")
       ).replace(/\\/g, "/");
       const lineage = (() => {
         try {
@@ -30412,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 {
@@ -30519,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_path19.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,
@@ -30539,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(" ")}`
@@ -30593,7 +30713,7 @@ var init_orchestrator = __esm({
     };
     runCoreResearch = async (params) => {
       const { spec } = params;
-      const cwd = import_node_path19.default.resolve(params.cwd ?? process.cwd());
+      const cwd = import_node_path20.default.resolve(params.cwd ?? process.cwd());
       const prepared = await prepareCoreResearch(spec);
       const resolvedVariants = [];
       for (const variant of spec.variants) {
@@ -30611,7 +30731,7 @@ var init_orchestrator = __esm({
           artifactHashes: { variant: sha256Json(variant) }
         });
         let runId = "";
-        const backtestLogPath = import_node_path19.default.join(
+        const backtestLogPath = import_node_path20.default.join(
           prepared.paths.runLogDir,
           `${variant.id}-backtest.log`
         );
@@ -30627,7 +30747,7 @@ var init_orchestrator = __esm({
             env: {
               PROJECT_CWD: cwd,
               ...params.sourceRepositoryRoot ? {
-                [SOURCE_REPOSITORY_ROOT_ENV]: import_node_path19.default.resolve(
+                [SOURCE_REPOSITORY_ROOT_ENV]: import_node_path20.default.resolve(
                   params.sourceRepositoryRoot
                 )
               } : {}
@@ -30642,12 +30762,12 @@ var init_orchestrator = __esm({
           if (!runId) {
             throw new Error(`Backtest for ${variant.id} did not report a run id`);
           }
-          const exportLogPath = import_node_path19.default.join(
+          const exportLogPath = import_node_path20.default.join(
             prepared.paths.runLogDir,
             `${variant.id}-export.log`
           );
           const exportParts = [];
-          const cliPath = import_node_path19.default.resolve(process.argv[1]);
+          const cliPath = import_node_path20.default.resolve(process.argv[1]);
           await runCommand2({
             command: [
               process.execPath,
@@ -30667,14 +30787,14 @@ var init_orchestrator = __esm({
             env: {
               PROJECT_CWD: cwd,
               ...params.sourceRepositoryRoot ? {
-                [SOURCE_REPOSITORY_ROOT_ENV]: import_node_path19.default.resolve(
+                [SOURCE_REPOSITORY_ROOT_ENV]: import_node_path20.default.resolve(
                   params.sourceRepositoryRoot
                 )
               } : {}
             },
             onLine: (line) => {
               const match = line.match(/^part\d+:\s+(.+)$/);
-              if (match) exportParts.push(import_node_path19.default.resolve(cwd, match[1].trim()));
+              if (match) exportParts.push(import_node_path20.default.resolve(cwd, match[1].trim()));
             }
           });
           if (!exportParts.length) {
@@ -30685,7 +30805,7 @@ var init_orchestrator = __esm({
           const traceFiles = await (0, import_coreResearch.listCoreResearchTraceFiles)({
             strategyName: spec.strategy,
             runId,
-            outDir: import_node_path19.default.resolve(cwd, "data/research/core/trace")
+            outDir: import_node_path20.default.resolve(cwd, "data/research/core/trace")
           });
           resolvedVariants.push({
             ...variant,
@@ -30705,7 +30825,7 @@ var init_orchestrator = __esm({
               ...Object.fromEntries(
                 await Promise.all(
                   exportParts.map(async (filePath) => [
-                    import_node_path19.default.basename(filePath),
+                    import_node_path20.default.basename(filePath),
                     await sha256File(filePath)
                   ])
                 )
@@ -30724,7 +30844,7 @@ var init_orchestrator = __esm({
         }
       }
       await writeJsonAtomic(
-        import_node_path19.default.join(prepared.paths.researchDir, "resolved-runs.json"),
+        import_node_path20.default.join(prepared.paths.researchDir, "resolved-runs.json"),
         {
           schema: "tradejs-core-research-resolved-runs/v1",
           researchId: spec.researchId,
@@ -30744,12 +30864,12 @@ var coreResearch_exports = {};
 __export(coreResearch_exports, {
   main: () => main34
 });
-var import_promises26, import_node_path20, 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_node_path20 = __toESM(require("path"));
+    import_promises27 = __toESM(require("fs/promises"));
+    import_node_path21 = __toESM(require("path"));
     import_chalk41 = __toESM(require("chalk"));
     init_io();
     init_orchestrator();
@@ -30773,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_path20.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");
@@ -30804,14 +30924,14 @@ The run command executes only variants with an explicit command[] in the preregi
         return;
       }
       if (command === "index") {
-        const rootDir = import_node_path20.default.resolve(
+        const rootDir = import_node_path21.default.resolve(
           roots.projectRoot,
           required(valueAfter(argv2, "--root"), "--root")
         );
         const index = await writeCoreResearchStageIndex(rootDir);
         console.log(
           import_chalk41.default.green(
-            `Core research index: ${import_node_path20.default.join(rootDir, "index.json")} (${index.families.length} families)`
+            `Core research index: ${import_node_path21.default.join(rootDir, "index.json")} (${index.families.length} families)`
           )
         );
         return;
@@ -30820,7 +30940,7 @@ The run command executes only variants with an explicit command[] in the preregi
         projectRoot: roots.projectRoot
       });
       if (command === "init") {
-        const outputPath = import_node_path20.default.resolve(
+        const outputPath = import_node_path21.default.resolve(
           roots.projectRoot,
           required(valueAfter(argv2, "--out"), "--out")
         );
@@ -30844,7 +30964,7 @@ The run command executes only variants with an explicit command[] in the preregi
         );
         return;
       }
-      const specPath = import_node_path20.default.resolve(
+      const specPath = import_node_path21.default.resolve(
         roots.projectRoot,
         required(valueAfter(argv2, "--spec"), "--spec")
       );
@@ -31498,12 +31618,12 @@ __export(replayRuntimeEvidence_exports, {
   replayRuntimeEvidence: () => replayRuntimeEvidence,
   summarizeReplayComparison: () => summarizeReplayComparison
 });
-var import_promises27, import_node_path21, 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_node_path21 = __toESM(require("path"));
+    import_promises28 = __toESM(require("fs/promises"));
+    import_node_path22 = __toESM(require("path"));
     import_args27 = __toESM(require("args"));
     import_chalk43 = __toESM(require("chalk"));
     import_redis19 = require("@tradejs/infra/redis");
@@ -31762,10 +31882,10 @@ var init_replayRuntimeEvidence = __esm({
       runtimeEvidenceFile,
       projectRoot: projectRoot18
     }) => {
-      const runtimeEvidencePath = typeof runtimeEvidenceFile === "string" && runtimeEvidenceFile.trim() ? import_node_path21.default.resolve(projectRoot18, runtimeEvidenceFile.trim()) : null;
+      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",
@@ -31851,9 +31971,9 @@ var init_replayRuntimeEvidence = __esm({
         },
         runtime: runtime.payload
       };
-      const outPath = import_node_path21.default.resolve(projectRoot18, String(flags35.out));
-      await import_promises27.default.mkdir(import_node_path21.default.dirname(outPath), { recursive: true });
-      await import_promises27.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
+      const outPath = import_node_path22.default.resolve(projectRoot18, String(flags35.out));
+      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(
@@ -31875,15 +31995,6 @@ var init_replayRuntimeEvidence = __esm({
   }
 });
 
-// src/lib/runtimeEvidenceArtifacts.ts
-var runtimeEvidenceArtifacts_exports = {};
-var init_runtimeEvidenceArtifacts = __esm({
-  "src/lib/runtimeEvidenceArtifacts.ts"() {
-    "use strict";
-    __reExport(runtimeEvidenceArtifacts_exports, require("@tradejs/node/diagnostics"));
-  }
-});
-
 // src/lib/runtimeEvidenceProducer.ts
 var runtimeEvidenceProducer_exports = {};
 var init_runtimeEvidenceProducer = __esm({
@@ -31903,13 +32014,13 @@ var init_runtimeFeedbackArtifacts = __esm({
 });
 
 // src/lib/runtimeFeedbackReplay.ts
-var import_node_child_process7, import_promises28, import_node_path22, 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_node_path22 = __toESM(require("path"));
+    import_promises29 = __toESM(require("fs/promises"));
+    import_node_path23 = __toESM(require("path"));
     init_runtimeEvidenceDeployment();
     init_runtimeEvidenceArtifacts();
     init_runtimeEvidenceProducer();
@@ -32096,9 +32207,9 @@ $ ${[executable, ...command].join(" ")}
         throw new Error("Cannot resolve the TradeJS CLI executable path");
       }
       const runtimeEvidenceBundle = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(
-        import_node_path22.default.dirname(runtimeEvidencePath)
+        import_node_path23.default.dirname(runtimeEvidencePath)
       );
-      if (import_node_path22.default.resolve(runtimeEvidenceBundle.payloadPath) !== runtimeEvidencePath) {
+      if (import_node_path23.default.resolve(runtimeEvidenceBundle.payloadPath) !== runtimeEvidencePath) {
         throw new Error(
           `Runtime evidence must be the verified bundle payload: ${runtimeEvidenceBundle.payloadPath}`
         );
@@ -32125,16 +32236,16 @@ $ ${[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_path22.default.join(outDir, runtimeFeedbackArtifacts_exports.RUNTIME_FEEDBACK_REPLAY_FILE);
-      const logHandle = await import_promises28.default.open(
-        import_node_path22.default.join(outDir, runtimeFeedbackArtifacts_exports.RUNTIME_FEEDBACK_LOG_FILE),
+      const replayEvidencePath = import_node_path23.default.join(outDir, runtimeFeedbackArtifacts_exports.RUNTIME_FEEDBACK_REPLAY_FILE);
+      const logHandle = await import_promises29.default.open(
+        import_node_path23.default.join(outDir, runtimeFeedbackArtifacts_exports.RUNTIME_FEEDBACK_LOG_FILE),
         "wx"
       );
       const commands = buildRuntimeFeedbackReplayCommands({
@@ -32176,11 +32287,11 @@ __export(runtimeFeedbackReplay_exports, {
   main: () => main37,
   runtimeFeedbackReplay: () => runtimeFeedbackReplay
 });
-var import_node_path23, import_args28, import_chalk44, flags25, projectRoot9, runtimeFeedbackReplay, main37;
+var import_node_path24, import_args28, import_chalk44, flags25, projectRoot9, runtimeFeedbackReplay, main37;
 var init_runtimeFeedbackReplay2 = __esm({
   "src/scripts/runtimeFeedbackReplay.ts"() {
     "use strict";
-    import_node_path23 = __toESM(require("path"));
+    import_node_path24 = __toESM(require("path"));
     import_args28 = __toESM(require("args"));
     import_chalk44 = __toESM(require("chalk"));
     init_runtimeFeedbackReplay();
@@ -32198,8 +32309,8 @@ var init_runtimeFeedbackReplay2 = __esm({
         );
       }
       const verified = await runRuntimeFeedbackReplay({
-        runtimeEvidencePath: import_node_path23.default.resolve(projectRoot9, runtimeEvidence2),
-        outDir: import_node_path23.default.resolve(projectRoot9, outDir),
+        runtimeEvidencePath: import_node_path24.default.resolve(projectRoot9, runtimeEvidence2),
+        outDir: import_node_path24.default.resolve(projectRoot9, outDir),
         runId: String(flags25.runId ?? "").trim() || void 0,
         projectRoot: projectRoot9
       });
@@ -32357,11 +32468,11 @@ __export(runtimeFeedbackNotify_exports, {
   main: () => main38,
   runtimeFeedbackNotify: () => runtimeFeedbackNotify
 });
-var import_node_path24, import_args29, import_chalk45, flags26, projectRoot10, runtimeFeedbackNotify, main38;
+var import_node_path25, import_args29, import_chalk45, flags26, projectRoot10, runtimeFeedbackNotify, main38;
 var init_runtimeFeedbackNotify = __esm({
   "src/scripts/runtimeFeedbackNotify.ts"() {
     "use strict";
-    import_node_path24 = __toESM(require("path"));
+    import_node_path25 = __toESM(require("path"));
     import_args29 = __toESM(require("args"));
     import_chalk45 = __toESM(require("chalk"));
     init_runtimeFeedbackNotification();
@@ -32375,7 +32486,7 @@ var init_runtimeFeedbackNotify = __esm({
       if (!bundle) {
         throw new Error("Provide --bundle for runtime feedback notification.");
       }
-      const bundleDir = import_node_path24.default.resolve(projectRoot10, bundle);
+      const bundleDir = import_node_path25.default.resolve(projectRoot10, bundle);
       if (flags26.dryRun) {
         const verified = await (0, runtimeFeedbackArtifacts_exports.verifyRuntimeFeedbackReplayBundle)(bundleDir);
         console.log(buildRuntimeFeedbackTelegramMessage(verified.replayEvidence));
@@ -32391,13 +32502,13 @@ var init_runtimeFeedbackNotify = __esm({
 });
 
 // src/lib/runtimeEvidenceSync.ts
-var import_node_child_process8, import_promises29, import_node_path25, 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_node_path25 = __toESM(require("path"));
+    import_promises30 = __toESM(require("fs/promises"));
+    import_node_path26 = __toESM(require("path"));
     import_node_util = require("util");
     init_runtimeEvidenceArtifacts();
     init_runtimeEvidenceDeployment();
@@ -32431,15 +32542,15 @@ var init_runtimeEvidenceSync = __esm({
       withTrailingSlash(source),
       withTrailingSlash(destination)
     ];
-    receiptPath = (receiptsRoot, artifactId) => import_node_path25.default.join(receiptsRoot, `${safeSegment2(artifactId, "artifact")}.json`);
+    receiptPath = (receiptsRoot, artifactId) => import_node_path26.default.join(receiptsRoot, `${safeSegment2(artifactId, "artifact")}.json`);
     compareBundles = (left, right) => left.manifest.window.endTime - right.manifest.window.endTime || left.manifest.createdAt - right.manifest.createdAt;
     listPendingRuntimeEvidenceBundles = async ({
       evidenceRoot,
       deploymentId
     }) => {
       const safeDeploymentId = safeSegment2(deploymentId, "production");
-      const artifactsRoot = import_node_path25.default.join(evidenceRoot, "artifacts", safeDeploymentId);
-      const receiptsRoot = import_node_path25.default.join(evidenceRoot, "receipts", safeDeploymentId);
+      const artifactsRoot = import_node_path26.default.join(evidenceRoot, "artifacts", safeDeploymentId);
+      const receiptsRoot = import_node_path26.default.join(evidenceRoot, "receipts", safeDeploymentId);
       const bundles = await (0, runtimeEvidenceArtifacts_exports.discoverRuntimeEvidenceBundles)(artifactsRoot);
       const pending = [];
       for (const bundleDir of bundles) {
@@ -32447,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;
@@ -32470,7 +32581,7 @@ var init_runtimeEvidenceSync = __esm({
           `Artifact deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
         );
       }
-      const receiptsRoot = import_node_path25.default.join(evidenceRoot, "receipts", safeDeploymentId);
+      const receiptsRoot = import_node_path26.default.join(evidenceRoot, "receipts", safeDeploymentId);
       const finalPath = receiptPath(receiptsRoot, verified.manifest.artifactId);
       const temporaryPath = `${finalPath}.tmp-${process.pid}`;
       const receipt = {
@@ -32484,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 ({
@@ -32506,11 +32617,11 @@ var init_runtimeEvidenceSync = __esm({
       }
     }) => {
       const safeDeploymentId = safeSegment2(deploymentId, "production");
-      const inboxRoot = import_node_path25.default.join(evidenceRoot, "inbox", safeDeploymentId);
-      const artifactsRoot = import_node_path25.default.join(evidenceRoot, "artifacts", safeDeploymentId);
+      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,
@@ -32527,14 +32638,14 @@ var init_runtimeEvidenceSync = __esm({
           );
         }
         (0, runtimeEvidenceDeployment_exports.assertCurrentRuntimeEvidenceArtifact)(verified.artifact);
-        const destinationDir = import_node_path25.default.join(
+        const destinationDir = import_node_path26.default.join(
           artifactsRoot,
           ...dateParts(verified.manifest.window.endTime),
           safeSegment2(verified.manifest.artifactId, "artifact")
         );
-        await import_promises29.default.mkdir(import_node_path25.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);
@@ -32543,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));
       }
@@ -32563,13 +32674,13 @@ var init_runtimeEvidenceSync = __esm({
 });
 
 // src/lib/runtimeFeedbackSync.ts
-var import_node_child_process9, import_promises30, import_node_path26, 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_node_path26 = __toESM(require("path"));
+    import_promises31 = __toESM(require("fs/promises"));
+    import_node_path27 = __toESM(require("path"));
     import_node_util2 = require("util");
     init_runtimeFeedbackArtifacts();
     init_runtimeEvidenceSync();
@@ -32602,11 +32713,11 @@ var init_runtimeFeedbackSync = __esm({
       }
     }) => {
       const safeDeploymentId = safeSegment3(deploymentId, "production");
-      const inboxRoot = import_node_path26.default.join(feedbackRoot, "inbox", safeDeploymentId);
-      const artifactsRoot = import_node_path26.default.join(feedbackRoot, "artifacts", safeDeploymentId);
+      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,
@@ -32622,15 +32733,15 @@ var init_runtimeFeedbackSync = __esm({
             `Runtime feedback deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
           );
         }
-        const destinationDir = import_node_path26.default.join(
+        const destinationDir = import_node_path27.default.join(
           artifactsRoot,
           ...dateParts2(verified.manifest.window.endTime),
           safeSegment3(verified.manifest.runtimeEvidence.artifactId, "artifact"),
           safeSegment3(verified.manifest.runId, "run")
         );
-        await import_promises30.default.mkdir(import_node_path26.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);
@@ -32639,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));
       }
@@ -32659,11 +32770,11 @@ __export(runtimeFeedbackSync_exports, {
   main: () => main39,
   runtimeFeedbackSync: () => runtimeFeedbackSync
 });
-var import_node_path27, import_args30, import_chalk46, flags27, projectRoot11, runtimeFeedbackSync, main39;
+var import_node_path28, import_args30, import_chalk46, flags27, projectRoot11, runtimeFeedbackSync, main39;
 var init_runtimeFeedbackSync2 = __esm({
   "src/scripts/runtimeFeedbackSync.ts"() {
     "use strict";
-    import_node_path27 = __toESM(require("path"));
+    import_node_path28 = __toESM(require("path"));
     import_args30 = __toESM(require("args"));
     import_chalk46 = __toESM(require("chalk"));
     init_runtimeFeedbackSync();
@@ -32691,7 +32802,7 @@ var init_runtimeFeedbackSync2 = __esm({
           "Provide --source or RUNTIME_FEEDBACK_RSYNC_SOURCE for runtime feedback sync."
         );
       }
-      const feedbackRoot = import_node_path27.default.resolve(projectRoot11, String(flags27.dir));
+      const feedbackRoot = import_node_path28.default.resolve(projectRoot11, String(flags27.dir));
       const result = await syncRuntimeFeedbackReplayBundles({
         source,
         feedbackRoot,
@@ -32723,13 +32834,13 @@ var init_runtimeFeedbackSync2 = __esm({
 });
 
 // src/lib/runtimeEvidenceCompositionSnapshots.ts
-var import_node_crypto14, import_promises31, import_node_path28, 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_path28 = __toESM(require("path"));
+    import_node_crypto15 = require("crypto");
+    import_promises32 = __toESM(require("fs/promises"));
+    import_node_path29 = __toESM(require("path"));
     init_runtimeEvidenceDeployment();
     init_runtimeEvidenceProducer();
     SNAPSHOT_FILE = "snapshot.json";
@@ -32750,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)) {
@@ -32772,9 +32883,9 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
     };
     verifyRuntimeEvidenceCompositionSnapshot = async (bundleDir) => {
       const [manifestText, payload, completeText] = await Promise.all([
-        import_promises31.default.readFile(import_node_path28.default.join(bundleDir, MANIFEST_FILE), "utf8"),
-        import_promises31.default.readFile(import_node_path28.default.join(bundleDir, SNAPSHOT_FILE)),
-        import_promises31.default.readFile(import_node_path28.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) {
@@ -32837,39 +32948,39 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
           bytes: Buffer.byteLength(payload)
         }
       };
-      const snapshotsRoot = import_node_path28.default.join(evidenceRoot, "snapshots", deploymentId);
-      const bundleDir = import_node_path28.default.join(snapshotsRoot, compositionId);
-      const temporaryDir = import_node_path28.default.join(
+      const snapshotsRoot = import_node_path29.default.join(evidenceRoot, "snapshots", deploymentId);
+      const bundleDir = import_node_path29.default.join(snapshotsRoot, compositionId);
+      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_path28.default.join(temporaryDir, SNAPSHOT_FILE), payload, "utf8"),
-          import_promises31.default.writeFile(
-            import_node_path28.default.join(temporaryDir, MANIFEST_FILE),
+          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(
-          import_node_path28.default.join(temporaryDir, COMPLETE_FILE),
+        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);
@@ -32903,31 +33014,31 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
         );
       }
       await publishRuntimeEvidenceCompositionSnapshot({
-        evidenceRoot: import_node_path28.default.join(projectRoot18, "data", "runtime-evidence"),
+        evidenceRoot: import_node_path29.default.join(projectRoot18, "data", "runtime-evidence"),
         userName: userName3,
         deployment,
         producer
       });
     };
     discoverRuntimeEvidenceCompositionSnapshots = async (evidenceRoot) => {
-      const rootDir = import_node_path28.default.join(evidenceRoot, "snapshots");
+      const rootDir = import_node_path29.default.join(evidenceRoot, "snapshots");
       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_path28.default.join(rootDir, deployment.name);
-        const compositions = await import_promises31.default.readdir(deploymentDir, {
+        const deploymentDir = import_node_path29.default.join(rootDir, deployment.name);
+        const compositions = await import_promises32.default.readdir(deploymentDir, {
           withFileTypes: true
         });
         bundleDirs.push(
           ...compositions.filter(
             (entry) => entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.includes(".tmp-")
-          ).map((entry) => import_node_path28.default.join(deploymentDir, entry.name))
+          ).map((entry) => import_node_path29.default.join(deploymentDir, entry.name))
         );
       }
       return Promise.all(
@@ -33106,12 +33217,12 @@ __export(runtimeEvidence_exports, {
   main: () => main40,
   runtimeEvidence: () => runtimeEvidence
 });
-var import_promises32, import_node_path29, 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_node_path29 = __toESM(require("path"));
+    import_promises33 = __toESM(require("fs/promises"));
+    import_node_path30 = __toESM(require("path"));
     import_args31 = __toESM(require("args"));
     import_chalk47 = __toESM(require("chalk"));
     init_runtimeDebugEvidence();
@@ -33218,7 +33329,7 @@ var init_runtimeEvidence = __esm({
         deploymentId
       });
       const snapshots = publishDir && producer ? await loadRuntimeEvidenceCompositionSnapshots({
-        publishRoot: import_node_path29.default.resolve(projectRoot12, publishDir),
+        publishRoot: import_node_path30.default.resolve(projectRoot12, publishDir),
         currentDeployment: deploymentSnapshot,
         currentProducer: producer
       }) : /* @__PURE__ */ new Map([
@@ -33292,14 +33403,14 @@ var init_runtimeEvidence = __esm({
         throw new Error("Runtime evidence window has no versioned runtime rows");
       }
       const artifact = current.artifact;
-      const outPath = import_node_path29.default.resolve(projectRoot12, String(flags28.out));
-      await import_promises32.default.mkdir(import_node_path29.default.dirname(outPath), { recursive: true });
-      await import_promises32.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
+      const outPath = import_node_path30.default.resolve(projectRoot12, String(flags28.out));
+      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(
           ({ artifact: artifact2, composition }) => (0, runtimeEvidenceArtifacts_exports.publishRuntimeEvidenceBundle)({
-            publishRoot: import_node_path29.default.resolve(projectRoot12, publishDir),
+            publishRoot: import_node_path30.default.resolve(projectRoot12, publishDir),
             deploymentId,
             userName: String(flags28.user),
             startTime,
@@ -33345,11 +33456,11 @@ __export(runtimeEvidenceSync_exports, {
   main: () => main41,
   runtimeEvidenceSync: () => runtimeEvidenceSync
 });
-var import_node_path30, import_args32, import_chalk48, flags29, projectRoot13, runtimeEvidenceSync, main41;
+var import_node_path31, import_args32, import_chalk48, flags29, projectRoot13, runtimeEvidenceSync, main41;
 var init_runtimeEvidenceSync2 = __esm({
   "src/scripts/runtimeEvidenceSync.ts"() {
     "use strict";
-    import_node_path30 = __toESM(require("path"));
+    import_node_path31 = __toESM(require("path"));
     import_args32 = __toESM(require("args"));
     import_chalk48 = __toESM(require("chalk"));
     init_runtimeEvidenceSync();
@@ -33377,7 +33488,7 @@ var init_runtimeEvidenceSync2 = __esm({
           "Provide --source or RUNTIME_EVIDENCE_RSYNC_SOURCE for runtime evidence sync."
         );
       }
-      const evidenceRoot = import_node_path30.default.resolve(projectRoot13, String(flags29.dir));
+      const evidenceRoot = import_node_path31.default.resolve(projectRoot13, String(flags29.dir));
       const result = await syncRuntimeEvidenceBundles({
         source,
         evidenceRoot,
@@ -34415,26 +34526,43 @@ var init_monitoringProfile = __esm({
 });
 
 // src/lib/strategyRelease/evidenceRetention.ts
-var DAY_MS14, planStrategyEvidenceRetention;
+var DAY_MS14, isResearchRetired, planStrategyEvidenceRetention;
 var init_evidenceRetention = __esm({
   "src/lib/strategyRelease/evidenceRetention.ts"() {
     "use strict";
     DAY_MS14 = 864e5;
+    isResearchRetired = (research) => research?.status === "retired" && research.retirement?.policy === "discard-unrecoverable-without-rerun" && Boolean(research.retirement.reason.trim()) && Boolean(research.retirement.missingEvidence.length) && research.retirement.missingEvidence.every((item) => Boolean(item.trim()));
     planStrategyEvidenceRetention = ({
       now: now2,
       entries,
+      research,
       retentionDays = {
         operational_redis: 3,
         verbose_payload: 14,
+        research_payload: 0,
+        research_cache: 0,
         verified_runtime_bundle: 90,
         compact_ledger: null
       }
     }) => {
       const keep = [];
       const remove = [];
+      const retired = isResearchRetired(research);
+      const roles = new Set(
+        research?.permanentArtifacts.map((artifact) => artifact.role)
+      );
+      const terminalResearch = Boolean(
+        (research?.status === "completed" || retired) && Number.isFinite(research?.completedAt) && research.completedAt <= now2 && (retired ? ["note"] : ["note", "candidates", "metrics"]).every(
+          (role) => roles.has(role)
+        )
+      );
       for (const entry of entries) {
         const days = retentionDays[entry.kind];
-        if (days == null || !entry.verified || !entry.aggregated || now2 - entry.createdAt <= days * DAY_MS14) {
+        const isResearch = entry.kind === "research_payload" || entry.kind === "research_cache";
+        const completedResearch = Boolean(
+          terminalResearch && research?.researchId === entry.researchId && /^[a-f0-9]{64}$/.test(entry.sha256 ?? "")
+        );
+        if (isResearch && !completedResearch || days == null || !entry.verified || !entry.aggregated && !(isResearch && retired) || !isResearch && now2 - entry.createdAt <= days * DAY_MS14) {
           keep.push(entry);
         } else {
           remove.push(entry);
@@ -34464,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),
@@ -34611,13 +34739,13 @@ async function collectReleaseEvidenceReferences(references) {
     })
   );
 }
-var import_node_crypto15, import_promises33, import_node_path31, 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_path31 = __toESM(require("path"));
+    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");
     init_liveDiagnosis();
@@ -34636,11 +34764,11 @@ var init_strategyRelease = __esm({
       const artifact = input.chartArtifact;
       if (!artifact?.path || !SHA256_RE2.test(artifact.sha256)) return false;
       try {
-        const artifactPath = import_node_path31.default.resolve(artifact.path);
+        const artifactPath = import_node_path32.default.resolve(artifact.path);
         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
         );
@@ -34651,11 +34779,11 @@ var init_strategyRelease = __esm({
     readVerifiedJsonArtifact = async (artifact) => {
       if (!artifact?.path || !SHA256_RE2.test(artifact.sha256)) return null;
       try {
-        const artifactPath = import_node_path31.default.resolve(artifact.path);
+        const artifactPath = import_node_path32.default.resolve(artifact.path);
         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;
       }
@@ -35201,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",
@@ -35252,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) => {
@@ -35314,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_path31.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,
@@ -35338,13 +35466,13 @@ var init_strategyRelease = __esm({
           path: entry.path
         }))
       });
-      const releasePath = import_node_path31.default.join(
+      const releasePath = import_node_path32.default.join(
         rootDir,
         "releases",
         safeSegment5(manifest.strategy, "strategy"),
         `${manifest.releaseId}.json`
       );
-      const markerPath = import_node_path31.default.join(
+      const markerPath = import_node_path32.default.join(
         rootDir,
         "markers",
         safeSegment5(manifest.strategy, "strategy"),
@@ -35424,13 +35552,13 @@ var init_strategyRelease = __esm({
         markers,
         sourceArtifacts
       });
-      const diagnosisPath = import_node_path31.default.join(
+      const diagnosisPath = import_node_path32.default.join(
         rootDir,
         "diagnoses",
         safeSegment5(diagnosis.strategy, "strategy"),
         `${diagnosisId}.json`
       );
-      const markerPath = import_node_path31.default.join(
+      const markerPath = import_node_path32.default.join(
         rootDir,
         "markers",
         safeSegment5(diagnosis.strategy, "strategy"),
@@ -35620,11 +35748,11 @@ var init_strategyRelease = __esm({
       const specSha256 = finiteString3(artifact.specSha256);
       assert3(researchId != null, "core result researchId is required");
       assert3(specSha256 != null, "core result specSha256 is required");
-      const researchDir = import_node_path31.default.dirname(resultPath);
-      const manifestPath = import_node_path31.default.join(researchDir, "manifest.json");
-      const specPath = import_node_path31.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 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_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"
@@ -35633,14 +35761,14 @@ 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(
         artifactHashes ?? {}
       )) {
         assert3(
-          !import_node_path31.default.isAbsolute(relativePath) && !relativePath.split(/[\\/]/).includes(".."),
+          !import_node_path32.default.isAbsolute(relativePath) && !relativePath.split(/[\\/]/).includes(".."),
           `core bundle artifact ${relativePath} escapes its research directory`
         );
         assert3(
@@ -35648,7 +35776,7 @@ var init_strategyRelease = __esm({
           `core bundle artifact ${relativePath} has an invalid checksum`
         );
         const actualSha256 = await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(
-          import_node_path31.default.join(researchDir, relativePath)
+          import_node_path32.default.join(researchDir, relativePath)
         );
         assert3(
           actualSha256 === expectedSha256,
@@ -35665,13 +35793,13 @@ __export(runtimeScorecard_exports, {
   main: () => main42,
   runtimeScorecard: () => runtimeScorecard
 });
-var import_promises34, import_node_crypto16, import_node_path32, 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_node_path32 = __toESM(require("path"));
+    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"));
     init_runtimeEvidenceArtifacts();
@@ -35741,15 +35869,15 @@ var init_runtimeScorecard2 = __esm({
     projectRoot14 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     resolveOptionalPath = (value) => {
       const raw = String(value ?? "").trim();
-      return raw ? import_node_path32.default.resolve(projectRoot14, raw) : null;
+      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);
@@ -35820,13 +35948,13 @@ var init_runtimeScorecard2 = __esm({
         strategy: scorecardStrategy,
         llmComparatorPolicy: verifiedRelease?.manifest.prospective.llmComparatorPolicy ?? "ai_approved_only"
       });
-      const outPath = import_node_path32.default.resolve(projectRoot14, String(flags30.out));
+      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_path32.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"
@@ -35840,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)}
 `,
@@ -35861,7 +35989,7 @@ var init_runtimeScorecard2 = __esm({
             composition: verifiedRelease?.manifest.composition,
             sourceArtifacts: await Promise.all(
               sourcePaths.map(async (sourcePath) => ({
-                artifactId: import_node_path32.default.basename(sourcePath),
+                artifactId: import_node_path33.default.basename(sourcePath),
                 path: sourcePath,
                 sha256: await sha256File2(sourcePath)
               }))
@@ -35872,11 +36000,11 @@ var init_runtimeScorecard2 = __esm({
       let receiptPath2 = null;
       if (flags30.markProcessed) {
         const runtimeEvidenceBundle = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(
-          import_node_path32.default.dirname(runtimeEvidencePath)
+          import_node_path33.default.dirname(runtimeEvidencePath)
         );
         const feedbackSource = replayEvidencePath ? await (0, runtimeFeedbackArtifacts_exports.verifyRuntimeFeedbackReplaySource)({
-          bundleDir: import_node_path32.default.dirname(replayEvidencePath),
-          runtimeEvidenceBundleDir: import_node_path32.default.dirname(runtimeEvidencePath)
+          bundleDir: import_node_path33.default.dirname(replayEvidencePath),
+          runtimeEvidenceBundleDir: import_node_path33.default.dirname(runtimeEvidencePath)
         }).catch((error) => {
           if (runtimeEvidenceBundle.artifact.producer) throw error;
           return null;
@@ -35887,9 +36015,9 @@ var init_runtimeScorecard2 = __esm({
           );
         }
         receiptPath2 = await markRuntimeEvidenceBundleProcessed({
-          evidenceRoot: import_node_path32.default.resolve(projectRoot14, String(flags30.evidenceDir)),
+          evidenceRoot: import_node_path33.default.resolve(projectRoot14, String(flags30.evidenceDir)),
           deploymentId: String(flags30.deployment),
-          bundleDir: import_node_path32.default.dirname(runtimeEvidencePath),
+          bundleDir: import_node_path33.default.dirname(runtimeEvidencePath),
           scorecardPath: outPath,
           runtimeFeedback: feedbackSource ? {
             artifactId: feedbackSource.feedback.manifest.artifactId,
@@ -36080,21 +36208,316 @@ var init_runtimeControl = __esm({
   }
 });
 
+// src/lib/strategyRelease/researchFileConsumers.ts
+var import_node_path34, import_node_child_process10, import_node_util3, execFileAsync3, runCommand3, GUEST_FILE_CHECK, assertNoResearchFileConsumers;
+var init_researchFileConsumers = __esm({
+  "src/lib/strategyRelease/researchFileConsumers.ts"() {
+    "use strict";
+    import_node_path34 = __toESM(require("path"));
+    import_node_child_process10 = require("child_process");
+    import_node_util3 = require("util");
+    execFileAsync3 = (0, import_node_util3.promisify)(import_node_child_process10.execFile);
+    runCommand3 = (command, args39) => execFileAsync3(command, args39, { maxBuffer: 32 * 1024 * 1024 });
+    GUEST_FILE_CHECK = `
+import os, sys, json
+if os.geteuid() != 0:
+    raise RuntimeError('Cannot inspect every container process')
+wanted = set(json.loads(sys.argv[1]))
+opened = set()
+for pid in os.listdir('/proc'):
+    if not pid.isdigit():
+        continue
+    for kind in ('fd', 'map_files'):
+        directory = '/proc/' + pid + '/' + kind
+        try:
+            names = os.listdir(directory)
+        except FileNotFoundError:
+            continue
+        for name in names:
+            try:
+                target = os.readlink(directory + '/' + name)
+            except FileNotFoundError:
+                continue
+            if target in wanted:
+                opened.add(target)
+print(json.dumps(sorted(opened)))
+`;
+    assertNoResearchFileConsumers = async (files, run = runCommand3) => {
+      const virtualPids = /* @__PURE__ */ new Set();
+      const wanted = new Set(files.map((file) => import_node_path34.default.resolve(file)));
+      let commonRoot = files.length ? import_node_path34.default.dirname(files[0]) : "";
+      while (commonRoot && files.some((file) => {
+        const relative = import_node_path34.default.relative(commonRoot, file);
+        return relative === ".." || relative.startsWith(`..${import_node_path34.default.sep}`) || import_node_path34.default.isAbsolute(relative);
+      }))
+        commonRoot = import_node_path34.default.dirname(commonRoot);
+      const selectors = [];
+      if (files.length > 1e3 && commonRoot !== import_node_path34.default.parse(commonRoot).root) {
+        selectors.push(["+D", commonRoot]);
+      } else {
+        for (let offset = 0; offset < files.length; offset += 100)
+          selectors.push(["--", ...files.slice(offset, offset + 100)]);
+      }
+      for (const selector of selectors) {
+        let output;
+        try {
+          output = (await run("lsof", ["-F", "pcn", ...selector])).stdout;
+        } catch (error) {
+          if (error.code === 1) continue;
+          throw error;
+        }
+        let pid = "";
+        let virtual = false;
+        for (const line of output.split("\n")) {
+          if (line.startsWith("p")) {
+            pid = line.slice(1);
+            virtual = false;
+          }
+          if (line.startsWith("c"))
+            virtual = line.startsWith("ccom.apple.Virtualization.");
+          if (line.startsWith("n")) {
+            if (!wanted.has(import_node_path34.default.resolve(line.slice(1)))) continue;
+            if (!virtual || !/^\d+$/.test(pid))
+              throw new Error(
+                `Research cleanup found open files: ${line.slice(1)}`
+              );
+            virtualPids.add(pid);
+          }
+        }
+      }
+      if (!virtualPids.size) return;
+      for (const pid of virtualPids) {
+        const comm = (await run("ps", ["-p", pid, "-o", "comm="])).stdout.trim();
+        if (comm !== "/System/Library/Frameworks/Virtualization.framework/Versions/A/XPCServices/com.apple.Virtualization.VirtualMachine.xpc/Contents/MacOS/com.apple.Virtualization.VirtualMachine") {
+          throw new Error("Unrecognized virtual file consumer");
+        }
+      }
+      const contexts = JSON.parse(
+        (await run("docker", ["context", "inspect"])).stdout
+      );
+      if (contexts.length !== 1 || !contexts[0].Endpoints.docker.Host.startsWith("unix://")) {
+        throw new Error("Research file inspection requires a local Docker socket");
+      }
+      const ids = (await run("docker", ["ps", "-q"])).stdout.trim().split(/\s+/).filter(Boolean);
+      if (!ids.length)
+        throw new Error("Cannot resolve virtual research file handles");
+      const containers = JSON.parse(
+        (await run("docker", ["inspect", ...ids])).stdout
+      );
+      const covered = /* @__PURE__ */ new Set();
+      for (const container of containers) {
+        const guestFiles = /* @__PURE__ */ new Set();
+        for (const mount of container.Mounts) {
+          if (mount.Type !== "bind") continue;
+          for (const file of files) {
+            const relative = import_node_path34.default.relative(mount.Source, file);
+            if (relative === "" || !relative.startsWith(`..${import_node_path34.default.sep}`) && relative !== ".." && !import_node_path34.default.isAbsolute(relative)) {
+              guestFiles.add(import_node_path34.default.posix.join(mount.Destination, relative));
+              covered.add(file);
+            }
+          }
+        }
+        if (!guestFiles.size) continue;
+        const paths = [...guestFiles];
+        for (let offset = 0; offset < paths.length; offset += 250) {
+          const opened = JSON.parse(
+            (await run("docker", [
+              "exec",
+              container.Id,
+              "python",
+              "-c",
+              GUEST_FILE_CHECK,
+              JSON.stringify(paths.slice(offset, offset + 250))
+            ])).stdout
+          );
+          if (!Array.isArray(opened) || opened.length)
+            throw new Error("Research cleanup found open files in a container");
+        }
+      }
+      if (covered.size !== files.length)
+        throw new Error("Unresolved virtual research file handles");
+    };
+  }
+});
+
+// src/lib/strategyRelease/researchRetention.ts
+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_promises36 = __toESM(require("fs/promises"));
+    import_node_path35 = __toESM(require("path"));
+    import_node_crypto18 = require("crypto");
+    import_strategyReleaseEvidence3 = require("@tradejs/infra/strategyReleaseEvidence");
+    init_researchFileConsumers();
+    init_evidenceRetention();
+    SHA256_RE3 = /^[a-f0-9]{64}$/;
+    mapFiles = async (entries, visit) => {
+      const results2 = new Array(entries.length);
+      let next = 0;
+      const workers = await Promise.allSettled(
+        Array.from({ length: Math.min(8, entries.length) }, async () => {
+          while (next < entries.length) {
+            const index = next++;
+            results2[index] = await visit(entries[index]);
+          }
+        })
+      );
+      for (const worker of workers)
+        if (worker.status === "rejected") throw worker.reason;
+      return results2;
+    };
+    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_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);
+      const journalPath = `${receiptPath2}.deleted.jsonl`;
+      const permanent = new Set(
+        options.research.permanentArtifacts.map((entry) => resolve(entry.path))
+      );
+      if (!inside(projectRoot18, receiptPath2) || permanent.has(receiptPath2) || permanent.has(journalPath)) {
+        throw new Error(
+          "Cleanup receipt must be separate from permanent research artifacts"
+        );
+      }
+      permanent.add(receiptPath2);
+      permanent.add(journalPath);
+      for (const file of options.protectedPaths ?? []) permanent.add(resolve(file));
+      const retired = isResearchRetired(options.research);
+      if (options.research.status !== "completed" && !retired || !Number.isFinite(options.research.completedAt) || options.research.completedAt > Date.now()) {
+        throw new Error("Research must be completed before cleanup");
+      }
+      for (const role of retired ? ["note"] : ["note", "candidates", "metrics"]) {
+        if (!options.research.permanentArtifacts.some((entry) => entry.role === role)) {
+          throw new Error(`Missing permanent research ${role}`);
+        }
+      }
+      await mapFiles(options.research.permanentArtifacts, async (artifact) => {
+        const file = resolve(artifact.path);
+        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_promises36.default.open(file, "r");
+          try {
+            const header = Buffer.alloc(4096);
+            const { bytesRead } = await handle.read(header, 0, header.length, 0);
+            const frontmatter = header.subarray(0, bytesRead).toString("utf8").match(/^---\r?\n([\s\S]*?)\r?\n---/);
+            if (!frontmatter || !/^schema:\s*tradejs-research\/v1\s*$/m.test(frontmatter[1]) || !(retired ? /^reproduction:\s*(?:complete|partial|blocked|legacy-partial)\s*$/m.test(
+              frontmatter[1]
+            ) : /^reproduction:\s*complete\s*$/m.test(frontmatter[1]))) {
+              throw new Error(
+                `Research note must have reproduction: complete: ${file}`
+              );
+            }
+          } finally {
+            await handle.close();
+          }
+        }
+      });
+      const checkedPaths = /* @__PURE__ */ new Set();
+      const checked = await mapFiles(options.entries, async (entry) => {
+        const file = resolve(entry.path);
+        if (!["research_payload", "research_cache"].includes(entry.kind) || entry.researchId !== options.research.researchId || !entry.verified || !entry.aggregated && !retired || !SHA256_RE3.test(entry.sha256 ?? "") || !inside(dataRoot, file) || permanent.has(file) || /\.(?:md|patch|diff)$/i.test(file)) {
+          throw new Error(`Not a disposable research file: ${file}`);
+        }
+        if (checkedPaths.has(file))
+          throw new Error(`Duplicate cleanup path: ${file}`);
+        checkedPaths.add(file);
+        if (await import_promises36.default.realpath(file) !== file)
+          throw new Error(`Research cleanup refuses symlinks: ${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}`
+          );
+        }
+        return { entry, file, mtimeMs: stat.mtimeMs, ino: stat.ino };
+      });
+      await assertNoResearchFileConsumers(checked.map((entry) => entry.file));
+      const receipt = {
+        schema: "tradejs-research-cleanup-receipt/v1",
+        researchId: options.research.researchId,
+        completedAt: options.research.completedAt,
+        ...retired ? { retirement: options.research.retirement } : {},
+        journalPath,
+        permanentArtifacts: options.research.permanentArtifacts,
+        scope: "reported aggregates and frozen candidates; new trade-level analyses require a rerun",
+        status: "planned",
+        files: checked.map(({ entry, file }) => ({
+          path: file,
+          sha256: entry.sha256,
+          bytes: entry.bytes,
+          removed: false
+        }))
+      };
+      if (!options.apply) return receipt;
+      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_promises36.default.open(`${receiptPath2}.lock`, "wx");
+      let journal;
+      const writeReceipt = async () => {
+        const temp = `${receiptPath2}.${process.pid}.tmp`;
+        await import_promises36.default.writeFile(temp, `${JSON.stringify(receipt, null, 2)}
+`, "utf8");
+        await import_promises36.default.rename(temp, receiptPath2);
+      };
+      try {
+        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_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_promises36.default.unlink(file);
+          receipt.files[index].removed = true;
+          await journal.write(`${JSON.stringify(receipt.files[index])}
+`);
+        }
+        receipt.status = "completed";
+        await writeReceipt();
+        return receipt;
+      } catch (error) {
+        if (journal) await writeReceipt();
+        throw error;
+      } finally {
+        await journal?.close();
+        await lock.close();
+        await import_promises36.default.unlink(`${receiptPath2}.lock`);
+      }
+    };
+  }
+});
+
 // src/scripts/strategyRelease.ts
 var strategyRelease_exports = {};
 __export(strategyRelease_exports, {
   main: () => main44,
   runStrategyReleaseCommand: () => runStrategyReleaseCommand
 });
-var import_promises35, import_node_fs6, import_node_readline3, import_node_path33, 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_promises35 = __toESM(require("fs/promises"));
+    import_promises37 = __toESM(require("fs/promises"));
     import_node_fs6 = require("fs");
     import_node_readline3 = require("readline");
-    import_node_path33 = __toESM(require("path"));
+    import_node_path36 = __toESM(require("path"));
     import_chalk50 = __toESM(require("chalk"));
+    init_researchRetention();
     init_strategyRelease();
     valueAfter2 = (argv2, name) => {
       const index = argv2.indexOf(name);
@@ -36106,17 +36529,17 @@ var init_strategyRelease2 = __esm({
     };
     writeJsonAtomic3 = async (filePath, value) => {
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-      await import_promises35.default.mkdir(import_node_path33.default.dirname(filePath), { recursive: true });
-      await import_promises35.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_promises35.default.rename(temporaryPath, filePath);
+      await import_promises37.default.rename(temporaryPath, filePath);
     };
     runStrategyReleaseCommand = async (options) => {
-      const inputPath = import_node_path33.default.resolve(options.inputPath);
+      const inputPath = import_node_path36.default.resolve(options.inputPath);
       if (options.command === "verify") {
         const envelope = await verifyStrategyReleaseEnvelope(inputPath);
         return {
@@ -36154,7 +36577,7 @@ var init_strategyRelease2 = __esm({
           endTime,
           days: options.days?.length ? options.days : [7, 30, 90]
         });
-        const outputPath = import_node_path33.default.resolve(
+        const outputPath = import_node_path36.default.resolve(
           options.outputPath ?? "output/strategy-monitoring-profile.json"
         );
         await writeJsonAtomic3(outputPath, profile);
@@ -36165,22 +36588,40 @@ var init_strategyRelease2 = __esm({
           profile
         };
       }
-      const input = JSON.parse(await import_promises35.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) {
-          await writeJsonAtomic3(import_node_path33.default.resolve(options.outputPath), decision);
+          await writeJsonAtomic3(import_node_path36.default.resolve(options.outputPath), decision);
         }
         return {
           kind: "decided",
           ...decision,
-          outputPath: options.outputPath ? import_node_path33.default.resolve(options.outputPath) : null
+          outputPath: options.outputPath ? import_node_path36.default.resolve(options.outputPath) : null
         };
       }
       if (options.command === "retention") {
         const plan = planStrategyEvidenceRetention(input);
-        if (options.apply) {
-          await Promise.all(plan.delete.map((entry) => import_promises35.default.rm(entry.path)));
+        const researchEntries = plan.delete.filter(
+          (entry) => entry.kind === "research_payload" || entry.kind === "research_cache"
+        );
+        const receiptPath2 = options.outputPath ?? `${inputPath}.receipt.json`;
+        if (researchEntries.length) {
+          if (researchEntries.length !== plan.delete.length) {
+            throw new Error(
+              "Research cleanup requires a separate inventory from runtime retention"
+            );
+          }
+          await applyResearchRetention({
+            projectRoot: process.env.PROJECT_CWD ?? process.cwd(),
+            research: input.research,
+            entries: researchEntries,
+            receiptPath: receiptPath2,
+            apply: Boolean(options.apply),
+            protectedPaths: [inputPath]
+          });
+        } else if (options.apply) {
+          await Promise.all(plan.delete.map((entry) => import_promises37.default.rm(entry.path)));
         }
         return {
           kind: "retention",
@@ -36188,17 +36629,18 @@ var init_strategyRelease2 = __esm({
           keepCount: plan.keep.length,
           deleteCount: plan.delete.length,
           bytesReclaimable: plan.bytesReclaimable,
-          delete: plan.delete.map((entry) => entry.path)
+          delete: plan.delete.map((entry) => entry.path),
+          ...researchEntries.length && options.apply ? { receiptPath: receiptPath2 } : {}
         };
       }
       if (options.command === "diagnose") {
         const diagnosis = buildStrategyLiveDiagnosis(input);
-        const outputPath = import_node_path33.default.resolve(
+        const outputPath = import_node_path36.default.resolve(
           options.outputPath ?? "output/strategy-live-diagnosis.json"
         );
         await writeJsonAtomic3(outputPath, diagnosis);
         const published2 = options.rootDir ? await publishStrategyLiveDiagnosis({
-          rootDir: import_node_path33.default.resolve(options.rootDir),
+          rootDir: import_node_path36.default.resolve(options.rootDir),
           diagnosis,
           sourceArtifacts: input.sourceArtifacts ?? []
         }) : null;
@@ -36215,7 +36657,7 @@ var init_strategyRelease2 = __esm({
         evidence: await collectReleaseEvidenceReferences(input.evidence ?? [])
       });
       const published = await publishStrategyRelease({
-        rootDir: import_node_path33.default.resolve(options.rootDir ?? "data/strategy-release"),
+        rootDir: import_node_path36.default.resolve(options.rootDir ?? "data/strategy-release"),
         manifest
       });
       return {
@@ -36275,12 +36717,12 @@ __export(serverHealth_exports, {
   main: () => main45,
   resolveServerHealthThresholds: () => resolveServerHealthThresholds
 });
-var import_config10, import_node_child_process10, import_node_os3, import_node_fs7, import_args34, import_redis20, DEFAULT_STATE, DEFAULT_THRESHOLDS, escapeHtml6, formatPctValue, formatLoadPerCore, formatGiB, formatDuration2, readDiskUsage, parseMeminfoBytes, readMemorySnapshot, runDiagnosticCommand, runDiagnosticCommands, collectServerHealthSnapshot, buildHumanSummaryLines, evaluateServerHealth, shouldRecover, buildAlertMessage, buildRecoveryMessage, buildServerHealthDiagnostics, getStateKey, toFiniteNumber3, resolveServerHealthThresholds, main45;
+var import_config10, import_node_child_process11, import_node_os3, import_node_fs7, import_args34, import_redis20, DEFAULT_STATE, DEFAULT_THRESHOLDS, escapeHtml6, formatPctValue, formatLoadPerCore, formatGiB, formatDuration2, readDiskUsage, parseMeminfoBytes, readMemorySnapshot, runDiagnosticCommand, runDiagnosticCommands, collectServerHealthSnapshot, buildHumanSummaryLines, evaluateServerHealth, shouldRecover, buildAlertMessage, buildRecoveryMessage, buildServerHealthDiagnostics, getStateKey, toFiniteNumber3, resolveServerHealthThresholds, main45;
 var init_serverHealth = __esm({
   "src/scripts/serverHealth.ts"() {
     "use strict";
     import_config10 = require("dotenv/config");
-    import_node_child_process10 = require("child_process");
+    import_node_child_process11 = require("child_process");
     import_node_os3 = __toESM(require("os"));
     import_node_fs7 = require("fs");
     import_args34 = __toESM(require("args"));
@@ -36317,21 +36759,21 @@ var init_serverHealth = __esm({
       }
       return `${minutes}m`;
     };
-    readDiskUsage = (path44) => {
+    readDiskUsage = (path47) => {
       try {
-        const stats = (0, import_node_fs7.statfsSync)(path44);
+        const stats = (0, import_node_fs7.statfsSync)(path47);
         const totalBlocks = Number(stats.blocks ?? 0);
         const availableBlocks = Number(stats.bavail ?? 0);
         if (totalBlocks <= 0) {
-          return { path: path44, usedPct: null };
+          return { path: path47, usedPct: null };
         }
         const usedPct = (totalBlocks - Math.max(0, availableBlocks)) / totalBlocks * 100;
         return {
-          path: path44,
+          path: path47,
           usedPct: Number.isFinite(usedPct) ? usedPct : null
         };
       } catch {
-        return { path: path44, usedPct: null };
+        return { path: path47, usedPct: null };
       }
     };
     parseMeminfoBytes = (value) => {
@@ -36396,7 +36838,7 @@ var init_serverHealth = __esm({
       }
     };
     runDiagnosticCommand = (command, args39) => {
-      const output = (0, import_node_child_process10.execFileSync)(command, args39, {
+      const output = (0, import_node_child_process11.execFileSync)(command, args39, {
         encoding: "utf8",
         timeout: 5e3,
         maxBuffer: 1024 * 1024,
@@ -38083,12 +38525,12 @@ __export(runtimeParity_exports, {
   main: () => main46,
   runtimeParity: () => runtimeParity
 });
-var import_config11, import_node_crypto17, 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_crypto17 = require("crypto");
+    import_node_crypto19 = require("crypto");
     import_args35 = __toESM(require("args"));
     import_chalk52 = __toESM(require("chalk"));
     import_constants19 = require("@tradejs/core/constants");
@@ -38471,9 +38913,9 @@ var init_runtimeParity2 = __esm({
                 start: window.start,
                 end: window.end
               },
-              name: `${target.symbol}_${target.strategy}_${(0, import_node_crypto17.randomUUID)().slice(0, 8)}`,
-              testId: (0, import_node_crypto17.randomUUID)().slice(0, 8),
-              testSuiteId: (0, import_node_crypto17.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,