@tradejs/cli 3.1.29-beta.297 → 3.1.29-beta.299

package/dist/cli.js

@@ -454,10 +454,10 @@ var init_charts = __esm({
       const span = Math.max(1e-9, maxY - minY), x = (time2) => 72 + 852 * (time2 - minX) / Math.max(1, maxX - minX), y = (value) => 238 - 196 * (value - minY) / span;
       const paths = populated.map((item) => {
         const points = sampleResearchCurve(item.points);
-        const path57 = points.map(
+        const path58 = points.map(
           ([time2, value], index) => `${index ? "H" : "M"}${x(time2).toFixed(2)}${index ? "V" : ","}${y(value).toFixed(2)}`
         ).join(" ");
-        return `<path d="${path57}" fill="none" stroke="${escapeResearchHtml(item.color)}" stroke-width="2.5" stroke-linejoin="round"/>`;
+        return `<path d="${path58}" fill="none" stroke="${escapeResearchHtml(item.color)}" stroke-width="2.5" stroke-linejoin="round"/>`;
       }).join("");
       return `<figure class="chart"><figcaption>${escapeResearchHtml(title)}</figcaption><svg viewBox="0 0 960 285" role="img" aria-label="${escapeResearchHtml(title)}"><title>${escapeResearchHtml(title)}</title>${[
         4
@@ -526,7 +526,7 @@ function pricePanel(t, c, step, x, y, w, h) {
     ["bbLower", "#8898ab"]
   ]) {
     let previous = null;
-    const path57 = c.map((b) => {
+    const path58 = c.map((b) => {
       const v = b[key2];
       if (v == null) {
         previous = null;
@@ -536,7 +536,7 @@ function pricePanel(t, c, step, x, y, w, h) {
       previous = b.timestamp;
       return `${command}${X(b.timestamp)},${Y(v)}`;
     }).join(" ");
-    s += `<path d="${path57}" fill="none" stroke="${color}" stroke-width="1.4"/>`;
+    s += `<path d="${path58}" fill="none" stroke="${color}" stroke-width="1.4"/>`;
   }
   for (const line of t.figures.lines)
     s += `<polyline points="${line.points.map((p) => `${X(p.timestamp)},${Y(p.value)}`).join(" ")}" fill="none" stroke="#0284c7" stroke-width="2"/>`;
@@ -3822,9 +3822,9 @@ var init_features = __esm({
       "targetsymbol",
       "universe"
     ]);
-    normalizeFeaturePath = (path57) => (Array.isArray(path57) ? path57 : path57.split(".")).filter(Boolean).map((segment) => segment.toLowerCase());
-    classifyAiPocketCoverageFeaturePath = (path57) => {
-      const segments = normalizeFeaturePath(path57);
+    normalizeFeaturePath = (path58) => (Array.isArray(path58) ? path58 : path58.split(".")).filter(Boolean).map((segment) => segment.toLowerCase());
+    classifyAiPocketCoverageFeaturePath = (path58) => {
+      const segments = normalizeFeaturePath(path58);
       const normalizedPath = segments.join(".");
       if (segments.some(
         (segment) => segment.includes("cmc") || segment.includes("coinmarketcap")
@@ -3998,8 +3998,8 @@ var init_features = __esm({
       "volumeusd",
       "vwap"
     ]);
-    classifyAiPocketFeaturePath = (path57) => {
-      const segments = (Array.isArray(path57) ? path57 : path57.split(".")).filter(
+    classifyAiPocketFeaturePath = (path58) => {
+      const segments = (Array.isArray(path58) ? path58 : path58.split(".")).filter(
         Boolean
       );
       const normalized = segments.map((segment) => segment.toLowerCase());
@@ -4329,11 +4329,11 @@ var init_features = __esm({
         excludeFeaturePattern.source,
         excludeFeaturePattern.flags.replace(/[gy]/g, "")
       ) : void 0;
-      const isOperatorExcluded = (path57) => {
-        if (!exclusion?.test(path57)) {
+      const isOperatorExcluded = (path58) => {
+        if (!exclusion?.test(path58)) {
           return false;
         }
-        onFeatureExcluded?.({ path: path57, classification: "operator-excluded" });
+        onFeatureExcluded?.({ path: path58, classification: "operator-excluded" });
         return true;
       };
       const signal = payload.signal ?? {};
@@ -4416,15 +4416,15 @@ var init_features = __esm({
       if (registered) {
         (0, import_aiFeatures.validateAiFeatureSnapshot)(registered);
         for (const definition of registered.definitions) {
-          const path57 = `registered.${definition.id}`;
-          if (isOperatorExcluded(path57)) continue;
+          const path58 = `registered.${definition.id}`;
+          if (isOperatorExcluded(path58)) continue;
           const value = registered.values[definition.id];
           const classification = definition.role === "outcome" || definition.role === "policy" ? "derived-policy" : definition.role !== "input" ? definition.role : featurePolicy === "causal-stationary" && !definition.stationary ? "raw-nonstationary" : value === null || value === "unknown" ? "data-quality" : "eligible";
           if (classification !== "eligible") {
-            onFeatureExcluded?.({ path: path57, classification });
+            onFeatureExcluded?.({ path: path58, classification });
             continue;
           }
-          features[path57] = value;
+          features[path58] = value;
         }
       }
       return { features, featureCoverage };
@@ -8543,7 +8543,7 @@ var init_command = __esm({
           options.testSince
         );
         const sources = await Promise.all(
-          filePaths.map(async (path57) => ({ path: path57, sha256: await sha256File(path57) }))
+          filePaths.map(async (path58) => ({ path: path58, sha256: await sha256File(path58) }))
         );
         const dataset = await evaluateAiPocketSearchDataset({
           prepared: preparedDataset,
@@ -13595,27 +13595,27 @@ var init_coinMarketCapContextBackfill = __esm({
       totalCredits: 0,
       byPath: /* @__PURE__ */ new Map()
     });
-    getCoinMarketCapPathLabel = (path57) => {
-      if (path57.includes("global-metrics")) return "global";
-      if (path57.includes("cryptocurrency/quotes")) return "reference";
-      if (path57.includes("exchange/quotes")) return "exchangeLiquidity";
-      if (path57.includes("fear-and-greed")) return "fearGreed";
-      if (path57.includes("cmc100")) return "cmc100";
-      if (path57.includes("cmc20")) return "cmc20";
-      return path57;
-    };
-    recordCoinMarketCapFetchStats = (stats, path57, creditCount) => {
+    getCoinMarketCapPathLabel = (path58) => {
+      if (path58.includes("global-metrics")) return "global";
+      if (path58.includes("cryptocurrency/quotes")) return "reference";
+      if (path58.includes("exchange/quotes")) return "exchangeLiquidity";
+      if (path58.includes("fear-and-greed")) return "fearGreed";
+      if (path58.includes("cmc100")) return "cmc100";
+      if (path58.includes("cmc20")) return "cmc20";
+      return path58;
+    };
+    recordCoinMarketCapFetchStats = (stats, path58, creditCount) => {
       if (!stats) return;
-      const existing = stats.byPath.get(path57) ?? { requests: 0, credits: 0 };
+      const existing = stats.byPath.get(path58) ?? { requests: 0, credits: 0 };
       existing.requests += 1;
       existing.credits += creditCount ?? 0;
       stats.requests += 1;
       stats.totalCredits += creditCount ?? 0;
-      stats.byPath.set(path57, existing);
+      stats.byPath.set(path58, existing);
     };
     formatCoinMarketCapFetchStats = (stats) => {
       const byPath = [...stats.byPath.entries()].map(
-        ([path57, item]) => `${getCoinMarketCapPathLabel(path57)}=${item.requests}req/${item.credits}cr`
+        ([path58, item]) => `${getCoinMarketCapPathLabel(path58)}=${item.requests}req/${item.credits}cr`
       ).join(" ");
       return `apiRequests=${stats.requests} apiCredits=${stats.totalCredits}${byPath ? ` ${byPath}` : ""}`;
     };
@@ -17435,8 +17435,14 @@ var init_backtest = __esm({
       console.log(import_chalk15.default.gray(`full report: ${markdownReportPath}`));
       console.log("");
       if (!isFastMode || flags5.persistResults) {
-        await (0, import_redis8.setData)(
-          import_redis8.redisKeys.backtestResults(userName, flags5.config, timestamp),
+        const mcpTimestamp = process.env.MCP_WORKER === "true" ? process.env.MCP_BACKTEST_RESULT_TIMESTAMP : void 0;
+        const saveResult = mcpTimestamp ? import_redis8.setDataStrict : import_redis8.setData;
+        await saveResult(
+          import_redis8.redisKeys.backtestResults(
+            userName,
+            flags5.config,
+            mcpTimestamp ?? timestamp
+          ),
           {
             config: flags5.config,
             mode: "config",
@@ -26064,13 +26070,16 @@ async function fetchTarget(userName3, request, target, loaded) {
   const interval4 = dataset.interval;
   const missing = (time2) => time2 >= day && time2 < end && !loaded.has(time2);
   if (dataset.provider === "CoinMarketCap") {
-    await backfillCoinMarketCapContext({
+    const params = {
       userName: userName3,
       startMs: day,
       preloadStartMs: day,
       endMs: end,
       repairDataset: dataset.id
-    });
+    };
+    if (resolveCoinMarketCapBackfillWindow(params).fromMs > day)
+      return "outside_configured_history";
+    await backfillCoinMarketCapContext(params);
     return;
   }
   if (dataset.provider === "Coinalyze") {
@@ -26079,7 +26088,7 @@ async function fetchTarget(userName3, request, target, loaded) {
       userName3,
       series
     );
-    if (!marketSymbol) return;
+    if (!marketSymbol) return "no_matching_market";
     const { derivativesRows = [] } = await import_connectors11.marketDataProviders.coinalyze.fetchWindow({
       symbol: series,
       marketSymbol,
@@ -26171,8 +26180,7 @@ async function fetchTarget(userName3, request, target, loaded) {
   const universe = (0, import_strategies11.getBinanceBreadthUniverses)().find(
     (item) => item.universe === series
   );
-  if (!universe)
-    throw new Error("The historical Binance basket is unavailable.");
+  if (!universe) return "historical_basket_unavailable";
   const candlesBySymbol = {};
   const warmup = day - 2 * DAY_MS11;
   for (let offset = 0; offset < universe.symbols.length; offset += 4) {
@@ -26201,14 +26209,16 @@ async function main17() {
     );
   await (0, import_client5.waitForDbReady)();
   const before = await (0, import_dataCoverage.readDataBackfillSlots)(request, target.end);
-  if (before.loaded.size < before.expected)
-    await fetchTarget(userName3, request, target, before.loaded);
+  const outcome = before.loaded.size < before.expected ? await fetchTarget(userName3, request, target, before.loaded) : void 0;
   const after = await (0, import_dataCoverage.readDataBackfillSlots)(request, target.end);
   const result = {
     loaded: after.loaded.size,
     added: Math.max(0, after.loaded.size - before.loaded.size),
     missing: Math.max(0, after.expected - after.loaded.size)
   };
+  if (result.missing) {
+    result.outcome = outcome ?? (result.added ? "some_missing_slots_filled" : "no_missing_slots_filled");
+  }
   console.log(`TRADEJS_DATA_BACKFILL ${JSON.stringify(result)}`);
 }
 var import_connectors11, import_candles3, import_client5, import_dataCoverage, import_derivatives2, import_marketContext5, import_spread, import_strategies11, DAY_MS11;
@@ -28446,12 +28456,11 @@ var init_runtimeEvidenceArtifacts = __esm({
 });
 
 // src/lib/mcpReplayProcess.ts
-var import_node_path19, import_node_crypto14, import_promises22, client, buildMcpReplayProcess;
+var import_node_path19, import_promises22, client, buildMcpReplayProcess;
 var init_mcpReplayProcess = __esm({
   "src/lib/mcpReplayProcess.ts"() {
     "use strict";
     import_node_path19 = __toESM(require("path"));
-    import_node_crypto14 = require("crypto");
     import_promises22 = __toESM(require("fs/promises"));
     init_runtimeEvidenceArtifacts();
     client = `
@@ -28492,6 +28501,7 @@ const timer = setInterval(() => {
 `;
     buildMcpReplayProcess = async ({
       evidencePath,
+      expectedEvidenceSha256,
       outDir,
       runId,
       projectRoot: projectRoot18,
@@ -28502,6 +28512,9 @@ const timer = setInterval(() => {
       const bundle = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(import_node_path19.default.dirname(evidencePath));
       if (import_node_path19.default.resolve(evidencePath) !== import_node_path19.default.resolve(bundle.payloadPath))
         throw new Error("Replay requires the verified bundle payload");
+      const payloadSha256 = bundle.manifest.payload.sha256;
+      if (expectedEvidenceSha256 && expectedEvidenceSha256 !== payloadSha256)
+        throw new Error("Runtime evidence changed since job submission");
       const relative = import_node_path19.default.relative(import_node_path19.default.join(projectRoot18, "data"), evidencePath);
       if (relative.startsWith("..") || import_node_path19.default.isAbsolute(relative))
         throw new Error("Evidence must be inside Project data");
@@ -28511,14 +28524,13 @@ const timer = setInterval(() => {
       );
       if (heartbeat.protocolVersion !== 2 || !Number.isFinite(heartbeat.observedAt) || Date.now() - heartbeat.observedAt < 0 || Date.now() - heartbeat.observedAt > 12e4)
         throw new Error("Host replay runner heartbeat is stale");
-      const bytes = await import_promises22.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_crypto14.createHash)("sha256").update(bytes).digest("hex")
+        payloadSha256
       });
       void outDir;
       return {
@@ -28529,28 +28541,123 @@ const timer = setInterval(() => {
   }
 });
 
+// src/lib/mcpJobOutputs.ts
+var import_promises23, import_node_path20, import_redis16, import_diagnostics, import_mcp, mcpBacktestResultTimestamp, collectEvidence, collectReplay, collectMcpJobOutputs;
+var init_mcpJobOutputs = __esm({
+  "src/lib/mcpJobOutputs.ts"() {
+    "use strict";
+    import_promises23 = require("fs/promises");
+    import_node_path20 = __toESM(require("path"));
+    import_redis16 = require("@tradejs/infra/redis");
+    import_diagnostics = require("@tradejs/node/diagnostics");
+    import_mcp = require("@tradejs/node/mcp");
+    init_runFormatting();
+    mcpBacktestResultTimestamp = (job) => createTimestamp(new Date(job.createdAt));
+    collectEvidence = async (job) => Promise.all(
+      (await (0, import_diagnostics.discoverRuntimeEvidenceBundles)((0, import_mcp.mcpJobDirectory)(job))).map(
+        async (bundleDir) => {
+          const { manifest } = await (0, import_diagnostics.verifyRuntimeEvidenceBundle)(bundleDir);
+          if (manifest.userName !== job.userName || manifest.deploymentId !== job.request.deploymentId || manifest.window.startTime !== job.request.startTime || manifest.window.endTime !== job.request.endTime)
+            throw new Error("Runtime evidence does not match the job");
+          return {
+            bundleDir,
+            id: (0, import_mcp.mcpId)(`${manifest.artifactId}:${manifest.payload.sha256}`)
+          };
+        }
+      )
+    );
+    collectReplay = async (job) => {
+      const sourceDir = import_node_path20.default.dirname(String(job.request.verifiedEvidencePath));
+      const source = await (0, import_diagnostics.verifyRuntimeEvidenceBundle)(sourceDir);
+      const { artifactId, deploymentId, userName: userName3, window } = source.manifest;
+      if (userName3 !== job.userName || deploymentId !== job.request.deploymentId || job.request.verifiedEvidenceSha256 !== void 0 && job.request.verifiedEvidenceSha256 !== source.manifest.payload.sha256 || !/^[A-Za-z0-9._-]+$/.test(artifactId) || !/^[A-Za-z0-9._-]+$/.test(deploymentId) || [".", ".."].includes(artifactId) || [".", ".."].includes(deploymentId))
+        throw new Error("Runtime evidence does not match the replay job");
+      const root = import_node_path20.default.join((0, import_mcp.mcpProjectRoot)(), "data/runtime-feedback");
+      const receipt = JSON.parse(
+        await (0, import_promises23.readFile)(
+          import_node_path20.default.join(root, "completed", deploymentId, `${artifactId}.json`),
+          "utf8"
+        )
+      );
+      if (!(0, import_mcp.isMcpRecord)(receipt) || receipt.schemaVersion !== 1 || receipt.runtimeEvidenceArtifactId !== artifactId || typeof receipt.runtimeFeedbackBundle !== "string")
+        throw new Error("Invalid replay completion receipt");
+      const runId = import_node_path20.default.basename(receipt.runtimeFeedbackBundle);
+      if (!/^[A-Za-z0-9_-]+$/.test(runId))
+        throw new Error("Invalid replay bundle name");
+      const day = new Date(window.endTime).toISOString().slice(0, 10).split("-");
+      const bundleDir = import_node_path20.default.join(
+        root,
+        "ready",
+        deploymentId,
+        ...day,
+        artifactId,
+        runId
+      );
+      const { feedback } = await (0, import_diagnostics.verifyRuntimeFeedbackReplaySource)({
+        bundleDir,
+        runtimeEvidenceBundleDir: sourceDir
+      });
+      const { manifest } = feedback;
+      return [
+        {
+          bundleDir,
+          id: (0, import_mcp.mcpId)(
+            `${manifest.artifactId}:${manifest.payloads.replayEvidence.sha256}`
+          )
+        }
+      ];
+    };
+    collectMcpJobOutputs = async (job) => {
+      if (job.kind === "backtest") {
+        const config2 = job.request.frozenConfigId;
+        if (typeof config2 !== "string")
+          throw new Error("Invalid frozen backtest config");
+        const timestamp = mcpBacktestResultTimestamp(job);
+        if (!await (0, import_redis16.getDataStrict)(
+          import_redis16.redisKeys.backtestResults(job.userName, config2, timestamp)
+        ))
+          throw new Error("Backtest result was not saved");
+        return { resultId: `${config2}:${timestamp}` };
+      }
+      const bundles = job.kind === "runtime-evidence" ? await collectEvidence(job) : await collectReplay(job);
+      if (!bundles.length)
+        throw new Error("No verified diagnostic report was saved");
+      for (const { id, bundleDir } of bundles) {
+        if (!await import_redis16.mcpStorage.put(
+          (0, import_mcp.mcpArtifactLocationId)(job.userName, id),
+          bundleDir,
+          import_mcp.MCP_JOB_TTL
+        ))
+          throw new Error("Diagnostic report location could not be saved");
+      }
+      return { artifactIds: bundles.map(({ id }) => id) };
+    };
+  }
+});
+
 // src/scripts/mcpWorker.ts
 var mcpWorker_exports = {};
 __export(mcpWorker_exports, {
   main: () => main29
 });
-var import_node_child_process4, import_node_crypto15, import_promises23, import_redis16, import_mcp, pause, leaseKey, LEASE_SECONDS, JOB_TIMEOUT_MS, main29;
+var import_node_child_process4, import_node_crypto14, import_promises24, import_redis17, import_mcp2, pause, leaseKey, LEASE_SECONDS, JOB_TIMEOUT_MS, main29;
 var init_mcpWorker = __esm({
   "src/scripts/mcpWorker.ts"() {
     "use strict";
     import_node_child_process4 = require("child_process");
-    import_node_crypto15 = require("crypto");
-    import_promises23 = require("fs/promises");
-    import_redis16 = require("@tradejs/infra/redis");
-    import_mcp = require("@tradejs/node/mcp");
+    import_node_crypto14 = require("crypto");
+    import_promises24 = require("fs/promises");
+    import_redis17 = require("@tradejs/infra/redis");
+    import_mcp2 = require("@tradejs/node/mcp");
     init_mcpReplayProcess();
+    init_mcpJobOutputs();
     pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
     leaseKey = "worker:lease";
     LEASE_SECONDS = 15;
     JOB_TIMEOUT_MS = 60 * 60 * 1e3;
     main29 = async (options = {}) => {
-      const owner = (0, import_node_crypto15.randomUUID)();
-      if (!await import_redis16.mcpStorage.put(leaseKey, owner, LEASE_SECONDS, true))
+      const owner = (0, import_node_crypto14.randomUUID)();
+      if (!await import_redis17.mcpStorage.put(leaseKey, owner, LEASE_SECONDS, true))
         throw new Error("Another MCP worker owns this storage");
       let stopping = false;
       let child;
@@ -28565,7 +28672,7 @@ var init_mcpWorker = __esm({
         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_promises23.readFile)(`${root}/heartbeat.json`, "utf8")
+            await (0, import_promises24.readFile)(`${root}/heartbeat.json`, "utf8")
           );
           replayReady = heartbeat2.protocolVersion === 2 && Number.isFinite(heartbeat2.observedAt) && Date.now() - heartbeat2.observedAt >= 0 && Date.now() - heartbeat2.observedAt < 12e4;
           replayReadiness = replayReady && (heartbeat2.readiness === "ready" || heartbeat2.readiness === "waiting_resources") ? heartbeat2.readiness : "unknown";
@@ -28614,10 +28721,10 @@ var init_mcpWorker = __esm({
         if (renewing || leaseLost) return;
         renewing = true;
         try {
-          if (!await import_redis16.mcpStorage.compare(leaseKey, owner, owner, LEASE_SECONDS))
+          if (!await import_redis17.mcpStorage.compare(leaseKey, owner, owner, LEASE_SECONDS))
             throw new Error("Worker lease lost");
           await updateReplayReady();
-          await import_redis16.mcpStorage.put("worker:heartbeat", heartbeatValue(), LEASE_SECONDS);
+          await import_redis17.mcpStorage.put("worker:heartbeat", heartbeatValue(), LEASE_SECONDS);
         } catch {
           leaseLost = true;
           stop();
@@ -28626,17 +28733,17 @@ var init_mcpWorker = __esm({
         }
       }, 2e3);
       try {
-        manifestHash = await (0, import_mcp.mcpPackageManifestHash)();
+        manifestHash = await (0, import_mcp2.mcpPackageManifestHash)();
         await updateReplayReady();
-        await import_redis16.mcpStorage.put("worker:heartbeat", heartbeatValue(), LEASE_SECONDS);
+        await import_redis17.mcpStorage.put("worker:heartbeat", heartbeatValue(), LEASE_SECONDS);
         let cursor = "0";
         do {
-          const page = await import_redis16.mcpStorage.scan("jobs:", cursor);
+          const page = await import_redis17.mcpStorage.scan("jobs:", cursor);
           cursor = page.cursor;
           for (const key2 of page.ids) {
-            const job = await import_redis16.mcpStorage.get(key2);
+            const job = await import_redis17.mcpStorage.get(key2);
             if (job?.status === "running")
-              await import_redis16.mcpStorage.compare(
+              await import_redis17.mcpStorage.compare(
                 key2,
                 job,
                 {
@@ -28646,7 +28753,7 @@ var init_mcpWorker = __esm({
                   finishedAt: Date.now(),
                   updatedAt: Date.now()
                 },
-                import_mcp.MCP_JOB_TTL
+                import_mcp2.MCP_JOB_TTL
               );
           }
         } while (cursor !== "0" && !stopping);
@@ -28657,10 +28764,10 @@ var init_mcpWorker = __esm({
           let queued;
           cursor = "0";
           do {
-            const page = await import_redis16.mcpStorage.scan("jobs:", cursor);
+            const page = await import_redis17.mcpStorage.scan("jobs:", cursor);
             cursor = page.cursor;
             for (const key2 of page.ids) {
-              const job = await import_redis16.mcpStorage.get(key2);
+              const job = await import_redis17.mcpStorage.get(key2);
               if (job && ["queued", "waiting_resources", "waiting_executor"].includes(
                 job.status
               ) && (!queued || job.createdAt < queued.createdAt))
@@ -28671,17 +28778,17 @@ var init_mcpWorker = __esm({
             await pause(1e3);
             continue;
           }
-          const jobKey = (0, import_mcp.mcpJobStorageId)(queued.userName, queued.id);
+          const jobKey = (0, import_mcp2.mcpJobStorageId)(queued.userName, queued.id);
           const started = {
             ...queued,
             status: queued.kind === "runtime-feedback-replay" ? "waiting_executor" : "running",
             ...queued.kind === "runtime-feedback-replay" ? {} : { startedAt: Date.now() },
             updatedAt: Date.now()
           };
-          if (!await import_redis16.mcpStorage.compare(jobKey, queued, started, import_mcp.MCP_JOB_TTL))
+          if (!await import_redis17.mcpStorage.compare(jobKey, queued, started, import_mcp2.MCP_JOB_TTL))
             continue;
           if (started.kind !== "runtime-feedback-replay" && started.packageManifestSha256 !== manifestHash) {
-            await import_redis16.mcpStorage.compare(
+            await import_redis17.mcpStorage.compare(
               jobKey,
               started,
               {
@@ -28690,19 +28797,19 @@ var init_mcpWorker = __esm({
                 error: "Package composition changed since submission",
                 finishedAt: Date.now()
               },
-              import_mcp.MCP_JOB_TTL
+              import_mcp2.MCP_JOB_TTL
             );
             continue;
           }
-          await (0, import_promises23.mkdir)((0, import_mcp.mcpJobDirectory)(started), { recursive: true });
+          await (0, import_promises24.mkdir)((0, import_mcp2.mcpJobDirectory)(started), { recursive: true });
           if (started.kind === "backtest")
-            await (0, import_redis16.setDataStrict)(
-              import_redis16.redisKeys.backtestConfig(
+            await (0, import_redis17.setDataStrict)(
+              import_redis17.redisKeys.backtestConfig(
                 started.userName,
                 String(started.request.frozenConfigId)
               ),
               started.request.resolvedConfig,
-              { expire: import_mcp.MCP_JOB_TTL }
+              { expire: import_mcp2.MCP_JOB_TTL }
             );
           const jobEnv = {
             ...process.env,
@@ -28715,6 +28822,8 @@ var init_mcpWorker = __esm({
             MAKE_ORDERS: "false",
             TRADEJS_EXTERNAL_ORDER_PLACEMENT: "false"
           };
+          if (started.kind === "backtest")
+            jobEnv.MCP_BACKTEST_RESULT_TIMESTAMP = mcpBacktestResultTimestamp(started);
           if (started.kind === "runtime-feedback-replay") {
             for (const name of Object.keys(jobEnv)) {
               if (/secret|password|token|api.?key|private.?key|cookie|credential/i.test(
@@ -28740,13 +28849,14 @@ var init_mcpWorker = __esm({
             if (started.kind === "runtime-feedback-replay")
               command = await buildMcpReplayProcess({
                 evidencePath: String(started.request.verifiedEvidencePath),
-                outDir: (0, import_mcp.mcpJobDirectory)(started),
+                expectedEvidenceSha256: typeof started.request.verifiedEvidenceSha256 === "string" ? started.request.verifiedEvidenceSha256 : void 0,
+                outDir: (0, import_mcp2.mcpJobDirectory)(started),
                 runId: started.id,
                 projectRoot: process.env.PROJECT_CWD || process.cwd(),
                 env: process.env
               });
           } catch (error) {
-            await import_redis16.mcpStorage.compare(
+            await import_redis17.mcpStorage.compare(
               jobKey,
               started,
               {
@@ -28754,9 +28864,9 @@ var init_mcpWorker = __esm({
                 status: "failed",
                 finishedAt: Date.now(),
                 updatedAt: Date.now(),
-                error: error instanceof Error ? (0, import_mcp.redactMcpJobLog)(error.message) : "Replay preparation failed"
+                error: error instanceof Error ? (0, import_mcp2.redactMcpJobLog)(error.message) : "Replay preparation failed"
               },
-              import_mcp.MCP_JOB_TTL
+              import_mcp2.MCP_JOB_TTL
             );
             continue;
           }
@@ -28776,7 +28886,7 @@ var init_mcpWorker = __esm({
           const logs = [];
           const log = (chunk) => {
             const lines = chunk.toString().replace(/\u001b\[[0-9;]*m/g, "").split(/[\r\n]+/).filter(Boolean);
-            logs.push(...lines.map(import_mcp.redactMcpJobLog));
+            logs.push(...lines.map(import_mcp2.redactMcpJobLog));
             if (logs.length > 150) logs.splice(0, logs.length - 150);
           };
           currentChild.stdout?.on("data", log);
@@ -28784,7 +28894,7 @@ var init_mcpWorker = __esm({
           let killAt;
           const monitor = setInterval(async () => {
             try {
-              const latest = await import_redis16.mcpStorage.get(jobKey);
+              const latest = await import_redis17.mcpStorage.get(jobKey);
               if (!latest || latest.cancelRequested || stopping || timedOut) {
                 killAt ??= Date.now();
                 signalChild(Date.now() - killAt > 8e3 ? "SIGKILL" : "SIGTERM");
@@ -28794,7 +28904,7 @@ var init_mcpWorker = __esm({
                 try {
                   const root = process.env.MCP_REPLAY_REQUEST_ROOT || `${process.env.PROJECT_CWD || process.cwd()}/data/mcp-replay-requests`;
                   const state = JSON.parse(
-                    await (0, import_promises23.readFile)(`${root}/${latest.id}.state`, "utf8")
+                    await (0, import_promises24.readFile)(`${root}/${latest.id}.state`, "utf8")
                   );
                   if (state && typeof state === "object" && "status" in state && (state.status === "waiting_resources" || state.status === "waiting_executor" || state.status === "running"))
                     replayStatus = state.status;
@@ -28809,7 +28919,7 @@ var init_mcpWorker = __esm({
                 }
               }
               if (latest && !leaseLost)
-                await import_redis16.mcpStorage.compare(
+                await import_redis17.mcpStorage.compare(
                   jobKey,
                   latest,
                   {
@@ -28821,7 +28931,7 @@ var init_mcpWorker = __esm({
                     logs: [...logs],
                     updatedAt: Date.now()
                   },
-                  import_mcp.MCP_JOB_TTL
+                  import_mcp2.MCP_JOB_TTL
                 );
             } catch {
               leaseLost = true;
@@ -28838,25 +28948,34 @@ var init_mcpWorker = __esm({
           clearTimeout(timeout);
           clearInterval(monitor);
           child = void 0;
+          let outputs = {};
+          if (!leaseLost && outcome.code === 0 && !outcome.error && !timedOut && !stopping) {
+            try {
+              outputs = await collectMcpJobOutputs(started);
+            } catch {
+              outcome.error = "Job finished but its saved output could not be verified";
+            }
+          }
           if (!leaseLost) {
             for (let attempt = 0; attempt < 4; attempt++) {
-              const latest = await import_redis16.mcpStorage.get(jobKey);
+              const latest = await import_redis17.mcpStorage.get(jobKey);
               if (!latest) break;
               const cancelled = latest.cancelRequested;
               const next = {
                 ...latest,
                 logs,
-                status: cancelled ? "cancelled" : outcome.code === 0 && !timedOut && !stopping ? "completed" : "failed",
+                status: cancelled ? "cancelled" : outcome.code === 0 && !outcome.error && !timedOut && !stopping ? "completed" : "failed",
+                ...cancelled || stopping ? {} : outputs,
                 exitCode: outcome.code,
                 updatedAt: Date.now(),
                 finishedAt: Date.now(),
-                ...cancelled ? {} : timedOut ? { error: "Job exceeded one hour" } : stopping ? { error: "Worker stopped; this job was not replayed" } : outcome.code !== 0 ? {
+                ...cancelled ? {} : timedOut ? { error: "Job exceeded one hour" } : stopping ? { error: "Worker stopped; this job was not replayed" } : outcome.code !== 0 || outcome.error ? {
                   error: outcome.error || (started.kind === "runtime-feedback-replay" ? logs.find(
                     (line) => line.startsWith("Host replay: ")
                   ) || logs.at(-1) : void 0) || "Research process failed"
                 } : {}
               };
-              if (await import_redis16.mcpStorage.compare(jobKey, latest, next, import_mcp.MCP_JOB_TTL))
+              if (await import_redis17.mcpStorage.compare(jobKey, latest, next, import_mcp2.MCP_JOB_TTL))
                 break;
             }
           }
@@ -28866,8 +28985,8 @@ var init_mcpWorker = __esm({
         options.signal?.removeEventListener("abort", stop);
         process.removeListener("SIGINT", stop);
         process.removeListener("SIGTERM", stop);
-        if (await import_redis16.mcpStorage.release(leaseKey, owner))
-          await import_redis16.mcpStorage.remove("worker:heartbeat");
+        if (await import_redis17.mcpStorage.release(leaseKey, owner))
+          await import_redis17.mcpStorage.remove("worker:heartbeat");
       }
       if (leaseLost)
         throw new Error("Worker lease lost; active computation was stopped");
@@ -29230,13 +29349,13 @@ var hyperliquidWhalesUpdate_exports = {};
 __export(hyperliquidWhalesUpdate_exports, {
   main: () => main32
 });
-var import_config8, import_args21, import_node_crypto16, import_strategies13, LEADERBOARD_URL, DAY_MS12, CANDIDATE_LIMIT, flags19, fingerprint, runConcurrent2, main32;
+var import_config8, import_args21, import_node_crypto15, import_strategies13, LEADERBOARD_URL, DAY_MS12, CANDIDATE_LIMIT, flags19, fingerprint, runConcurrent2, main32;
 var init_hyperliquidWhalesUpdate = __esm({
   "src/scripts/hyperliquidWhalesUpdate.ts"() {
     "use strict";
     import_config8 = require("dotenv/config");
     import_args21 = __toESM(require("args"));
-    import_node_crypto16 = require("crypto");
+    import_node_crypto15 = require("crypto");
     import_strategies13 = require("@tradejs/node/strategies");
     init_hyperliquidWhaleBackfill();
     init_hyperliquidRateLimiter();
@@ -29250,7 +29369,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_crypto16.createHash)("sha256").update(JSON.stringify(addresses)).digest("hex").slice(0, 16);
+    fingerprint = (addresses) => (0, import_node_crypto15.createHash)("sha256").update(JSON.stringify(addresses)).digest("hex").slice(0, 16);
     runConcurrent2 = async (params) => {
       let nextIndex = 0;
       await Promise.all(
@@ -29359,13 +29478,13 @@ var mlExport_exports = {};
 __export(mlExport_exports, {
   main: () => main33
 });
-var import_args22, import_chalk37, import_promises24, import_path8, import_ml, flags20, resolveRunScopedMlChunks, main33;
+var import_args22, import_chalk37, import_promises25, import_path8, import_ml, flags20, resolveRunScopedMlChunks, main33;
 var init_mlExport = __esm({
   "src/scripts/mlExport.ts"() {
     "use strict";
     import_args22 = __toESM(require("args"));
     import_chalk37 = __toESM(require("chalk"));
-    import_promises24 = __toESM(require("fs/promises"));
+    import_promises25 = __toESM(require("fs/promises"));
     import_path8 = __toESM(require("path"));
     import_ml = require("@tradejs/infra/ml");
     init_checkpoint();
@@ -29416,7 +29535,7 @@ var init_mlExport = __esm({
     };
     main33 = async () => {
       const outDir = String(flags20.outDir || "data/ml/export");
-      await import_promises24.default.mkdir(outDir, { recursive: true });
+      await import_promises25.default.mkdir(outDir, { recursive: true });
       const strategyName = await resolveExportStrategy({
         explicitStrategy: String(flags20.strategy || ""),
         outDir,
@@ -29461,7 +29580,7 @@ var init_mlExport = __esm({
       const shouldDeleteChunks = !Boolean(flags20.keepChunks);
       if (shouldDeleteChunks) {
         for (const filePath of chunkFiles) {
-          await import_promises24.default.rm(filePath, { force: true });
+          await import_promises25.default.rm(filePath, { force: true });
         }
       }
       console.log(import_chalk37.default.green(`Merged dataset saved: ${mergedPath}`));
@@ -29482,13 +29601,13 @@ var mlInspect_exports = {};
 __export(mlInspect_exports, {
   main: () => main34
 });
-var import_args23, import_chalk38, import_promises25, 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, main34;
+var import_args23, import_chalk38, import_promises26, 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, main34;
 var init_mlInspect = __esm({
   "src/scripts/mlInspect.ts"() {
     "use strict";
     import_args23 = __toESM(require("args"));
     import_chalk38 = __toESM(require("chalk"));
-    import_promises25 = __toESM(require("fs/promises"));
+    import_promises26 = __toESM(require("fs/promises"));
     import_fs3 = require("fs");
     import_path9 = __toESM(require("path"));
     import_readline2 = __toESM(require("readline"));
@@ -29665,7 +29784,7 @@ var init_mlInspect = __esm({
     };
     findLatestDataset = async (params) => {
       const { dir, strategy } = params;
-      const entries = await import_promises25.default.readdir(dir, { withFileTypes: true });
+      const entries = await import_promises26.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.")
@@ -29677,7 +29796,7 @@ var init_mlInspect = __esm({
       }
       const withMtime = await Promise.all(
         files.map(async (name) => {
-          const stat = await import_promises25.default.stat(import_path9.default.join(dir, name));
+          const stat = await import_promises26.default.stat(import_path9.default.join(dir, name));
           return { name, mtime: stat.mtimeMs };
         })
       );
@@ -29922,7 +30041,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_promises25.default.mkdir(reportDir, { recursive: true });
+      await import_promises26.default.mkdir(reportDir, { recursive: true });
       const reportPath = import_path9.default.join(
         reportDir,
         `${import_path9.default.basename(datasetPath, import_path9.default.extname(datasetPath))}.profile.html`
@@ -30018,12 +30137,12 @@ var mlTrainLatestSelect_exports = {};
 __export(mlTrainLatestSelect_exports, {
   main: () => main35
 });
-var import_path10, import_promises26, 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_MS13, SPLIT_PROGRESS_EVERY, parseTimestampMs, scanMaxLabeledTimestampMs, scanMaxTrainTimestampMs, hashFileNameSha1, prepareTrainWindowFiles, main35;
+var import_path10, import_promises27, 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_MS13, SPLIT_PROGRESS_EVERY, parseTimestampMs, scanMaxLabeledTimestampMs, scanMaxTrainTimestampMs, hashFileNameSha1, prepareTrainWindowFiles, main35;
 var init_mlTrainLatestSelect = __esm({
   "src/scripts/mlTrainLatestSelect.ts"() {
     "use strict";
     import_path10 = __toESM(require("path"));
-    import_promises26 = __toESM(require("fs/promises"));
+    import_promises27 = __toESM(require("fs/promises"));
     import_fs4 = require("fs");
     import_crypto2 = require("crypto");
     import_child_process3 = require("child_process");
@@ -30152,7 +30271,7 @@ var init_mlTrainLatestSelect = __esm({
       return defaultModel;
     };
     listDatasetFiles = async (dir, strategyName) => {
-      const entries = await import_promises26.default.readdir(dir, { withFileTypes: true });
+      const entries = await import_promises27.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);
@@ -30163,7 +30282,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_promises26.default.stat(import_path10.default.join(dir, name));
+          const stat = await import_promises27.default.stat(import_path10.default.join(dir, name));
           return { name, mtime: stat.mtimeMs };
         })
       );
@@ -30339,13 +30458,13 @@ var init_mlTrainLatestSelect = __esm({
       const metaPath = import_path10.default.join(dir, `${parsed.name}.windows.${key2}.meta.json`);
       try {
         const [metaRaw] = await Promise.all([
-          import_promises26.default.readFile(metaPath, "utf8"),
-          import_promises26.default.access(holdoutTrainPath),
-          import_promises26.default.access(holdoutTestPath),
-          import_promises26.default.access(prodPath),
+          import_promises27.default.readFile(metaPath, "utf8"),
+          import_promises27.default.access(holdoutTrainPath),
+          import_promises27.default.access(holdoutTestPath),
+          import_promises27.default.access(prodPath),
           ...walkForwardFoldDefs.flatMap((entry) => [
-            import_promises26.default.access(entry.trainPath),
-            import_promises26.default.access(entry.testPath)
+            import_promises27.default.access(entry.trainPath),
+            import_promises27.default.access(entry.testPath)
           ])
         ]);
         const meta2 = JSON.parse(metaRaw);
@@ -30712,7 +30831,7 @@ var init_mlTrainLatestSelect = __esm({
         },
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
-      await import_promises26.default.writeFile(metaPath, `${JSON.stringify(meta, null, 2)}
+      await import_promises27.default.writeFile(metaPath, `${JSON.stringify(meta, null, 2)}
 `, "utf8");
       return {
         holdoutTrainPath,
@@ -30770,7 +30889,7 @@ var init_mlTrainLatestSelect = __esm({
         process.exit(1);
       }
       try {
-        const inputStat = await import_promises26.default.stat(inputPath);
+        const inputStat = await import_promises27.default.stat(inputPath);
         const totalInputBytes = inputStat.size;
         const autoIncrementalThresholdGb = asInt7(
           process.env.ML_TRAIN_INCREMENTAL_THRESHOLD_GB,
@@ -30959,7 +31078,7 @@ var init_mlTrainLatestSelect = __esm({
           const modelDir = import_path10.default.join(modelDirRoot, "models");
           let savedModels = [];
           try {
-            const entries = await import_promises26.default.readdir(modelDir, { withFileTypes: true });
+            const entries = await import_promises27.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();
@@ -30981,7 +31100,7 @@ var init_mlTrainLatestSelect = __esm({
         process.exitCode = finalCode;
       } finally {
         for (const file of cleanupFiles) {
-          await import_promises26.default.rm(file, { force: true });
+          await import_promises27.default.rm(file, { force: true });
         }
       }
       process.exit(process.exitCode ?? 1);
@@ -31013,20 +31132,20 @@ __export(researchAuto_exports, {
   toStrategyConfigGrid: () => toStrategyConfigGrid2,
   trimTextTail: () => trimTextTail2
 });
-var import_args25, import_chalk40, import_node_child_process5, import_promises27, import_node_os2, import_node_path20, import_constants19, import_ai8, import_logger7, import_redis17, 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, main36;
+var import_args25, import_chalk40, import_node_child_process5, import_promises28, import_node_os2, import_node_path21, import_constants19, import_ai8, import_logger7, import_redis18, 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, main36;
 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_promises27 = __toESM(require("fs/promises"));
+    import_promises28 = __toESM(require("fs/promises"));
     import_node_os2 = __toESM(require("os"));
-    import_node_path20 = __toESM(require("path"));
+    import_node_path21 = __toESM(require("path"));
     import_constants19 = require("@tradejs/core/constants");
     import_ai8 = require("@tradejs/infra/ai");
     import_logger7 = require("@tradejs/infra/logger");
-    import_redis17 = require("@tradejs/infra/redis");
+    import_redis18 = require("@tradejs/infra/redis");
     import_registry4 = require("@tradejs/node/registry");
     init_runtimeRedis();
     init_runtimeStrategyBacktest();
@@ -31056,9 +31175,9 @@ var init_researchAuto = __esm({
     flags23 = import_args25.default.parse(process.argv);
     ({ projectRoot: projectRoot8 } = resolveResearchRoots());
     dotenvPath = String(
-      process.env.DOTENV_CONFIG_PATH || import_node_path20.default.join(projectRoot8, ".env")
-    ).trim() || import_node_path20.default.join(projectRoot8, ".env");
-    getResearchAutoLockPath = (userName3) => import_node_path20.default.join(
+      process.env.DOTENV_CONFIG_PATH || import_node_path21.default.join(projectRoot8, ".env")
+    ).trim() || import_node_path21.default.join(projectRoot8, ".env");
+    getResearchAutoLockPath = (userName3) => import_node_path21.default.join(
       projectRoot8,
       "data",
       "cache",
@@ -31067,7 +31186,7 @@ var init_researchAuto = __esm({
     );
     readResearchAutoLock = async (lockPath) => {
       try {
-        const raw = await import_promises27.default.readFile(lockPath, "utf8");
+        const raw = await import_promises28.default.readFile(lockPath, "utf8");
         return JSON.parse(raw);
       } catch {
         return null;
@@ -31102,9 +31221,9 @@ var init_researchAuto = __esm({
         startedAt,
         argv: [...process.argv]
       };
-      await import_promises27.default.mkdir(import_node_path20.default.dirname(lockPath), { recursive: true });
+      await import_promises28.default.mkdir(import_node_path21.default.dirname(lockPath), { recursive: true });
       const writeLock = async () => {
-        await import_promises27.default.writeFile(lockPath, JSON.stringify(nextLock, null, 2), {
+        await import_promises28.default.writeFile(lockPath, JSON.stringify(nextLock, null, 2), {
           flag: "wx"
         });
       };
@@ -31123,7 +31242,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_promises27.default.unlink(lockPath).catch(() => void 0);
+      await import_promises28.default.unlink(lockPath).catch(() => void 0);
       await writeLock();
       return lockPath;
     };
@@ -31135,7 +31254,7 @@ var init_researchAuto = __esm({
       if (existingLock && existingLock.pid !== process.pid) {
         return;
       }
-      await import_promises27.default.unlink(lockPath).catch(() => void 0);
+      await import_promises28.default.unlink(lockPath).catch(() => void 0);
     };
     resolvePositiveInteger = (value, fallback) => {
       const parsed = Number.parseInt(String(value ?? ""), 10);
@@ -31228,18 +31347,18 @@ var init_researchAuto = __esm({
       }
     });
     saveRun = async (run) => {
-      await (0, import_redis17.setData)(import_redis17.redisKeys.researchRun(run.userName, run.runId), run, {
+      await (0, import_redis18.setData)(import_redis18.redisKeys.researchRun(run.userName, run.runId), run, {
         expire: import_constants19.TTL_1M
       });
-      await (0, import_redis17.setData)(import_redis17.redisKeys.researchLatestRun(run.userName, run.strategy), run, {
+      await (0, import_redis18.setData)(import_redis18.redisKeys.researchLatestRun(run.userName, run.strategy), run, {
         expire: import_constants19.TTL_1M
       });
     };
     listMergedFiles3 = async (outDir, strategyName) => {
       try {
-        const entries = await import_promises27.default.readdir(outDir);
+        const entries = await import_promises28.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_path20.default.join(outDir, name));
+        return entries.filter((name) => name.startsWith(prefix) && name.endsWith(".jsonl")).sort().map((name) => import_node_path21.default.join(outDir, name));
       } catch {
         return [];
       }
@@ -31373,7 +31492,7 @@ var init_researchAuto = __esm({
       return new Promise((resolve, reject) => {
         const child = (0, import_node_child_process5.spawn)(
           process.execPath,
-          [import_node_path20.default.resolve(process.argv[1]), params.command, ...params.args],
+          [import_node_path21.default.resolve(process.argv[1]), params.command, ...params.args],
           {
             cwd: projectRoot8,
             env,
@@ -31461,8 +31580,8 @@ var init_researchAuto = __esm({
       const candidates = [];
       for (const strategy of availableStrategies) {
         const config2 = `${strategy}:research`;
-        const latestRun = await (0, import_redis17.getData)(
-          import_redis17.redisKeys.researchLatestRun(userName3, strategy),
+        const latestRun = await (0, import_redis18.getData)(
+          import_redis18.redisKeys.researchLatestRun(userName3, strategy),
           null
         );
         const lastFinishedAt = latestRun?.finishedAt ? Date.parse(latestRun.finishedAt) : 0;
@@ -31556,8 +31675,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_path20.default.resolve(projectRoot8, outDirArg);
-      const cleanDirArg = import_node_path20.default.relative(import_node_path20.default.join(projectRoot8, "data"), outDir).replace(/\\/g, "/");
+      const outDir = import_node_path21.default.resolve(projectRoot8, outDirArg);
+      const cleanDirArg = import_node_path21.default.relative(import_node_path21.default.join(projectRoot8, "data"), outDir).replace(/\\/g, "/");
       const target = await resolveTarget();
       const runId = `${Date.now()}-${(0, import_ai8.toFileToken)(target.strategy)}`;
       const run = {
@@ -31641,13 +31760,13 @@ var init_researchAuto = __esm({
           startedAt
         };
         await saveRun(run);
-        const strategyConfigKey = import_redis17.redisKeys.strategyConfig(
+        const strategyConfigKey = import_redis18.redisKeys.strategyConfig(
           userName3,
           target.strategy
         );
-        const backtestConfigKey = import_redis17.redisKeys.backtestConfig(userName3, target.config);
+        const backtestConfigKey = import_redis18.redisKeys.backtestConfig(userName3, target.config);
         const defaults = await (0, import_registry4.getStrategyDefaults)(target.strategy, projectRoot8) || {};
-        const userStrategyConfig = await (0, import_redis17.getData)(
+        const userStrategyConfig = await (0, import_redis18.getData)(
           strategyConfigKey,
           {}
         );
@@ -31661,7 +31780,7 @@ var init_researchAuto = __esm({
           );
         }
         const backtestConfig = toStrategyConfigGrid2(strategyConfig);
-        await (0, import_redis17.setData)(backtestConfigKey, backtestConfig, { expire: 0 });
+        await (0, import_redis18.setData)(backtestConfigKey, backtestConfig, { expire: 0 });
         logResearch(
           `stored backtest config at ${backtestConfigKey} with ${Object.keys(strategyConfig).length} top-level fields`
         );
@@ -31701,7 +31820,7 @@ var init_researchAuto = __esm({
           `resource knobs: researchAutoHeapMb=${RESEARCH_AUTO_PARENT_HEAP_MB}, backtestParentHeapMb=${RESEARCH_AUTO_BACKTEST_PARENT_HEAP_MB}, aiTrainParentHeapMb=${RESEARCH_AUTO_AI_TRAIN_PARENT_HEAP_MB}, agentParentHeapMb=${RESEARCH_AUTO_AGENT_PARENT_HEAP_MB}, backtestWorkerHeapMb=${process.env.BACKTEST_WORKER_HEAP_MB || "auto"}, backtestMaxParallel=${process.env.BACKTEST_MAX_PARALLEL || "auto"}, klineConcurrency=${process.env.KLINE_CONCURRENCY_LIMIT || "default"}`
         );
         const backtestKeysBefore = new Set(
-          await (0, import_redis17.getKeys)(getBacktestResultsPrefix(userName3, target.config))
+          await (0, import_redis18.getKeys)(getBacktestResultsPrefix(userName3, target.config))
         );
         const aiFilesBefore = new Set(
           await listMergedFiles3(outDir, target.strategy)
@@ -31763,14 +31882,14 @@ var init_researchAuto = __esm({
             captureMode: "full"
           }
         );
-        const backtestKeysAfter = await (0, import_redis17.getKeys)(
+        const backtestKeysAfter = await (0, import_redis18.getKeys)(
           getBacktestResultsPrefix(userName3, target.config)
         );
         const newBacktestKeys = backtestKeysAfter.filter((key2) => !backtestKeysBefore.has(key2)).sort();
         const backtestResultKey = newBacktestKeys[newBacktestKeys.length - 1] || backtestKeysAfter.sort().at(-1);
         if (backtestResultKey) {
           logResearch(`detected backtest result key ${backtestResultKey}`);
-          const backtestResult = await (0, import_redis17.getData)(backtestResultKey, null);
+          const backtestResult = await (0, import_redis18.getData)(backtestResultKey, null);
           run.artifacts.backtestResultKey = backtestResultKey;
           run.artifacts.backtestResult = backtestResult ? {
             finishedAt: backtestResult.finishedAt,
@@ -31891,14 +32010,14 @@ Telegram report failed: ${suffix}`;
 });
 
 // src/lib/coreResearch/artifacts.ts
-var import_node_fs7, import_node_events2, import_promises28, import_node_path21, csv, writeLine, closeOutput, writeCoreResearchMatches, writeCoreResearchTrades, summarizeCoreResearchComparison;
+var import_node_fs7, import_node_events2, import_promises29, import_node_path22, csv, writeLine, closeOutput, writeCoreResearchMatches, writeCoreResearchTrades, summarizeCoreResearchComparison;
 var init_artifacts = __esm({
   "src/lib/coreResearch/artifacts.ts"() {
     "use strict";
     import_node_fs7 = require("fs");
     import_node_events2 = require("events");
-    import_promises28 = __toESM(require("fs/promises"));
-    import_node_path21 = __toESM(require("path"));
+    import_promises29 = __toESM(require("fs/promises"));
+    import_node_path22 = __toESM(require("path"));
     init_io();
     csv = (value) => {
       const text3 = String(value ?? "");
@@ -31912,7 +32031,7 @@ var init_artifacts = __esm({
       await (0, import_node_events2.once)(output, "close");
     };
     writeCoreResearchMatches = async (params) => {
-      await import_promises28.default.mkdir(import_node_path21.default.dirname(params.filePath), { recursive: true });
+      await import_promises29.default.mkdir(import_node_path22.default.dirname(params.filePath), { recursive: true });
       const output = (0, import_node_fs7.createWriteStream)(params.filePath, { encoding: "utf8" });
       await writeLine(
         output,
@@ -31963,7 +32082,7 @@ var init_artifacts = __esm({
       await closeOutput(output);
     };
     writeCoreResearchTrades = async (params) => {
-      await import_promises28.default.mkdir(import_node_path21.default.dirname(params.filePath), { recursive: true });
+      await import_promises29.default.mkdir(import_node_path22.default.dirname(params.filePath), { recursive: true });
       const output = (0, import_node_fs7.createWriteStream)(params.filePath, { encoding: "utf8" });
       for (const variant of params.variants) {
         for (const trade of variant.trades) {
@@ -32251,13 +32370,13 @@ var init_comparison = __esm({
 });
 
 // src/lib/coreResearch/dataset.ts
-var import_node_crypto17, import_node_fs8, import_node_path22, import_node_readline3, asRecord4, finiteNumber4, normalizeDirection, findStrategySetupIdentity, classifyBreadth, classifyDerivatives, resolveCoreResearchRegime, normalizeCompletedTrade, completedTradeIdentity, positionCycleIdentity, sumBy, weightedPrice, aggregatePositionCycles, compareText, compareTrades, readCoreResearchVariant;
+var import_node_crypto16, import_node_fs8, import_node_path23, import_node_readline3, 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_crypto17 = require("crypto");
+    import_node_crypto16 = require("crypto");
     import_node_fs8 = require("fs");
-    import_node_path22 = __toESM(require("path"));
+    import_node_path23 = __toESM(require("path"));
     import_node_readline3 = __toESM(require("readline"));
     asRecord4 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
     finiteNumber4 = (value, field) => {
@@ -32468,9 +32587,9 @@ var init_dataset2 = __esm({
       const seen = /* @__PURE__ */ new Map();
       let duplicateRowsDropped = 0;
       for (const inputPath of variant.files) {
-        const filePath = import_node_path22.default.resolve(inputPath);
+        const filePath = import_node_path23.default.resolve(inputPath);
         const input = (0, import_node_fs8.createReadStream)(filePath);
-        const hash2 = (0, import_node_crypto17.createHash)("sha256");
+        const hash2 = (0, import_node_crypto16.createHash)("sha256");
         input.on("data", (chunk) => hash2.update(chunk));
         const lines = import_node_readline3.default.createInterface({ input, crlfDelay: Infinity });
         const fileTrades = [];
@@ -32960,14 +33079,14 @@ var init_selection = __esm({
 });
 
 // src/lib/coreResearch/orchestrator.ts
-var import_promises29, import_node_path23, import_node_child_process6, import_node_crypto18, import_coreResearch, summarizeSupplementalFiles, analyzeCoreResearchPrepared, analyzeCoreResearch, createCoreResearchSpecTemplate, runCommand2, commandValue, commandHas, validateCoreResearchRunCommand, runCoreResearch;
+var import_promises30, import_node_path24, import_node_child_process6, import_node_crypto17, import_coreResearch, summarizeSupplementalFiles, analyzeCoreResearchPrepared, analyzeCoreResearch, createCoreResearchSpecTemplate, runCommand2, commandValue, commandHas, validateCoreResearchRunCommand, runCoreResearch;
 var init_orchestrator = __esm({
   "src/lib/coreResearch/orchestrator.ts"() {
     "use strict";
-    import_promises29 = __toESM(require("fs/promises"));
-    import_node_path23 = __toESM(require("path"));
+    import_promises30 = __toESM(require("fs/promises"));
+    import_node_path24 = __toESM(require("path"));
     import_node_child_process6 = require("child_process");
-    import_node_crypto18 = require("crypto");
+    import_node_crypto17 = require("crypto");
     import_coreResearch = require("@tradejs/infra/coreResearch");
     init_artifacts();
     init_io();
@@ -33173,7 +33292,7 @@ var init_orchestrator = __esm({
       const primarySourceHashes = Object.fromEntries(
         analyses.flatMap(
           (analysis) => analysis.files.map((file) => [
-            import_node_path23.default.relative(paths.researchDir, file.path),
+            import_node_path24.default.relative(paths.researchDir, file.path),
             file.sha256
           ])
         )
@@ -33192,8 +33311,8 @@ var init_orchestrator = __esm({
       const supplementalSourceHashes = Object.fromEntries(
         await Promise.all(
           supplementalSourcePaths.map(async (filePath) => [
-            import_node_path23.default.relative(paths.researchDir, import_node_path23.default.resolve(filePath)),
-            await sha256File(import_node_path23.default.resolve(filePath))
+            import_node_path24.default.relative(paths.researchDir, import_node_path24.default.resolve(filePath)),
+            await sha256File(import_node_path24.default.resolve(filePath))
           ])
         )
       );
@@ -33264,7 +33383,7 @@ var init_orchestrator = __esm({
       const tradesByVariant = new Map(
         windowed.map((entry) => [entry.variant.id, entry.trades])
       );
-      await import_promises29.default.writeFile(
+      await import_promises30.default.writeFile(
         paths.reportPath,
         buildCoreResearchHtml({ spec, result, tradesByVariant }),
         "utf8"
@@ -33278,17 +33397,17 @@ var init_orchestrator = __esm({
         "trades.jsonl": await sha256File(paths.tradesPath),
         "report.html": await sha256File(paths.reportPath)
       };
-      const resolvedRunsPath = import_node_path23.default.join(paths.researchDir, "resolved-runs.json");
+      const resolvedRunsPath = import_node_path24.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_promises29.default.readdir(paths.runLogDir)) {
+        for (const name of await import_promises30.default.readdir(paths.runLogDir)) {
           if (!name.endsWith(".log")) continue;
           artifactHashes[`runs/${name}`] = await sha256File(
-            import_node_path23.default.join(paths.runLogDir, name)
+            import_node_path24.default.join(paths.runLogDir, name)
           );
         }
       } catch (error) {
@@ -33345,9 +33464,9 @@ var init_orchestrator = __esm({
       }
     };
     createCoreResearchSpecTemplate = (params) => {
-      const rootDir = import_node_path23.default.relative(
-        import_node_path23.default.resolve(params.projectRoot),
-        import_node_path23.default.join(import_node_path23.default.resolve(params.projectRoot), "data", "research", "core")
+      const rootDir = import_node_path24.default.relative(
+        import_node_path24.default.resolve(params.projectRoot),
+        import_node_path24.default.join(import_node_path24.default.resolve(params.projectRoot), "data", "research", "core")
       ).replace(/\\/g, "/");
       const lineage = (() => {
         try {
@@ -33378,7 +33497,7 @@ var init_orchestrator = __esm({
             gitSha,
             ...sourceRepository ? { sourceRepository } : {},
             ...dirtyDiff ? {
-              dirtyDiffSha256: (0, import_node_crypto18.createHash)("sha256").update(dirtyDiff).digest("hex")
+              dirtyDiffSha256: (0, import_node_crypto17.createHash)("sha256").update(dirtyDiff).digest("hex")
             } : {}
           };
         } catch {
@@ -33485,7 +33604,7 @@ var init_orchestrator = __esm({
     };
     runCommand2 = async (params) => {
       if (!params.command.length) throw new Error("Cannot run an empty command");
-      await import_promises29.default.mkdir(import_node_path23.default.dirname(params.logPath), { recursive: true });
+      await import_promises30.default.mkdir(import_node_path24.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,
@@ -33505,7 +33624,7 @@ var init_orchestrator = __esm({
         child.once("close", (code) => resolve(code ?? 1));
       });
       const output = chunks.join("");
-      await import_promises29.default.writeFile(params.logPath, output, "utf8");
+      await import_promises30.default.writeFile(params.logPath, output, "utf8");
       if (exitCode !== 0) {
         throw new Error(
           `Command failed with exit ${exitCode}: ${params.command.join(" ")}`
@@ -33559,7 +33678,7 @@ var init_orchestrator = __esm({
     };
     runCoreResearch = async (params) => {
       const { spec } = params;
-      const cwd = import_node_path23.default.resolve(params.cwd ?? process.cwd());
+      const cwd = import_node_path24.default.resolve(params.cwd ?? process.cwd());
       const prepared = await prepareCoreResearch(spec);
       await verifyPreparedSupport(prepared);
       const resolvedVariants = [];
@@ -33578,7 +33697,7 @@ var init_orchestrator = __esm({
           artifactHashes: { variant: sha256Json(variant) }
         });
         let runId = "";
-        const backtestLogPath = import_node_path23.default.join(
+        const backtestLogPath = import_node_path24.default.join(
           prepared.paths.runLogDir,
           `${variant.id}-backtest.log`
         );
@@ -33594,7 +33713,7 @@ var init_orchestrator = __esm({
             env: {
               PROJECT_CWD: cwd,
               ...params.sourceRepositoryRoot ? {
-                [SOURCE_REPOSITORY_ROOT_ENV]: import_node_path23.default.resolve(
+                [SOURCE_REPOSITORY_ROOT_ENV]: import_node_path24.default.resolve(
                   params.sourceRepositoryRoot
                 )
               } : {}
@@ -33609,12 +33728,12 @@ var init_orchestrator = __esm({
           if (!runId) {
             throw new Error(`Backtest for ${variant.id} did not report a run id`);
           }
-          const exportLogPath = import_node_path23.default.join(
+          const exportLogPath = import_node_path24.default.join(
             prepared.paths.runLogDir,
             `${variant.id}-export.log`
           );
           const exportParts = [];
-          const cliPath = import_node_path23.default.resolve(process.argv[1]);
+          const cliPath = import_node_path24.default.resolve(process.argv[1]);
           await runCommand2({
             command: [
               process.execPath,
@@ -33634,14 +33753,14 @@ var init_orchestrator = __esm({
             env: {
               PROJECT_CWD: cwd,
               ...params.sourceRepositoryRoot ? {
-                [SOURCE_REPOSITORY_ROOT_ENV]: import_node_path23.default.resolve(
+                [SOURCE_REPOSITORY_ROOT_ENV]: import_node_path24.default.resolve(
                   params.sourceRepositoryRoot
                 )
               } : {}
             },
             onLine: (line) => {
               const match = line.match(/^part\d+:\s+(.+)$/);
-              if (match) exportParts.push(import_node_path23.default.resolve(cwd, match[1].trim()));
+              if (match) exportParts.push(import_node_path24.default.resolve(cwd, match[1].trim()));
             }
           });
           if (!exportParts.length) {
@@ -33652,7 +33771,7 @@ var init_orchestrator = __esm({
           const traceFiles = await (0, import_coreResearch.listCoreResearchTraceFiles)({
             strategyName: spec.strategy,
             runId,
-            outDir: import_node_path23.default.resolve(cwd, "data/research/core/trace")
+            outDir: import_node_path24.default.resolve(cwd, "data/research/core/trace")
           });
           resolvedVariants.push({
             ...variant,
@@ -33672,7 +33791,7 @@ var init_orchestrator = __esm({
               ...Object.fromEntries(
                 await Promise.all(
                   exportParts.map(async (filePath) => [
-                    import_node_path23.default.basename(filePath),
+                    import_node_path24.default.basename(filePath),
                     await sha256File(filePath)
                   ])
                 )
@@ -33691,7 +33810,7 @@ var init_orchestrator = __esm({
         }
       }
       await writeJsonAtomic(
-        import_node_path23.default.join(prepared.paths.researchDir, "resolved-runs.json"),
+        import_node_path24.default.join(prepared.paths.researchDir, "resolved-runs.json"),
         {
           schema: "tradejs-core-research-resolved-runs/v1",
           researchId: spec.researchId,
@@ -33711,12 +33830,12 @@ var coreResearch_exports = {};
 __export(coreResearch_exports, {
   main: () => main37
 });
-var import_promises30, import_node_path24, import_chalk41, valueAfter, required, parseTimestamp, readSymbols, printUsage, main37;
+var import_promises31, import_node_path25, import_chalk41, valueAfter, required, parseTimestamp, readSymbols, printUsage, main37;
 var init_coreResearch = __esm({
   "src/scripts/coreResearch.ts"() {
     "use strict";
-    import_promises30 = __toESM(require("fs/promises"));
-    import_node_path24 = __toESM(require("path"));
+    import_promises31 = __toESM(require("fs/promises"));
+    import_node_path25 = __toESM(require("path"));
     import_chalk41 = __toESM(require("chalk"));
     init_io();
     init_orchestrator();
@@ -33740,7 +33859,7 @@ var init_coreResearch = __esm({
       const symbolsFile = valueAfter(argv2, "--symbolsFile");
       if (symbolsFile) {
         const parsed = JSON.parse(
-          await import_promises30.default.readFile(import_node_path24.default.resolve(projectRoot18, symbolsFile), "utf8")
+          await import_promises31.default.readFile(import_node_path25.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");
@@ -33771,14 +33890,14 @@ The run command executes only variants with an explicit command[] in the preregi
         return;
       }
       if (command === "index") {
-        const rootDir = import_node_path24.default.resolve(
+        const rootDir = import_node_path25.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_path24.default.join(rootDir, "index.json")} (${index.families.length} families)`
+            `Core research index: ${import_node_path25.default.join(rootDir, "index.json")} (${index.families.length} families)`
           )
         );
         return;
@@ -33787,7 +33906,7 @@ The run command executes only variants with an explicit command[] in the preregi
         projectRoot: roots.projectRoot
       });
       if (command === "init") {
-        const outputPath = import_node_path24.default.resolve(
+        const outputPath = import_node_path25.default.resolve(
           roots.projectRoot,
           required(valueAfter(argv2, "--out"), "--out")
         );
@@ -33811,7 +33930,7 @@ The run command executes only variants with an explicit command[] in the preregi
         );
         return;
       }
-      const specPath = import_node_path24.default.resolve(
+      const specPath = import_node_path25.default.resolve(
         roots.projectRoot,
         required(valueAfter(argv2, "--spec"), "--spec")
       );
@@ -33961,7 +34080,7 @@ var init_specification = __esm({
       if (!spec.budget || !spec.selection || !spec.diagnostics)
         throw new Error("Missing research budgets or criteria");
       if (spec.featurePaths !== void 0 && (!Array.isArray(spec.featurePaths) || !spec.featurePaths.length || spec.featurePaths.length > 64 || new Set(spec.featurePaths).size !== spec.featurePaths.length || spec.featurePaths.some(
-        (path57) => typeof path57 !== "string" || !/^additionalIndicators\.[a-zA-Z0-9_.]+$/.test(path57) || classifyAiPocketFeaturePath(path57.split(".")) !== "eligible"
+        (path58) => typeof path58 !== "string" || !/^additionalIndicators\.[a-zA-Z0-9_.]+$/.test(path58) || classifyAiPocketFeaturePath(path58.split(".")) !== "eligible"
       )))
         throw new Error("Feature paths must be unique causal market features");
       positive(spec.budget.maxVariants, "maxVariants", 12);
@@ -34044,10 +34163,10 @@ var init_specification = __esm({
       ))
         throw new Error("Invalid event horizons");
       if (!Array.isArray(spec.diagnostics.requiredPaths) || !spec.diagnostics.requiredPaths.length || spec.diagnostics.requiredPaths.some(
-        (path57) => !/^[a-zA-Z0-9_.]+$/.test(path57) || classifyAiPocketFeaturePath([
+        (path58) => !/^[a-zA-Z0-9_.]+$/.test(path58) || classifyAiPocketFeaturePath([
           "additionalIndicators",
           "baseContext",
-          ...path57.split(".")
+          ...path58.split(".")
         ]) !== "eligible"
       ))
         throw new Error("Required context paths must be causal market features");
@@ -34092,30 +34211,30 @@ __export(io_exports, {
   verifyResearchState: () => verifyResearchState,
   withResearchLock: () => withResearchLock
 });
-var import_promises31, import_node_path25, import_node_os3, import_node_crypto19, researchDirectory, readJson, boundResearchPath, withResearchLock, verifyResearchState, verifyCompletedResearch, initializeResearchState, isRetainedDeletion;
+var import_promises32, import_node_path26, import_node_os3, import_node_crypto18, researchDirectory, readJson, boundResearchPath, withResearchLock, verifyResearchState, verifyCompletedResearch, initializeResearchState, isRetainedDeletion;
 var init_io2 = __esm({
   "src/lib/strategyResearch/io.ts"() {
     "use strict";
-    import_promises31 = __toESM(require("fs/promises"));
-    import_node_path25 = __toESM(require("path"));
+    import_promises32 = __toESM(require("fs/promises"));
+    import_node_path26 = __toESM(require("path"));
     import_node_os3 = __toESM(require("os"));
-    import_node_crypto19 = require("crypto");
+    import_node_crypto18 = require("crypto");
     init_io();
-    researchDirectory = (projectRoot18, spec) => import_node_path25.default.join(projectRoot18, "data/research/strategy", spec.core.researchId);
-    readJson = async (file) => JSON.parse(await import_promises31.default.readFile(file, "utf8"));
+    researchDirectory = (projectRoot18, spec) => import_node_path26.default.join(projectRoot18, "data/research/strategy", spec.core.researchId);
+    readJson = async (file) => JSON.parse(await import_promises32.default.readFile(file, "utf8"));
     boundResearchPath = async (root, relative) => {
-      const target = import_node_path25.default.resolve(root, relative);
-      const realRoot = await import_promises31.default.realpath(root);
+      const target = import_node_path26.default.resolve(root, relative);
+      const realRoot = await import_promises32.default.realpath(root);
       let ancestor = target;
       while (true) {
         try {
-          const real = await import_promises31.default.realpath(ancestor);
-          if (real !== realRoot && !real.startsWith(`${realRoot}${import_node_path25.default.sep}`))
+          const real = await import_promises32.default.realpath(ancestor);
+          if (real !== realRoot && !real.startsWith(`${realRoot}${import_node_path26.default.sep}`))
             throw new Error(`Research path escapes Project: ${relative}`);
           break;
         } catch (error) {
           if (error.code !== "ENOENT") throw error;
-          const parent = import_node_path25.default.dirname(ancestor);
+          const parent = import_node_path26.default.dirname(ancestor);
           if (parent === ancestor) throw error;
           ancestor = parent;
         }
@@ -34127,9 +34246,9 @@ var init_io2 = __esm({
         projectRoot18,
         "data/research/strategy/.lock"
       );
-      await import_promises31.default.mkdir(import_node_path25.default.dirname(file), { recursive: true });
-      const token = (0, import_node_crypto19.randomUUID)();
-      const acquire = () => import_promises31.default.writeFile(
+      await import_promises32.default.mkdir(import_node_path26.default.dirname(file), { recursive: true });
+      const token = (0, import_node_crypto18.randomUUID)();
+      const acquire = () => import_promises32.default.writeFile(
         file,
         JSON.stringify({ pid: process.pid, host: import_node_os3.default.hostname(), token }),
         { flag: "wx", mode: 384 }
@@ -34150,18 +34269,18 @@ var init_io2 = __esm({
           if (probe.code === "ESRCH") alive = false;
         }
         if (alive) throw new Error(`Research is already running (pid=${lock.pid})`);
-        await import_promises31.default.unlink(file);
+        await import_promises32.default.unlink(file);
         await acquire();
       }
       try {
         return await work();
       } finally {
         const owner = await readJson(file);
-        if (owner.token === token) await import_promises31.default.unlink(file);
+        if (owner.token === token) await import_promises32.default.unlink(file);
       }
     };
     verifyResearchState = async (directory, state) => {
-      const frozenSpec = await readJson(import_node_path25.default.join(directory, "spec.json"));
+      const frozenSpec = await readJson(import_node_path26.default.join(directory, "spec.json"));
       if (sha256Json(frozenSpec) !== state.specSha256)
         throw new Error("Frozen research spec changed");
       for (const [name, stage] of Object.entries(state.stages)) {
@@ -34180,14 +34299,14 @@ var init_io2 = __esm({
     };
     verifyCompletedResearch = async (directory, state) => {
       await verifyResearchState(directory, state);
-      const manifest = await readJson(import_node_path25.default.join(directory, "manifest.json"));
+      const manifest = await readJson(import_node_path26.default.join(directory, "manifest.json"));
       if (manifest.specSha256 !== state.specSha256)
         throw new Error("Final manifest spec mismatch");
       for (const [relative, expected] of Object.entries(manifest.artifacts))
         if (await sha256File(await boundResearchPath(directory, relative)) !== expected)
           throw new Error(`Changed final research artifact: ${relative}`);
-      const inventory = await readJson(import_node_path25.default.join(directory, "retention.json"));
-      const projectRoot18 = import_node_path25.default.resolve(directory, "../../../..");
+      const inventory = await readJson(import_node_path26.default.join(directory, "retention.json"));
+      const projectRoot18 = import_node_path26.default.resolve(directory, "../../../..");
       for (const artifact of inventory.research.permanentArtifacts) {
         const file = await boundResearchPath(projectRoot18, artifact.path);
         if (await sha256File(file) !== artifact.sha256)
@@ -34195,8 +34314,8 @@ var init_io2 = __esm({
       }
     };
     initializeResearchState = async (directory, spec, lineage) => {
-      await import_promises31.default.mkdir(directory, { recursive: true });
-      const file = import_node_path25.default.join(directory, "state.json");
+      await import_promises32.default.mkdir(directory, { recursive: true });
+      const file = import_node_path26.default.join(directory, "state.json");
       let previous;
       try {
         previous = await readJson(file);
@@ -34220,18 +34339,18 @@ var init_io2 = __esm({
         status: "running",
         stages: {}
       };
-      await writeJsonAtomic(import_node_path25.default.join(directory, "spec.json"), spec);
+      await writeJsonAtomic(import_node_path26.default.join(directory, "spec.json"), spec);
       await writeJsonAtomic(file, state);
       return state;
     };
     isRetainedDeletion = async (directory, file, hash2) => {
       try {
-        const inventory = await readJson(import_node_path25.default.join(directory, "retention.json"));
+        const inventory = await readJson(import_node_path26.default.join(directory, "retention.json"));
         const index = inventory.entries.findIndex(
           (entry) => entry.path === file && entry.sha256 === hash2
         );
         if (index < 0) return false;
-        const receipt = await readJson(import_node_path25.default.join(directory, "retention", `${index}.json`));
+        const receipt = await readJson(import_node_path26.default.join(directory, "retention", `${index}.json`));
         return ["applying", "completed"].includes(receipt.status) && receipt.files[0]?.path === file && receipt.files[0]?.sha256 === hash2;
       } catch (error) {
         if (error.code === "ENOENT") return false;
@@ -35271,11 +35390,11 @@ var init_report2 = __esm({
 });
 
 // src/lib/strategyRelease/researchFileConsumers.ts
-var import_node_path26, import_node_child_process7, import_node_util, execFileAsync, runCommand3, GUEST_FILE_CHECK, assertNoResearchFileConsumers;
+var import_node_path27, import_node_child_process7, import_node_util, execFileAsync, runCommand3, GUEST_FILE_CHECK, assertNoResearchFileConsumers;
 var init_researchFileConsumers = __esm({
   "src/lib/strategyRelease/researchFileConsumers.ts"() {
     "use strict";
-    import_node_path26 = __toESM(require("path"));
+    import_node_path27 = __toESM(require("path"));
     import_node_child_process7 = require("child_process");
     import_node_util = require("util");
     execFileAsync = (0, import_node_util.promisify)(import_node_child_process7.execFile);
@@ -35306,15 +35425,15 @@ print(json.dumps(sorted(opened)))
 `;
     assertNoResearchFileConsumers = async (files, run = runCommand3) => {
       const virtualPids = /* @__PURE__ */ new Set();
-      const wanted = new Set(files.map((file) => import_node_path26.default.resolve(file)));
-      let commonRoot = files.length ? import_node_path26.default.dirname(files[0]) : "";
+      const wanted = new Set(files.map((file) => import_node_path27.default.resolve(file)));
+      let commonRoot = files.length ? import_node_path27.default.dirname(files[0]) : "";
       while (commonRoot && files.some((file) => {
-        const relative = import_node_path26.default.relative(commonRoot, file);
-        return relative === ".." || relative.startsWith(`..${import_node_path26.default.sep}`) || import_node_path26.default.isAbsolute(relative);
+        const relative = import_node_path27.default.relative(commonRoot, file);
+        return relative === ".." || relative.startsWith(`..${import_node_path27.default.sep}`) || import_node_path27.default.isAbsolute(relative);
       }))
-        commonRoot = import_node_path26.default.dirname(commonRoot);
+        commonRoot = import_node_path27.default.dirname(commonRoot);
       const selectors = [];
-      if (files.length > 1e3 && commonRoot !== import_node_path26.default.parse(commonRoot).root) {
+      if (files.length > 1e3 && commonRoot !== import_node_path27.default.parse(commonRoot).root) {
         selectors.push(["+D", commonRoot]);
       } else {
         for (let offset = 0; offset < files.length; offset += 100)
@@ -35338,7 +35457,7 @@ print(json.dumps(sorted(opened)))
           if (line.startsWith("c"))
             virtual = line.startsWith("ccom.apple.Virtualization.");
           if (line.startsWith("n")) {
-            if (!wanted.has(import_node_path26.default.resolve(line.slice(1)))) continue;
+            if (!wanted.has(import_node_path27.default.resolve(line.slice(1)))) continue;
             if (!virtual || !/^\d+$/.test(pid))
               throw new Error(
                 `Research cleanup found open files: ${line.slice(1)}`
@@ -35372,9 +35491,9 @@ print(json.dumps(sorted(opened)))
         for (const mount of container.Mounts) {
           if (mount.Type !== "bind") continue;
           for (const file of files) {
-            const relative = import_node_path26.default.relative(mount.Source, file);
-            if (relative === "" || !relative.startsWith(`..${import_node_path26.default.sep}`) && relative !== ".." && !import_node_path26.default.isAbsolute(relative)) {
-              guestFiles.add(import_node_path26.default.posix.join(mount.Destination, relative));
+            const relative = import_node_path27.default.relative(mount.Source, file);
+            if (relative === "" || !relative.startsWith(`..${import_node_path27.default.sep}`) && relative !== ".." && !import_node_path27.default.isAbsolute(relative)) {
+              guestFiles.add(import_node_path27.default.posix.join(mount.Destination, relative));
               covered.add(file);
             }
           }
@@ -35455,14 +35574,14 @@ var init_evidenceRetention = __esm({
 });
 
 // src/lib/strategyRelease/researchRetention.ts
-var import_promises32, import_researchMetricSnapshot, import_node_path27, import_node_crypto20, import_strategyReleaseEvidence2, SHA256_RE2, mapFiles, fileSha256, inside, applyResearchRetention;
+var import_promises33, import_researchMetricSnapshot, import_node_path28, import_node_crypto19, import_strategyReleaseEvidence2, SHA256_RE2, mapFiles, fileSha256, inside, applyResearchRetention;
 var init_researchRetention = __esm({
   "src/lib/strategyRelease/researchRetention.ts"() {
     "use strict";
-    import_promises32 = __toESM(require("fs/promises"));
+    import_promises33 = __toESM(require("fs/promises"));
     import_researchMetricSnapshot = require("@tradejs/infra/researchMetricSnapshot");
-    import_node_path27 = __toESM(require("path"));
-    import_node_crypto20 = require("crypto");
+    import_node_path28 = __toESM(require("path"));
+    import_node_crypto19 = require("crypto");
     import_strategyReleaseEvidence2 = require("@tradejs/infra/strategyReleaseEvidence");
     init_researchFileConsumers();
     init_evidenceRetention();
@@ -35482,15 +35601,15 @@ var init_researchRetention = __esm({
         if (worker.status === "rejected") throw worker.reason;
       return results2;
     };
-    fileSha256 = async (file, bytes) => bytes <= 1024 * 1024 ? (0, import_node_crypto20.createHash)("sha256").update(await import_promises32.default.readFile(file)).digest("hex") : (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(file);
+    fileSha256 = async (file, bytes) => bytes <= 1024 * 1024 ? (0, import_node_crypto19.createHash)("sha256").update(await import_promises33.default.readFile(file)).digest("hex") : (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(file);
     inside = (root, file) => {
-      const relative = import_node_path27.default.relative(root, file);
-      return relative !== "" && !relative.startsWith(`..${import_node_path27.default.sep}`) && relative !== ".." && !import_node_path27.default.isAbsolute(relative);
+      const relative = import_node_path28.default.relative(root, file);
+      return relative !== "" && !relative.startsWith(`..${import_node_path28.default.sep}`) && relative !== ".." && !import_node_path28.default.isAbsolute(relative);
     };
     applyResearchRetention = async (options) => {
-      const projectRoot18 = await import_promises32.default.realpath(options.projectRoot);
-      const dataRoot = import_node_path27.default.join(projectRoot18, "data");
-      const resolve = (file) => import_node_path27.default.resolve(projectRoot18, file);
+      const projectRoot18 = await import_promises33.default.realpath(options.projectRoot);
+      const dataRoot = import_node_path28.default.join(projectRoot18, "data");
+      const resolve = (file) => import_node_path28.default.resolve(projectRoot18, file);
       const receiptPath2 = resolve(options.receiptPath);
       const journalPath = `${receiptPath2}.deleted.jsonl`;
       const permanent = new Set(
@@ -35515,13 +35634,13 @@ var init_researchRetention = __esm({
       }
       await mapFiles(options.research.permanentArtifacts, async (artifact) => {
         const file = resolve(artifact.path);
-        if (!inside(projectRoot18, await import_promises32.default.realpath(file)) || !SHA256_RE2.test(artifact.sha256) || await fileSha256(file, (await import_promises32.default.stat(file)).size) !== artifact.sha256) {
+        if (!inside(projectRoot18, await import_promises33.default.realpath(file)) || !SHA256_RE2.test(artifact.sha256) || await fileSha256(file, (await import_promises33.default.stat(file)).size) !== artifact.sha256) {
           throw new Error(
             `Permanent research artifact checksum/path mismatch: ${file}`
           );
         }
         if (artifact.role === "note") {
-          const handle = await import_promises32.default.open(file, "r");
+          const handle = await import_promises33.default.open(file, "r");
           try {
             const header = Buffer.alloc(4096);
             const { bytesRead } = await handle.read(header, 0, header.length, 0);
@@ -35534,9 +35653,9 @@ var init_researchRetention = __esm({
               );
             }
             if (!retired && /^schema:\s*tradejs-research\/v2\s*$/m.test(frontmatter[1])) {
-              if ((await import_promises32.default.stat(file)).size > 8 * 1024 * 1024)
+              if ((await import_promises33.default.stat(file)).size > 8 * 1024 * 1024)
                 throw new Error("Compact permanent note exceeds 8 MiB");
-              const content = await import_promises32.default.readFile(file, "utf8");
+              const content = await import_promises33.default.readFile(file, "utf8");
               const section = content.split("## Metrics snapshot (machine-readable)")[1]?.split("## Reported metrics")[0] ?? "";
               const blocks = [
                 ...section.matchAll(/```json\r?\n([\s\S]*?)\r?\n```/g)
@@ -35561,9 +35680,9 @@ var init_researchRetention = __esm({
         if (checkedPaths.has(file))
           throw new Error(`Duplicate cleanup path: ${file}`);
         checkedPaths.add(file);
-        if (await import_promises32.default.realpath(file) !== file)
+        if (await import_promises33.default.realpath(file) !== file)
           throw new Error(`Research cleanup refuses symlinks: ${file}`);
-        const stat = await import_promises32.default.lstat(file);
+        const stat = await import_promises33.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}`
@@ -35589,29 +35708,29 @@ var init_researchRetention = __esm({
         }))
       };
       if (!options.apply) return receipt;
-      await import_promises32.default.mkdir(import_node_path27.default.dirname(receiptPath2), { recursive: true });
-      if (await import_promises32.default.realpath(import_node_path27.default.dirname(receiptPath2)) !== import_node_path27.default.dirname(receiptPath2)) {
+      await import_promises33.default.mkdir(import_node_path28.default.dirname(receiptPath2), { recursive: true });
+      if (await import_promises33.default.realpath(import_node_path28.default.dirname(receiptPath2)) !== import_node_path28.default.dirname(receiptPath2)) {
         throw new Error("Cleanup receipt refuses symlinked directories");
       }
-      const lock = await import_promises32.default.open(`${receiptPath2}.lock`, "wx");
+      const lock = await import_promises33.default.open(`${receiptPath2}.lock`, "wx");
       let journal;
       const writeReceipt = async () => {
         const temp = `${receiptPath2}.${process.pid}.tmp`;
-        await import_promises32.default.writeFile(temp, `${JSON.stringify(receipt, null, 2)}
+        await import_promises33.default.writeFile(temp, `${JSON.stringify(receipt, null, 2)}
 `, "utf8");
-        await import_promises32.default.rename(temp, receiptPath2);
+        await import_promises33.default.rename(temp, receiptPath2);
       };
       try {
-        journal = await import_promises32.default.open(journalPath, "wx");
+        journal = await import_promises33.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_promises32.default.lstat(file);
+          const stat = await import_promises33.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_promises32.default.unlink(file);
+          await import_promises33.default.unlink(file);
           receipt.files[index].removed = true;
           await journal.write(`${JSON.stringify(receipt.files[index])}
 `);
@@ -35625,19 +35744,19 @@ var init_researchRetention = __esm({
       } finally {
         await journal?.close();
         await lock.close();
-        await import_promises32.default.unlink(`${receiptPath2}.lock`);
+        await import_promises33.default.unlink(`${receiptPath2}.lock`);
       }
     };
   }
 });
 
 // src/lib/strategyResearch/retention.ts
-var import_promises33, import_node_path28, createResearchRetentionInventory, applyRetentionInventory, finishResearchRetention;
+var import_promises34, import_node_path29, createResearchRetentionInventory, applyRetentionInventory, finishResearchRetention;
 var init_retention = __esm({
   "src/lib/strategyResearch/retention.ts"() {
     "use strict";
-    import_promises33 = __toESM(require("fs/promises"));
-    import_node_path28 = __toESM(require("path"));
+    import_promises34 = __toESM(require("fs/promises"));
+    import_node_path29 = __toESM(require("path"));
     init_researchRetention();
     init_io();
     init_io2();
@@ -35645,17 +35764,17 @@ var init_retention = __esm({
       const permanentArtifacts = [];
       for (const [role, file] of [
         ["note", notePath],
-        ["metrics", import_node_path28.default.join(directory, "result.json")],
-        ["candidates", import_node_path28.default.join(directory, "03-freeze-gates/result.json")],
-        ["candidates", import_node_path28.default.join(directory, "resolved-spec.json")],
-        ["ledger", import_node_path28.default.join(directory, "05-freeze-primary/result.json")],
-        ["chart", import_node_path28.default.join(directory, "report.html")],
+        ["metrics", import_node_path29.default.join(directory, "result.json")],
+        ["candidates", import_node_path29.default.join(directory, "03-freeze-gates/result.json")],
+        ["candidates", import_node_path29.default.join(directory, "resolved-spec.json")],
+        ["ledger", import_node_path29.default.join(directory, "05-freeze-primary/result.json")],
+        ["chart", import_node_path29.default.join(directory, "report.html")],
         ...[
           "source.patch",
           "source-baseline.tar",
           "source-untracked.json",
           "source-jev-models.json"
-        ].map((file2) => ["source", import_node_path28.default.join(directory, file2)])
+        ].map((file2) => ["source", import_node_path29.default.join(directory, file2)])
       ]) {
         try {
           permanentArtifacts.push({
@@ -35682,7 +35801,7 @@ var init_retention = __esm({
                 (variant) => variant.files.includes(source)
               ))
                 files.set(
-                  await import_promises33.default.realpath(await boundResearchPath(projectRoot18, source)),
+                  await import_promises34.default.realpath(await boundResearchPath(projectRoot18, source)),
                   sha2
                 );
             }
@@ -35691,7 +35810,7 @@ var init_retention = __esm({
       }
       const entries = [];
       for (const [file, hash2] of files) {
-        const stat = await import_promises33.default.stat(file);
+        const stat = await import_promises34.default.stat(file);
         entries.push({
           path: file,
           kind: "research_payload",
@@ -35715,13 +35834,13 @@ var init_retention = __esm({
     };
     applyRetentionInventory = async (projectRoot18, directory) => {
       const inventory = await readJson(
-        import_node_path28.default.join(directory, "retention.json")
+        import_node_path29.default.join(directory, "retention.json")
       );
-      const receipts = import_node_path28.default.join(directory, "retention");
-      await import_promises33.default.mkdir(receipts, { recursive: true });
+      const receipts = import_node_path29.default.join(directory, "retention");
+      await import_promises34.default.mkdir(receipts, { recursive: true });
       for (let index = 0; index < inventory.entries.length; index++) {
         const entry = inventory.entries[index];
-        const receiptPath2 = import_node_path28.default.join(receipts, `${index}.json`);
+        const receiptPath2 = import_node_path29.default.join(receipts, `${index}.json`);
         let receipt;
         try {
           receipt = await readJson(receiptPath2);
@@ -35736,7 +35855,7 @@ var init_retention = __esm({
             );
           if (receipt.status === "completed" && recorded.removed) continue;
           try {
-            await import_promises33.default.stat(entry.path);
+            await import_promises34.default.stat(entry.path);
           } catch (error) {
             if (error.code !== "ENOENT") throw error;
             if (receipt.status !== "applying") throw error;
@@ -35757,13 +35876,13 @@ var init_retention = __esm({
           entries: [entry],
           receiptPath: receiptPath2,
           apply: true,
-          protectedPaths: [import_node_path28.default.join(directory, "retention.json")]
+          protectedPaths: [import_node_path29.default.join(directory, "retention.json")]
         });
       }
       return { status: "completed", files: inventory.entries.length };
     };
     finishResearchRetention = async (projectRoot18, directory) => {
-      const statusPath = import_node_path28.default.join(directory, "retention-status.json");
+      const statusPath = import_node_path29.default.join(directory, "retention-status.json");
       try {
         const result = await applyRetentionInventory(projectRoot18, directory);
         await writeJsonAtomic(statusPath, result);
@@ -35780,13 +35899,13 @@ var init_retention = __esm({
 });
 
 // src/lib/strategyResearch/orchestrator.ts
-var import_promises34, import_researchMetricSnapshot2, import_node_path29, runStrategyResearch;
+var import_promises35, import_researchMetricSnapshot2, import_node_path30, runStrategyResearch;
 var init_orchestrator2 = __esm({
   "src/lib/strategyResearch/orchestrator.ts"() {
     "use strict";
-    import_promises34 = __toESM(require("fs/promises"));
+    import_promises35 = __toESM(require("fs/promises"));
     import_researchMetricSnapshot2 = require("@tradejs/infra/researchMetricSnapshot");
-    import_node_path29 = __toESM(require("path"));
+    import_node_path30 = __toESM(require("path"));
     init_metrics();
     init_io();
     init_specification();
@@ -35801,7 +35920,7 @@ var init_orchestrator2 = __esm({
     runStrategyResearch = async (parameters) => {
       let spec = validateStrategyResearchSpec(parameters.spec);
       const { backend } = parameters;
-      const projectRoot18 = await import_promises34.default.realpath(parameters.projectRoot);
+      const projectRoot18 = await import_promises35.default.realpath(parameters.projectRoot);
       await boundResearchPath(
         projectRoot18,
         `data/research/strategy/${spec.core.researchId}`
@@ -35810,7 +35929,7 @@ var init_orchestrator2 = __esm({
         const directory = researchDirectory(projectRoot18, spec);
         const lineage = await backend.lineage();
         const state = await initializeResearchState(directory, spec, lineage);
-        const statePath = import_node_path29.default.join(directory, "state.json");
+        const statePath = import_node_path30.default.join(directory, "state.json");
         const elapsedBefore = state.elapsedMs ?? 0;
         const activeStart = Date.now();
         const elapsed = () => elapsedBefore + Date.now() - activeStart;
@@ -35820,7 +35939,7 @@ var init_orchestrator2 = __esm({
             directory,
             state,
             conclusion: await readJson(
-              import_node_path29.default.join(directory, "result.json")
+              import_node_path30.default.join(directory, "result.json")
             )
           };
         }
@@ -35829,14 +35948,14 @@ var init_orchestrator2 = __esm({
           state.elapsedMs = elapsed();
           return writeJsonAtomic(statePath, state);
         };
-        const event = async (stage2, status) => import_promises34.default.appendFile(
-          import_node_path29.default.join(directory, "events.jsonl"),
+        const event = async (stage2, status) => import_promises35.default.appendFile(
+          import_node_path30.default.join(directory, "events.jsonl"),
           `${JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), stage: stage2, status, specSha256: state.specSha256 })}
 `
         );
         const stage = async (name, work) => {
           const stageDirectory = await boundResearchPath(directory, name);
-          const resultPath = import_node_path29.default.join(stageDirectory, "result.json");
+          const resultPath = import_node_path30.default.join(stageDirectory, "result.json");
           if (state.stages[name]?.status === "completed")
             return readJson(resultPath);
           if (elapsed() > spec.budget.maxMinutes * 6e4)
@@ -35851,20 +35970,20 @@ var init_orchestrator2 = __esm({
           };
           state.status = "running";
           delete state.error;
-          await import_promises34.default.mkdir(stageDirectory, { recursive: true });
+          await import_promises35.default.mkdir(stageDirectory, { recursive: true });
           await save();
           await event(name, "started");
-          await import_promises34.default.writeFile(
-            import_node_path29.default.join(directory, "report.html"),
+          await import_promises35.default.writeFile(
+            import_node_path30.default.join(directory, "report.html"),
             buildStrategyResearchReport({ spec, state, diagnostics })
           );
           try {
             const result = await work(stageDirectory);
             await writeJsonAtomic(resultPath, result);
             const artifacts = {};
-            for (const file of await import_promises34.default.readdir(stageDirectory)) {
-              const full = import_node_path29.default.join(stageDirectory, file);
-              if ((await import_promises34.default.stat(full)).isFile())
+            for (const file of await import_promises35.default.readdir(stageDirectory)) {
+              const full = import_node_path30.default.join(stageDirectory, file);
+              if ((await import_promises35.default.stat(full)).isFile())
                 artifacts[`${name}/${file}`] = await sha256File(full);
             }
             if (name === "01-preflight") {
@@ -35875,7 +35994,7 @@ var init_orchestrator2 = __esm({
                 "source-jev-models.json"
               ]) {
                 try {
-                  artifacts[file] = await sha256File(import_node_path29.default.join(directory, file));
+                  artifacts[file] = await sha256File(import_node_path30.default.join(directory, file));
                 } catch (error) {
                   if (error.code !== "ENOENT")
                     throw error;
@@ -35908,14 +36027,14 @@ var init_orchestrator2 = __esm({
           let previousRunId;
           try {
             previousRunId = (await readJson(
-              import_node_path29.default.join(folder, "native-run.json")
+              import_node_path30.default.join(folder, "native-run.json")
             )).runId;
           } catch (error) {
             if (error.code !== "ENOENT") throw error;
           }
           if (!previousRunId) {
             try {
-              if ((await import_promises34.default.stat(import_node_path29.default.join(folder, "backtest.log"))).size)
+              if ((await import_promises35.default.stat(import_node_path30.default.join(folder, "backtest.log"))).size)
                 throw new Error(
                   "Previous native attempt has no recorded run identity; inspect its log before another launch"
                 );
@@ -35936,7 +36055,7 @@ var init_orchestrator2 = __esm({
             },
             variant,
             folder,
-            async (runId) => writeJsonAtomic(import_node_path29.default.join(folder, "native-run.json"), { runId }),
+            async (runId) => writeJsonAtomic(import_node_path30.default.join(folder, "native-run.json"), { runId }),
             previousRunId,
             confirmation
           );
@@ -35951,15 +36070,15 @@ var init_orchestrator2 = __esm({
         try {
           const inventory = await stage("01-preflight", async () => {
             const prior = [];
-            const root = import_node_path29.default.dirname(directory);
-            for (const id of await import_promises34.default.readdir(root)) {
+            const root = import_node_path30.default.dirname(directory);
+            for (const id of await import_promises35.default.readdir(root)) {
               if (id === spec.core.researchId || id.startsWith(".")) continue;
               try {
                 const previous = await readJson(
-                  import_node_path29.default.join(root, id, "spec.json")
+                  import_node_path30.default.join(root, id, "spec.json")
                 );
                 const previousState = await readJson(
-                  import_node_path29.default.join(root, id, "state.json")
+                  import_node_path30.default.join(root, id, "state.json")
                 );
                 const overlap = previous.core.strategy === spec.core.strategy && previous.core.window.start < spec.core.window.end && previous.core.window.end > (spec.testSince || spec.core.window.start);
                 if (overlap && previousState.holdoutOpenedAt)
@@ -35985,7 +36104,7 @@ var init_orchestrator2 = __esm({
                 let previous;
                 try {
                   previous = (await readJson(
-                    import_node_path29.default.join(folder, "native-run.json")
+                    import_node_path30.default.join(folder, "native-run.json")
                   )).runId;
                 } catch (error) {
                   if (error.code !== "ENOENT")
@@ -35995,7 +36114,7 @@ var init_orchestrator2 = __esm({
                   spec,
                   control,
                   folder,
-                  async (runId) => writeJsonAtomic(import_node_path29.default.join(folder, "native-run.json"), {
+                  async (runId) => writeJsonAtomic(import_node_path30.default.join(folder, "native-run.json"), {
                     runId
                   }),
                   previous
@@ -36009,7 +36128,7 @@ var init_orchestrator2 = __esm({
             );
             spec = { ...spec, testSince: partition.testSince };
           }
-          await writeJsonAtomic(import_node_path29.default.join(directory, "resolved-spec.json"), spec);
+          await writeJsonAtomic(import_node_path30.default.join(directory, "resolved-spec.json"), spec);
           let gates = [];
           let primaryId = null;
           let frozenSelection;
@@ -36065,10 +36184,10 @@ var init_orchestrator2 = __esm({
               core: { ...spec.core, researchId: spec.frozenFrom }
             });
             const parentState = await readJson(
-              import_node_path29.default.join(parentDirectory, "state.json")
+              import_node_path30.default.join(parentDirectory, "state.json")
             );
             const parentSpec = await readJson(
-              import_node_path29.default.join(parentDirectory, "spec.json")
+              import_node_path30.default.join(parentDirectory, "spec.json")
             );
             const { verifyCompletedResearch: verifyCompletedResearch2 } = await Promise.resolve().then(() => (init_io2(), io_exports));
             await verifyCompletedResearch2(parentDirectory, parentState);
@@ -36095,10 +36214,10 @@ var init_orchestrator2 = __esm({
                 "Frozen revalidation requires complete, unchanged rules/runtime and a strictly new period"
               );
             gates = await readJson(
-              import_node_path29.default.join(parentDirectory, "03-freeze-gates/result.json")
+              import_node_path30.default.join(parentDirectory, "03-freeze-gates/result.json")
             );
             frozenSelection = await readJson(
-              import_node_path29.default.join(parentDirectory, "05-freeze-primary/result.json")
+              import_node_path30.default.join(parentDirectory, "05-freeze-primary/result.json")
             );
             if (frozenSelection.schema !== "tradejs-research-selection/v1" || !Array.isArray(frozenSelection.compositions))
               throw new Error(
@@ -36227,7 +36346,7 @@ var init_orchestrator2 = __esm({
               `06-raw-metrics-${variant.id}`,
               async (folder) => {
                 const resolved = spec.frozenFrom ? (await run(spec, variant, `06-raw-revalidation-${variant.id}`)).variant : (await readJson(
-                  import_node_path29.default.join(directory, `02-raw-${variant.id}`, "result.json")
+                  import_node_path30.default.join(directory, `02-raw-${variant.id}`, "result.json")
                 )).variant;
                 const dataset = await backend.loadDataset(
                   spec,
@@ -36404,7 +36523,7 @@ var init_orchestrator2 = __esm({
           for (const name of Object.keys(state.stages)) {
             try {
               const result = await readJson(
-                import_node_path29.default.join(directory, name, "result.json")
+                import_node_path30.default.join(directory, name, "result.json")
               );
               if (result?.variant)
                 executions.push({ stage: name, ...result.variant });
@@ -36412,7 +36531,7 @@ var init_orchestrator2 = __esm({
               if (error.code !== "ENOENT") throw error;
             }
           }
-          await writeJsonAtomic(import_node_path29.default.join(directory, "result.json"), {
+          await writeJsonAtomic(import_node_path30.default.join(directory, "result.json"), {
             ...conclusion,
             executions,
             rawCore: Object.entries(rawReports).map(([id, windows]) => ({
@@ -36425,8 +36544,8 @@ var init_orchestrator2 = __esm({
           state.status = "completed";
           delete state.error;
           await save();
-          await import_promises34.default.writeFile(
-            import_node_path29.default.join(directory, "report.html"),
+          await import_promises35.default.writeFile(
+            import_node_path30.default.join(directory, "report.html"),
             buildStrategyResearchReport({
               spec,
               state,
@@ -36439,7 +36558,7 @@ var init_orchestrator2 = __esm({
             projectRoot18,
             `notes/${spec.core.strategy}`
           );
-          await import_promises34.default.mkdir(noteDirectory, { recursive: true });
+          await import_promises35.default.mkdir(noteDirectory, { recursive: true });
           const compact = {
             ...conclusion,
             gates,
@@ -36513,8 +36632,8 @@ ${conclusion.nextAction} Current-snapshot universe; no deployment authorization.
             throw new Error(
               "Compact permanent note exceeds 8 MiB; archive source separately, never truncate metrics"
             );
-          await import_promises34.default.writeFile(
-            import_node_path29.default.join(
+          await import_promises35.default.writeFile(
+            import_node_path30.default.join(
               noteDirectory,
               `${spec.core.createdAt.slice(0, 10)}-${spec.core.researchId}.md`
             ),
@@ -36522,8 +36641,8 @@ ${conclusion.nextAction} Current-snapshot universe; no deployment authorization.
             { flag: "wx" }
           ).catch(async (error) => {
             if (error.code !== "EEXIST") throw error;
-            const existing = await import_promises34.default.readFile(
-              import_node_path29.default.join(
+            const existing = await import_promises35.default.readFile(
+              import_node_path30.default.join(
                 noteDirectory,
                 `${spec.core.createdAt.slice(0, 10)}-${spec.core.researchId}.md`
               ),
@@ -36535,19 +36654,19 @@ ${conclusion.nextAction} Current-snapshot universe; no deployment authorization.
               );
           });
           await writeJsonAtomic(
-            import_node_path29.default.join(directory, "retention.json"),
+            import_node_path30.default.join(directory, "retention.json"),
             await createResearchRetentionInventory(
               projectRoot18,
               directory,
               spec,
               state,
-              import_node_path29.default.join(
+              import_node_path30.default.join(
                 noteDirectory,
                 `${spec.core.createdAt.slice(0, 10)}-${spec.core.researchId}.md`
               )
             )
           );
-          await writeJsonAtomic(import_node_path29.default.join(directory, "manifest.json"), {
+          await writeJsonAtomic(import_node_path30.default.join(directory, "manifest.json"), {
             schema: "tradejs-strategy-research-manifest/v1",
             specSha256: state.specSha256,
             artifacts: Object.fromEntries(
@@ -36561,7 +36680,7 @@ ${conclusion.nextAction} Current-snapshot universe; no deployment authorization.
                   "retention.json"
                 ].map(async (file) => [
                   file,
-                  await sha256File(import_node_path29.default.join(directory, file))
+                  await sha256File(import_node_path30.default.join(directory, file))
                 ])
               )
             )
@@ -36574,7 +36693,7 @@ ${conclusion.nextAction} Current-snapshot universe; no deployment authorization.
             );
           }
           parameters.onProgress?.(
-            `\u0418\u0442\u043E\u0433: ${conclusion.status}. \u041E\u0442\u0447\u0451\u0442: ${import_node_path29.default.join(directory, "report.html")}`
+            `\u0418\u0442\u043E\u0433: ${conclusion.status}. \u041E\u0442\u0447\u0451\u0442: ${import_node_path30.default.join(directory, "report.html")}`
           );
           return { directory, state, conclusion };
         } catch (error) {
@@ -36595,9 +36714,9 @@ ${conclusion.nextAction} Current-snapshot universe; no deployment authorization.
               frozenGates: 0
             }
           };
-          await writeJsonAtomic(import_node_path29.default.join(directory, "result.json"), conclusion);
-          await import_promises34.default.writeFile(
-            import_node_path29.default.join(directory, "report.html"),
+          await writeJsonAtomic(import_node_path30.default.join(directory, "result.json"), conclusion);
+          await import_promises35.default.writeFile(
+            import_node_path30.default.join(directory, "report.html"),
             buildStrategyResearchReport({ spec, state, conclusion, diagnostics })
           );
           throw error;
@@ -36608,18 +36727,18 @@ ${conclusion.nextAction} Current-snapshot universe; no deployment authorization.
 });
 
 // src/lib/strategyResearch/native.ts
-var import_promises35, import_node_fs9, import_node_path30, import_node_os4, import_node_readline4, import_node_child_process8, import_node_module3, import_redis18, import_ai9, import_backtest7, import_registry5, import_connectors15, import_data9, import_coreResearch2, import_jev6, validateResearchJevTraining, nativeConfig, runResearchCommand, createNativeStrategyResearchBackend;
+var import_promises36, import_node_fs9, import_node_path31, import_node_os4, import_node_readline4, import_node_child_process8, import_node_module3, import_redis19, import_ai9, import_backtest7, import_registry5, import_connectors15, import_data9, import_coreResearch2, import_jev6, validateResearchJevTraining, nativeConfig, runResearchCommand, createNativeStrategyResearchBackend;
 var init_native = __esm({
   "src/lib/strategyResearch/native.ts"() {
     "use strict";
-    import_promises35 = __toESM(require("fs/promises"));
+    import_promises36 = __toESM(require("fs/promises"));
     import_node_fs9 = require("fs");
-    import_node_path30 = __toESM(require("path"));
+    import_node_path31 = __toESM(require("path"));
     import_node_os4 = __toESM(require("os"));
     import_node_readline4 = __toESM(require("readline"));
     import_node_child_process8 = require("child_process");
     import_node_module3 = require("module");
-    import_redis18 = require("@tradejs/infra/redis");
+    import_redis19 = require("@tradejs/infra/redis");
     import_ai9 = require("@tradejs/node/ai");
     import_backtest7 = require("@tradejs/node/backtest");
     import_registry5 = require("@tradejs/node/registry");
@@ -36780,7 +36899,7 @@ var init_native = __esm({
     };
     createNativeStrategyResearchBackend = (parameters) => {
       const { projectRoot: projectRoot18, sourceRepositoryRoot } = parameters;
-      const cliPath = import_node_path30.default.resolve(parameters.cliPath ?? process.argv[1]);
+      const cliPath = import_node_path31.default.resolve(parameters.cliPath ?? process.argv[1]);
       let connector;
       const getConnector = async (spec) => {
         if (connector) return connector;
@@ -36859,57 +36978,57 @@ var init_native = __esm({
           const untrackedHashes = await Promise.all(
             untracked.map(async (file) => [
               file,
-              await sha256File(import_node_path30.default.join(sourceRepositoryRoot, file))
+              await sha256File(import_node_path31.default.join(sourceRepositoryRoot, file))
             ])
           );
           const requireFromRuntime = (0, import_node_module3.createRequire)(cliPath);
           const hashes = {};
           const hashRuntimeDirectory = async (directory, label, root = directory) => {
-            for (const entry of await import_promises35.default.readdir(directory, {
+            for (const entry of await import_promises36.default.readdir(directory, {
               withFileTypes: true
             })) {
-              const file = import_node_path30.default.join(directory, entry.name);
+              const file = import_node_path31.default.join(directory, entry.name);
               if (entry.isDirectory())
                 await hashRuntimeDirectory(file, label, root);
               else if (/\.(?:m?js|cjs|json)$/.test(entry.name))
-                hashes[`${label}:${import_node_path30.default.relative(root, file)}`] = await sha256File(file);
+                hashes[`${label}:${import_node_path31.default.relative(root, file)}`] = await sha256File(file);
             }
           };
-          await hashRuntimeDirectory(import_node_path30.default.dirname(cliPath), "cli-runtime");
+          await hashRuntimeDirectory(import_node_path31.default.dirname(cliPath), "cli-runtime");
           for (const entry of [
             "@tradejs/node/backtest",
             "@tradejs/node/ai",
             "@tradejs/core/strategies"
           ]) {
             const resolved = requireFromRuntime.resolve(entry);
-            const directory = import_node_path30.default.dirname(resolved);
+            const directory = import_node_path31.default.dirname(resolved);
             await hashRuntimeDirectory(directory, entry);
           }
-          const projectPackages = import_node_path30.default.join(projectRoot18, "node_modules/@tradejs");
-          for (const name of (await import_promises35.default.readdir(projectPackages)).sort()) {
-            const packageRoot = import_node_path30.default.join(projectPackages, name);
+          const projectPackages = import_node_path31.default.join(projectRoot18, "node_modules/@tradejs");
+          for (const name of (await import_promises36.default.readdir(projectPackages)).sort()) {
+            const packageRoot = import_node_path31.default.join(projectPackages, name);
             const visit = async (directory) => {
-              for (const entry of await import_promises35.default.readdir(directory, {
+              for (const entry of await import_promises36.default.readdir(directory, {
                 withFileTypes: true
               })) {
-                const file = import_node_path30.default.join(directory, entry.name);
+                const file = import_node_path31.default.join(directory, entry.name);
                 if (entry.isDirectory()) await visit(file);
                 else if (/\.(?:m?js|cjs|json)$/.test(entry.name))
-                  hashes[`installed:${name}:${import_node_path30.default.relative(packageRoot, file)}`] = await sha256File(file);
+                  hashes[`installed:${name}:${import_node_path31.default.relative(packageRoot, file)}`] = await sha256File(file);
               }
             };
             try {
-              await visit(import_node_path30.default.join(packageRoot, "dist"));
+              await visit(import_node_path31.default.join(packageRoot, "dist"));
               hashes[`installed:${name}:package.json`] = await sha256File(
-                import_node_path30.default.join(packageRoot, "package.json")
+                import_node_path31.default.join(packageRoot, "package.json")
               );
             } catch (error) {
               if (error.code !== "ENOENT") throw error;
             }
           }
           return {
-            sourceRoot: await import_promises35.default.realpath(sourceRepositoryRoot),
-            projectRoot: await import_promises35.default.realpath(projectRoot18),
+            sourceRoot: await import_promises36.default.realpath(sourceRepositoryRoot),
+            projectRoot: await import_promises36.default.realpath(projectRoot18),
             sourceGitSha: git(["rev-parse", "HEAD"]).trim(),
             sourceDiffSha256: sha256Json(git(["diff", "--binary", "HEAD"])),
             sourceUntrackedSha256: sha256Json(untrackedHashes),
@@ -36934,8 +37053,8 @@ var init_native = __esm({
             projectRoot18,
             `data/research/strategy/${spec.core.researchId}`
           );
-          await import_promises35.default.writeFile(
-            import_node_path30.default.join(directory, "source.patch"),
+          await import_promises36.default.writeFile(
+            import_node_path31.default.join(directory, "source.patch"),
             (0, import_node_child_process8.execFileSync)("git", ["diff", "--binary", "HEAD"], {
               cwd: sourceRepositoryRoot,
               maxBuffer: 32 * 1024 * 1024
@@ -36948,7 +37067,7 @@ var init_native = __esm({
               "--format=tar",
               "HEAD",
               "--output",
-              import_node_path30.default.join(directory, "source-baseline.tar")
+              import_node_path31.default.join(directory, "source-baseline.tar")
             ],
             { cwd: sourceRepositoryRoot }
           );
@@ -36969,7 +37088,7 @@ var init_native = __esm({
                 "Untracked credentials cannot be archived as research source"
               );
             const file = await boundResearchPath(sourceRepositoryRoot, relative);
-            const content = await import_promises35.default.readFile(file);
+            const content = await import_promises36.default.readFile(file);
             sourceBytes += content.length;
             if (sourceBytes > 32 * 1024 * 1024)
               throw new Error("Untracked source archive exceeds 32 MiB");
@@ -36980,7 +37099,7 @@ var init_native = __esm({
             });
           }
           await writeJsonAtomic(
-            import_node_path30.default.join(directory, "source-untracked.json"),
+            import_node_path31.default.join(directory, "source-untracked.json"),
             sourceFiles
           );
           const models = /* @__PURE__ */ new Map();
@@ -36988,7 +37107,7 @@ var init_native = __esm({
             const jev = (0, import_jev6.parseJevConfig)(variant.resolvedConfig.JEV);
             if (jev?.source !== "local") continue;
             const file = await boundResearchPath(projectRoot18, jev.modelFile);
-            const bytes = await import_promises35.default.readFile(file);
+            const bytes = await import_promises36.default.readFile(file);
             if (bytes.length > 32 * 1024 * 1024 || await sha256File(file) !== jev.modelSha256)
               throw new Error("Frozen local Jev model size/checksum mismatch");
             validateResearchJevTraining(
@@ -37002,7 +37121,7 @@ var init_native = __esm({
             });
           }
           if (models.size)
-            await writeJsonAtomic(import_node_path30.default.join(directory, "source-jev-models.json"), [
+            await writeJsonAtomic(import_node_path31.default.join(directory, "source-jev-models.json"), [
               ...models.values()
             ]);
           const coverage = [];
@@ -37050,7 +37169,7 @@ var init_native = __esm({
             };
           }
           assertResources(spec);
-          await import_promises35.default.mkdir(directory, { recursive: true });
+          await import_promises36.default.mkdir(directory, { recursive: true });
           const config2 = nativeConfig(spec, variant);
           const jev = (0, import_jev6.parseJevConfig)(config2.JEV);
           if (jev?.source === "provider")
@@ -37083,17 +37202,17 @@ var init_native = __esm({
           const grid = Object.fromEntries(
             Object.entries(config2).map(([key3, value]) => [key3, [value]])
           );
-          const key2 = import_redis18.redisKeys.backtestConfig("root", configName);
-          const existing = await (0, import_redis18.getData)(key2, null);
+          const key2 = import_redis19.redisKeys.backtestConfig("root", configName);
+          const existing = await (0, import_redis19.getData)(key2, null);
           if (existing != null && sha256Json(existing) !== sha256Json(grid))
             throw new Error(`Frozen research config changed: ${configName}`);
-          if (existing == null) await (0, import_redis18.setData)(key2, grid, { expire: 0 });
+          if (existing == null) await (0, import_redis19.setData)(key2, grid, { expire: 0 });
           let runId = previousRunId ?? "";
           const common = {
             executable: process.execPath,
             cwd: projectRoot18,
             timeoutMs: spec.budget.maxMinutes * 6e4,
-            processReceipt: import_node_path30.default.join(directory, "native-process.json"),
+            processReceipt: import_node_path31.default.join(directory, "native-process.json"),
             env: {
               PROJECT_CWD: projectRoot18,
               TRADEJS_SOURCE_REPOSITORY_ROOT: sourceRepositoryRoot,
@@ -37111,7 +37230,7 @@ var init_native = __esm({
           if (previousManifest?.status !== "completed")
             await runResearchCommand({
               ...common,
-              log: import_node_path30.default.join(directory, "backtest.log"),
+              log: import_node_path31.default.join(directory, "backtest.log"),
               args: [
                 cliPath,
                 "backtest",
@@ -37168,13 +37287,13 @@ var init_native = __esm({
             userName: "root"
           });
           if (completed.length === manifest.testSuite.length && completed.every((entry) => Number(entry.result.stat.orders) === 0)) {
-            const empty = import_node_path30.default.join(directory, "verified-empty.jsonl");
-            await import_promises35.default.writeFile(empty, "");
+            const empty = import_node_path31.default.join(directory, "verified-empty.jsonl");
+            await import_promises36.default.writeFile(empty, "");
             files.push(empty);
           } else
             await runResearchCommand({
               ...common,
-              log: import_node_path30.default.join(directory, "export.log"),
+              log: import_node_path31.default.join(directory, "export.log"),
               args: [
                 cliPath,
                 "ai-export",
@@ -37189,7 +37308,7 @@ var init_native = __esm({
               ],
               onLine: (line) => {
                 const match = line.match(/^part\d+:\s+(.+)$/);
-                if (match) files.push(import_node_path30.default.resolve(projectRoot18, match[1].trim()));
+                if (match) files.push(import_node_path31.default.resolve(projectRoot18, match[1].trim()));
               }
             });
           if (!files.length)
@@ -37205,7 +37324,7 @@ var init_native = __esm({
             configSha256: sha256Json(config2)
           };
           await writeJsonAtomic(
-            import_node_path30.default.join(directory, "sources.json"),
+            import_node_path31.default.join(directory, "sources.json"),
             Object.fromEntries(
               await Promise.all(
                 files.map(async (file) => [file, await sha256File(file)])
@@ -37250,7 +37369,7 @@ var init_native = __esm({
             )
           });
           await writeJsonAtomic(
-            import_node_path30.default.join(directory, "reconciliation.json"),
+            import_node_path31.default.join(directory, "reconciliation.json"),
             reconciliation
           );
           if (reconciliation.status !== "match")
@@ -37469,12 +37588,12 @@ var init_native = __esm({
           const traceFiles = variant.runId ? await (0, import_coreResearch2.listCoreResearchTraceFiles)({
             strategyName: spec.core.strategy,
             runId: variant.runId,
-            outDir: import_node_path30.default.join(projectRoot18, "data/research/core/trace")
+            outDir: import_node_path31.default.join(projectRoot18, "data/research/core/trace")
           }) : [];
           const funnel2 = traceFiles.length ? await summarizeCoreResearchTrace(traceFiles) : null;
           if (variant.configName === `${spec.core.strategy}:auto-${spec.core.researchId}-${variant.id}`)
             await writeJsonAtomic(
-              import_node_path30.default.join(directory, "payloads.json"),
+              import_node_path31.default.join(directory, "payloads.json"),
               Object.fromEntries(
                 await Promise.all(
                   traceFiles.map(async (file) => [file, await sha256File(file)])
@@ -37521,17 +37640,17 @@ var strategyResearch_exports = {};
 __export(strategyResearch_exports, {
   main: () => main38
 });
-var import_promises36, import_node_path31, import_redis19, usage, main38;
+var import_promises37, import_node_path32, import_redis20, usage, main38;
 var init_strategyResearch2 = __esm({
   "src/scripts/strategyResearch.ts"() {
     "use strict";
-    import_promises36 = __toESM(require("fs/promises"));
-    import_node_path31 = __toESM(require("path"));
+    import_promises37 = __toESM(require("fs/promises"));
+    import_node_path32 = __toESM(require("path"));
     init_strategyResearch();
     init_researchRoots();
     init_io();
     init_orchestrator();
-    import_redis19 = require("@tradejs/infra/redis");
+    import_redis20 = require("@tradejs/infra/redis");
     init_io2();
     usage = `Usage:
   tradejs research:strategy init --coreSpec <core-spec.json> --out <workflow.json>
@@ -37584,7 +37703,7 @@ Revalidate keeps the frozen rule and evaluates a new period without fitting.
       const resolve = (key2) => boundResearchPath(projectRoot18, required4(key2));
       if (command === "init") {
         const output = await resolve("--out");
-        await import_promises36.default.mkdir(import_node_path31.default.dirname(output), { recursive: true });
+        await import_promises37.default.mkdir(import_node_path32.default.dirname(output), { recursive: true });
         const timestamp = (key2) => {
           const text3 = required4(key2);
           const value = /^\d+$/.test(text3) ? Number(text3) : Date.parse(text3);
@@ -37619,8 +37738,8 @@ Revalidate keeps the frozen rule and evaluates a new period without fitting.
                 throw new Error(
                   "Every config must belong to the selected strategy"
                 );
-              const grid = await (0, import_redis19.getData)(
-                import_redis19.redisKeys.backtestConfig("root", configName),
+              const grid = await (0, import_redis20.getData)(
+                import_redis20.redisKeys.backtestConfig("root", configName),
                 null
               );
               if (!grid || typeof grid !== "object" || Array.isArray(grid) || !Object.keys(grid).length)
@@ -37661,7 +37780,7 @@ Revalidate keeps the frozen rule and evaluates a new period without fitting.
         const spec2 = validateStrategyResearchSpec(
           createStrategyResearchSpec(loaded.spec)
         );
-        await import_promises36.default.writeFile(output, `${JSON.stringify(spec2, null, 2)}
+        await import_promises37.default.writeFile(output, `${JSON.stringify(spec2, null, 2)}
 `, {
           flag: "wx"
         });
@@ -37676,7 +37795,7 @@ Revalidate keeps the frozen rule and evaluates a new period without fitting.
       const directory = researchDirectory(projectRoot18, spec);
       if (command === "status") {
         const state = await readJson(
-          import_node_path31.default.join(directory, "state.json")
+          import_node_path32.default.join(directory, "state.json")
         );
         console.log(
           JSON.stringify(
@@ -37684,9 +37803,9 @@ Revalidate keeps the frozen rule and evaluates a new period without fitting.
               status: state.status,
               stages: state.stages,
               error: state.error,
-              report: import_node_path31.default.join(directory, "report.html"),
+              report: import_node_path32.default.join(directory, "report.html"),
               retention: await readJson(
-                import_node_path31.default.join(directory, "retention-status.json")
+                import_node_path32.default.join(directory, "retention-status.json")
               ).catch((error) => {
                 if (error.code === "ENOENT") return { status: "not-started" };
                 throw error;
@@ -37700,7 +37819,7 @@ Revalidate keeps the frozen rule and evaluates a new period without fitting.
       }
       if (command === "verify" || command === "revalidate") {
         const state = await readJson(
-          import_node_path31.default.join(directory, "state.json")
+          import_node_path32.default.join(directory, "state.json")
         );
         await verifyCompletedResearch(directory, state);
         if (command === "verify") {
@@ -37735,8 +37854,8 @@ Revalidate keeps the frozen rule and evaluates a new period without fitting.
           }
         });
         const output = await resolve("--out");
-        await import_promises36.default.mkdir(import_node_path31.default.dirname(output), { recursive: true });
-        await import_promises36.default.writeFile(output, `${JSON.stringify(next, null, 2)}
+        await import_promises37.default.mkdir(import_node_path32.default.dirname(output), { recursive: true });
+        await import_promises37.default.writeFile(output, `${JSON.stringify(next, null, 2)}
 `, {
           flag: "wx"
         });
@@ -37760,7 +37879,7 @@ __export(results_exports, {
   main: () => main39,
   results: () => results
 });
-var import_args26, import_chalk42, import_connectors16, import_cli11, import_redis20, ListIt4, flags24, MIN_PROFIT, MIN_WIN_RATE, MIN_ORDERS_PER_MONTH, createListIt4, formatPercent4, getMonthlyReturn, toStrategyResultEntry, toStrategyResults, getTestConfigs, buildBestResults, getSavedProfitsBySymbol, getCoverageRow, results, main39;
+var import_args26, import_chalk42, import_connectors16, import_cli11, import_redis21, ListIt4, flags24, MIN_PROFIT, MIN_WIN_RATE, MIN_ORDERS_PER_MONTH, createListIt4, formatPercent4, getMonthlyReturn, toStrategyResultEntry, toStrategyResults, getTestConfigs, buildBestResults, getSavedProfitsBySymbol, getCoverageRow, results, main39;
 var init_results = __esm({
   "src/scripts/results.ts"() {
     "use strict";
@@ -37768,7 +37887,7 @@ var init_results = __esm({
     import_chalk42 = __toESM(require("chalk"));
     import_connectors16 = require("@tradejs/connectors");
     import_cli11 = require("@tradejs/node/cli");
-    import_redis20 = require("@tradejs/infra/redis");
+    import_redis21 = require("@tradejs/infra/redis");
     ListIt4 = require("list-it");
     import_args26.default.example(
       "yarn results --strategy TrendLine --coverage",
@@ -37808,8 +37927,8 @@ var init_results = __esm({
       [...rows].map((row) => [row.symbol, toStrategyResultEntry(row)])
     );
     getTestConfigs = async (userName3) => {
-      const testSummariesKey = typeof import_redis20.redisKeys.testSummaries === "function" ? import_redis20.redisKeys.testSummaries(userName3) : null;
-      const indexedItems = testSummariesKey ? await (0, import_redis20.getData)(testSummariesKey, null) : null;
+      const testSummariesKey = typeof import_redis21.redisKeys.testSummaries === "function" ? import_redis21.redisKeys.testSummaries(userName3) : null;
+      const indexedItems = testSummariesKey ? await (0, import_redis21.getData)(testSummariesKey, null) : null;
       if (Array.isArray(indexedItems) && indexedItems.length) {
         return indexedItems.map((item) => {
           const testName = typeof item?.value === "string" ? item.value : null;
@@ -37820,8 +37939,8 @@ var init_results = __esm({
           return { strategyName, testName };
         }).filter(Boolean);
       }
-      const testsPrefix = import_redis20.redisKeys.tests(userName3);
-      const keys = await (0, import_redis20.getKeys)(testsPrefix);
+      const testsPrefix = import_redis21.redisKeys.tests(userName3);
+      const keys = await (0, import_redis21.getKeys)(testsPrefix);
       const configKeys = keys.filter((key2) => key2.endsWith(":config"));
       return configKeys.map((key2) => {
         const parts = key2.split(":");
@@ -37840,15 +37959,15 @@ var init_results = __esm({
         testName,
         strategyName: strategyFromIndex
       } of testConfigs) {
-        const config2 = await (0, import_redis20.getData)(
-          import_redis20.redisKeys.testConfig(userName3, strategyFromIndex, testName),
+        const config2 = await (0, import_redis21.getData)(
+          import_redis21.redisKeys.testConfig(userName3, strategyFromIndex, testName),
           null
         );
         if (!config2 || config2.strategyName !== strategyName) {
           continue;
         }
-        const stat = await (0, import_redis20.getData)(
-          import_redis20.redisKeys.testStat(userName3, strategyFromIndex, testName),
+        const stat = await (0, import_redis21.getData)(
+          import_redis21.redisKeys.testStat(userName3, strategyFromIndex, testName),
           null
         );
         if (!stat) {
@@ -37893,8 +38012,8 @@ var init_results = __esm({
       return savedProfitBySymbol;
     };
     getCoverageRow = async (strategyName, userName3, goodSymbols) => {
-      const currentResults = await (0, import_redis20.getData)(
-        import_redis20.redisKeys.strategyResults(userName3, strategyName),
+      const currentResults = await (0, import_redis21.getData)(
+        import_redis21.redisKeys.strategyResults(userName3, strategyName),
         {}
       );
       const existingSymbols = new Set(Object.keys(currentResults));
@@ -37928,8 +38047,8 @@ var init_results = __esm({
       const strategyName = flags24.strategy;
       const userName3 = flags24.user;
       if (flags24.clear) {
-        const cleared = await (0, import_redis20.delKey)(
-          import_redis20.redisKeys.strategyResults(userName3, strategyName)
+        const cleared = await (0, import_redis21.delKey)(
+          import_redis21.redisKeys.strategyResults(userName3, strategyName)
         );
         console.log(
           cleared ? import_chalk42.default.green(`Cleared results:${strategyName}`) : import_chalk42.default.yellow(`No results to clear for ${strategyName}`)
@@ -37977,8 +38096,8 @@ var init_results = __esm({
             console.log(import_chalk42.default.yellow("No good results to merge."));
             process.exit(0);
           }
-          const current = await (0, import_redis20.getData)(
-            import_redis20.redisKeys.strategyResults(userName3, strategyName),
+          const current = await (0, import_redis21.getData)(
+            import_redis21.redisKeys.strategyResults(userName3, strategyName),
             {}
           );
           const savedProfitBySymbol = await getSavedProfitsBySymbol(current);
@@ -38000,7 +38119,7 @@ var init_results = __esm({
             ...current,
             ...toStrategyResults(updates)
           };
-          await (0, import_redis20.setData)(import_redis20.redisKeys.strategyResults(userName3, strategyName), merged, {
+          await (0, import_redis21.setData)(import_redis21.redisKeys.strategyResults(userName3, strategyName), merged, {
             expire: 0
           });
           if (flags24.verbose) {
@@ -38041,8 +38160,8 @@ var init_results = __esm({
           );
           process.exit(0);
         }
-        await (0, import_redis20.setData)(
-          import_redis20.redisKeys.strategyResults(userName3, strategyName),
+        await (0, import_redis21.setData)(
+          import_redis21.redisKeys.strategyResults(userName3, strategyName),
           resultsConfig,
           {
             expire: 0
@@ -38061,11 +38180,11 @@ var init_results = __esm({
 });
 
 // src/lib/runtimeDebugEvidence.ts
-var import_redis21, RUNTIME_DEBUG_TIMEZONE, RUNTIME_DEBUG_TIMEZONE_LABEL, formatRuntimeDebugDateTime, getRuntimeDebugDateParts, formatRuntimeDebugIsoDayKey, buildRuntimeDebugEvaluationId, filterByStrategies, collectRuntimeDebugEvidence, buildRuntimeDebugReportPayload, buildRuntimeEvidenceReportPayload, buildRuntimeDebugReportAttachment;
+var import_redis22, RUNTIME_DEBUG_TIMEZONE, RUNTIME_DEBUG_TIMEZONE_LABEL, formatRuntimeDebugDateTime, getRuntimeDebugDateParts, formatRuntimeDebugIsoDayKey, buildRuntimeDebugEvaluationId, filterByStrategies, collectRuntimeDebugEvidence, buildRuntimeDebugReportPayload, buildRuntimeEvidenceReportPayload, buildRuntimeDebugReportAttachment;
 var init_runtimeDebugEvidence = __esm({
   "src/lib/runtimeDebugEvidence.ts"() {
     "use strict";
-    import_redis21 = require("@tradejs/infra/redis");
+    import_redis22 = require("@tradejs/infra/redis");
     init_runtimeRedis();
     init_runtimeSignalsLoader();
     init_runtimeSignalsStorage();
@@ -38172,24 +38291,24 @@ var init_runtimeDebugEvidence = __esm({
           const tradeDayKey = (0, import_time5.getRuntimeStorageDayKey)(trade.entryTimestamp);
           const signalDayKey = signal != null ? (0, import_time5.getRuntimeStorageDayKey)(signal.timestamp) : tradeDayKey;
           const evaluationDayKey = knownEvaluation != null ? (0, import_time5.getRuntimeStorageDayKey)(knownEvaluation.timestamp) : signalDayKey;
-          const tradeKey = import_redis21.redisKeys.runtimeTrade(userName3, trade.orderId);
-          const tradeBucketKey = import_redis21.redisKeys.runtimeTradeBucket(
+          const tradeKey = import_redis22.redisKeys.runtimeTrade(userName3, trade.orderId);
+          const tradeBucketKey = import_redis22.redisKeys.runtimeTradeBucket(
             userName3,
             tradeDayKey
           );
-          const activeTradeKey = import_redis21.redisKeys.runtimeActiveTrade(
+          const activeTradeKey = import_redis22.redisKeys.runtimeActiveTrade(
             userName3,
             trade.symbol,
             trade.deploymentId ?? trade.accountId
           );
-          const signalKey = trade.signalId != null ? import_redis21.redisKeys.storeSignal(trade.symbol, trade.signalId) : null;
-          const evaluationBucketKey = import_redis21.redisKeys.runtimeSignalEvaluationBucket(
+          const signalKey = trade.signalId != null ? import_redis22.redisKeys.storeSignal(trade.symbol, trade.signalId) : null;
+          const evaluationBucketKey = import_redis22.redisKeys.runtimeSignalEvaluationBucket(
             userName3,
             evaluationDayKey,
             knownEvaluation?.strategy ?? trade.strategy
           );
           const evaluationField = knownEvaluation?.evaluationId ?? evaluationId;
-          const evaluationKey = import_redis21.redisKeys.runtimeSignalEvaluation(
+          const evaluationKey = import_redis22.redisKeys.runtimeSignalEvaluation(
             userName3,
             evaluationField
           );
@@ -38200,11 +38319,11 @@ var init_runtimeDebugEvidence = __esm({
             directEvaluationValue,
             bucketEvaluationValue
           ] = await Promise.all([
-            (0, import_redis21.getData)(tradeKey, null),
-            (0, import_redis21.getData)(activeTradeKey, null),
-            signalKey ? (0, import_redis21.getData)(signalKey, null) : Promise.resolve(null),
-            (0, import_redis21.getData)(evaluationKey, null),
-            knownEvaluation ? Promise.resolve(knownEvaluation) : (0, import_redis21.getHashJsonField)(
+            (0, import_redis22.getData)(tradeKey, null),
+            (0, import_redis22.getData)(activeTradeKey, null),
+            signalKey ? (0, import_redis22.getData)(signalKey, null) : Promise.resolve(null),
+            (0, import_redis22.getData)(evaluationKey, null),
+            knownEvaluation ? Promise.resolve(knownEvaluation) : (0, import_redis22.getHashJsonField)(
               evaluationBucketKey,
               evaluationField,
               null
@@ -38261,12 +38380,12 @@ var init_runtimeDebugEvidence = __esm({
           dayKeys
         },
         redisPrefixes: {
-          runtimeTrades: import_redis21.redisKeys.runtimeTrades(userName3),
-          runtimeTradeBuckets: import_redis21.redisKeys.runtimeTradeBuckets(userName3),
-          runtimeActiveTrades: import_redis21.redisKeys.runtimeActiveTrades(userName3),
-          runtimeSignals: import_redis21.redisKeys.runtimeSignalBuckets(userName3),
-          runtimeSignalEvaluations: import_redis21.redisKeys.runtimeSignalEvaluationBuckets(userName3),
-          runtimeSignalEvaluationStats: import_redis21.redisKeys.runtimeSignalEvaluationStatsBuckets(userName3)
+          runtimeTrades: import_redis22.redisKeys.runtimeTrades(userName3),
+          runtimeTradeBuckets: import_redis22.redisKeys.runtimeTradeBuckets(userName3),
+          runtimeActiveTrades: import_redis22.redisKeys.runtimeActiveTrades(userName3),
+          runtimeSignals: import_redis22.redisKeys.runtimeSignalBuckets(userName3),
+          runtimeSignalEvaluations: import_redis22.redisKeys.runtimeSignalEvaluationBuckets(userName3),
+          runtimeSignalEvaluationStats: import_redis22.redisKeys.runtimeSignalEvaluationStatsBuckets(userName3)
         },
         counts: {
           trades: trades.length,
@@ -38277,18 +38396,18 @@ var init_runtimeDebugEvidence = __esm({
         },
         trades: debugTrades,
         signals: signals2.map((signal) => ({
-          redisKey: import_redis21.redisKeys.storeSignal(signal.symbol, signal.signalId),
+          redisKey: import_redis22.redisKeys.storeSignal(signal.symbol, signal.signalId),
           signal
         })),
         evaluations: reportEvaluations.map((evaluation) => ({
           redisDebug: {
-            key: import_redis21.redisKeys.runtimeSignalEvaluationBucket(
+            key: import_redis22.redisKeys.runtimeSignalEvaluationBucket(
               userName3,
               (0, import_time5.getRuntimeStorageDayKey)(evaluation.timestamp),
               evaluation.strategy
             ),
             field: evaluation.evaluationId,
-            directKey: import_redis21.redisKeys.runtimeSignalEvaluation(
+            directKey: import_redis22.redisKeys.runtimeSignalEvaluation(
               userName3,
               evaluation.evaluationId
             )
@@ -38353,17 +38472,17 @@ __export(replayRuntimeEvidence_exports, {
   replayRuntimeEvidence: () => replayRuntimeEvidence,
   summarizeReplayComparison: () => summarizeReplayComparison
 });
-var import_promises37, import_node_path32, import_args27, import_chalk43, import_redis22, toEpochMs2, resolveWindow, parseStrategyFilter, asRecord5, asArray2, sum, groupCount, compactMatched, resolveItemStrategy, summarizeReplayComparison, loadReplayResult, getReplayStrategies, loadRuntimePayload, replayRuntimeEvidence, main40;
+var import_promises38, import_node_path33, import_args27, import_chalk43, import_redis23, toEpochMs2, resolveWindow, parseStrategyFilter, asRecord5, asArray2, sum, groupCount, compactMatched, resolveItemStrategy, summarizeReplayComparison, loadReplayResult, getReplayStrategies, loadRuntimePayload, replayRuntimeEvidence, main40;
 var init_replayRuntimeEvidence = __esm({
   "src/scripts/replayRuntimeEvidence.ts"() {
     "use strict";
     init_jsonFile();
     init_memoryProfile();
-    import_promises37 = __toESM(require("fs/promises"));
-    import_node_path32 = __toESM(require("path"));
+    import_promises38 = __toESM(require("fs/promises"));
+    import_node_path33 = __toESM(require("path"));
     import_args27 = __toESM(require("args"));
     import_chalk43 = __toESM(require("chalk"));
-    import_redis22 = require("@tradejs/infra/redis");
+    import_redis23 = require("@tradejs/infra/redis");
     init_runtimeDebugEvidence();
     init_support2();
     import_args27.default.option(["u", "user"], "Use user config", "root");
@@ -38586,18 +38705,18 @@ var init_replayRuntimeEvidence = __esm({
         return {
           key: replayKey,
           availableKeys: void 0,
-          value: await (0, import_redis22.getData)(replayKey, null)
+          value: await (0, import_redis23.getData)(replayKey, null)
         };
       }
-      const prefix = import_redis22.redisKeys.backtestResults(userName3, REPLAY_RESULTS_CONFIG, "");
-      const keys = (await (0, import_redis22.getKeys)(prefix)).sort(
+      const prefix = import_redis23.redisKeys.backtestResults(userName3, REPLAY_RESULTS_CONFIG, "");
+      const keys = (await (0, import_redis23.getKeys)(prefix)).sort(
         (left, right) => left.localeCompare(right)
       );
       const key2 = keys[keys.length - 1] ?? null;
       return {
         key: key2,
         availableKeys: keys.slice(-10),
-        value: key2 ? await (0, import_redis22.getData)(key2, null) : null
+        value: key2 ? await (0, import_redis23.getData)(key2, null) : null
       };
     };
     getReplayStrategies = (replayValue) => {
@@ -38622,10 +38741,10 @@ var init_replayRuntimeEvidence = __esm({
       runtimeEvidenceFile,
       projectRoot: projectRoot18
     }) => {
-      const runtimeEvidencePath = typeof runtimeEvidenceFile === "string" && runtimeEvidenceFile.trim() ? import_node_path32.default.resolve(projectRoot18, runtimeEvidenceFile.trim()) : null;
+      const runtimeEvidencePath = typeof runtimeEvidenceFile === "string" && runtimeEvidenceFile.trim() ? import_node_path33.default.resolve(projectRoot18, runtimeEvidenceFile.trim()) : null;
       if (runtimeEvidencePath) {
         const artifact = JSON.parse(
-          await import_promises37.default.readFile(runtimeEvidencePath, "utf8")
+          await import_promises38.default.readFile(runtimeEvidencePath, "utf8")
         );
         return {
           source: "file",
@@ -38711,8 +38830,8 @@ var init_replayRuntimeEvidence = __esm({
         },
         runtime: runtime.payload
       };
-      const outPath = import_node_path32.default.resolve(projectRoot18, String(flags36.out));
-      await import_promises37.default.mkdir(import_node_path32.default.dirname(outPath), { recursive: true });
+      const outPath = import_node_path33.default.resolve(projectRoot18, String(flags36.out));
+      await import_promises38.default.mkdir(import_node_path33.default.dirname(outPath), { recursive: true });
       const memory = createReplayMemoryProfile();
       memory?.("evidence:write:start");
       await writeReplayJsonFile(outPath, artifact);
@@ -38756,14 +38875,14 @@ var init_runtimeFeedbackArtifacts = __esm({
 });
 
 // src/lib/runtimeFeedbackReplay.ts
-var import_node_child_process9, import_promises38, import_node_path33, import_mcp2, REQUIRED_ENV, FORBIDDEN_SECRET_ENV, unsafeRedisHosts, safeSegment, assertRuntimeFeedbackReplaySafety, buildRuntimeFeedbackReplayCommands, runLoggedCommand, runRuntimeFeedbackReplay;
+var import_node_child_process9, import_promises39, import_node_path34, import_mcp3, REQUIRED_ENV, FORBIDDEN_SECRET_ENV, unsafeRedisHosts, safeSegment, assertRuntimeFeedbackReplaySafety, buildRuntimeFeedbackReplayCommands, runLoggedCommand, runRuntimeFeedbackReplay;
 var init_runtimeFeedbackReplay = __esm({
   "src/lib/runtimeFeedbackReplay.ts"() {
     "use strict";
     import_node_child_process9 = require("child_process");
-    import_promises38 = __toESM(require("fs/promises"));
-    import_node_path33 = __toESM(require("path"));
-    import_mcp2 = require("@tradejs/node/mcp");
+    import_promises39 = __toESM(require("fs/promises"));
+    import_node_path34 = __toESM(require("path"));
+    import_mcp3 = require("@tradejs/node/mcp");
     init_runtimeEvidenceDeployment();
     init_runtimeEvidenceArtifacts();
     init_runtimeEvidenceProducer();
@@ -38898,7 +39017,7 @@ var init_runtimeFeedbackReplay = __esm({
       logHandle
     }) => {
       await logHandle.writeFile(
-        "\n" + (0, import_mcp2.formatMcpArtifactLogLine)(`$ ${[executable, ...command].join(" ")}`)
+        "\n" + (0, import_mcp3.formatMcpArtifactLogLine)(`$ ${[executable, ...command].join(" ")}`)
       );
       const child = (0, import_node_child_process9.spawn)(executable, command, {
         cwd,
@@ -38921,7 +39040,7 @@ var init_runtimeFeedbackReplay = __esm({
       let pendingLogWrite = Promise.resolve();
       const copyLog = async (input, output) => {
         const writeLine2 = async (line) => {
-          const formatted = (0, import_mcp2.formatMcpArtifactLogLine)(line);
+          const formatted = (0, import_mcp3.formatMcpArtifactLogLine)(line);
           pendingLogWrite = pendingLogWrite.then(
             () => logHandle.writeFile(formatted)
           );
@@ -38964,9 +39083,9 @@ var init_runtimeFeedbackReplay = __esm({
         throw new Error("Cannot resolve the TradeJS CLI executable path");
       }
       const runtimeEvidenceBundle = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(
-        import_node_path33.default.dirname(runtimeEvidencePath)
+        import_node_path34.default.dirname(runtimeEvidencePath)
       );
-      if (import_node_path33.default.resolve(runtimeEvidenceBundle.payloadPath) !== runtimeEvidencePath) {
+      if (import_node_path34.default.resolve(runtimeEvidenceBundle.payloadPath) !== runtimeEvidencePath) {
         throw new Error(
           `Runtime evidence must be the verified bundle payload: ${runtimeEvidenceBundle.payloadPath}`
         );
@@ -38993,16 +39112,16 @@ var init_runtimeFeedbackReplay = __esm({
       if (!intervals.size) {
         throw new Error("Runtime feedback replay requires an active interval");
       }
-      await import_promises38.default.mkdir(outDir, { recursive: true });
-      const existing = await import_promises38.default.readdir(outDir);
+      await import_promises39.default.mkdir(outDir, { recursive: true });
+      const existing = await import_promises39.default.readdir(outDir);
       if (existing.length) {
         throw new Error(
           `Runtime feedback output directory must be empty: ${outDir}`
         );
       }
-      const replayEvidencePath = import_node_path33.default.join(outDir, runtimeFeedbackArtifacts_exports.RUNTIME_FEEDBACK_REPLAY_FILE);
-      const logHandle = await import_promises38.default.open(
-        import_node_path33.default.join(outDir, runtimeFeedbackArtifacts_exports.RUNTIME_FEEDBACK_LOG_FILE),
+      const replayEvidencePath = import_node_path34.default.join(outDir, runtimeFeedbackArtifacts_exports.RUNTIME_FEEDBACK_REPLAY_FILE);
+      const logHandle = await import_promises39.default.open(
+        import_node_path34.default.join(outDir, runtimeFeedbackArtifacts_exports.RUNTIME_FEEDBACK_LOG_FILE),
         "wx"
       );
       const commands = buildRuntimeFeedbackReplayCommands({
@@ -39044,11 +39163,11 @@ __export(runtimeFeedbackReplay_exports, {
   main: () => main41,
   runtimeFeedbackReplay: () => runtimeFeedbackReplay
 });
-var import_node_path34, import_args28, import_chalk44, flags25, projectRoot9, runtimeFeedbackReplay, main41;
+var import_node_path35, import_args28, import_chalk44, flags25, projectRoot9, runtimeFeedbackReplay, main41;
 var init_runtimeFeedbackReplay2 = __esm({
   "src/scripts/runtimeFeedbackReplay.ts"() {
     "use strict";
-    import_node_path34 = __toESM(require("path"));
+    import_node_path35 = __toESM(require("path"));
     import_args28 = __toESM(require("args"));
     import_chalk44 = __toESM(require("chalk"));
     init_runtimeFeedbackReplay();
@@ -39066,8 +39185,8 @@ var init_runtimeFeedbackReplay2 = __esm({
         );
       }
       const verified = await runRuntimeFeedbackReplay({
-        runtimeEvidencePath: import_node_path34.default.resolve(projectRoot9, runtimeEvidence2),
-        outDir: import_node_path34.default.resolve(projectRoot9, outDir),
+        runtimeEvidencePath: import_node_path35.default.resolve(projectRoot9, runtimeEvidence2),
+        outDir: import_node_path35.default.resolve(projectRoot9, outDir),
         runId: String(flags25.runId ?? "").trim() || void 0,
         projectRoot: projectRoot9
       });
@@ -39229,11 +39348,11 @@ __export(runtimeFeedbackNotify_exports, {
   main: () => main42,
   runtimeFeedbackNotify: () => runtimeFeedbackNotify
 });
-var import_node_path35, import_args29, import_chalk45, flags26, projectRoot10, runtimeFeedbackNotify, main42;
+var import_node_path36, import_args29, import_chalk45, flags26, projectRoot10, runtimeFeedbackNotify, main42;
 var init_runtimeFeedbackNotify = __esm({
   "src/scripts/runtimeFeedbackNotify.ts"() {
     "use strict";
-    import_node_path35 = __toESM(require("path"));
+    import_node_path36 = __toESM(require("path"));
     import_args29 = __toESM(require("args"));
     import_chalk45 = __toESM(require("chalk"));
     init_runtimeFeedbackNotification();
@@ -39247,7 +39366,7 @@ var init_runtimeFeedbackNotify = __esm({
       if (!bundle) {
         throw new Error("Provide --bundle for runtime feedback notification.");
       }
-      const bundleDir = import_node_path35.default.resolve(projectRoot10, bundle);
+      const bundleDir = import_node_path36.default.resolve(projectRoot10, bundle);
       if (flags26.dryRun) {
         const verified = await (0, runtimeFeedbackArtifacts_exports.verifyRuntimeFeedbackReplayBundle)(bundleDir);
         console.log(buildRuntimeFeedbackTelegramMessage(verified.replayEvidence));
@@ -40060,13 +40179,13 @@ ${reactions}
 });
 
 // src/lib/runtimeEvidenceSync.ts
-var import_node_child_process10, import_promises39, import_node_path36, import_node_util2, execFileAsync2, isExistingDestinationError, safeSegment2, withTrailingSlash, dateParts, buildRuntimeEvidenceRsyncArgs, receiptPath, compareBundles, listPendingRuntimeEvidenceBundles, markRuntimeEvidenceBundleProcessed, syncRuntimeEvidenceBundles;
+var import_node_child_process10, import_promises40, import_node_path37, import_node_util2, execFileAsync2, isExistingDestinationError, safeSegment2, withTrailingSlash, dateParts, buildRuntimeEvidenceRsyncArgs, receiptPath, compareBundles, listPendingRuntimeEvidenceBundles, markRuntimeEvidenceBundleProcessed, syncRuntimeEvidenceBundles;
 var init_runtimeEvidenceSync = __esm({
   "src/lib/runtimeEvidenceSync.ts"() {
     "use strict";
     import_node_child_process10 = require("child_process");
-    import_promises39 = __toESM(require("fs/promises"));
-    import_node_path36 = __toESM(require("path"));
+    import_promises40 = __toESM(require("fs/promises"));
+    import_node_path37 = __toESM(require("path"));
     import_node_util2 = require("util");
     init_runtimeEvidenceArtifacts();
     init_runtimeEvidenceDeployment();
@@ -40100,15 +40219,15 @@ var init_runtimeEvidenceSync = __esm({
       withTrailingSlash(source),
       withTrailingSlash(destination)
     ];
-    receiptPath = (receiptsRoot, artifactId) => import_node_path36.default.join(receiptsRoot, `${safeSegment2(artifactId, "artifact")}.json`);
+    receiptPath = (receiptsRoot, artifactId) => import_node_path37.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_path36.default.join(evidenceRoot, "artifacts", safeDeploymentId);
-      const receiptsRoot = import_node_path36.default.join(evidenceRoot, "receipts", safeDeploymentId);
+      const artifactsRoot = import_node_path37.default.join(evidenceRoot, "artifacts", safeDeploymentId);
+      const receiptsRoot = import_node_path37.default.join(evidenceRoot, "receipts", safeDeploymentId);
       const bundles = await (0, runtimeEvidenceArtifacts_exports.discoverRuntimeEvidenceBundles)(artifactsRoot);
       const pending = [];
       for (const bundleDir of bundles) {
@@ -40116,7 +40235,7 @@ var init_runtimeEvidenceSync = __esm({
         if (verified.manifest.deploymentId !== safeDeploymentId) continue;
         (0, runtimeEvidenceDeployment_exports.assertCurrentRuntimeEvidenceArtifact)(verified.artifact);
         try {
-          await import_promises39.default.access(receiptPath(receiptsRoot, verified.manifest.artifactId));
+          await import_promises40.default.access(receiptPath(receiptsRoot, verified.manifest.artifactId));
           continue;
         } catch (error) {
           if (error.code !== "ENOENT") throw error;
@@ -40139,7 +40258,7 @@ var init_runtimeEvidenceSync = __esm({
           `Artifact deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
         );
       }
-      const receiptsRoot = import_node_path36.default.join(evidenceRoot, "receipts", safeDeploymentId);
+      const receiptsRoot = import_node_path37.default.join(evidenceRoot, "receipts", safeDeploymentId);
       const finalPath = receiptPath(receiptsRoot, verified.manifest.artifactId);
       const temporaryPath = `${finalPath}.tmp-${process.pid}`;
       const receipt = {
@@ -40153,14 +40272,14 @@ var init_runtimeEvidenceSync = __esm({
           replayEvidenceSha256: runtimeFeedback.replayEvidenceSha256
         } : {}
       };
-      await import_promises39.default.mkdir(receiptsRoot, { recursive: true });
-      await import_promises39.default.writeFile(
+      await import_promises40.default.mkdir(receiptsRoot, { recursive: true });
+      await import_promises40.default.writeFile(
         temporaryPath,
         `${JSON.stringify(receipt, null, 2)}
 `,
         "utf8"
       );
-      await import_promises39.default.rename(temporaryPath, finalPath);
+      await import_promises40.default.rename(temporaryPath, finalPath);
       return finalPath;
     };
     syncRuntimeEvidenceBundles = async ({
@@ -40175,11 +40294,11 @@ var init_runtimeEvidenceSync = __esm({
       }
     }) => {
       const safeDeploymentId = safeSegment2(deploymentId, "production");
-      const inboxRoot = import_node_path36.default.join(evidenceRoot, "inbox", safeDeploymentId);
-      const artifactsRoot = import_node_path36.default.join(evidenceRoot, "artifacts", safeDeploymentId);
+      const inboxRoot = import_node_path37.default.join(evidenceRoot, "inbox", safeDeploymentId);
+      const artifactsRoot = import_node_path37.default.join(evidenceRoot, "artifacts", safeDeploymentId);
       await Promise.all([
-        import_promises39.default.mkdir(inboxRoot, { recursive: true }),
-        import_promises39.default.mkdir(artifactsRoot, { recursive: true })
+        import_promises40.default.mkdir(inboxRoot, { recursive: true }),
+        import_promises40.default.mkdir(artifactsRoot, { recursive: true })
       ]);
       const rsyncArgs = buildRuntimeEvidenceRsyncArgs({
         source,
@@ -40196,14 +40315,14 @@ var init_runtimeEvidenceSync = __esm({
           );
         }
         (0, runtimeEvidenceDeployment_exports.assertCurrentRuntimeEvidenceArtifact)(verified.artifact);
-        const destinationDir = import_node_path36.default.join(
+        const destinationDir = import_node_path37.default.join(
           artifactsRoot,
           ...dateParts(verified.manifest.window.endTime),
           safeSegment2(verified.manifest.artifactId, "artifact")
         );
-        await import_promises39.default.mkdir(import_node_path36.default.dirname(destinationDir), { recursive: true });
+        await import_promises40.default.mkdir(import_node_path37.default.dirname(destinationDir), { recursive: true });
         try {
-          await import_promises39.default.rename(bundleDir, destinationDir);
+          await import_promises40.default.rename(bundleDir, destinationDir);
         } catch (error) {
           if (!isExistingDestinationError(error)) throw error;
           const existing = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(destinationDir);
@@ -40212,7 +40331,7 @@ var init_runtimeEvidenceSync = __esm({
               `Conflicting runtime evidence artifact ${verified.manifest.artifactId}`
             );
           }
-          await import_promises39.default.rm(bundleDir, { recursive: true, force: true });
+          await import_promises40.default.rm(bundleDir, { recursive: true, force: true });
         }
         received.push(await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(destinationDir));
       }
@@ -40232,14 +40351,14 @@ var init_runtimeEvidenceSync = __esm({
 });
 
 // src/lib/runtimeFeedbackProcess.ts
-var import_promises40, import_node_path37, import_node_crypto21, import_diagnostics2, processRuntimeFeedbackPair;
+var import_promises41, import_node_path38, import_node_crypto20, import_diagnostics3, processRuntimeFeedbackPair;
 var init_runtimeFeedbackProcess = __esm({
   "src/lib/runtimeFeedbackProcess.ts"() {
     "use strict";
-    import_promises40 = __toESM(require("fs/promises"));
-    import_node_path37 = __toESM(require("path"));
-    import_node_crypto21 = require("crypto");
-    import_diagnostics2 = require("@tradejs/node/diagnostics");
+    import_promises41 = __toESM(require("fs/promises"));
+    import_node_path38 = __toESM(require("path"));
+    import_node_crypto20 = require("crypto");
+    import_diagnostics3 = require("@tradejs/node/diagnostics");
     init_executionCalibration();
     init_runtimeScorecard();
     init_runtimeEvidenceSync();
@@ -40250,16 +40369,16 @@ var init_runtimeFeedbackProcess = __esm({
       outputRoot,
       historyDir
     }) => {
-      const { runtimeEvidence: runtimeEvidence2, feedback } = await (0, import_diagnostics2.verifyRuntimeFeedbackReplaySource)(
+      const { runtimeEvidence: runtimeEvidence2, feedback } = await (0, import_diagnostics3.verifyRuntimeFeedbackReplaySource)(
         { bundleDir: replayDir, runtimeEvidenceBundleDir: runtimeDir }
       );
       const { artifactId, deploymentId } = runtimeEvidence2.manifest;
-      const snapshot = (0, import_diagnostics2.parseRuntimeEvidenceDeploymentSnapshot)(
+      const snapshot = (0, import_diagnostics3.parseRuntimeEvidenceDeploymentSnapshot)(
         runtimeEvidence2.artifact.deployment
       );
       if (!snapshot)
         throw new Error("Runtime evidence requires a deployment snapshot");
-      const strategies = (0, import_diagnostics2.activeRuntimeEvidenceStrategies)(snapshot);
+      const strategies = (0, import_diagnostics3.activeRuntimeEvidenceStrategies)(snapshot);
       for (const segment of [
         artifactId,
         deploymentId,
@@ -40268,17 +40387,17 @@ var init_runtimeFeedbackProcess = __esm({
         if (!/^[A-Za-z0-9._:-]+$/.test(segment) || segment === "." || segment === "..")
           throw new Error("Invalid feedback output path identity");
       }
-      const receiptPath2 = import_node_path37.default.join(
+      const receiptPath2 = import_node_path38.default.join(
         evidenceRoot,
         "receipts",
         deploymentId,
         `${artifactId}.json`
       );
-      await import_promises40.default.mkdir(import_node_path37.default.dirname(receiptPath2), { recursive: true });
+      await import_promises41.default.mkdir(import_node_path38.default.dirname(receiptPath2), { recursive: true });
       const lock = receiptPath2 + ".processing";
-      await import_promises40.default.mkdir(lock);
+      await import_promises41.default.mkdir(lock);
       try {
-        const previous = await import_promises40.default.readFile(receiptPath2, "utf8").catch((error) => {
+        const previous = await import_promises41.default.readFile(receiptPath2, "utf8").catch((error) => {
           if (error.code !== "ENOENT") throw error;
           return null;
         });
@@ -40286,7 +40405,7 @@ var init_runtimeFeedbackProcess = __esm({
           const receipt = JSON.parse(previous);
           if (!receipt || typeof receipt !== "object" || !("schemaVersion" in receipt) || receipt.schemaVersion !== 2 || !("payloadSha256" in receipt) || !("runtimeFeedbackArtifactId" in receipt) || !("replayEvidenceSha256" in receipt) || !("scorecardPath" in receipt) || receipt.payloadSha256 !== runtimeEvidence2.manifest.payload.sha256 || receipt.runtimeFeedbackArtifactId !== feedback.manifest.artifactId || receipt.replayEvidenceSha256 !== feedback.manifest.payloads.replayEvidence.sha256 || typeof receipt.scorecardPath !== "string")
             throw new Error("Processing receipt conflicts with the exact pair");
-          await import_promises40.default.access(receipt.scorecardPath);
+          await import_promises41.default.access(receipt.scorecardPath);
           return {
             processed: false,
             receiptPath: receiptPath2,
@@ -40295,17 +40414,17 @@ var init_runtimeFeedbackProcess = __esm({
         }
         const history = [];
         if (historyDir)
-          for (const directory of await (0, import_diagnostics2.discoverRuntimeEvidenceBundles)(historyDir))
-            history.push((await (0, import_diagnostics2.verifyRuntimeEvidenceBundle)(directory)).artifact);
-        const runId = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:.]/g, "") + "-" + (0, import_node_crypto21.randomUUID)();
-        const runDir = import_node_path37.default.join(outputRoot, artifactId, runId);
-        await import_promises40.default.mkdir(runDir, { recursive: true });
+          for (const directory of await (0, import_diagnostics3.discoverRuntimeEvidenceBundles)(historyDir))
+            history.push((await (0, import_diagnostics3.verifyRuntimeEvidenceBundle)(directory)).artifact);
+        const runId = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:.]/g, "") + "-" + (0, import_node_crypto20.randomUUID)();
+        const runDir = import_node_path38.default.join(outputRoot, artifactId, runId);
+        await import_promises41.default.mkdir(runDir, { recursive: true });
         const calibration = buildExecutionCalibrationReport({
           runtimeArtifact: runtimeEvidence2.artifact,
           replayEvidenceArtifact: feedback.replayEvidence
         });
-        await import_promises40.default.writeFile(
-          import_node_path37.default.join(runDir, "execution-calibration.json"),
+        await import_promises41.default.writeFile(
+          import_node_path38.default.join(runDir, "execution-calibration.json"),
           JSON.stringify(calibration, null, 2)
         );
         const inputs = {
@@ -40316,21 +40435,21 @@ var init_runtimeFeedbackProcess = __esm({
         };
         for (const strategy of [...strategies.map((s) => s.strategyName), null]) {
           const scorecard = buildRuntimeScorecard({ ...inputs, strategy });
-          const base = import_node_path37.default.join(
+          const base = import_node_path38.default.join(
             runDir,
             strategy ? `runtime-scorecard-${strategy}` : "runtime-scorecard"
           );
-          await import_promises40.default.writeFile(base + ".json", JSON.stringify(scorecard, null, 2));
-          await import_promises40.default.writeFile(
+          await import_promises41.default.writeFile(base + ".json", JSON.stringify(scorecard, null, 2));
+          await import_promises41.default.writeFile(
             base + ".md",
             formatRuntimeScorecardMarkdown(scorecard)
           );
         }
-        await (0, import_diagnostics2.verifyRuntimeFeedbackReplaySource)({
+        await (0, import_diagnostics3.verifyRuntimeFeedbackReplaySource)({
           bundleDir: replayDir,
           runtimeEvidenceBundleDir: runtimeDir
         });
-        const scorecardPath = import_node_path37.default.join(runDir, "runtime-scorecard.json");
+        const scorecardPath = import_node_path38.default.join(runDir, "runtime-scorecard.json");
         await markRuntimeEvidenceBundleProcessed({
           evidenceRoot,
           deploymentId,
@@ -40343,7 +40462,7 @@ var init_runtimeFeedbackProcess = __esm({
         });
         return { processed: true, receiptPath: receiptPath2, scorecardPath };
       } finally {
-        await import_promises40.default.rmdir(lock);
+        await import_promises41.default.rmdir(lock);
       }
     };
   }
@@ -40354,12 +40473,12 @@ var runtimeFeedbackProcess_exports = {};
 __export(runtimeFeedbackProcess_exports, {
   main: () => main43
 });
-var import_args30, import_node_path38, flags27, main43;
+var import_args30, import_node_path39, flags27, main43;
 var init_runtimeFeedbackProcess2 = __esm({
   "src/scripts/runtimeFeedbackProcess.ts"() {
     "use strict";
     import_args30 = __toESM(require("args"));
-    import_node_path38 = __toESM(require("path"));
+    import_node_path39 = __toESM(require("path"));
     init_runtimeFeedbackProcess();
     import_args30.default.option(
       "runtimeDir",
@@ -40382,11 +40501,11 @@ var init_runtimeFeedbackProcess2 = __esm({
       console.log(
         JSON.stringify(
           await processRuntimeFeedbackPair({
-            runtimeDir: import_node_path38.default.resolve(root, String(flags27.runtimeDir)),
-            replayDir: import_node_path38.default.resolve(root, String(flags27.replayDir)),
-            evidenceRoot: import_node_path38.default.join(root, "data/runtime-evidence"),
-            outputRoot: import_node_path38.default.join(root, "output/runtime-feedback"),
-            historyDir: import_node_path38.default.resolve(root, String(flags27.historyDir))
+            runtimeDir: import_node_path39.default.resolve(root, String(flags27.runtimeDir)),
+            replayDir: import_node_path39.default.resolve(root, String(flags27.replayDir)),
+            evidenceRoot: import_node_path39.default.join(root, "data/runtime-evidence"),
+            outputRoot: import_node_path39.default.join(root, "output/runtime-feedback"),
+            historyDir: import_node_path39.default.resolve(root, String(flags27.historyDir))
           })
         )
       );
@@ -40395,13 +40514,13 @@ var init_runtimeFeedbackProcess2 = __esm({
 });
 
 // src/lib/runtimeFeedbackSync.ts
-var import_node_child_process11, import_promises41, import_node_path39, import_node_util3, execFileAsync3, isExistingDestinationError2, safeSegment3, dateParts2, syncRuntimeFeedbackReplayBundles;
+var import_node_child_process11, import_promises42, import_node_path40, import_node_util3, execFileAsync3, isExistingDestinationError2, safeSegment3, dateParts2, syncRuntimeFeedbackReplayBundles;
 var init_runtimeFeedbackSync = __esm({
   "src/lib/runtimeFeedbackSync.ts"() {
     "use strict";
     import_node_child_process11 = require("child_process");
-    import_promises41 = __toESM(require("fs/promises"));
-    import_node_path39 = __toESM(require("path"));
+    import_promises42 = __toESM(require("fs/promises"));
+    import_node_path40 = __toESM(require("path"));
     import_node_util3 = require("util");
     init_runtimeFeedbackArtifacts();
     init_runtimeEvidenceSync();
@@ -40434,11 +40553,11 @@ var init_runtimeFeedbackSync = __esm({
       }
     }) => {
       const safeDeploymentId = safeSegment3(deploymentId, "production");
-      const inboxRoot = import_node_path39.default.join(feedbackRoot, "inbox", safeDeploymentId);
-      const artifactsRoot = import_node_path39.default.join(feedbackRoot, "artifacts", safeDeploymentId);
+      const inboxRoot = import_node_path40.default.join(feedbackRoot, "inbox", safeDeploymentId);
+      const artifactsRoot = import_node_path40.default.join(feedbackRoot, "artifacts", safeDeploymentId);
       await Promise.all([
-        import_promises41.default.mkdir(inboxRoot, { recursive: true }),
-        import_promises41.default.mkdir(artifactsRoot, { recursive: true })
+        import_promises42.default.mkdir(inboxRoot, { recursive: true }),
+        import_promises42.default.mkdir(artifactsRoot, { recursive: true })
       ]);
       const rsyncArgs = buildRuntimeEvidenceRsyncArgs({
         source,
@@ -40454,15 +40573,15 @@ var init_runtimeFeedbackSync = __esm({
             `Runtime feedback deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
           );
         }
-        const destinationDir = import_node_path39.default.join(
+        const destinationDir = import_node_path40.default.join(
           artifactsRoot,
           ...dateParts2(verified.manifest.window.endTime),
           safeSegment3(verified.manifest.runtimeEvidence.artifactId, "artifact"),
           safeSegment3(verified.manifest.runId, "run")
         );
-        await import_promises41.default.mkdir(import_node_path39.default.dirname(destinationDir), { recursive: true });
+        await import_promises42.default.mkdir(import_node_path40.default.dirname(destinationDir), { recursive: true });
         try {
-          await import_promises41.default.rename(bundleDir, destinationDir);
+          await import_promises42.default.rename(bundleDir, destinationDir);
         } catch (error) {
           if (!isExistingDestinationError2(error)) throw error;
           const existing = await (0, runtimeFeedbackArtifacts_exports.verifyRuntimeFeedbackReplayBundle)(destinationDir);
@@ -40471,7 +40590,7 @@ var init_runtimeFeedbackSync = __esm({
               `Conflicting runtime feedback replay ${verified.manifest.artifactId}`
             );
           }
-          await import_promises41.default.rm(bundleDir, { recursive: true, force: true });
+          await import_promises42.default.rm(bundleDir, { recursive: true, force: true });
         }
         received.push(await (0, runtimeFeedbackArtifacts_exports.verifyRuntimeFeedbackReplayBundle)(destinationDir));
       }
@@ -40491,11 +40610,11 @@ __export(runtimeFeedbackSync_exports, {
   main: () => main44,
   runtimeFeedbackSync: () => runtimeFeedbackSync
 });
-var import_node_path40, import_args31, import_chalk46, flags28, projectRoot11, runtimeFeedbackSync, main44;
+var import_node_path41, import_args31, import_chalk46, flags28, projectRoot11, runtimeFeedbackSync, main44;
 var init_runtimeFeedbackSync2 = __esm({
   "src/scripts/runtimeFeedbackSync.ts"() {
     "use strict";
-    import_node_path40 = __toESM(require("path"));
+    import_node_path41 = __toESM(require("path"));
     import_args31 = __toESM(require("args"));
     import_chalk46 = __toESM(require("chalk"));
     init_runtimeFeedbackSync();
@@ -40523,7 +40642,7 @@ var init_runtimeFeedbackSync2 = __esm({
           "Provide --source or RUNTIME_FEEDBACK_RSYNC_SOURCE for runtime feedback sync."
         );
       }
-      const feedbackRoot = import_node_path40.default.resolve(projectRoot11, String(flags28.dir));
+      const feedbackRoot = import_node_path41.default.resolve(projectRoot11, String(flags28.dir));
       const result = await syncRuntimeFeedbackReplayBundles({
         source,
         feedbackRoot,
@@ -40555,13 +40674,13 @@ var init_runtimeFeedbackSync2 = __esm({
 });
 
 // src/lib/runtimeEvidenceCompositionSnapshots.ts
-var import_node_crypto22, import_promises42, import_node_path41, SNAPSHOT_FILE, MANIFEST_FILE, COMPLETE_FILE, createRuntimeEvidenceCompositionSnapshotRecorder, isRecord2, sha256, safeSegment4, isExistingDestinationError3, parseManifest, verifyRuntimeEvidenceCompositionSnapshot, sameSnapshot, publishRuntimeEvidenceCompositionSnapshot, captureRuntimeEvidenceCompositionSnapshot, discoverRuntimeEvidenceCompositionSnapshots;
+var import_node_crypto21, import_promises43, import_node_path42, 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_crypto22 = require("crypto");
-    import_promises42 = __toESM(require("fs/promises"));
-    import_node_path41 = __toESM(require("path"));
+    import_node_crypto21 = require("crypto");
+    import_promises43 = __toESM(require("fs/promises"));
+    import_node_path42 = __toESM(require("path"));
     init_runtimeEvidenceDeployment();
     init_runtimeEvidenceProducer();
     SNAPSHOT_FILE = "snapshot.json";
@@ -40582,7 +40701,7 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
       };
     };
     isRecord2 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
-    sha256 = (value) => (0, import_node_crypto22.createHash)("sha256").update(value).digest("hex");
+    sha256 = (value) => (0, import_node_crypto21.createHash)("sha256").update(value).digest("hex");
     safeSegment4 = (value, label) => {
       const normalized = value.trim();
       if (!normalized || !/^[a-zA-Z0-9._:-]+$/.test(normalized)) {
@@ -40604,9 +40723,9 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
     };
     verifyRuntimeEvidenceCompositionSnapshot = async (bundleDir) => {
       const [manifestText, payload, completeText] = await Promise.all([
-        import_promises42.default.readFile(import_node_path41.default.join(bundleDir, MANIFEST_FILE), "utf8"),
-        import_promises42.default.readFile(import_node_path41.default.join(bundleDir, SNAPSHOT_FILE)),
-        import_promises42.default.readFile(import_node_path41.default.join(bundleDir, COMPLETE_FILE), "utf8")
+        import_promises43.default.readFile(import_node_path42.default.join(bundleDir, MANIFEST_FILE), "utf8"),
+        import_promises43.default.readFile(import_node_path42.default.join(bundleDir, SNAPSHOT_FILE)),
+        import_promises43.default.readFile(import_node_path42.default.join(bundleDir, COMPLETE_FILE), "utf8")
       ]);
       const manifest = parseManifest(JSON.parse(manifestText));
       if (completeText.trim() !== manifest.deploymentCompositionId) {
@@ -40669,39 +40788,39 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
           bytes: Buffer.byteLength(payload)
         }
       };
-      const snapshotsRoot = import_node_path41.default.join(evidenceRoot, "snapshots", deploymentId);
-      const bundleDir = import_node_path41.default.join(snapshotsRoot, compositionId);
-      const temporaryDir = import_node_path41.default.join(
+      const snapshotsRoot = import_node_path42.default.join(evidenceRoot, "snapshots", deploymentId);
+      const bundleDir = import_node_path42.default.join(snapshotsRoot, compositionId);
+      const temporaryDir = import_node_path42.default.join(
         evidenceRoot,
         "incoming",
-        `snapshot-${compositionId}.tmp-${(0, import_node_crypto22.randomUUID)()}`
+        `snapshot-${compositionId}.tmp-${(0, import_node_crypto21.randomUUID)()}`
       );
-      await import_promises42.default.mkdir(temporaryDir, { recursive: true });
+      await import_promises43.default.mkdir(temporaryDir, { recursive: true });
       try {
         await Promise.all([
-          import_promises42.default.writeFile(import_node_path41.default.join(temporaryDir, SNAPSHOT_FILE), payload, "utf8"),
-          import_promises42.default.writeFile(
-            import_node_path41.default.join(temporaryDir, MANIFEST_FILE),
+          import_promises43.default.writeFile(import_node_path42.default.join(temporaryDir, SNAPSHOT_FILE), payload, "utf8"),
+          import_promises43.default.writeFile(
+            import_node_path42.default.join(temporaryDir, MANIFEST_FILE),
             `${JSON.stringify(manifest, null, 2)}
 `,
             "utf8"
           )
         ]);
-        await import_promises42.default.writeFile(
-          import_node_path41.default.join(temporaryDir, COMPLETE_FILE),
+        await import_promises43.default.writeFile(
+          import_node_path42.default.join(temporaryDir, COMPLETE_FILE),
           `${compositionId}
 `,
           "utf8"
         );
-        await import_promises42.default.mkdir(snapshotsRoot, { recursive: true });
+        await import_promises43.default.mkdir(snapshotsRoot, { recursive: true });
         try {
-          await import_promises42.default.rename(temporaryDir, bundleDir);
+          await import_promises43.default.rename(temporaryDir, bundleDir);
         } catch (error) {
           if (!isExistingDestinationError3(error)) throw error;
-          await import_promises42.default.rm(temporaryDir, { recursive: true, force: true });
+          await import_promises43.default.rm(temporaryDir, { recursive: true, force: true });
         }
       } catch (error) {
-        await import_promises42.default.rm(temporaryDir, { recursive: true, force: true });
+        await import_promises43.default.rm(temporaryDir, { recursive: true, force: true });
         throw error;
       }
       const verified = await verifyRuntimeEvidenceCompositionSnapshot(bundleDir);
@@ -40735,31 +40854,31 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
         );
       }
       await publishRuntimeEvidenceCompositionSnapshot({
-        evidenceRoot: import_node_path41.default.join(projectRoot18, "data", "runtime-evidence"),
+        evidenceRoot: import_node_path42.default.join(projectRoot18, "data", "runtime-evidence"),
         userName: userName3,
         deployment,
         producer
       });
     };
     discoverRuntimeEvidenceCompositionSnapshots = async (evidenceRoot) => {
-      const rootDir = import_node_path41.default.join(evidenceRoot, "snapshots");
+      const rootDir = import_node_path42.default.join(evidenceRoot, "snapshots");
       const bundleDirs = [];
       let deployments;
       try {
-        deployments = await import_promises42.default.readdir(rootDir, { withFileTypes: true });
+        deployments = await import_promises43.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_path41.default.join(rootDir, deployment.name);
-        const compositions = await import_promises42.default.readdir(deploymentDir, {
+        const deploymentDir = import_node_path42.default.join(rootDir, deployment.name);
+        const compositions = await import_promises43.default.readdir(deploymentDir, {
           withFileTypes: true
         });
         bundleDirs.push(
           ...compositions.filter(
             (entry) => entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.includes(".tmp-")
-          ).map((entry) => import_node_path41.default.join(deploymentDir, entry.name))
+          ).map((entry) => import_node_path42.default.join(deploymentDir, entry.name))
         );
       }
       return Promise.all(
@@ -40960,12 +41079,12 @@ __export(runtimeEvidence_exports, {
   main: () => main45,
   runtimeEvidence: () => runtimeEvidence
 });
-var import_promises43, import_node_path42, import_args32, import_chalk47, flags29, projectRoot12, toEpochMs3, resolveWindow2, parseStrategyFilter2, runtimeEvidence, main45;
+var import_promises44, import_node_path43, import_args32, import_chalk47, flags29, projectRoot12, toEpochMs3, resolveWindow2, parseStrategyFilter2, runtimeEvidence, main45;
 var init_runtimeEvidence = __esm({
   "src/scripts/runtimeEvidence.ts"() {
     "use strict";
-    import_promises43 = __toESM(require("fs/promises"));
-    import_node_path42 = __toESM(require("path"));
+    import_promises44 = __toESM(require("fs/promises"));
+    import_node_path43 = __toESM(require("path"));
     import_args32 = __toESM(require("args"));
     import_chalk47 = __toESM(require("chalk"));
     init_runtimeDebugEvidence();
@@ -41072,7 +41191,7 @@ var init_runtimeEvidence = __esm({
         deploymentId
       });
       const snapshots = publishDir && producer ? await loadRuntimeEvidenceCompositionSnapshots({
-        publishRoot: import_node_path42.default.resolve(projectRoot12, publishDir),
+        publishRoot: import_node_path43.default.resolve(projectRoot12, publishDir),
         currentDeployment: deploymentSnapshot,
         currentProducer: producer
       }) : /* @__PURE__ */ new Map([
@@ -41146,14 +41265,14 @@ var init_runtimeEvidence = __esm({
         throw new Error("Runtime evidence window has no versioned runtime rows");
       }
       const artifact = current.artifact;
-      const outPath = import_node_path42.default.resolve(projectRoot12, String(flags29.out));
-      await import_promises43.default.mkdir(import_node_path42.default.dirname(outPath), { recursive: true });
-      await import_promises43.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
+      const outPath = import_node_path43.default.resolve(projectRoot12, String(flags29.out));
+      await import_promises44.default.mkdir(import_node_path43.default.dirname(outPath), { recursive: true });
+      await import_promises44.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_path42.default.resolve(projectRoot12, publishDir),
+            publishRoot: import_node_path43.default.resolve(projectRoot12, publishDir),
             deploymentId,
             userName: String(flags29.user),
             startTime,
@@ -41199,11 +41318,11 @@ __export(runtimeEvidenceSync_exports, {
   main: () => main46,
   runtimeEvidenceSync: () => runtimeEvidenceSync
 });
-var import_node_path43, import_args33, import_chalk48, flags30, projectRoot13, runtimeEvidenceSync, main46;
+var import_node_path44, import_args33, import_chalk48, flags30, projectRoot13, runtimeEvidenceSync, main46;
 var init_runtimeEvidenceSync2 = __esm({
   "src/scripts/runtimeEvidenceSync.ts"() {
     "use strict";
-    import_node_path43 = __toESM(require("path"));
+    import_node_path44 = __toESM(require("path"));
     import_args33 = __toESM(require("args"));
     import_chalk48 = __toESM(require("chalk"));
     init_runtimeEvidenceSync();
@@ -41231,7 +41350,7 @@ var init_runtimeEvidenceSync2 = __esm({
           "Provide --source or RUNTIME_EVIDENCE_RSYNC_SOURCE for runtime evidence sync."
         );
       }
-      const evidenceRoot = import_node_path43.default.resolve(projectRoot13, String(flags30.dir));
+      const evidenceRoot = import_node_path44.default.resolve(projectRoot13, String(flags30.dir));
       const result = await syncRuntimeEvidenceBundles({
         source,
         evidenceRoot,
@@ -41488,7 +41607,7 @@ async function collectReleaseEvidenceReferences(references) {
       let artifact;
       try {
         const parsed = JSON.parse(
-          await import_promises44.default.readFile(reference.path, "utf8")
+          await import_promises45.default.readFile(reference.path, "utf8")
         );
         assert3(
           parsed != null && typeof parsed === "object" && !Array.isArray(parsed),
@@ -41641,13 +41760,13 @@ async function collectReleaseEvidenceReferences(references) {
     })
   );
 }
-var import_node_crypto23, import_promises44, import_node_path44, import_types9, import_strategyReleaseEvidence3, SHA256_RE3, 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_crypto22, import_promises45, import_node_path45, import_types9, import_strategyReleaseEvidence3, SHA256_RE3, 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_crypto23 = require("crypto");
-    import_promises44 = __toESM(require("fs/promises"));
-    import_node_path44 = __toESM(require("path"));
+    import_node_crypto22 = require("crypto");
+    import_promises45 = __toESM(require("fs/promises"));
+    import_node_path45 = __toESM(require("path"));
     import_types9 = require("@tradejs/types");
     import_strategyReleaseEvidence3 = require("@tradejs/infra/strategyReleaseEvidence");
     init_liveDiagnosis();
@@ -41666,11 +41785,11 @@ var init_strategyRelease = __esm({
       const artifact = input.chartArtifact;
       if (!artifact?.path || !SHA256_RE3.test(artifact.sha256)) return false;
       try {
-        const artifactPath = import_node_path44.default.resolve(artifact.path);
+        const artifactPath = import_node_path45.default.resolve(artifact.path);
         if (await (0, import_strategyReleaseEvidence3.strategyEvidenceFileSha256)(artifactPath) !== artifact.sha256) {
           return false;
         }
-        const report = JSON.parse(await import_promises44.default.readFile(artifactPath, "utf8"));
+        const report = JSON.parse(await import_promises45.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
         );
@@ -41681,11 +41800,11 @@ var init_strategyRelease = __esm({
     readVerifiedJsonArtifact = async (artifact) => {
       if (!artifact?.path || !SHA256_RE3.test(artifact.sha256)) return null;
       try {
-        const artifactPath = import_node_path44.default.resolve(artifact.path);
+        const artifactPath = import_node_path45.default.resolve(artifact.path);
         if (await (0, import_strategyReleaseEvidence3.strategyEvidenceFileSha256)(artifactPath) !== artifact.sha256) {
           return null;
         }
-        return JSON.parse(await import_promises44.default.readFile(artifactPath, "utf8"));
+        return JSON.parse(await import_promises45.default.readFile(artifactPath, "utf8"));
       } catch {
         return null;
       }
@@ -42231,7 +42350,7 @@ var init_strategyRelease = __esm({
       manifest
     });
     verifyStrategyReleaseEnvelope = async (valueOrPath) => {
-      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises44.default.readFile(valueOrPath, "utf8")) : valueOrPath;
+      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises45.default.readFile(valueOrPath, "utf8")) : valueOrPath;
       const envelope = value;
       assert3(
         envelope?.schema === "tradejs-strategy-release-envelope/v1",
@@ -42282,7 +42401,7 @@ var init_strategyRelease = __esm({
       return envelope;
     };
     verifyStrategyEvidenceMarkerEnvelope = async (valueOrPath) => {
-      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises44.default.readFile(valueOrPath, "utf8")) : valueOrPath;
+      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises45.default.readFile(valueOrPath, "utf8")) : valueOrPath;
       return (0, import_strategyReleaseEvidence3.verifyStrategyEvidenceMarkerEnvelope)(value);
     };
     releaseMarkers = (manifest) => {
@@ -42344,14 +42463,14 @@ var init_strategyRelease = __esm({
     };
     writeJsonAtomic2 = async (filePath, value) => {
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-      await import_promises44.default.mkdir(import_node_path44.default.dirname(filePath), { recursive: true });
-      await import_promises44.default.writeFile(
+      await import_promises45.default.mkdir(import_node_path45.default.dirname(filePath), { recursive: true });
+      await import_promises45.default.writeFile(
         temporaryPath,
         `${canonicalStrategyReleaseJson(value)}
 `,
         "utf8"
       );
-      await import_promises44.default.rename(temporaryPath, filePath);
+      await import_promises45.default.rename(temporaryPath, filePath);
     };
     publishStrategyRelease = async ({
       rootDir,
@@ -42368,13 +42487,13 @@ var init_strategyRelease = __esm({
           path: entry.path
         }))
       });
-      const releasePath = import_node_path44.default.join(
+      const releasePath = import_node_path45.default.join(
         rootDir,
         "releases",
         safeSegment5(manifest.strategy, "strategy"),
         `${manifest.releaseId}.json`
       );
-      const markerPath = import_node_path44.default.join(
+      const markerPath = import_node_path45.default.join(
         rootDir,
         "markers",
         safeSegment5(manifest.strategy, "strategy"),
@@ -42454,13 +42573,13 @@ var init_strategyRelease = __esm({
         markers,
         sourceArtifacts
       });
-      const diagnosisPath = import_node_path44.default.join(
+      const diagnosisPath = import_node_path45.default.join(
         rootDir,
         "diagnoses",
         safeSegment5(diagnosis.strategy, "strategy"),
         `${diagnosisId}.json`
       );
-      const markerPath = import_node_path44.default.join(
+      const markerPath = import_node_path45.default.join(
         rootDir,
         "markers",
         safeSegment5(diagnosis.strategy, "strategy"),
@@ -42650,11 +42769,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_path44.default.dirname(resultPath);
-      const manifestPath = import_node_path44.default.join(researchDir, "manifest.json");
-      const specPath = import_node_path44.default.join(researchDir, "spec.json");
-      const manifestBytes = await import_promises44.default.readFile(manifestPath).catch(() => null);
-      const specBytes = await import_promises44.default.readFile(specPath).catch(() => null);
+      const researchDir = import_node_path45.default.dirname(resultPath);
+      const manifestPath = import_node_path45.default.join(researchDir, "manifest.json");
+      const specPath = import_node_path45.default.join(researchDir, "spec.json");
+      const manifestBytes = await import_promises45.default.readFile(manifestPath).catch(() => null);
+      const specBytes = await import_promises45.default.readFile(specPath).catch(() => null);
       assert3(
         manifestBytes != null && specBytes != null,
         "core result must belong to a completed core research bundle"
@@ -42663,14 +42782,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_crypto23.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_crypto22.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_path44.default.isAbsolute(relativePath) && !relativePath.split(/[\\/]/).includes(".."),
+          !import_node_path45.default.isAbsolute(relativePath) && !relativePath.split(/[\\/]/).includes(".."),
           `core bundle artifact ${relativePath} escapes its research directory`
         );
         assert3(
@@ -42678,7 +42797,7 @@ var init_strategyRelease = __esm({
           `core bundle artifact ${relativePath} has an invalid checksum`
         );
         const actualSha256 = await (0, import_strategyReleaseEvidence3.strategyEvidenceFileSha256)(
-          import_node_path44.default.join(researchDir, relativePath)
+          import_node_path45.default.join(researchDir, relativePath)
         );
         assert3(
           actualSha256 === expectedSha256,
@@ -42695,13 +42814,13 @@ __export(runtimeScorecard_exports, {
   main: () => main47,
   runtimeScorecard: () => runtimeScorecard
 });
-var import_promises45, import_node_crypto24, import_node_path45, import_args34, import_chalk49, flags31, projectRoot14, resolveOptionalPath, readJson2, assertReportType, sha256File2, loadHistoryArtifacts, runtimeScorecard, main47;
+var import_promises46, import_node_crypto23, import_node_path46, import_args34, import_chalk49, flags31, projectRoot14, resolveOptionalPath, readJson2, assertReportType, sha256File2, loadHistoryArtifacts, runtimeScorecard, main47;
 var init_runtimeScorecard2 = __esm({
   "src/scripts/runtimeScorecard.ts"() {
     "use strict";
-    import_promises45 = __toESM(require("fs/promises"));
-    import_node_crypto24 = require("crypto");
-    import_node_path45 = __toESM(require("path"));
+    import_promises46 = __toESM(require("fs/promises"));
+    import_node_crypto23 = require("crypto");
+    import_node_path46 = __toESM(require("path"));
     import_args34 = __toESM(require("args"));
     import_chalk49 = __toESM(require("chalk"));
     init_runtimeEvidenceArtifacts();
@@ -42771,15 +42890,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_path45.default.resolve(projectRoot14, raw) : null;
+      return raw ? import_node_path46.default.resolve(projectRoot14, raw) : null;
     };
-    readJson2 = async (filePath) => filePath ? JSON.parse(await import_promises45.default.readFile(filePath, "utf8")) : void 0;
+    readJson2 = async (filePath) => filePath ? JSON.parse(await import_promises46.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_crypto24.createHash)("sha256").update(await import_promises45.default.readFile(filePath)).digest("hex");
+    sha256File2 = async (filePath) => (0, import_node_crypto23.createHash)("sha256").update(await import_promises46.default.readFile(filePath)).digest("hex");
     loadHistoryArtifacts = async (historyDir) => {
       if (!historyDir) return [];
       const bundleDirs = await (0, runtimeEvidenceArtifacts_exports.discoverRuntimeEvidenceBundles)(historyDir);
@@ -42850,13 +42969,13 @@ var init_runtimeScorecard2 = __esm({
         strategy: scorecardStrategy,
         llmComparatorPolicy: verifiedRelease?.manifest.prospective.llmComparatorPolicy ?? "ai_approved_only"
       });
-      const outPath = import_node_path45.default.resolve(projectRoot14, String(flags31.out));
+      const outPath = import_node_path46.default.resolve(projectRoot14, String(flags31.out));
       const markdownPath = outPath.replace(/\.json$/i, "") + ".md";
-      await import_promises45.default.mkdir(import_node_path45.default.dirname(outPath), { recursive: true });
+      await import_promises46.default.mkdir(import_node_path46.default.dirname(outPath), { recursive: true });
       await Promise.all([
-        import_promises45.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
+        import_promises46.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
 `, "utf8"),
-        import_promises45.default.writeFile(
+        import_promises46.default.writeFile(
           markdownPath,
           formatRuntimeScorecardMarkdown(scorecard),
           "utf8"
@@ -42870,7 +42989,7 @@ var init_runtimeScorecard2 = __esm({
       const diagnosisPath = diagnosis ? outPath.replace(/\.json$/i, "") + ".diagnosis.json" : null;
       const strategyReleaseRoot = resolveOptionalPath(flags31.strategyReleaseRoot);
       if (diagnosis && diagnosisPath) {
-        await import_promises45.default.writeFile(
+        await import_promises46.default.writeFile(
           diagnosisPath,
           `${JSON.stringify(diagnosis, null, 2)}
 `,
@@ -42891,7 +43010,7 @@ var init_runtimeScorecard2 = __esm({
             composition: verifiedRelease?.manifest.composition,
             sourceArtifacts: await Promise.all(
               sourcePaths.map(async (sourcePath) => ({
-                artifactId: import_node_path45.default.basename(sourcePath),
+                artifactId: import_node_path46.default.basename(sourcePath),
                 path: sourcePath,
                 sha256: await sha256File2(sourcePath)
               }))
@@ -42902,11 +43021,11 @@ var init_runtimeScorecard2 = __esm({
       let receiptPath2 = null;
       if (flags31.markProcessed) {
         const runtimeEvidenceBundle = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(
-          import_node_path45.default.dirname(runtimeEvidencePath)
+          import_node_path46.default.dirname(runtimeEvidencePath)
         );
         const feedbackSource = replayEvidencePath ? await (0, runtimeFeedbackArtifacts_exports.verifyRuntimeFeedbackReplaySource)({
-          bundleDir: import_node_path45.default.dirname(replayEvidencePath),
-          runtimeEvidenceBundleDir: import_node_path45.default.dirname(runtimeEvidencePath)
+          bundleDir: import_node_path46.default.dirname(replayEvidencePath),
+          runtimeEvidenceBundleDir: import_node_path46.default.dirname(runtimeEvidencePath)
         }).catch((error) => {
           if (runtimeEvidenceBundle.artifact.producer) throw error;
           return null;
@@ -42917,9 +43036,9 @@ var init_runtimeScorecard2 = __esm({
           );
         }
         receiptPath2 = await markRuntimeEvidenceBundleProcessed({
-          evidenceRoot: import_node_path45.default.resolve(projectRoot14, String(flags31.evidenceDir)),
+          evidenceRoot: import_node_path46.default.resolve(projectRoot14, String(flags31.evidenceDir)),
           deploymentId: String(flags31.deployment),
-          bundleDir: import_node_path45.default.dirname(runtimeEvidencePath),
+          bundleDir: import_node_path46.default.dirname(runtimeEvidencePath),
           scorecardPath: outPath,
           runtimeFeedback: feedbackSource ? {
             artifactId: feedbackSource.feedback.manifest.artifactId,
@@ -43116,14 +43235,14 @@ __export(strategyRelease_exports, {
   main: () => main49,
   runStrategyReleaseCommand: () => runStrategyReleaseCommand
 });
-var import_promises46, import_node_fs10, import_node_readline5, import_node_path46, import_chalk50, valueAfter2, required3, writeJsonAtomic3, runStrategyReleaseCommand, printUsage2, main49;
+var import_promises47, import_node_fs10, import_node_readline5, import_node_path47, import_chalk50, valueAfter2, required3, writeJsonAtomic3, runStrategyReleaseCommand, printUsage2, main49;
 var init_strategyRelease2 = __esm({
   "src/scripts/strategyRelease.ts"() {
     "use strict";
-    import_promises46 = __toESM(require("fs/promises"));
+    import_promises47 = __toESM(require("fs/promises"));
     import_node_fs10 = require("fs");
     import_node_readline5 = require("readline");
-    import_node_path46 = __toESM(require("path"));
+    import_node_path47 = __toESM(require("path"));
     import_chalk50 = __toESM(require("chalk"));
     init_researchRetention();
     init_strategyRelease();
@@ -43137,17 +43256,17 @@ var init_strategyRelease2 = __esm({
     };
     writeJsonAtomic3 = async (filePath, value) => {
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-      await import_promises46.default.mkdir(import_node_path46.default.dirname(filePath), { recursive: true });
-      await import_promises46.default.writeFile(
+      await import_promises47.default.mkdir(import_node_path47.default.dirname(filePath), { recursive: true });
+      await import_promises47.default.writeFile(
         temporaryPath,
         `${JSON.stringify(value, null, 2)}
 `,
         "utf8"
       );
-      await import_promises46.default.rename(temporaryPath, filePath);
+      await import_promises47.default.rename(temporaryPath, filePath);
     };
     runStrategyReleaseCommand = async (options) => {
-      const inputPath = import_node_path46.default.resolve(options.inputPath);
+      const inputPath = import_node_path47.default.resolve(options.inputPath);
       if (options.command === "verify") {
         const envelope = await verifyStrategyReleaseEnvelope(inputPath);
         return {
@@ -43185,7 +43304,7 @@ var init_strategyRelease2 = __esm({
           endTime,
           days: options.days?.length ? options.days : [7, 30, 90]
         });
-        const outputPath = import_node_path46.default.resolve(
+        const outputPath = import_node_path47.default.resolve(
           options.outputPath ?? "output/strategy-monitoring-profile.json"
         );
         await writeJsonAtomic3(outputPath, profile);
@@ -43196,16 +43315,16 @@ var init_strategyRelease2 = __esm({
           profile
         };
       }
-      const input = JSON.parse(await import_promises46.default.readFile(inputPath, "utf8"));
+      const input = JSON.parse(await import_promises47.default.readFile(inputPath, "utf8"));
       if (options.command === "decide") {
         const decision = await deriveStrategyReleaseResearchDecision(input);
         if (options.outputPath) {
-          await writeJsonAtomic3(import_node_path46.default.resolve(options.outputPath), decision);
+          await writeJsonAtomic3(import_node_path47.default.resolve(options.outputPath), decision);
         }
         return {
           kind: "decided",
           ...decision,
-          outputPath: options.outputPath ? import_node_path46.default.resolve(options.outputPath) : null
+          outputPath: options.outputPath ? import_node_path47.default.resolve(options.outputPath) : null
         };
       }
       if (options.command === "retention") {
@@ -43229,7 +43348,7 @@ var init_strategyRelease2 = __esm({
             protectedPaths: [inputPath]
           });
         } else if (options.apply) {
-          await Promise.all(plan.delete.map((entry) => import_promises46.default.rm(entry.path)));
+          await Promise.all(plan.delete.map((entry) => import_promises47.default.rm(entry.path)));
         }
         return {
           kind: "retention",
@@ -43243,12 +43362,12 @@ var init_strategyRelease2 = __esm({
       }
       if (options.command === "diagnose") {
         const diagnosis = buildStrategyLiveDiagnosis(input);
-        const outputPath = import_node_path46.default.resolve(
+        const outputPath = import_node_path47.default.resolve(
           options.outputPath ?? "output/strategy-live-diagnosis.json"
         );
         await writeJsonAtomic3(outputPath, diagnosis);
         const published2 = options.rootDir ? await publishStrategyLiveDiagnosis({
-          rootDir: import_node_path46.default.resolve(options.rootDir),
+          rootDir: import_node_path47.default.resolve(options.rootDir),
           diagnosis,
           sourceArtifacts: input.sourceArtifacts ?? []
         }) : null;
@@ -43265,7 +43384,7 @@ var init_strategyRelease2 = __esm({
         evidence: await collectReleaseEvidenceReferences(input.evidence ?? [])
       });
       const published = await publishStrategyRelease({
-        rootDir: import_node_path46.default.resolve(options.rootDir ?? "data/strategy-release"),
+        rootDir: import_node_path47.default.resolve(options.rootDir ?? "data/strategy-release"),
         manifest
       });
       return {
@@ -43325,7 +43444,7 @@ __export(serverHealth_exports, {
   main: () => main50,
   resolveServerHealthThresholds: () => resolveServerHealthThresholds
 });
-var import_config10, import_node_child_process12, import_node_os5, import_node_fs11, import_args35, import_redis23, DEFAULT_STATE, DEFAULT_THRESHOLDS, escapeHtml6, formatPctValue, formatLoadPerCore, formatGiB, formatDuration2, readDiskUsage, parseMeminfoBytes, readMemorySnapshot, runDiagnosticCommand, runDiagnosticCommands, collectServerHealthSnapshot, buildHumanSummaryLines, evaluateServerHealth, shouldRecover, buildAlertMessage, buildRecoveryMessage, buildServerHealthDiagnostics, getStateKey, toFiniteNumber3, resolveServerHealthThresholds, main50;
+var import_config10, import_node_child_process12, import_node_os5, import_node_fs11, import_args35, import_redis24, DEFAULT_STATE, DEFAULT_THRESHOLDS, escapeHtml6, formatPctValue, formatLoadPerCore, formatGiB, formatDuration2, readDiskUsage, parseMeminfoBytes, readMemorySnapshot, runDiagnosticCommand, runDiagnosticCommands, collectServerHealthSnapshot, buildHumanSummaryLines, evaluateServerHealth, shouldRecover, buildAlertMessage, buildRecoveryMessage, buildServerHealthDiagnostics, getStateKey, toFiniteNumber3, resolveServerHealthThresholds, main50;
 var init_serverHealth = __esm({
   "src/scripts/serverHealth.ts"() {
     "use strict";
@@ -43334,7 +43453,7 @@ var init_serverHealth = __esm({
     import_node_os5 = __toESM(require("os"));
     import_node_fs11 = require("fs");
     import_args35 = __toESM(require("args"));
-    import_redis23 = require("@tradejs/infra/redis");
+    import_redis24 = require("@tradejs/infra/redis");
     init_telegramReports();
     DEFAULT_STATE = {
       status: "healthy",
@@ -43367,21 +43486,21 @@ var init_serverHealth = __esm({
       }
       return `${minutes}m`;
     };
-    readDiskUsage = (path57) => {
+    readDiskUsage = (path58) => {
       try {
-        const stats = (0, import_node_fs11.statfsSync)(path57);
+        const stats = (0, import_node_fs11.statfsSync)(path58);
         const totalBlocks = Number(stats.blocks ?? 0);
         const availableBlocks = Number(stats.bavail ?? 0);
         if (totalBlocks <= 0) {
-          return { path: path57, usedPct: null };
+          return { path: path58, usedPct: null };
         }
         const usedPct = (totalBlocks - Math.max(0, availableBlocks)) / totalBlocks * 100;
         return {
-          path: path57,
+          path: path58,
           usedPct: Number.isFinite(usedPct) ? usedPct : null
         };
       } catch {
-        return { path: path57, usedPct: null };
+        return { path: path58, usedPct: null };
       }
     };
     parseMeminfoBytes = (value) => {
@@ -43744,7 +43863,7 @@ var init_serverHealth = __esm({
       const diskPath = String(flags36.diskPath || "/");
       const snapshot = collectServerHealthSnapshot(diskPath);
       const stateKey = getStateKey(String(flags36.user), snapshot.hostname);
-      const prevState = await (0, import_redis23.getData)(stateKey, DEFAULT_STATE) ?? DEFAULT_STATE;
+      const prevState = await (0, import_redis24.getData)(stateKey, DEFAULT_STATE) ?? DEFAULT_STATE;
       const evaluation = evaluateServerHealth(snapshot, thresholds);
       const cooldownMs = Math.max(60, Number(flags36.cooldownSec)) * 1e3;
       const now2 = snapshot.timestamp;
@@ -43757,7 +43876,7 @@ var init_serverHealth = __esm({
           lastOkAt: prevState.lastOkAt,
           activeIssueCodes: evaluation.issues.map((issue) => issue.code)
         };
-        await (0, import_redis23.setData)(stateKey, nextState2, { expire: 0 });
+        await (0, import_redis24.setData)(stateKey, nextState2, { expire: 0 });
         if (shouldSend) {
           const message = buildAlertMessage({
             evaluation,
@@ -43786,7 +43905,7 @@ var init_serverHealth = __esm({
         lastOkAt: now2,
         activeIssueCodes: []
       };
-      await (0, import_redis23.setData)(stateKey, nextState, { expire: 0 });
+      await (0, import_redis24.setData)(stateKey, nextState, { expire: 0 });
       if (recovered) {
         const message = buildRecoveryMessage({ snapshot, prevState });
         if (flags36.printOnly) {
@@ -45133,18 +45252,18 @@ __export(runtimeParity_exports, {
   main: () => main51,
   runtimeParity: () => runtimeParity
 });
-var import_config11, import_node_crypto25, import_args36, import_chalk52, import_constants20, import_time13, import_logger8, import_redis24, import_cli12, import_backtest8, import_connectors17, flags32, interval3, projectRoot16, DEFAULT_LOOKBACK_DAYS, DETAIL_LIMIT2, DEFAULT_REPLAY_ENV, resolveParityConnectorName, createConnector, buildReplayAiAnalyses, formatReplayEnvSummary, buildReplayConfig, warmReplayHistory, runtimeParity, main51;
+var import_config11, import_node_crypto24, import_args36, import_chalk52, import_constants20, import_time13, import_logger8, import_redis25, import_cli12, import_backtest8, import_connectors17, flags32, interval3, projectRoot16, DEFAULT_LOOKBACK_DAYS, DETAIL_LIMIT2, DEFAULT_REPLAY_ENV, resolveParityConnectorName, createConnector, buildReplayAiAnalyses, formatReplayEnvSummary, buildReplayConfig, warmReplayHistory, runtimeParity, main51;
 var init_runtimeParity2 = __esm({
   "src/scripts/runtimeParity.ts"() {
     "use strict";
     import_config11 = require("dotenv/config");
-    import_node_crypto25 = require("crypto");
+    import_node_crypto24 = require("crypto");
     import_args36 = __toESM(require("args"));
     import_chalk52 = __toESM(require("chalk"));
     import_constants20 = require("@tradejs/core/constants");
     import_time13 = require("@tradejs/core/time");
     import_logger8 = require("@tradejs/infra/logger");
-    import_redis24 = require("@tradejs/infra/redis");
+    import_redis25 = require("@tradejs/infra/redis");
     import_cli12 = require("@tradejs/node/cli");
     import_backtest8 = require("@tradejs/node/backtest");
     import_connectors17 = require("@tradejs/node/connectors");
@@ -45304,8 +45423,8 @@ var init_runtimeParity2 = __esm({
       toleranceMs
     }) => {
       const [userConfig, strategyResults] = await Promise.all([
-        (0, import_redis24.getData)(import_redis24.redisKeys.strategyConfig(userName3, strategy), {}),
-        (0, import_redis24.getData)(import_redis24.redisKeys.strategyResults(userName3, strategy), {})
+        (0, import_redis25.getData)(import_redis25.redisKeys.strategyConfig(userName3, strategy), {}),
+        (0, import_redis25.getData)(import_redis25.redisKeys.strategyResults(userName3, strategy), {})
       ]);
       const typedResults = strategyResults ?? {};
       const symbolResult = typedResults?.[symbol];
@@ -45521,9 +45640,9 @@ var init_runtimeParity2 = __esm({
                 start: window.start,
                 end: window.end
               },
-              name: `${target.symbol}_${target.strategy}_${(0, import_node_crypto25.randomUUID)().slice(0, 8)}`,
-              testId: (0, import_node_crypto25.randomUUID)().slice(0, 8),
-              testSuiteId: (0, import_node_crypto25.randomUUID)().slice(0, 8),
+              name: `${target.symbol}_${target.strategy}_${(0, import_node_crypto24.randomUUID)().slice(0, 8)}`,
+              testId: (0, import_node_crypto24.randomUUID)().slice(0, 8),
+              testSuiteId: (0, import_node_crypto24.randomUUID)().slice(0, 8),
               strategyName: target.strategy,
               strategyConfig: replayConfig,
               connectorName,
@@ -45741,11 +45860,11 @@ var init_skipStats = __esm({
 });
 
 // src/lib/signals/evaluations.ts
-var import_redis25, runtimeLineageScopeCache, runtimeLineageScopeCacheDayKey, runtimeLineageScopeCacheLoaded, buildRuntimeSignalEvaluationId, buildLineageField, flushRuntimeSignalEvaluations, createRuntimeSignalEvaluationBuffer;
+var import_redis26, runtimeLineageScopeCache, runtimeLineageScopeCacheDayKey, runtimeLineageScopeCacheLoaded, buildRuntimeSignalEvaluationId, buildLineageField, flushRuntimeSignalEvaluations, createRuntimeSignalEvaluationBuffer;
 var init_evaluations = __esm({
   "src/lib/signals/evaluations.ts"() {
     "use strict";
-    import_redis25 = require("@tradejs/infra/redis");
+    import_redis26 = require("@tradejs/infra/redis");
     init_runtimeSignalsStorage();
     init_runtimeLineage();
     runtimeLineageScopeCache = /* @__PURE__ */ new Map();
@@ -45796,7 +45915,7 @@ var init_evaluations = __esm({
           runtimeLineageScopeCacheDayKey = dayKey;
           runtimeLineageScopeCacheLoaded = false;
         }
-        const lineageBucket = import_redis25.redisKeys.runtimeLineageScopeBucket(
+        const lineageBucket = import_redis26.redisKeys.runtimeLineageScopeBucket(
           dayEvaluations[0].userName,
           dayKey
         );
@@ -45804,7 +45923,7 @@ var init_evaluations = __esm({
           (evaluation) => evaluation.runtimeLineage != null
         );
         if (lineageEvaluations.length > 0 && !runtimeLineageScopeCacheLoaded) {
-          const storedScopes = await (0, import_redis25.getHashJsonValues)(lineageBucket);
+          const storedScopes = await (0, import_redis26.getHashJsonValues)(lineageBucket);
           for (const scope of storedScopes) {
             const lineageField = buildLineageField(scope);
             runtimeLineageScopeCache.set(`${lineageBucket}:${lineageField}`, scope);
@@ -45849,7 +45968,7 @@ var init_evaluations = __esm({
           lineageWrites.set(lineageField, scope);
         }
         if (lineageWrites.size > 0) {
-          await (0, import_redis25.setHashJsonFields)(
+          await (0, import_redis26.setHashJsonFields)(
             lineageBucket,
             [...lineageWrites].map(([field, data]) => ({ field, data })),
             {
@@ -45861,7 +45980,7 @@ var init_evaluations = __esm({
         const statsIncrements = /* @__PURE__ */ new Map();
         for (const evaluation of dayEvaluations) {
           if (shouldStoreDetailedRuntimeSignalEvaluation(evaluation)) {
-            const bucket = import_redis25.redisKeys.runtimeSignalEvaluationBucket(
+            const bucket = import_redis26.redisKeys.runtimeSignalEvaluationBucket(
               evaluation.userName,
               dayKey,
               evaluation.strategy
@@ -45873,7 +45992,7 @@ var init_evaluations = __esm({
             });
             detailedWrites.set(bucket, entries);
           }
-          const statsBucket = import_redis25.redisKeys.runtimeSignalEvaluationStatsBucket(
+          const statsBucket = import_redis26.redisKeys.runtimeSignalEvaluationStatsBucket(
             evaluation.userName,
             dayKey,
             evaluation.strategy,
@@ -45889,12 +46008,12 @@ var init_evaluations = __esm({
         }
         await Promise.all([
           ...[...detailedWrites].map(
-            ([bucket, entries]) => (0, import_redis25.setHashJsonFields)(bucket, entries, {
+            ([bucket, entries]) => (0, import_redis26.setHashJsonFields)(bucket, entries, {
               expire: runtimeSignalRetentionTtl
             })
           ),
           ...[...statsIncrements].map(
-            ([bucket, increments]) => (0, import_redis25.incrHashFields)(bucket, increments, {
+            ([bucket, increments]) => (0, import_redis26.incrHashFields)(bucket, increments, {
               expire: runtimeSignalRetentionTtl
             })
           )
@@ -45910,7 +46029,7 @@ var init_evaluations = __esm({
         const runtimeSignalRetentionTtl = getRuntimeSignalRetentionTtlSeconds();
         const signalRefsByBucket = /* @__PURE__ */ new Map();
         for (const { userName: userName3, signal } of pendingSignals) {
-          const bucket = import_redis25.redisKeys.runtimeSignalBucket(
+          const bucket = import_redis26.redisKeys.runtimeSignalBucket(
             userName3,
             (0, import_time5.getRuntimeStorageDayKey)(signal.timestamp),
             signal.strategy
@@ -45924,14 +46043,14 @@ var init_evaluations = __esm({
         }
         await Promise.all([
           ...pendingSignals.map(
-            ({ signal }) => (0, import_redis25.setData)(
-              import_redis25.redisKeys.storeSignal(signal.symbol, signal.signalId),
+            ({ signal }) => (0, import_redis26.setData)(
+              import_redis26.redisKeys.storeSignal(signal.symbol, signal.signalId),
               toStoredRuntimeSignal(signal),
               { expire: runtimeSignalRetentionTtl }
             )
           ),
           ...[...signalRefsByBucket].map(
-            ([bucket, entries]) => (0, import_redis25.setHashJsonFields)(bucket, entries, {
+            ([bucket, entries]) => (0, import_redis26.setHashJsonFields)(bucket, entries, {
               expire: runtimeSignalRetentionTtl
             })
           )
@@ -48511,14 +48630,14 @@ var user_add_exports = {};
 __export(user_add_exports, {
   main: () => main57
 });
-var import_args39, import_chalk55, import_bcryptjs, import_redis26, flags35, main57;
+var import_args39, import_chalk55, import_bcryptjs, import_redis27, flags35, main57;
 var init_user_add = __esm({
   "src/scripts/user-add.ts"() {
     "use strict";
     import_args39 = __toESM(require("args"));
     import_chalk55 = __toESM(require("chalk"));
     import_bcryptjs = __toESM(require("bcryptjs"));
-    import_redis26 = require("@tradejs/infra/redis");
+    import_redis27 = require("@tradejs/infra/redis");
     import_args39.default.example("yarn user-add -u myname -p 123456", "Create or update user");
     import_args39.default.option(["u", "user"], "Username", "");
     import_args39.default.option(["p", "password"], "Password (plain text)", "");
@@ -48531,14 +48650,14 @@ var init_user_add = __esm({
         process.exit(1);
       }
       const passwordHash = await import_bcryptjs.default.hash(password, 10);
-      const existing = await (0, import_redis26.getData)(import_redis26.redisKeys.user(userName3), null);
+      const existing = await (0, import_redis27.getData)(import_redis27.redisKeys.user(userName3), null);
       const next = {
         ...existing ?? {},
         passwordHash,
         userName: userName3,
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
-      await (0, import_redis26.setData)(import_redis26.redisKeys.user(userName3), next, {
+      await (0, import_redis27.setData)(import_redis27.redisKeys.user(userName3), next, {
         expire: 0
       });
       console.log(import_chalk55.default.green(`User ${userName3} updated`));
@@ -48557,7 +48676,7 @@ __export(cli_exports, {
 });
 module.exports = __toCommonJS(cli_exports);
 var import_config16 = require("dotenv/config");
-var import_redis27 = require("@tradejs/infra/redis");
+var import_redis28 = require("@tradejs/infra/redis");
 var import_client10 = require("@tradejs/infra/timescale/client");
 var scriptLoaders = {
   "research-visuals": () => Promise.resolve().then(() => (init_researchVisuals2(), researchVisuals_exports)),
@@ -48633,7 +48752,7 @@ var runLoadedModule = async (loaded) => {
   }
 };
 var cleanupCliResources = async () => {
-  await Promise.allSettled([(0, import_redis27.closeRedisConnection)(), (0, import_client10.closeTimescalePool)()]);
+  await Promise.allSettled([(0, import_redis28.closeRedisConnection)(), (0, import_client10.closeTimescalePool)()]);
 };
 var main58 = async () => {
   const [, scriptPath, command = "", ...args40] = process.argv;