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

package/dist/cli.js

@@ -26,6 +26,7 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
   // If the importer is in node compatibility mode or this is not an ESM
   // file that has been converted to a CommonJS file using a Babel-
@@ -2207,9 +2208,9 @@ var init_features = __esm({
       "targetsymbol",
       "universe"
     ]);
-    normalizeFeaturePath = (path47) => (Array.isArray(path47) ? path47 : path47.split(".")).filter(Boolean).map((segment) => segment.toLowerCase());
-    classifyAiPocketCoverageFeaturePath = (path47) => {
-      const segments = normalizeFeaturePath(path47);
+    normalizeFeaturePath = (path44) => (Array.isArray(path44) ? path44 : path44.split(".")).filter(Boolean).map((segment) => segment.toLowerCase());
+    classifyAiPocketCoverageFeaturePath = (path44) => {
+      const segments = normalizeFeaturePath(path44);
       const normalizedPath = segments.join(".");
       if (segments.some(
         (segment) => segment.includes("cmc") || segment.includes("coinmarketcap")
@@ -2383,8 +2384,8 @@ var init_features = __esm({
       "volumeusd",
       "vwap"
     ]);
-    classifyAiPocketFeaturePath = (path47) => {
-      const segments = (Array.isArray(path47) ? path47 : path47.split(".")).filter(
+    classifyAiPocketFeaturePath = (path44) => {
+      const segments = (Array.isArray(path44) ? path44 : path44.split(".")).filter(
         Boolean
       );
       const normalized = segments.map((segment) => segment.toLowerCase());
@@ -2701,11 +2702,11 @@ var init_features = __esm({
         excludeFeaturePattern.source,
         excludeFeaturePattern.flags.replace(/[gy]/g, "")
       ) : void 0;
-      const isOperatorExcluded = (path47) => {
-        if (!exclusion?.test(path47)) {
+      const isOperatorExcluded = (path44) => {
+        if (!exclusion?.test(path44)) {
           return false;
         }
-        onFeatureExcluded?.({ path: path47, classification: "operator-excluded" });
+        onFeatureExcluded?.({ path: path44, classification: "operator-excluded" });
         return true;
       };
       const signal = payload.signal ?? {};
@@ -11156,27 +11157,27 @@ var init_coinMarketCapContextBackfill = __esm({
       totalCredits: 0,
       byPath: /* @__PURE__ */ new Map()
     });
-    getCoinMarketCapPathLabel = (path47) => {
-      if (path47.includes("global-metrics")) return "global";
-      if (path47.includes("cryptocurrency/quotes")) return "reference";
-      if (path47.includes("exchange/quotes")) return "exchangeLiquidity";
-      if (path47.includes("fear-and-greed")) return "fearGreed";
-      if (path47.includes("cmc100")) return "cmc100";
-      if (path47.includes("cmc20")) return "cmc20";
-      return path47;
-    };
-    recordCoinMarketCapFetchStats = (stats, path47, creditCount) => {
+    getCoinMarketCapPathLabel = (path44) => {
+      if (path44.includes("global-metrics")) return "global";
+      if (path44.includes("cryptocurrency/quotes")) return "reference";
+      if (path44.includes("exchange/quotes")) return "exchangeLiquidity";
+      if (path44.includes("fear-and-greed")) return "fearGreed";
+      if (path44.includes("cmc100")) return "cmc100";
+      if (path44.includes("cmc20")) return "cmc20";
+      return path44;
+    };
+    recordCoinMarketCapFetchStats = (stats, path44, creditCount) => {
       if (!stats) return;
-      const existing = stats.byPath.get(path47) ?? { requests: 0, credits: 0 };
+      const existing = stats.byPath.get(path44) ?? { requests: 0, credits: 0 };
       existing.requests += 1;
       existing.credits += creditCount ?? 0;
       stats.requests += 1;
       stats.totalCredits += creditCount ?? 0;
-      stats.byPath.set(path47, existing);
+      stats.byPath.set(path44, existing);
     };
     formatCoinMarketCapFetchStats = (stats) => {
       const byPath = [...stats.byPath.entries()].map(
-        ([path47, item]) => `${getCoinMarketCapPathLabel(path47)}=${item.requests}req/${item.credits}cr`
+        ([path44, item]) => `${getCoinMarketCapPathLabel(path44)}=${item.requests}req/${item.credits}cr`
       ).join(" ");
       return `apiRequests=${stats.requests} apiCredits=${stats.totalCredits}${byPath ? ` ${byPath}` : ""}`;
     };
@@ -13563,6 +13564,11 @@ var init_cliConfig = __esm({
       "Skip per-test artifact persistence and keep only in-memory summary/AI-ML dataset output",
       false
     );
+    import_args6.default.option(
+      ["Y", "persistResults"],
+      "Persist lightweight result summaries even in fast mode",
+      false
+    );
     import_args6.default.option(
       "researchTrace",
       "Write compact setup/entry/exit/skip research trace JSONL",
@@ -14806,7 +14812,7 @@ var init_backtest = __esm({
       }
       console.log(import_chalk15.default.gray(`full report: ${markdownReportPath}`));
       console.log("");
-      if (!isFastMode) {
+      if (!isFastMode || flags5.persistResults) {
         await (0, import_redis7.setData)(
           import_redis7.redisKeys.backtestResults(userName, flags5.config, timestamp),
           {
@@ -15235,305 +15241,11 @@ var init_runtimeLineage = __esm({
 });
 
 // src/lib/runtimeEvidenceDeployment.ts
-var import_runtimeStrategies3, isRecord, isNonEmptyString, isPackageVersionMap, INTERVALS, UNIVERSES, isRuntimeStrategySelection, samePackageVersions, runtimeLineageMatchesStrategySnapshot, parseRuntimeEvidenceDeploymentSnapshot, activeRuntimeEvidenceStrategies, unwrapRuntimeEvidenceRows, assertCurrentRuntimeEvidenceArtifact, resolveRuntimeEvidenceTickerUniverse, runtimeDeploymentFromEvidence, resolveRuntimeEvidenceDeploymentSnapshot;
+var runtimeEvidenceDeployment_exports = {};
 var init_runtimeEvidenceDeployment = __esm({
   "src/lib/runtimeEvidenceDeployment.ts"() {
     "use strict";
-    import_runtimeStrategies3 = require("@tradejs/node/runtimeStrategies");
-    isRecord = (value) => value != null && typeof value === "object" && !Array.isArray(value);
-    isNonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
-    isPackageVersionMap = (value) => isRecord(value) && Object.keys(value).length > 0 && Object.entries(value).every(
-      ([name, version]) => name.startsWith("@tradejs/") && isNonEmptyString(version)
-    );
-    INTERVALS = /* @__PURE__ */ new Set([
-      "1",
-      "3",
-      "5",
-      "15",
-      "30",
-      "60",
-      "120",
-      "240",
-      "360",
-      "720",
-      "D",
-      "W",
-      "M"
-    ]);
-    UNIVERSES = /* @__PURE__ */ new Set(["crypto", "tradfi"]);
-    isRuntimeStrategySelection = (value) => value === void 0 || isRecord(value) && Object.keys(value).length === 1 && Object.keys(value).every((key) => key === "tickers") && Array.isArray(value.tickers) && value.tickers.length > 0 && value.tickers.every((ticker) => isNonEmptyString(ticker));
-    samePackageVersions = (left, right) => {
-      if (!left || !right) return false;
-      const leftEntries = Object.entries(left).sort(
-        ([a], [b]) => a.localeCompare(b)
-      );
-      const rightEntries = Object.entries(right).sort(
-        ([a], [b]) => a.localeCompare(b)
-      );
-      return JSON.stringify(leftEntries) === JSON.stringify(rightEntries);
-    };
-    runtimeLineageMatchesStrategySnapshot = ({
-      lineage,
-      deployment,
-      strategy
-    }) => lineage?.schemaVersion === 3 && lineage.strategyRevision === strategy.strategyRevision && lineage.deploymentCompositionId === deployment.deploymentCompositionId && lineage.strategyPackageVersion === strategy.strategyPackageVersion && lineage.runtimePackageVersion === strategy.runtimePackageVersion && samePackageVersions(
-      lineage.strategyDependencyVersions,
-      strategy.strategyDependencyVersions
-    );
-    parseRuntimeEvidenceDeploymentSnapshot = (value) => {
-      if (!isRecord(value) || value.schemaVersion !== 2 || !isNonEmptyString(value.id) || !isNonEmptyString(value.deploymentCompositionId) || !/^dc1:[a-f0-9]{16}$/.test(value.deploymentCompositionId) || !isNonEmptyString(value.label) || !isNonEmptyString(value.connectorName) || !isNonEmptyString(value.provider) || !isNonEmptyString(value.accountId) || typeof value.enabled !== "boolean" || !Array.isArray(value.strategies)) {
-        throw new Error(
-          "Runtime evidence deployment snapshot is missing or invalid"
-        );
-      }
-      const strategies = value.strategies.map((candidate) => {
-        if (!isRecord(candidate) || !isNonEmptyString(candidate.strategyName) || !isNonEmptyString(candidate.strategyRevision) || !/^sr1:[a-f0-9]{16}$/.test(candidate.strategyRevision) || typeof candidate.enabled !== "boolean" || !["active", "entries_paused"].includes(String(candidate.controlState)) || !INTERVALS.has(String(candidate.interval)) || !UNIVERSES.has(String(candidate.universe)) || !isNonEmptyString(candidate.strategyPackage) || !isNonEmptyString(candidate.strategyPackageVersion) || !isPackageVersionMap(candidate.strategyDependencyVersions) || !isNonEmptyString(candidate.runtimePackageVersion) || !isRecord(candidate.strategyConfig) || !isRuntimeStrategySelection(candidate.selection)) {
-          throw new Error(
-            "Runtime evidence deployment strategy snapshot is invalid"
-          );
-        }
-        if (String(candidate.strategyConfig.INTERVAL) !== String(candidate.interval) || String(candidate.strategyConfig.UNIVERSE) !== String(candidate.universe)) {
-          throw new Error(
-            `Runtime evidence strategy config does not match its scope: ${candidate.strategyName}`
-          );
-        }
-        if (candidate.accountId != null && (!isNonEmptyString(candidate.accountId) || candidate.accountId !== value.accountId)) {
-          throw new Error(
-            `Runtime evidence strategy account does not match deployment: ${candidate.strategyName}`
-          );
-        }
-        return candidate;
-      });
-      const identities = /* @__PURE__ */ new Set();
-      for (const strategy of strategies) {
-        if (identities.has(strategy.strategyName)) {
-          throw new Error(
-            `Duplicate runtime evidence strategy: ${strategy.strategyName}`
-          );
-        }
-        identities.add(strategy.strategyName);
-      }
-      return {
-        ...value,
-        strategies
-      };
-    };
-    activeRuntimeEvidenceStrategies = (deployment) => deployment.enabled ? deployment.strategies.filter((strategy) => strategy.enabled) : [];
-    unwrapRuntimeEvidenceRows = (value, field) => (Array.isArray(value) ? value : []).map((candidate) => {
-      const record = isRecord(candidate) ? candidate : null;
-      const nested = record && isRecord(record[field]) ? record[field] : null;
-      return nested ?? record;
-    }).filter((record) => record != null);
-    assertCurrentRuntimeEvidenceArtifact = (artifact) => {
-      if (!isRecord(artifact) || artifact.reportType !== "runtime-evidence") {
-        throw new Error("Invalid runtime evidence artifact");
-      }
-      const deployment = parseRuntimeEvidenceDeploymentSnapshot(
-        artifact.deployment
-      );
-      const activeStrategies = activeRuntimeEvidenceStrategies(deployment);
-      if (activeStrategies.length === 0) {
-        throw new Error("Runtime evidence deployment has no enabled strategies");
-      }
-      const runtime = isRecord(artifact.runtime) ? artifact.runtime : null;
-      if (!runtime) {
-        throw new Error("Runtime evidence payload is missing");
-      }
-      if ("strategyConfigs" in runtime) {
-        throw new Error(
-          "Runtime evidence payload contains removed strategyConfigs data"
-        );
-      }
-      if ("evaluationStatsBuckets" in runtime) {
-        throw new Error(
-          "Runtime evidence payload contains removed lineage-less evaluationStatsBuckets data"
-        );
-      }
-      const rowFields = [
-        "trades",
-        "signals",
-        "evaluations",
-        "lineageScopes"
-      ];
-      for (const field of rowFields) {
-        if (!Array.isArray(runtime[field])) {
-          throw new Error(`Runtime evidence payload ${field} must be an array`);
-        }
-      }
-      const snapshots = new Map(
-        activeStrategies.map((strategy) => [strategy.strategyName, strategy])
-      );
-      const assertRows = (label, rows, lineageField) => {
-        for (const row of rows) {
-          const strategyName = String(row.strategy ?? "").trim();
-          const strategy = snapshots.get(strategyName);
-          if (!strategy || row.deploymentId !== deployment.id || row.accountId !== deployment.accountId || !runtimeLineageMatchesStrategySnapshot({
-            lineage: isRecord(row[lineageField]) ? row[lineageField] : void 0,
-            deployment,
-            strategy
-          })) {
-            throw new Error(
-              `Runtime evidence ${label} row is outside the current embedded deployment lineage`
-            );
-          }
-        }
-      };
-      assertRows(
-        "trade",
-        unwrapRuntimeEvidenceRows(runtime.trades, "trade"),
-        "runtimeLineage"
-      );
-      assertRows(
-        "signal",
-        unwrapRuntimeEvidenceRows(runtime.signals, "signal"),
-        "runtimeLineage"
-      );
-      assertRows(
-        "evaluation",
-        unwrapRuntimeEvidenceRows(runtime.evaluations, "evaluation"),
-        "runtimeLineage"
-      );
-      assertRows(
-        "lineage scope",
-        unwrapRuntimeEvidenceRows(runtime.lineageScopes, "lineageScope"),
-        "lineage"
-      );
-      return deployment;
-    };
-    resolveRuntimeEvidenceTickerUniverse = ({
-      deployment,
-      lineageScopes,
-      fallbackTickers
-    }) => {
-      const declaredTickers = deployment.tickers?.filter(isNonEmptyString) ?? [];
-      if (declaredTickers.length > 0) {
-        return {
-          ...deployment,
-          tickers: [
-            ...new Set(declaredTickers.map((ticker) => ticker.trim()))
-          ].sort()
-        };
-      }
-      const activeStrategies = activeRuntimeEvidenceStrategies(deployment);
-      if (activeStrategies.length > 0 && activeStrategies.every((strategy) => strategy.selection?.tickers?.length)) {
-        return {
-          ...deployment,
-          tickers: [
-            ...new Set(
-              activeStrategies.flatMap(
-                (strategy) => strategy.selection?.tickers ?? []
-              )
-            )
-          ].sort()
-        };
-      }
-      const strategiesByName = new Map(
-        activeStrategies.map((strategy) => [strategy.strategyName, strategy])
-      );
-      const tickers = /* @__PURE__ */ new Set();
-      for (const scope of lineageScopes) {
-        const strategy = strategiesByName.get(scope.strategy);
-        if (!strategy || scope.deploymentId !== deployment.id || scope.accountId !== deployment.accountId || !isNonEmptyString(scope.symbol) || !runtimeLineageMatchesStrategySnapshot({
-          lineage: scope.lineage,
-          deployment,
-          strategy
-        })) {
-          continue;
-        }
-        tickers.add(scope.symbol.trim());
-      }
-      if (tickers.size === 0) {
-        const verifiedFallbackTickers = fallbackTickers?.filter(isNonEmptyString) ?? [];
-        if (verifiedFallbackTickers.length > 0) {
-          return {
-            ...deployment,
-            tickers: [
-              ...new Set(verifiedFallbackTickers.map((ticker) => ticker.trim()))
-            ].sort()
-          };
-        }
-        throw new Error(
-          "Runtime evidence has no immutable ticker universe for the embedded deployment composition"
-        );
-      }
-      return { ...deployment, tickers: [...tickers].sort() };
-    };
-    runtimeDeploymentFromEvidence = (deployment) => ({
-      id: deployment.id,
-      deploymentCompositionId: deployment.deploymentCompositionId,
-      label: deployment.label,
-      connectorName: deployment.connectorName,
-      provider: deployment.provider,
-      accountId: deployment.accountId,
-      enabled: deployment.enabled,
-      strategies: deployment.strategies.map(
-        ({ strategyName, strategyRevision, enabled, controlState, selection }) => ({
-          strategyName,
-          strategyRevision,
-          enabled,
-          controlState,
-          ...selection ? { selection } : {}
-        })
-      ),
-      ...deployment.assetClasses ? { assetClasses: [...deployment.assetClasses] } : {},
-      ...deployment.tickers ? { tickers: [...deployment.tickers] } : {}
-    });
-    resolveRuntimeEvidenceDeploymentSnapshot = async ({
-      userName: userName3,
-      projectRoot: projectRoot18,
-      deploymentId
-    }) => {
-      const [deployment, strategies] = await Promise.all([
-        (0, import_runtimeStrategies3.getRuntimeDeployment)({ userName: userName3, projectRoot: projectRoot18, deploymentId }),
-        (0, import_runtimeStrategies3.loadResolvedRuntimeStrategies)({ userName: userName3, projectRoot: projectRoot18, deploymentId })
-      ]);
-      if (!deployment) {
-        throw new Error(`Runtime deployment not found: ${deploymentId}`);
-      }
-      return {
-        schemaVersion: 2,
-        id: deployment.id,
-        deploymentCompositionId: deployment.deploymentCompositionId,
-        label: deployment.label,
-        connectorName: deployment.connectorName,
-        provider: deployment.provider,
-        accountId: deployment.accountId,
-        enabled: deployment.enabled,
-        strategies: strategies.map(
-          ({
-            strategyName,
-            strategyRevision,
-            enabled,
-            controlState,
-            interval: interval4,
-            universe,
-            accountId,
-            strategyPackage,
-            strategyPackageVersion,
-            strategyDependencyVersions,
-            runtimePackageVersion,
-            strategyConfig,
-            selection
-          }) => ({
-            strategyName,
-            strategyRevision,
-            enabled,
-            controlState,
-            interval: interval4,
-            universe,
-            ...accountId ? { accountId } : {},
-            strategyPackage,
-            strategyPackageVersion,
-            strategyDependencyVersions,
-            runtimePackageVersion,
-            strategyConfig,
-            ...selection ? { selection } : {}
-          })
-        ),
-        ...deployment.assetClasses ? { assetClasses: [...deployment.assetClasses] } : {},
-        ...deployment.tickers ? { tickers: [...deployment.tickers] } : {}
-      };
-    };
+    __reExport(runtimeEvidenceDeployment_exports, require("@tradejs/node/diagnostics"));
   }
 });
 
@@ -15558,7 +15270,7 @@ var init_runtimeEvidenceSource = __esm({
       deployment
     }) => {
       const activeStrategies = new Set(
-        activeRuntimeEvidenceStrategies(deployment).map(
+        (0, runtimeEvidenceDeployment_exports.activeRuntimeEvidenceStrategies)(deployment).map(
           ({ strategyName }) => strategyName
         )
       );
@@ -15582,7 +15294,7 @@ var init_runtimeEvidenceSource = __esm({
       if (!root || !runtime) {
         throw new Error(`Invalid runtime evidence JSON: ${resolvedPath}`);
       }
-      assertCurrentRuntimeEvidenceArtifact(root);
+      (0, runtimeEvidenceDeployment_exports.assertCurrentRuntimeEvidenceArtifact)(root);
       const rootWindow = asRecord2(root.window);
       const runtimeWindow2 = asRecord2(runtime.window);
       return {
@@ -15592,8 +15304,8 @@ var init_runtimeEvidenceSource = __esm({
         userName: String(root.userName ?? runtime.userName ?? "").trim(),
         startTime: asFiniteNumber(rootWindow?.startTime) ?? asFiniteNumber(runtimeWindow2?.startTime),
         endTime: asFiniteNumber(rootWindow?.endTime) ?? asFiniteNumber(runtimeWindow2?.endTime),
-        deployment: resolveRuntimeEvidenceTickerUniverse({
-          deployment: parseRuntimeEvidenceDeploymentSnapshot(root.deployment),
+        deployment: (0, runtimeEvidenceDeployment_exports.resolveRuntimeEvidenceTickerUniverse)({
+          deployment: (0, runtimeEvidenceDeployment_exports.parseRuntimeEvidenceDeploymentSnapshot)(root.deployment),
           lineageScopes: unwrapRows(
             runtime.lineageScopes,
             "lineageScope"
@@ -16857,7 +16569,7 @@ var init_historicalSignalsReplayResults = __esm({
 });
 
 // src/lib/replay/historicalSignalsReplay.ts
-var import_chalk17, import_progress8, import_node_path8, import_node_module2, import_strategies5, import_time4, import_logger, import_redis8, import_connectors6, import_cli5, import_strategies6, import_runtimeStrategies4, projectReplayCacheReleasers, getProjectReplayCacheReleasers, releaseReplayCacheCopies, loadRuntimeStrategies, loadReferenceConnector, buildAfterSignalsContext, getConnectorName, loadHistoricalReplayReferences, runHistoricalSignalsReplay;
+var import_chalk17, import_progress8, import_node_path8, import_node_module2, import_strategies5, import_time4, import_logger, import_redis8, import_connectors6, import_cli5, import_strategies6, import_runtimeStrategies3, projectReplayCacheReleasers, getProjectReplayCacheReleasers, releaseReplayCacheCopies, loadRuntimeStrategies, loadReferenceConnector, buildAfterSignalsContext, getConnectorName, loadHistoricalReplayReferences, runHistoricalSignalsReplay;
 var init_historicalSignalsReplay = __esm({
   "src/lib/replay/historicalSignalsReplay.ts"() {
     "use strict";
@@ -16872,7 +16584,7 @@ var init_historicalSignalsReplay = __esm({
     import_connectors6 = require("@tradejs/node/connectors");
     import_cli5 = require("@tradejs/node/cli");
     import_strategies6 = require("@tradejs/node/strategies");
-    import_runtimeStrategies4 = require("@tradejs/node/runtimeStrategies");
+    import_runtimeStrategies3 = require("@tradejs/node/runtimeStrategies");
     init_cliConfig2();
     init_portfolioReplayConnector();
     init_hooks();
@@ -16925,7 +16637,7 @@ var init_historicalSignalsReplay = __esm({
           if (!strategyCreator) {
             throw new Error(`Unknown strategy: ${strategyName}`);
           }
-          const installed = await (0, import_runtimeStrategies4.getRuntimeStrategyPackageMetadata)({
+          const installed = await (0, import_runtimeStrategies3.getRuntimeStrategyPackageMetadata)({
             strategyName,
             projectRoot: replayProjectRoot,
             strategyModule
@@ -20986,7 +20698,7 @@ ${markdownTable2(strategyRows)}
 });
 
 // src/scripts/replayRunner.ts
-var import_chalk21, import_constants14, import_data5, import_time8, import_redis11, import_candles, import_runtimeStrategies5, import_strategies7, prepareReplayBinanceMarketContext, replayMarketContextInterval, cachedTickerSymbols, finishReplay, replayBacktest;
+var import_chalk21, import_constants14, import_data5, import_time8, import_redis11, import_candles, import_runtimeStrategies4, import_strategies7, prepareReplayBinanceMarketContext, replayMarketContextInterval, cachedTickerSymbols, finishReplay, replayBacktest;
 var init_replayRunner = __esm({
   "src/scripts/replayRunner.ts"() {
     "use strict";
@@ -20996,7 +20708,7 @@ var init_replayRunner = __esm({
     import_time8 = require("@tradejs/core/time");
     import_redis11 = require("@tradejs/infra/redis");
     import_candles = require("@tradejs/infra/timescale/candles");
-    import_runtimeStrategies5 = require("@tradejs/node/runtimeStrategies");
+    import_runtimeStrategies4 = require("@tradejs/node/runtimeStrategies");
     import_strategies7 = require("@tradejs/node/strategies");
     init_runFormatting();
     init_runEnvironment();
@@ -21184,8 +20896,8 @@ var init_replayRunner = __esm({
         );
       }
       const replayComposition = evidenceMetadata ? {
-        deployment: runtimeDeploymentFromEvidence(evidenceMetadata.deployment),
-        strategies: activeRuntimeEvidenceStrategies(
+        deployment: (0, runtimeEvidenceDeployment_exports.runtimeDeploymentFromEvidence)(evidenceMetadata.deployment),
+        strategies: (0, runtimeEvidenceDeployment_exports.activeRuntimeEvidenceStrategies)(
           evidenceMetadata.deployment
         ).map(
           ({
@@ -21237,7 +20949,7 @@ var init_replayRunner = __esm({
         return {
           ...strategy,
           strategyConfig,
-          strategyRevision: (0, import_runtimeStrategies5.computeStrategyRevision)({
+          strategyRevision: (0, import_runtimeStrategies4.computeStrategyRevision)({
             strategyName: strategy.strategyName,
             strategyPackage: strategy.strategyPackage,
             strategyPackageVersion: strategy.strategyPackageVersion,
@@ -21247,7 +20959,7 @@ var init_replayRunner = __esm({
           })
         };
       });
-      const researchDeploymentCompositionId = (0, import_runtimeStrategies5.computeDeploymentCompositionId)({
+      const researchDeploymentCompositionId = (0, import_runtimeStrategies4.computeDeploymentCompositionId)({
         deploymentId: deployment.id,
         connectorName: deployment.connectorName,
         provider: deployment.provider,
@@ -24658,12 +24370,268 @@ var init_marketWs = __esm({
   }
 });
 
+// src/scripts/mcpWorker.ts
+var mcpWorker_exports = {};
+__export(mcpWorker_exports, {
+  main: () => main26
+});
+var import_node_child_process4, import_node_crypto8, import_promises17, import_redis15, import_mcp, pause, leaseKey, LEASE_SECONDS, JOB_TIMEOUT_MS, main26;
+var init_mcpWorker = __esm({
+  "src/scripts/mcpWorker.ts"() {
+    "use strict";
+    import_node_child_process4 = require("child_process");
+    import_node_crypto8 = require("crypto");
+    import_promises17 = require("fs/promises");
+    import_redis15 = require("@tradejs/infra/redis");
+    import_mcp = require("@tradejs/node/mcp");
+    pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+    leaseKey = "worker:lease";
+    LEASE_SECONDS = 15;
+    JOB_TIMEOUT_MS = 60 * 60 * 1e3;
+    main26 = async (options = {}) => {
+      const owner = (0, import_node_crypto8.randomUUID)();
+      if (!await import_redis15.mcpStorage.put(leaseKey, owner, LEASE_SECONDS, true))
+        throw new Error("Another MCP worker owns this storage");
+      let stopping = false;
+      let child;
+      let renewing = false;
+      let leaseLost = false;
+      let manifestHash = "";
+      const signalChild = (signal) => {
+        if (!child?.pid) return;
+        try {
+          process.kill(
+            process.platform === "win32" ? child.pid : -child.pid,
+            signal
+          );
+        } catch {
+        }
+      };
+      const heartbeatValue = () => ({
+        observedAt: Date.now(),
+        packageManifestSha256: manifestHash,
+        replayAvailable: Boolean(process.env.MCP_REPLAY_REDIS_HOST)
+      });
+      const stop = () => {
+        stopping = true;
+        signalChild("SIGTERM");
+      };
+      options.signal?.addEventListener("abort", stop, { once: true });
+      if (options.signal?.aborted) stop();
+      process.once("SIGINT", stop);
+      process.once("SIGTERM", stop);
+      const heartbeat = setInterval(async () => {
+        if (renewing || leaseLost) return;
+        renewing = true;
+        try {
+          if (!await import_redis15.mcpStorage.compare(leaseKey, owner, owner, LEASE_SECONDS))
+            throw new Error("Worker lease lost");
+          await import_redis15.mcpStorage.put("worker:heartbeat", heartbeatValue(), LEASE_SECONDS);
+        } catch {
+          leaseLost = true;
+          stop();
+        } finally {
+          renewing = false;
+        }
+      }, 2e3);
+      try {
+        manifestHash = await (0, import_mcp.mcpPackageManifestHash)();
+        await import_redis15.mcpStorage.put("worker:heartbeat", heartbeatValue(), LEASE_SECONDS);
+        let cursor = "0";
+        do {
+          const page = await import_redis15.mcpStorage.scan("jobs:", cursor);
+          cursor = page.cursor;
+          for (const key of page.ids) {
+            const job = await import_redis15.mcpStorage.get(key);
+            if (job?.status === "running")
+              await import_redis15.mcpStorage.compare(
+                key,
+                job,
+                {
+                  ...job,
+                  status: "failed",
+                  error: "Worker restarted; this job was not replayed",
+                  finishedAt: Date.now(),
+                  updatedAt: Date.now()
+                },
+                import_mcp.MCP_JOB_TTL
+              );
+          }
+        } while (cursor !== "0" && !stopping);
+        console.log(
+          "MCP worker ready (one job at a time, cached history, no live order commands)"
+        );
+        while (!stopping) {
+          let queued;
+          cursor = "0";
+          do {
+            const page = await import_redis15.mcpStorage.scan("jobs:", cursor);
+            cursor = page.cursor;
+            for (const key of page.ids) {
+              const job = await import_redis15.mcpStorage.get(key);
+              if (job?.status === "queued" && (!queued || job.createdAt < queued.createdAt))
+                queued = job;
+            }
+          } while (cursor !== "0" && !stopping);
+          if (!queued) {
+            await pause(1e3);
+            continue;
+          }
+          const jobKey = (0, import_mcp.mcpJobStorageId)(queued.userName, queued.id);
+          const started = {
+            ...queued,
+            status: "running",
+            startedAt: Date.now(),
+            updatedAt: Date.now()
+          };
+          if (!await import_redis15.mcpStorage.compare(jobKey, queued, started, import_mcp.MCP_JOB_TTL))
+            continue;
+          if (started.packageManifestSha256 !== manifestHash) {
+            await import_redis15.mcpStorage.compare(
+              jobKey,
+              started,
+              {
+                ...started,
+                status: "failed",
+                error: "Package composition changed since submission",
+                finishedAt: Date.now()
+              },
+              import_mcp.MCP_JOB_TTL
+            );
+            continue;
+          }
+          await (0, import_promises17.mkdir)((0, import_mcp.mcpJobDirectory)(started), { recursive: true });
+          if (started.kind === "backtest")
+            await (0, import_redis15.setDataStrict)(
+              import_redis15.redisKeys.backtestConfig(
+                started.userName,
+                String(started.request.frozenConfigId)
+              ),
+              started.request.resolvedConfig,
+              { expire: import_mcp.MCP_JOB_TTL }
+            );
+          const jobEnv = {
+            ...process.env,
+            NODE_OPTIONS: "--max-old-space-size=1024",
+            MCP_WORKER: "true",
+            BACKTEST_WORKER_HEAP_MB: "768",
+            BACKTEST_MAX_PARALLEL: "1",
+            AI_ENABLED: "false",
+            ML_ENABLED: "false",
+            MAKE_ORDERS: "false",
+            TRADEJS_EXTERNAL_ORDER_PLACEMENT: "false"
+          };
+          if (started.kind === "runtime-feedback-replay") {
+            for (const name of Object.keys(jobEnv)) {
+              if (/secret|token|api.?key|private.?key|cookie|credential/i.test(name))
+                delete jobEnv[name];
+            }
+            Object.assign(jobEnv, {
+              DOTENV_CONFIG_PATH: "/dev/null",
+              REDIS_HOST: process.env.MCP_REPLAY_REDIS_HOST,
+              REDIS_PORT: "6379",
+              REDIS_DB: "0",
+              RUNTIME_FEEDBACK_ISOLATED_REDIS: "true",
+              PGOPTIONS: "-c default_transaction_read_only=on",
+              TRADEJS_TIMESCALE_READ_ONLY: "true"
+            });
+          }
+          child = (0, import_node_child_process4.spawn)(process.execPath, [process.argv[1], ...started.args], {
+            cwd: process.env.PROJECT_CWD || process.cwd(),
+            env: jobEnv,
+            detached: process.platform !== "win32",
+            stdio: ["ignore", "pipe", "pipe"]
+          });
+          const currentChild = child;
+          let timedOut = false;
+          const timeout = setTimeout(() => {
+            timedOut = true;
+            signalChild("SIGTERM");
+          }, JOB_TIMEOUT_MS);
+          const logs = [];
+          const log = (chunk) => {
+            const lines = chunk.toString().replace(/\u001b\[[0-9;]*m/g, "").split(/[\r\n]+/).filter(Boolean);
+            logs.push(
+              ...lines.map(
+                (line) => line.slice(0, 1e3).replace(
+                  /((?:secret|password|api.?key|token|authorization)\s*[:=]\s*)\S+/gi,
+                  "$1[redacted]"
+                )
+              )
+            );
+            if (logs.length > 150) logs.splice(0, logs.length - 150);
+          };
+          currentChild.stdout?.on("data", log);
+          currentChild.stderr?.on("data", log);
+          let killAt;
+          const monitor = setInterval(async () => {
+            try {
+              const latest = await import_redis15.mcpStorage.get(jobKey);
+              if (!latest || latest.cancelRequested || stopping || timedOut) {
+                killAt ??= Date.now();
+                signalChild(Date.now() - killAt > 8e3 ? "SIGKILL" : "SIGTERM");
+              }
+              if (latest && !leaseLost)
+                await import_redis15.mcpStorage.compare(
+                  jobKey,
+                  latest,
+                  { ...latest, logs: [...logs], updatedAt: Date.now() },
+                  import_mcp.MCP_JOB_TTL
+                );
+            } catch {
+              leaseLost = true;
+              stop();
+            }
+          }, 1e3);
+          const outcome = await new Promise((resolve) => {
+            currentChild.once(
+              "error",
+              () => resolve({ code: null, error: "Unable to start research process" })
+            );
+            currentChild.once("exit", (code) => resolve({ code }));
+          });
+          clearTimeout(timeout);
+          clearInterval(monitor);
+          child = void 0;
+          if (!leaseLost) {
+            for (let attempt = 0; attempt < 4; attempt++) {
+              const latest = await import_redis15.mcpStorage.get(jobKey);
+              if (!latest) break;
+              const cancelled = latest.cancelRequested;
+              const next = {
+                ...latest,
+                logs,
+                status: cancelled ? "cancelled" : outcome.code === 0 && !timedOut && !stopping ? "completed" : "failed",
+                exitCode: outcome.code,
+                updatedAt: Date.now(),
+                finishedAt: Date.now(),
+                ...cancelled ? {} : timedOut ? { error: "Job exceeded one hour" } : stopping ? { error: "Worker stopped; this job was not replayed" } : outcome.code !== 0 ? { error: outcome.error || "Research process failed" } : {}
+              };
+              if (await import_redis15.mcpStorage.compare(jobKey, latest, next, import_mcp.MCP_JOB_TTL))
+                break;
+            }
+          }
+        }
+      } finally {
+        clearInterval(heartbeat);
+        options.signal?.removeEventListener("abort", stop);
+        process.removeListener("SIGINT", stop);
+        process.removeListener("SIGTERM", stop);
+        if (await import_redis15.mcpStorage.release(leaseKey, owner))
+          await import_redis15.mcpStorage.remove("worker:heartbeat");
+      }
+      if (leaseLost)
+        throw new Error("Worker lease lost; active computation was stopped");
+    };
+  }
+});
+
 // src/scripts/hyperliquidWhaleBackfill.ts
 var hyperliquidWhaleBackfill_exports = {};
 __export(hyperliquidWhaleBackfill_exports, {
-  main: () => main26
+  main: () => main27
 });
-var import_args20, flags18, parseTime, main26;
+var import_args20, flags18, parseTime, main27;
 var init_hyperliquidWhaleBackfill2 = __esm({
   "src/scripts/hyperliquidWhaleBackfill.ts"() {
     "use strict";
@@ -24683,7 +24651,7 @@ var init_hyperliquidWhaleBackfill2 = __esm({
       if (!Number.isFinite(parsed)) throw new Error(`Invalid timestamp: ${value}`);
       return parsed;
     };
-    main26 = async () => {
+    main27 = async () => {
       const toMs = parseTime(flags18.to, Date.now());
       const days = Number(flags18.days);
       const lookbackMs = (Number.isFinite(days) && days > 0 ? days : 1) * 864e5;
@@ -24892,14 +24860,14 @@ var init_hyperliquidWhaleStream = __esm({
 // src/scripts/hyperliquidWhaleIngest.ts
 var hyperliquidWhaleIngest_exports = {};
 __export(hyperliquidWhaleIngest_exports, {
-  main: () => main27
+  main: () => main28
 });
-var main27;
+var main28;
 var init_hyperliquidWhaleIngest = __esm({
   "src/scripts/hyperliquidWhaleIngest.ts"() {
     "use strict";
     init_hyperliquidWhaleStream();
-    main27 = async () => {
+    main28 = async () => {
       const controller = new AbortController();
       const stop = () => controller.abort();
       process.once("SIGINT", stop);
@@ -25011,15 +24979,15 @@ var init_hyperliquidWhaleSelection = __esm({
 // src/scripts/hyperliquidWhalesUpdate.ts
 var hyperliquidWhalesUpdate_exports = {};
 __export(hyperliquidWhalesUpdate_exports, {
-  main: () => main28
+  main: () => main29
 });
-var import_config8, import_args21, import_node_crypto8, import_strategies12, LEADERBOARD_URL, DAY_MS10, CANDIDATE_LIMIT, flags19, fingerprint, runConcurrent2, main28;
+var import_config8, import_args21, import_node_crypto9, import_strategies12, LEADERBOARD_URL, DAY_MS10, CANDIDATE_LIMIT, flags19, fingerprint, runConcurrent2, main29;
 var init_hyperliquidWhalesUpdate = __esm({
   "src/scripts/hyperliquidWhalesUpdate.ts"() {
     "use strict";
     import_config8 = require("dotenv/config");
     import_args21 = __toESM(require("args"));
-    import_node_crypto8 = require("crypto");
+    import_node_crypto9 = require("crypto");
     import_strategies12 = require("@tradejs/node/strategies");
     init_hyperliquidWhaleBackfill();
     init_hyperliquidRateLimiter();
@@ -25033,7 +25001,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_crypto8.createHash)("sha256").update(JSON.stringify(addresses)).digest("hex").slice(0, 16);
+    fingerprint = (addresses) => (0, import_node_crypto9.createHash)("sha256").update(JSON.stringify(addresses)).digest("hex").slice(0, 16);
     runConcurrent2 = async (params) => {
       let nextIndex = 0;
       await Promise.all(
@@ -25047,7 +25015,7 @@ var init_hyperliquidWhalesUpdate = __esm({
         })
       );
     };
-    main28 = async () => {
+    main29 = async () => {
       const explicitTo = flags19.to == null ? Number.NaN : Date.parse(String(flags19.to));
       const calibrationToMs = Number.isFinite(explicitTo) ? explicitTo : Math.floor(Date.now() / DAY_MS10) * DAY_MS10;
       const calibrationDays = Math.max(1, Number(flags19.days) || 7);
@@ -25140,15 +25108,15 @@ var init_hyperliquidWhalesUpdate = __esm({
 // src/scripts/mlExport.ts
 var mlExport_exports = {};
 __export(mlExport_exports, {
-  main: () => main29
+  main: () => main30
 });
-var import_args22, import_chalk37, import_promises17, import_path8, import_ml, flags20, resolveRunScopedMlChunks, main29;
+var import_args22, import_chalk37, import_promises18, import_path8, import_ml, flags20, resolveRunScopedMlChunks, main30;
 var init_mlExport = __esm({
   "src/scripts/mlExport.ts"() {
     "use strict";
     import_args22 = __toESM(require("args"));
     import_chalk37 = __toESM(require("chalk"));
-    import_promises17 = __toESM(require("fs/promises"));
+    import_promises18 = __toESM(require("fs/promises"));
     import_path8 = __toESM(require("path"));
     import_ml = require("@tradejs/infra/ml");
     init_checkpoint();
@@ -25197,9 +25165,9 @@ var init_mlExport = __esm({
         completedAttemptKeys: buildCompletedBacktestDatasetAttemptKeys(completed)
       };
     };
-    main29 = async () => {
+    main30 = async () => {
       const outDir = String(flags20.outDir || "data/ml/export");
-      await import_promises17.default.mkdir(outDir, { recursive: true });
+      await import_promises18.default.mkdir(outDir, { recursive: true });
       const strategyName = await resolveExportStrategy({
         explicitStrategy: String(flags20.strategy || ""),
         outDir,
@@ -25244,7 +25212,7 @@ var init_mlExport = __esm({
       const shouldDeleteChunks = !Boolean(flags20.keepChunks);
       if (shouldDeleteChunks) {
         for (const filePath of chunkFiles) {
-          await import_promises17.default.rm(filePath, { force: true });
+          await import_promises18.default.rm(filePath, { force: true });
         }
       }
       console.log(import_chalk37.default.green(`Merged dataset saved: ${mergedPath}`));
@@ -25263,15 +25231,15 @@ var init_mlExport = __esm({
 // src/scripts/mlInspect.ts
 var mlInspect_exports = {};
 __export(mlInspect_exports, {
-  main: () => main30
+  main: () => main31
 });
-var import_args23, import_chalk38, import_promises18, 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, main30;
+var import_args23, import_chalk38, import_promises19, import_fs3, import_path9, import_readline2, import_child_process2, flags21, toMode, toInspectTool, selectInspectTool, asPositiveInt, readRowsHead, readRowsTail, readRowsSample, quantileSorted, mean2, std, findLatestDataset, buildNumericStats, formatNumber5, runQuickInspect, runYDataInspect, main31;
 var init_mlInspect = __esm({
   "src/scripts/mlInspect.ts"() {
     "use strict";
     import_args23 = __toESM(require("args"));
     import_chalk38 = __toESM(require("chalk"));
-    import_promises18 = __toESM(require("fs/promises"));
+    import_promises19 = __toESM(require("fs/promises"));
     import_fs3 = require("fs");
     import_path9 = __toESM(require("path"));
     import_readline2 = __toESM(require("readline"));
@@ -25448,7 +25416,7 @@ var init_mlInspect = __esm({
     };
     findLatestDataset = async (params) => {
       const { dir, strategy } = params;
-      const entries = await import_promises18.default.readdir(dir, { withFileTypes: true });
+      const entries = await import_promises19.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.")
@@ -25460,7 +25428,7 @@ var init_mlInspect = __esm({
       }
       const withMtime = await Promise.all(
         files.map(async (name) => {
-          const stat = await import_promises18.default.stat(import_path9.default.join(dir, name));
+          const stat = await import_promises19.default.stat(import_path9.default.join(dir, name));
           return { name, mtime: stat.mtimeMs };
         })
       );
@@ -25705,7 +25673,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_promises18.default.mkdir(reportDir, { recursive: true });
+      await import_promises19.default.mkdir(reportDir, { recursive: true });
       const reportPath = import_path9.default.join(
         reportDir,
         `${import_path9.default.basename(datasetPath, import_path9.default.extname(datasetPath))}.profile.html`
@@ -25757,7 +25725,7 @@ var init_mlInspect = __esm({
       }
       console.log(import_chalk38.default.green(`Profile report saved: ${reportPath}`));
     };
-    main30 = async () => {
+    main31 = async () => {
       const dir = String(flags21.dir || "data/ml/export");
       const rowsToInspect = asPositiveInt(flags21.rows, 1e4);
       const mode = toMode(flags21.mode);
@@ -25799,14 +25767,14 @@ var init_mlInspect = __esm({
 // src/scripts/mlTrainLatestSelect.ts
 var mlTrainLatestSelect_exports = {};
 __export(mlTrainLatestSelect_exports, {
-  main: () => main31
+  main: () => main32
 });
-var import_path10, import_promises19, import_fs4, import_crypto2, import_child_process3, import_events, import_readline3, import_args24, import_chalk39, import_ml2, toFileToken6, asBool, asInt7, asNonNegativeInt, formatBytes, getMlContainerMemUsage, MODEL_TYPES, STRATEGIES, flags22, parseStrategy, parseModelType, selectModelType, listDatasetFiles, concatFiles, pipeNormalized, DAY_MS11, SPLIT_PROGRESS_EVERY, parseTimestampMs, scanMaxLabeledTimestampMs, scanMaxTrainTimestampMs, hashFileNameSha1, prepareTrainWindowFiles, main31;
+var import_path10, import_promises20, import_fs4, import_crypto2, import_child_process3, import_events, import_readline3, import_args24, import_chalk39, import_ml2, toFileToken6, asBool, asInt7, asNonNegativeInt, formatBytes, getMlContainerMemUsage, MODEL_TYPES, STRATEGIES, flags22, parseStrategy, parseModelType, selectModelType, listDatasetFiles, concatFiles, pipeNormalized, DAY_MS11, SPLIT_PROGRESS_EVERY, parseTimestampMs, scanMaxLabeledTimestampMs, scanMaxTrainTimestampMs, hashFileNameSha1, prepareTrainWindowFiles, main32;
 var init_mlTrainLatestSelect = __esm({
   "src/scripts/mlTrainLatestSelect.ts"() {
     "use strict";
     import_path10 = __toESM(require("path"));
-    import_promises19 = __toESM(require("fs/promises"));
+    import_promises20 = __toESM(require("fs/promises"));
     import_fs4 = require("fs");
     import_crypto2 = require("crypto");
     import_child_process3 = require("child_process");
@@ -25935,7 +25903,7 @@ var init_mlTrainLatestSelect = __esm({
       return defaultModel;
     };
     listDatasetFiles = async (dir, strategyName) => {
-      const entries = await import_promises19.default.readdir(dir, { withFileTypes: true });
+      const entries = await import_promises20.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);
@@ -25946,7 +25914,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_promises19.default.stat(import_path10.default.join(dir, name));
+          const stat = await import_promises20.default.stat(import_path10.default.join(dir, name));
           return { name, mtime: stat.mtimeMs };
         })
       );
@@ -26122,13 +26090,13 @@ var init_mlTrainLatestSelect = __esm({
       const metaPath = import_path10.default.join(dir, `${parsed.name}.windows.${key}.meta.json`);
       try {
         const [metaRaw] = await Promise.all([
-          import_promises19.default.readFile(metaPath, "utf8"),
-          import_promises19.default.access(holdoutTrainPath),
-          import_promises19.default.access(holdoutTestPath),
-          import_promises19.default.access(prodPath),
+          import_promises20.default.readFile(metaPath, "utf8"),
+          import_promises20.default.access(holdoutTrainPath),
+          import_promises20.default.access(holdoutTestPath),
+          import_promises20.default.access(prodPath),
           ...walkForwardFoldDefs.flatMap((entry) => [
-            import_promises19.default.access(entry.trainPath),
-            import_promises19.default.access(entry.testPath)
+            import_promises20.default.access(entry.trainPath),
+            import_promises20.default.access(entry.testPath)
           ])
         ]);
         const meta2 = JSON.parse(metaRaw);
@@ -26495,7 +26463,7 @@ var init_mlTrainLatestSelect = __esm({
         },
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
-      await import_promises19.default.writeFile(metaPath, `${JSON.stringify(meta, null, 2)}
+      await import_promises20.default.writeFile(metaPath, `${JSON.stringify(meta, null, 2)}
 `, "utf8");
       return {
         holdoutTrainPath,
@@ -26522,7 +26490,7 @@ var init_mlTrainLatestSelect = __esm({
         }
       };
     };
-    main31 = async () => {
+    main32 = async () => {
       const selectedFromCli = parseStrategy(flags22.strategy);
       const selected = selectedFromCli ?? await selectStrategy();
       const envModelType = (process.env.ML_MODEL_TYPE ?? "random_forest").trim().toLowerCase();
@@ -26553,7 +26521,7 @@ var init_mlTrainLatestSelect = __esm({
         process.exit(1);
       }
       try {
-        const inputStat = await import_promises19.default.stat(inputPath);
+        const inputStat = await import_promises20.default.stat(inputPath);
         const totalInputBytes = inputStat.size;
         const autoIncrementalThresholdGb = asInt7(
           process.env.ML_TRAIN_INCREMENTAL_THRESHOLD_GB,
@@ -26742,7 +26710,7 @@ var init_mlTrainLatestSelect = __esm({
           const modelDir = import_path10.default.join(modelDirRoot, "models");
           let savedModels = [];
           try {
-            const entries = await import_promises19.default.readdir(modelDir, { withFileTypes: true });
+            const entries = await import_promises20.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();
@@ -26764,7 +26732,7 @@ var init_mlTrainLatestSelect = __esm({
         process.exitCode = finalCode;
       } finally {
         for (const file of cleanupFiles) {
-          await import_promises19.default.rm(file, { force: true });
+          await import_promises20.default.rm(file, { force: true });
         }
       }
       process.exit(process.exitCode ?? 1);
@@ -26786,7 +26754,7 @@ __export(researchAuto_exports, {
   isProcessAlive: () => isProcessAlive,
   listMergedFiles: () => listMergedFiles3,
   listRuntimeStrategyNames: () => listRuntimeStrategyNames,
-  main: () => main32,
+  main: () => main33,
   parseJsonOutput: () => parseJsonOutput,
   releaseResearchAutoLock: () => releaseResearchAutoLock,
   resolveHeapMbFromEnv: () => resolveHeapMbFromEnv,
@@ -26796,20 +26764,20 @@ __export(researchAuto_exports, {
   toStrategyConfigGrid: () => toStrategyConfigGrid2,
   trimTextTail: () => trimTextTail2
 });
-var import_args25, import_chalk40, import_node_child_process4, import_promises20, import_node_os2, import_node_path14, import_constants18, import_ai8, import_logger6, import_redis15, 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, main32;
+var import_args25, import_chalk40, import_node_child_process5, import_promises21, import_node_os2, import_node_path14, import_constants18, import_ai8, import_logger6, import_redis16, import_registry4, flags23, projectRoot8, dotenvPath, getResearchAutoLockPath, readResearchAutoLock, isProcessAlive, acquireResearchAutoLock, releaseResearchAutoLock, resolvePositiveInteger, resolveHeapMbFromEnv, buildNodeOptions, RESEARCH_AUTO_PARENT_HEAP_MB, RESEARCH_AUTO_BACKTEST_PARENT_HEAP_MB, RESEARCH_AUTO_AI_TRAIN_PARENT_HEAP_MB, RESEARCH_AUTO_AGENT_PARENT_HEAP_MB, trimTextTail2, escapeHtml3, createEmptySteps, saveRun, listMergedFiles3, getBacktestResultsPrefix, listRuntimeStrategyNames, toStrategyConfigGrid2, formatMskDateTime, buildTelegramReport, runCliCommand, resolveTarget, parseJsonOutput, logResearch, executeNonBlockingStep, main33;
 var init_researchAuto = __esm({
   "src/scripts/researchAuto.ts"() {
     "use strict";
     import_args25 = __toESM(require("args"));
     import_chalk40 = __toESM(require("chalk"));
-    import_node_child_process4 = require("child_process");
-    import_promises20 = __toESM(require("fs/promises"));
+    import_node_child_process5 = require("child_process");
+    import_promises21 = __toESM(require("fs/promises"));
     import_node_os2 = __toESM(require("os"));
     import_node_path14 = __toESM(require("path"));
     import_constants18 = require("@tradejs/core/constants");
     import_ai8 = require("@tradejs/infra/ai");
     import_logger6 = require("@tradejs/infra/logger");
-    import_redis15 = require("@tradejs/infra/redis");
+    import_redis16 = require("@tradejs/infra/redis");
     import_registry4 = require("@tradejs/node/registry");
     init_runtimeRedis();
     init_runtimeStrategyBacktest();
@@ -26850,7 +26818,7 @@ var init_researchAuto = __esm({
     );
     readResearchAutoLock = async (lockPath) => {
       try {
-        const raw = await import_promises20.default.readFile(lockPath, "utf8");
+        const raw = await import_promises21.default.readFile(lockPath, "utf8");
         return JSON.parse(raw);
       } catch {
         return null;
@@ -26885,9 +26853,9 @@ var init_researchAuto = __esm({
         startedAt,
         argv: [...process.argv]
       };
-      await import_promises20.default.mkdir(import_node_path14.default.dirname(lockPath), { recursive: true });
+      await import_promises21.default.mkdir(import_node_path14.default.dirname(lockPath), { recursive: true });
       const writeLock = async () => {
-        await import_promises20.default.writeFile(lockPath, JSON.stringify(nextLock, null, 2), {
+        await import_promises21.default.writeFile(lockPath, JSON.stringify(nextLock, null, 2), {
           flag: "wx"
         });
       };
@@ -26906,7 +26874,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_promises20.default.unlink(lockPath).catch(() => void 0);
+      await import_promises21.default.unlink(lockPath).catch(() => void 0);
       await writeLock();
       return lockPath;
     };
@@ -26918,7 +26886,7 @@ var init_researchAuto = __esm({
       if (existingLock && existingLock.pid !== process.pid) {
         return;
       }
-      await import_promises20.default.unlink(lockPath).catch(() => void 0);
+      await import_promises21.default.unlink(lockPath).catch(() => void 0);
     };
     resolvePositiveInteger = (value, fallback) => {
       const parsed = Number.parseInt(String(value ?? ""), 10);
@@ -27011,16 +26979,16 @@ var init_researchAuto = __esm({
       }
     });
     saveRun = async (run) => {
-      await (0, import_redis15.setData)(import_redis15.redisKeys.researchRun(run.userName, run.runId), run, {
+      await (0, import_redis16.setData)(import_redis16.redisKeys.researchRun(run.userName, run.runId), run, {
         expire: import_constants18.TTL_1M
       });
-      await (0, import_redis15.setData)(import_redis15.redisKeys.researchLatestRun(run.userName, run.strategy), run, {
+      await (0, import_redis16.setData)(import_redis16.redisKeys.researchLatestRun(run.userName, run.strategy), run, {
         expire: import_constants18.TTL_1M
       });
     };
     listMergedFiles3 = async (outDir, strategyName) => {
       try {
-        const entries = await import_promises20.default.readdir(outDir);
+        const entries = await import_promises21.default.readdir(outDir);
         const prefix = `ai-dataset-${(0, import_ai8.toFileToken)(strategyName)}-merged-`;
         return entries.filter((name) => name.startsWith(prefix) && name.endsWith(".jsonl")).sort().map((name) => import_node_path14.default.join(outDir, name));
       } catch {
@@ -27154,7 +27122,7 @@ var init_researchAuto = __esm({
         } : {}
       };
       return new Promise((resolve, reject) => {
-        const child = (0, import_node_child_process4.spawn)(
+        const child = (0, import_node_child_process5.spawn)(
           process.execPath,
           [import_node_path14.default.resolve(process.argv[1]), params.command, ...params.args],
           {
@@ -27244,8 +27212,8 @@ var init_researchAuto = __esm({
       const candidates = [];
       for (const strategy of availableStrategies) {
         const config2 = `${strategy}:research`;
-        const latestRun = await (0, import_redis15.getData)(
-          import_redis15.redisKeys.researchLatestRun(userName3, strategy),
+        const latestRun = await (0, import_redis16.getData)(
+          import_redis16.redisKeys.researchLatestRun(userName3, strategy),
           null
         );
         const lastFinishedAt = latestRun?.finishedAt ? Date.parse(latestRun.finishedAt) : 0;
@@ -27321,7 +27289,7 @@ var init_researchAuto = __esm({
       );
       return result;
     };
-    main32 = async () => {
+    main33 = async () => {
       resolveRequiredResearchRoots({ projectRoot: projectRoot8 });
       const userName3 = String(flags23.user || "root").trim() || "root";
       const connector = String(flags23.connector || "bybit").trim() || "bybit";
@@ -27424,13 +27392,13 @@ var init_researchAuto = __esm({
           startedAt
         };
         await saveRun(run);
-        const strategyConfigKey = import_redis15.redisKeys.strategyConfig(
+        const strategyConfigKey = import_redis16.redisKeys.strategyConfig(
           userName3,
           target.strategy
         );
-        const backtestConfigKey = import_redis15.redisKeys.backtestConfig(userName3, target.config);
+        const backtestConfigKey = import_redis16.redisKeys.backtestConfig(userName3, target.config);
         const defaults = await (0, import_registry4.getStrategyDefaults)(target.strategy, projectRoot8) || {};
-        const userStrategyConfig = await (0, import_redis15.getData)(
+        const userStrategyConfig = await (0, import_redis16.getData)(
           strategyConfigKey,
           {}
         );
@@ -27444,7 +27412,7 @@ var init_researchAuto = __esm({
           );
         }
         const backtestConfig = toStrategyConfigGrid2(strategyConfig);
-        await (0, import_redis15.setData)(backtestConfigKey, backtestConfig, { expire: 0 });
+        await (0, import_redis16.setData)(backtestConfigKey, backtestConfig, { expire: 0 });
         logResearch(
           `stored backtest config at ${backtestConfigKey} with ${Object.keys(strategyConfig).length} top-level fields`
         );
@@ -27484,7 +27452,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_redis15.getKeys)(getBacktestResultsPrefix(userName3, target.config))
+          await (0, import_redis16.getKeys)(getBacktestResultsPrefix(userName3, target.config))
         );
         const aiFilesBefore = new Set(
           await listMergedFiles3(outDir, target.strategy)
@@ -27546,14 +27514,14 @@ var init_researchAuto = __esm({
             captureMode: "full"
           }
         );
-        const backtestKeysAfter = await (0, import_redis15.getKeys)(
+        const backtestKeysAfter = await (0, import_redis16.getKeys)(
           getBacktestResultsPrefix(userName3, target.config)
         );
         const newBacktestKeys = backtestKeysAfter.filter((key) => !backtestKeysBefore.has(key)).sort();
         const backtestResultKey = newBacktestKeys[newBacktestKeys.length - 1] || backtestKeysAfter.sort().at(-1);
         if (backtestResultKey) {
           logResearch(`detected backtest result key ${backtestResultKey}`);
-          const backtestResult = await (0, import_redis15.getData)(backtestResultKey, null);
+          const backtestResult = await (0, import_redis16.getData)(backtestResultKey, null);
           run.artifacts.backtestResultKey = backtestResultKey;
           run.artifacts.backtestResult = backtestResult ? {
             finishedAt: backtestResult.finishedAt,
@@ -27688,13 +27656,13 @@ var init_types = __esm({
 function assert(condition, message) {
   if (!condition) throw new Error(`Invalid core research spec: ${message}`);
 }
-var import_node_crypto9, import_node_fs3, import_promises21, import_backtest5, import_node_path15, RESEARCH_ID_RE, SHA256_RE, canonicalJson, sha256Text, sha256Json, sha256File, assertFinite, validateCoreResearchSpec, loadCoreResearchSpec, resolveCoreResearchPaths, writeJsonAtomic, buildLedgerRecordHash, readCoreResearchLedger, verifyCoreResearchLedger, appendCoreResearchLedger, validateCoreResearchParentLineage, prepareCoreResearch, verifyCoreResearchArtifacts, scanCoreResearchStages, writeCoreResearchStageIndex;
+var import_node_crypto10, import_node_fs3, import_promises22, import_backtest5, import_node_path15, RESEARCH_ID_RE, SHA256_RE, canonicalJson, sha256Text, sha256Json, sha256File, assertFinite, validateCoreResearchSpec, loadCoreResearchSpec, resolveCoreResearchPaths, writeJsonAtomic, buildLedgerRecordHash, readCoreResearchLedger, verifyCoreResearchLedger, appendCoreResearchLedger, validateCoreResearchParentLineage, prepareCoreResearch, verifyCoreResearchArtifacts, scanCoreResearchStages, writeCoreResearchStageIndex;
 var init_io = __esm({
   "src/lib/coreResearch/io.ts"() {
     "use strict";
-    import_node_crypto9 = require("crypto");
+    import_node_crypto10 = require("crypto");
     import_node_fs3 = require("fs");
-    import_promises21 = __toESM(require("fs/promises"));
+    import_promises22 = __toESM(require("fs/promises"));
     import_backtest5 = require("@tradejs/core/backtest");
     import_node_path15 = __toESM(require("path"));
     init_types();
@@ -27712,10 +27680,10 @@ var init_io = __esm({
       };
       return JSON.stringify(normalize(value));
     };
-    sha256Text = (value) => (0, import_node_crypto9.createHash)("sha256").update(value).digest("hex");
+    sha256Text = (value) => (0, import_node_crypto10.createHash)("sha256").update(value).digest("hex");
     sha256Json = (value) => sha256Text(canonicalJson(value));
     sha256File = async (filePath) => {
-      const hash = (0, import_node_crypto9.createHash)("sha256");
+      const hash = (0, import_node_crypto10.createHash)("sha256");
       const input = (0, import_node_fs3.createReadStream)(filePath);
       for await (const chunk of input) hash.update(chunk);
       return hash.digest("hex");
@@ -27956,7 +27924,7 @@ var init_io = __esm({
     };
     loadCoreResearchSpec = async (specPath) => {
       const resolvedPath = import_node_path15.default.resolve(specPath);
-      const parsed = JSON.parse(await import_promises21.default.readFile(resolvedPath, "utf8"));
+      const parsed = JSON.parse(await import_promises22.default.readFile(resolvedPath, "utf8"));
       const spec = validateCoreResearchSpec(parsed);
       return { resolvedPath, spec, specSha256: sha256Json(spec) };
     };
@@ -27978,17 +27946,17 @@ var init_io = __esm({
       };
     };
     writeJsonAtomic = async (filePath, value) => {
-      await import_promises21.default.mkdir(import_node_path15.default.dirname(filePath), { recursive: true });
+      await import_promises22.default.mkdir(import_node_path15.default.dirname(filePath), { recursive: true });
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-      await import_promises21.default.writeFile(temporaryPath, `${canonicalJson(value)}
+      await import_promises22.default.writeFile(temporaryPath, `${canonicalJson(value)}
 `, "utf8");
-      await import_promises21.default.rename(temporaryPath, filePath);
+      await import_promises22.default.rename(temporaryPath, filePath);
     };
     buildLedgerRecordHash = (record) => sha256Json(record);
     readCoreResearchLedger = async (ledgerPath) => {
       let text = "";
       try {
-        text = await import_promises21.default.readFile(ledgerPath, "utf8");
+        text = await import_promises22.default.readFile(ledgerPath, "utf8");
       } catch (error) {
         if (error.code === "ENOENT") return [];
         throw error;
@@ -28025,11 +27993,11 @@ var init_io = __esm({
     };
     appendCoreResearchLedger = async (params) => {
       const { ledgerPath } = params;
-      await import_promises21.default.mkdir(import_node_path15.default.dirname(ledgerPath), { recursive: true });
+      await import_promises22.default.mkdir(import_node_path15.default.dirname(ledgerPath), { recursive: true });
       const lockPath = `${ledgerPath}.lock`;
       let lock = null;
       try {
-        lock = await import_promises21.default.open(lockPath, "wx");
+        lock = await import_promises22.default.open(lockPath, "wx");
         const records = await readCoreResearchLedger(ledgerPath);
         const verified = verifyCoreResearchLedger(records);
         const payload = {
@@ -28048,7 +28016,7 @@ var init_io = __esm({
           ...payload,
           recordHash: buildLedgerRecordHash(payload)
         };
-        await import_promises21.default.appendFile(ledgerPath, `${canonicalJson(record)}
+        await import_promises22.default.appendFile(ledgerPath, `${canonicalJson(record)}
 `, "utf8");
         return record;
       } catch (error) {
@@ -28058,7 +28026,7 @@ var init_io = __esm({
         throw error;
       } finally {
         await lock?.close();
-        await import_promises21.default.rm(lockPath, { force: true });
+        await import_promises22.default.rm(lockPath, { force: true });
       }
     };
     validateCoreResearchParentLineage = async (spec) => {
@@ -28069,9 +28037,9 @@ var init_io = __esm({
       for (const parentResearchId of spec.parentResearchIds ?? []) {
         const parentDir = import_node_path15.default.join(rootDir, parentResearchId);
         const [parentSpec, parentManifest, parentResult] = await Promise.all([
-          import_promises21.default.readFile(import_node_path15.default.join(parentDir, "spec.json"), "utf8").then((text) => JSON.parse(text)),
-          import_promises21.default.readFile(import_node_path15.default.join(parentDir, "manifest.json"), "utf8").then((text) => JSON.parse(text)),
-          import_promises21.default.readFile(import_node_path15.default.join(parentDir, "result.json"), "utf8").then((text) => JSON.parse(text))
+          import_promises22.default.readFile(import_node_path15.default.join(parentDir, "spec.json"), "utf8").then((text) => JSON.parse(text)),
+          import_promises22.default.readFile(import_node_path15.default.join(parentDir, "manifest.json"), "utf8").then((text) => JSON.parse(text)),
+          import_promises22.default.readFile(import_node_path15.default.join(parentDir, "result.json"), "utf8").then((text) => JSON.parse(text))
         ]);
         validateCoreResearchSpec(parentSpec);
         if (parentManifest.status !== "completed") {
@@ -28118,12 +28086,12 @@ var init_io = __esm({
       await validateCoreResearchParentLineage(spec);
       const specSha256 = sha256Json(spec);
       const paths = resolveCoreResearchPaths(spec);
-      await import_promises21.default.mkdir(paths.researchDir, { recursive: true });
+      await import_promises22.default.mkdir(paths.researchDir, { recursive: true });
       let existing = null;
       let existingManifest = null;
       try {
         existing = JSON.parse(
-          await import_promises21.default.readFile(paths.specPath, "utf8")
+          await import_promises22.default.readFile(paths.specPath, "utf8")
         );
       } catch (error) {
         if (error.code !== "ENOENT") throw error;
@@ -28136,7 +28104,7 @@ var init_io = __esm({
       if (existing) {
         try {
           existingManifest = JSON.parse(
-            await import_promises21.default.readFile(paths.manifestPath, "utf8")
+            await import_promises22.default.readFile(paths.manifestPath, "utf8")
           );
         } catch (error) {
           if (error.code !== "ENOENT") throw error;
@@ -28175,7 +28143,7 @@ var init_io = __esm({
     verifyCoreResearchArtifacts = async (spec) => {
       const paths = resolveCoreResearchPaths(spec);
       const manifest = JSON.parse(
-        await import_promises21.default.readFile(paths.manifestPath, "utf8")
+        await import_promises22.default.readFile(paths.manifestPath, "utf8")
       );
       if (manifest.specSha256 !== sha256Json(spec)) {
         throw new Error("Manifest spec hash does not match the supplied spec");
@@ -28203,7 +28171,7 @@ var init_io = __esm({
       const resolvedRoot = import_node_path15.default.resolve(rootDir);
       let entries = [];
       try {
-        entries = await import_promises21.default.readdir(resolvedRoot);
+        entries = await import_promises22.default.readdir(resolvedRoot);
       } catch (error) {
         if (error.code === "ENOENT") {
           return {
@@ -28219,14 +28187,14 @@ var init_io = __esm({
         (left, right) => left < right ? -1 : left > right ? 1 : 0
       )) {
         const researchDir = import_node_path15.default.join(resolvedRoot, entry);
-        const stats = await import_promises21.default.stat(researchDir);
+        const stats = await import_promises22.default.stat(researchDir);
         if (!stats.isDirectory()) continue;
         let spec;
         let manifest;
         try {
           [spec, manifest] = await Promise.all([
-            import_promises21.default.readFile(import_node_path15.default.join(researchDir, "spec.json"), "utf8").then((text) => JSON.parse(text)),
-            import_promises21.default.readFile(import_node_path15.default.join(researchDir, "manifest.json"), "utf8").then((text) => JSON.parse(text))
+            import_promises22.default.readFile(import_node_path15.default.join(researchDir, "spec.json"), "utf8").then((text) => JSON.parse(text)),
+            import_promises22.default.readFile(import_node_path15.default.join(researchDir, "manifest.json"), "utf8").then((text) => JSON.parse(text))
           ]);
         } catch (error) {
           if (error.code === "ENOENT") continue;
@@ -28236,7 +28204,7 @@ var init_io = __esm({
         if (manifest.specSha256 !== sha256Json(spec)) {
           throw new Error(`Stage index found a spec hash mismatch for ${entry}`);
         }
-        const result = manifest.status === "completed" ? await import_promises21.default.readFile(import_node_path15.default.join(researchDir, "result.json"), "utf8").then((text) => JSON.parse(text)) : null;
+        const result = manifest.status === "completed" ? await import_promises22.default.readFile(import_node_path15.default.join(researchDir, "result.json"), "utf8").then((text) => JSON.parse(text)) : null;
         familyByResearch.set(spec.researchId, spec.hypothesis.family);
         experiments.push({
           researchId: spec.researchId,
@@ -28291,13 +28259,13 @@ var init_io = __esm({
 });
 
 // src/lib/coreResearch/artifacts.ts
-var import_node_fs4, import_node_events, import_promises22, import_node_path16, csv, writeLine, closeOutput, writeCoreResearchMatches, writeCoreResearchTrades;
+var import_node_fs4, import_node_events, import_promises23, import_node_path16, csv, writeLine, closeOutput, writeCoreResearchMatches, writeCoreResearchTrades;
 var init_artifacts = __esm({
   "src/lib/coreResearch/artifacts.ts"() {
     "use strict";
     import_node_fs4 = require("fs");
     import_node_events = require("events");
-    import_promises22 = __toESM(require("fs/promises"));
+    import_promises23 = __toESM(require("fs/promises"));
     import_node_path16 = __toESM(require("path"));
     init_io();
     csv = (value) => {
@@ -28312,7 +28280,7 @@ var init_artifacts = __esm({
       await (0, import_node_events.once)(output, "close");
     };
     writeCoreResearchMatches = async (params) => {
-      await import_promises22.default.mkdir(import_node_path16.default.dirname(params.filePath), { recursive: true });
+      await import_promises23.default.mkdir(import_node_path16.default.dirname(params.filePath), { recursive: true });
       const output = (0, import_node_fs4.createWriteStream)(params.filePath, { encoding: "utf8" });
       await writeLine(
         output,
@@ -28353,7 +28321,7 @@ var init_artifacts = __esm({
       await closeOutput(output);
     };
     writeCoreResearchTrades = async (params) => {
-      await import_promises22.default.mkdir(import_node_path16.default.dirname(params.filePath), { recursive: true });
+      await import_promises23.default.mkdir(import_node_path16.default.dirname(params.filePath), { recursive: true });
       const output = (0, import_node_fs4.createWriteStream)(params.filePath, { encoding: "utf8" });
       for (const variant of params.variants) {
         for (const trade of variant.trades) {
@@ -28593,14 +28561,14 @@ var init_rules = __esm({
 });
 
 // src/lib/coreResearch/statistics.ts
-var import_node_crypto10, createSeededRandom, percentile, calendarClusterBootstrap, applyHolmCorrection, inverseNormalCdf, erf, normalCdf, deflatedSharpeDiagnostic, combinations, probabilityOfBacktestOverfitting;
+var import_node_crypto11, createSeededRandom, percentile, calendarClusterBootstrap, applyHolmCorrection, inverseNormalCdf, erf, normalCdf, deflatedSharpeDiagnostic, combinations, probabilityOfBacktestOverfitting;
 var init_statistics = __esm({
   "src/lib/coreResearch/statistics.ts"() {
     "use strict";
-    import_node_crypto10 = require("crypto");
+    import_node_crypto11 = require("crypto");
     init_metrics();
     createSeededRandom = (seedText) => {
-      const digest = (0, import_node_crypto10.createHash)("sha256").update(seedText).digest();
+      const digest = (0, import_node_crypto11.createHash)("sha256").update(seedText).digest();
       let state = digest.readUInt32LE(0) || 1;
       return () => {
         state ^= state << 13;
@@ -29066,11 +29034,11 @@ var init_comparison = __esm({
 });
 
 // src/lib/coreResearch/dataset.ts
-var import_node_crypto11, import_node_fs5, import_node_path17, import_node_readline2, asRecord4, finiteNumber4, normalizeDirection, findStrategySetupIdentity, classifyBreadth, classifyDerivatives, resolveCoreResearchRegime, normalizeCompletedTrade, completedTradeIdentity, positionCycleIdentity, sumBy, weightedPrice, aggregatePositionCycles, compareText, compareTrades, readCoreResearchVariant;
+var import_node_crypto12, import_node_fs5, import_node_path17, import_node_readline2, asRecord4, finiteNumber4, normalizeDirection, findStrategySetupIdentity, classifyBreadth, classifyDerivatives, resolveCoreResearchRegime, normalizeCompletedTrade, completedTradeIdentity, positionCycleIdentity, sumBy, weightedPrice, aggregatePositionCycles, compareText, compareTrades, readCoreResearchVariant;
 var init_dataset2 = __esm({
   "src/lib/coreResearch/dataset.ts"() {
     "use strict";
-    import_node_crypto11 = require("crypto");
+    import_node_crypto12 = require("crypto");
     import_node_fs5 = require("fs");
     import_node_path17 = __toESM(require("path"));
     import_node_readline2 = __toESM(require("readline"));
@@ -29284,7 +29252,7 @@ var init_dataset2 = __esm({
       for (const inputPath of variant.files) {
         const filePath = import_node_path17.default.resolve(inputPath);
         const input = (0, import_node_fs5.createReadStream)(filePath);
-        const hash = (0, import_node_crypto11.createHash)("sha256");
+        const hash = (0, import_node_crypto12.createHash)("sha256");
         input.on("data", (chunk) => hash.update(chunk));
         const lines = import_node_readline2.default.createInterface({ input, crlfDelay: Infinity });
         const fileTrades = [];
@@ -29774,18 +29742,18 @@ var init_selection = __esm({
 });
 
 // src/lib/coreResearch/trace.ts
-var import_promises23, import_node_path18, summarizeCoreResearchTrace;
+var import_promises24, import_node_path18, summarizeCoreResearchTrace;
 var init_trace = __esm({
   "src/lib/coreResearch/trace.ts"() {
     "use strict";
-    import_promises23 = __toESM(require("fs/promises"));
+    import_promises24 = __toESM(require("fs/promises"));
     import_node_path18 = __toESM(require("path"));
     summarizeCoreResearchTrace = async (filePaths = []) => {
       const events = {};
       const skipCounts = {};
       for (const inputPath of filePaths) {
         const filePath = import_node_path18.default.resolve(inputPath);
-        const text = await import_promises23.default.readFile(filePath, "utf8");
+        const text = await import_promises24.default.readFile(filePath, "utf8");
         for (const [index, line] of text.split("\n").entries()) {
           if (!line.trim()) continue;
           let event;
@@ -29817,14 +29785,14 @@ var init_trace = __esm({
 });
 
 // src/lib/coreResearch/orchestrator.ts
-var import_promises24, import_node_path19, import_node_child_process5, import_node_crypto12, import_coreResearch, summarizeSupplementalFiles, analyzeCoreResearchPrepared, analyzeCoreResearch, createCoreResearchSpecTemplate, runCommand2, commandValue, commandHas, validateCoreResearchRunCommand, runCoreResearch;
+var import_promises25, import_node_path19, import_node_child_process6, import_node_crypto13, import_coreResearch, summarizeSupplementalFiles, analyzeCoreResearchPrepared, analyzeCoreResearch, createCoreResearchSpecTemplate, runCommand2, commandValue, commandHas, validateCoreResearchRunCommand, runCoreResearch;
 var init_orchestrator = __esm({
   "src/lib/coreResearch/orchestrator.ts"() {
     "use strict";
-    import_promises24 = __toESM(require("fs/promises"));
+    import_promises25 = __toESM(require("fs/promises"));
     import_node_path19 = __toESM(require("path"));
-    import_node_child_process5 = require("child_process");
-    import_node_crypto12 = require("crypto");
+    import_node_child_process6 = require("child_process");
+    import_node_crypto13 = require("crypto");
     import_coreResearch = require("@tradejs/infra/coreResearch");
     init_artifacts();
     init_io();
@@ -30113,7 +30081,7 @@ var init_orchestrator = __esm({
       const tradesByVariant = new Map(
         windowed.map((entry) => [entry.variant.id, entry.trades])
       );
-      await import_promises24.default.writeFile(
+      await import_promises25.default.writeFile(
         paths.reportPath,
         buildCoreResearchHtml({ spec, result, tradesByVariant }),
         "utf8"
@@ -30133,7 +30101,7 @@ var init_orchestrator = __esm({
         if (error.code !== "ENOENT") throw error;
       }
       try {
-        for (const name of await import_promises24.default.readdir(paths.runLogDir)) {
+        for (const name of await import_promises25.default.readdir(paths.runLogDir)) {
           if (!name.endsWith(".log")) continue;
           artifactHashes[`runs/${name}`] = await sha256File(
             import_node_path19.default.join(paths.runLogDir, name)
@@ -30199,12 +30167,12 @@ var init_orchestrator = __esm({
       ).replace(/\\/g, "/");
       const lineage = (() => {
         try {
-          const gitSha = (0, import_node_child_process5.execFileSync)("git", ["rev-parse", "HEAD"], {
+          const gitSha = (0, import_node_child_process6.execFileSync)("git", ["rev-parse", "HEAD"], {
             cwd: params.sourceRepositoryRoot,
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"]
           }).trim();
-          const dirtyDiff = (0, import_node_child_process5.execFileSync)(
+          const dirtyDiff = (0, import_node_child_process6.execFileSync)(
             "git",
             ["diff", "--binary", "--no-ext-diff", "HEAD"],
             {
@@ -30213,7 +30181,7 @@ var init_orchestrator = __esm({
               stdio: ["ignore", "pipe", "ignore"]
             }
           );
-          const sourceRepository = (0, import_node_child_process5.execFileSync)(
+          const sourceRepository = (0, import_node_child_process6.execFileSync)(
             "git",
             ["remote", "get-url", "origin"],
             {
@@ -30226,7 +30194,7 @@ var init_orchestrator = __esm({
             gitSha,
             ...sourceRepository ? { sourceRepository } : {},
             ...dirtyDiff ? {
-              dirtyDiffSha256: (0, import_node_crypto12.createHash)("sha256").update(dirtyDiff).digest("hex")
+              dirtyDiffSha256: (0, import_node_crypto13.createHash)("sha256").update(dirtyDiff).digest("hex")
             } : {}
           };
         } catch {
@@ -30333,9 +30301,9 @@ var init_orchestrator = __esm({
     };
     runCommand2 = async (params) => {
       if (!params.command.length) throw new Error("Cannot run an empty command");
-      await import_promises24.default.mkdir(import_node_path19.default.dirname(params.logPath), { recursive: true });
+      await import_promises25.default.mkdir(import_node_path19.default.dirname(params.logPath), { recursive: true });
       const chunks = [];
-      const child = (0, import_node_child_process5.spawn)(params.command[0], params.command.slice(1), {
+      const child = (0, import_node_child_process6.spawn)(params.command[0], params.command.slice(1), {
         cwd: params.cwd,
         env: { ...process.env, ...params.env },
         stdio: ["ignore", "pipe", "pipe"]
@@ -30353,7 +30321,7 @@ var init_orchestrator = __esm({
         child.once("close", (code) => resolve(code ?? 1));
       });
       const output = chunks.join("");
-      await import_promises24.default.writeFile(params.logPath, output, "utf8");
+      await import_promises25.default.writeFile(params.logPath, output, "utf8");
       if (exitCode !== 0) {
         throw new Error(
           `Command failed with exit ${exitCode}: ${params.command.join(" ")}`
@@ -30556,13 +30524,13 @@ var init_orchestrator = __esm({
 // src/scripts/coreResearch.ts
 var coreResearch_exports = {};
 __export(coreResearch_exports, {
-  main: () => main33
+  main: () => main34
 });
-var import_promises25, import_node_path20, import_chalk41, valueAfter, required, parseTimestamp, readSymbols, printUsage, main33;
+var import_promises26, import_node_path20, import_chalk41, valueAfter, required, parseTimestamp, readSymbols, printUsage, main34;
 var init_coreResearch = __esm({
   "src/scripts/coreResearch.ts"() {
     "use strict";
-    import_promises25 = __toESM(require("fs/promises"));
+    import_promises26 = __toESM(require("fs/promises"));
     import_node_path20 = __toESM(require("path"));
     import_chalk41 = __toESM(require("chalk"));
     init_io();
@@ -30587,7 +30555,7 @@ var init_coreResearch = __esm({
       const symbolsFile = valueAfter(argv2, "--symbolsFile");
       if (symbolsFile) {
         const parsed = JSON.parse(
-          await import_promises25.default.readFile(import_node_path20.default.resolve(projectRoot18, symbolsFile), "utf8")
+          await import_promises26.default.readFile(import_node_path20.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");
@@ -30607,7 +30575,7 @@ var init_coreResearch = __esm({
 
 The run command executes only variants with an explicit command[] in the preregistered spec. Variants with files[] are analyzed without starting a backtest.`);
     };
-    main33 = async () => {
+    main34 = async () => {
       const roots = resolveResearchRoots();
       process.chdir(roots.projectRoot);
       const argv2 = process.argv.slice(2);
@@ -30699,10 +30667,10 @@ The run command executes only variants with an explicit command[] in the preregi
 // src/scripts/results.ts
 var results_exports = {};
 __export(results_exports, {
-  main: () => main34,
+  main: () => main35,
   results: () => results
 });
-var import_args26, import_chalk42, import_connectors14, import_cli11, import_redis16, ListIt4, flags24, MIN_PROFIT, MIN_WIN_RATE, MIN_ORDERS_PER_MONTH, createListIt4, formatPercent4, getMonthlyReturn, toStrategyResultEntry, toStrategyResults, getTestConfigs, buildBestResults, getSavedProfitsBySymbol, getCoverageRow, results, main34;
+var import_args26, import_chalk42, import_connectors14, import_cli11, import_redis17, ListIt4, flags24, MIN_PROFIT, MIN_WIN_RATE, MIN_ORDERS_PER_MONTH, createListIt4, formatPercent4, getMonthlyReturn, toStrategyResultEntry, toStrategyResults, getTestConfigs, buildBestResults, getSavedProfitsBySymbol, getCoverageRow, results, main35;
 var init_results = __esm({
   "src/scripts/results.ts"() {
     "use strict";
@@ -30710,7 +30678,7 @@ var init_results = __esm({
     import_chalk42 = __toESM(require("chalk"));
     import_connectors14 = require("@tradejs/connectors");
     import_cli11 = require("@tradejs/node/cli");
-    import_redis16 = require("@tradejs/infra/redis");
+    import_redis17 = require("@tradejs/infra/redis");
     ListIt4 = require("list-it");
     import_args26.default.example(
       "yarn results --strategy TrendLine --coverage",
@@ -30750,8 +30718,8 @@ var init_results = __esm({
       [...rows].map((row) => [row.symbol, toStrategyResultEntry(row)])
     );
     getTestConfigs = async (userName3) => {
-      const testSummariesKey = typeof import_redis16.redisKeys.testSummaries === "function" ? import_redis16.redisKeys.testSummaries(userName3) : null;
-      const indexedItems = testSummariesKey ? await (0, import_redis16.getData)(testSummariesKey, null) : null;
+      const testSummariesKey = typeof import_redis17.redisKeys.testSummaries === "function" ? import_redis17.redisKeys.testSummaries(userName3) : null;
+      const indexedItems = testSummariesKey ? await (0, import_redis17.getData)(testSummariesKey, null) : null;
       if (Array.isArray(indexedItems) && indexedItems.length) {
         return indexedItems.map((item) => {
           const testName = typeof item?.value === "string" ? item.value : null;
@@ -30762,8 +30730,8 @@ var init_results = __esm({
           return { strategyName, testName };
         }).filter(Boolean);
       }
-      const testsPrefix = import_redis16.redisKeys.tests(userName3);
-      const keys = await (0, import_redis16.getKeys)(testsPrefix);
+      const testsPrefix = import_redis17.redisKeys.tests(userName3);
+      const keys = await (0, import_redis17.getKeys)(testsPrefix);
       const configKeys = keys.filter((key) => key.endsWith(":config"));
       return configKeys.map((key) => {
         const parts = key.split(":");
@@ -30782,15 +30750,15 @@ var init_results = __esm({
         testName,
         strategyName: strategyFromIndex
       } of testConfigs) {
-        const config2 = await (0, import_redis16.getData)(
-          import_redis16.redisKeys.testConfig(userName3, strategyFromIndex, testName),
+        const config2 = await (0, import_redis17.getData)(
+          import_redis17.redisKeys.testConfig(userName3, strategyFromIndex, testName),
           null
         );
         if (!config2 || config2.strategyName !== strategyName) {
           continue;
         }
-        const stat = await (0, import_redis16.getData)(
-          import_redis16.redisKeys.testStat(userName3, strategyFromIndex, testName),
+        const stat = await (0, import_redis17.getData)(
+          import_redis17.redisKeys.testStat(userName3, strategyFromIndex, testName),
           null
         );
         if (!stat) {
@@ -30835,8 +30803,8 @@ var init_results = __esm({
       return savedProfitBySymbol;
     };
     getCoverageRow = async (strategyName, userName3, goodSymbols) => {
-      const currentResults = await (0, import_redis16.getData)(
-        import_redis16.redisKeys.strategyResults(userName3, strategyName),
+      const currentResults = await (0, import_redis17.getData)(
+        import_redis17.redisKeys.strategyResults(userName3, strategyName),
         {}
       );
       const existingSymbols = new Set(Object.keys(currentResults));
@@ -30870,8 +30838,8 @@ var init_results = __esm({
       const strategyName = flags24.strategy;
       const userName3 = flags24.user;
       if (flags24.clear) {
-        const cleared = await (0, import_redis16.delKey)(
-          import_redis16.redisKeys.strategyResults(userName3, strategyName)
+        const cleared = await (0, import_redis17.delKey)(
+          import_redis17.redisKeys.strategyResults(userName3, strategyName)
         );
         console.log(
           cleared ? import_chalk42.default.green(`Cleared results:${strategyName}`) : import_chalk42.default.yellow(`No results to clear for ${strategyName}`)
@@ -30919,8 +30887,8 @@ var init_results = __esm({
             console.log(import_chalk42.default.yellow("No good results to merge."));
             process.exit(0);
           }
-          const current = await (0, import_redis16.getData)(
-            import_redis16.redisKeys.strategyResults(userName3, strategyName),
+          const current = await (0, import_redis17.getData)(
+            import_redis17.redisKeys.strategyResults(userName3, strategyName),
             {}
           );
           const savedProfitBySymbol = await getSavedProfitsBySymbol(current);
@@ -30942,7 +30910,7 @@ var init_results = __esm({
             ...current,
             ...toStrategyResults(updates)
           };
-          await (0, import_redis16.setData)(import_redis16.redisKeys.strategyResults(userName3, strategyName), merged, {
+          await (0, import_redis17.setData)(import_redis17.redisKeys.strategyResults(userName3, strategyName), merged, {
             expire: 0
           });
           if (flags24.verbose) {
@@ -30983,8 +30951,8 @@ var init_results = __esm({
           );
           process.exit(0);
         }
-        await (0, import_redis16.setData)(
-          import_redis16.redisKeys.strategyResults(userName3, strategyName),
+        await (0, import_redis17.setData)(
+          import_redis17.redisKeys.strategyResults(userName3, strategyName),
           resultsConfig,
           {
             expire: 0
@@ -30998,16 +30966,16 @@ var init_results = __esm({
       }
       process.exit();
     };
-    main34 = results;
+    main35 = results;
   }
 });
 
 // src/lib/runtimeDebugEvidence.ts
-var import_redis17, RUNTIME_DEBUG_TIMEZONE, RUNTIME_DEBUG_TIMEZONE_LABEL, formatRuntimeDebugDateTime, getRuntimeDebugDateParts, formatRuntimeDebugIsoDayKey, buildRuntimeDebugEvaluationId, filterByStrategies, collectRuntimeDebugEvidence, buildRuntimeDebugReportPayload, buildRuntimeEvidenceReportPayload, buildRuntimeDebugReportAttachment;
+var import_redis18, 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_redis17 = require("@tradejs/infra/redis");
+    import_redis18 = require("@tradejs/infra/redis");
     init_runtimeRedis();
     init_runtimeSignalsLoader();
     init_runtimeSignalsStorage();
@@ -31131,24 +31099,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_redis17.redisKeys.runtimeTrade(userName3, trade.orderId);
-          const tradeBucketKey = import_redis17.redisKeys.runtimeTradeBucket(
+          const tradeKey = import_redis18.redisKeys.runtimeTrade(userName3, trade.orderId);
+          const tradeBucketKey = import_redis18.redisKeys.runtimeTradeBucket(
             userName3,
             tradeDayKey
           );
-          const activeTradeKey = import_redis17.redisKeys.runtimeActiveTrade(
+          const activeTradeKey = import_redis18.redisKeys.runtimeActiveTrade(
             userName3,
             trade.symbol,
             trade.deploymentId ?? trade.accountId
           );
-          const signalKey = trade.signalId != null ? import_redis17.redisKeys.storeSignal(trade.symbol, trade.signalId) : null;
-          const evaluationBucketKey = import_redis17.redisKeys.runtimeSignalEvaluationBucket(
+          const signalKey = trade.signalId != null ? import_redis18.redisKeys.storeSignal(trade.symbol, trade.signalId) : null;
+          const evaluationBucketKey = import_redis18.redisKeys.runtimeSignalEvaluationBucket(
             userName3,
             evaluationDayKey,
             knownEvaluation?.strategy ?? trade.strategy
           );
           const evaluationField = knownEvaluation?.evaluationId ?? evaluationId;
-          const evaluationKey = import_redis17.redisKeys.runtimeSignalEvaluation(
+          const evaluationKey = import_redis18.redisKeys.runtimeSignalEvaluation(
             userName3,
             evaluationField
           );
@@ -31159,11 +31127,11 @@ var init_runtimeDebugEvidence = __esm({
             directEvaluationValue,
             bucketEvaluationValue
           ] = await Promise.all([
-            (0, import_redis17.getData)(tradeKey, null),
-            (0, import_redis17.getData)(activeTradeKey, null),
-            signalKey ? (0, import_redis17.getData)(signalKey, null) : Promise.resolve(null),
-            (0, import_redis17.getData)(evaluationKey, null),
-            knownEvaluation ? Promise.resolve(knownEvaluation) : (0, import_redis17.getHashJsonField)(
+            (0, import_redis18.getData)(tradeKey, null),
+            (0, import_redis18.getData)(activeTradeKey, null),
+            signalKey ? (0, import_redis18.getData)(signalKey, null) : Promise.resolve(null),
+            (0, import_redis18.getData)(evaluationKey, null),
+            knownEvaluation ? Promise.resolve(knownEvaluation) : (0, import_redis18.getHashJsonField)(
               evaluationBucketKey,
               evaluationField,
               null
@@ -31220,12 +31188,12 @@ var init_runtimeDebugEvidence = __esm({
           dayKeys
         },
         redisPrefixes: {
-          runtimeTrades: import_redis17.redisKeys.runtimeTrades(userName3),
-          runtimeTradeBuckets: import_redis17.redisKeys.runtimeTradeBuckets(userName3),
-          runtimeActiveTrades: import_redis17.redisKeys.runtimeActiveTrades(userName3),
-          runtimeSignals: import_redis17.redisKeys.runtimeSignalBuckets(userName3),
-          runtimeSignalEvaluations: import_redis17.redisKeys.runtimeSignalEvaluationBuckets(userName3),
-          runtimeSignalEvaluationStats: import_redis17.redisKeys.runtimeSignalEvaluationStatsBuckets(userName3)
+          runtimeTrades: import_redis18.redisKeys.runtimeTrades(userName3),
+          runtimeTradeBuckets: import_redis18.redisKeys.runtimeTradeBuckets(userName3),
+          runtimeActiveTrades: import_redis18.redisKeys.runtimeActiveTrades(userName3),
+          runtimeSignals: import_redis18.redisKeys.runtimeSignalBuckets(userName3),
+          runtimeSignalEvaluations: import_redis18.redisKeys.runtimeSignalEvaluationBuckets(userName3),
+          runtimeSignalEvaluationStats: import_redis18.redisKeys.runtimeSignalEvaluationStatsBuckets(userName3)
         },
         counts: {
           trades: trades.length,
@@ -31236,18 +31204,18 @@ var init_runtimeDebugEvidence = __esm({
         },
         trades: debugTrades,
         signals: signals2.map((signal) => ({
-          redisKey: import_redis17.redisKeys.storeSignal(signal.symbol, signal.signalId),
+          redisKey: import_redis18.redisKeys.storeSignal(signal.symbol, signal.signalId),
           signal
         })),
         evaluations: reportEvaluations.map((evaluation) => ({
           redisDebug: {
-            key: import_redis17.redisKeys.runtimeSignalEvaluationBucket(
+            key: import_redis18.redisKeys.runtimeSignalEvaluationBucket(
               userName3,
               (0, import_time5.getRuntimeStorageDayKey)(evaluation.timestamp),
               evaluation.strategy
             ),
             field: evaluation.evaluationId,
-            directKey: import_redis17.redisKeys.runtimeSignalEvaluation(
+            directKey: import_redis18.redisKeys.runtimeSignalEvaluation(
               userName3,
               evaluation.evaluationId
             )
@@ -31308,19 +31276,19 @@ var init_runtimeDebugEvidence = __esm({
 // src/scripts/replayRuntimeEvidence.ts
 var replayRuntimeEvidence_exports = {};
 __export(replayRuntimeEvidence_exports, {
-  main: () => main35,
+  main: () => main36,
   replayRuntimeEvidence: () => replayRuntimeEvidence,
   summarizeReplayComparison: () => summarizeReplayComparison
 });
-var import_promises26, import_node_path21, import_args27, import_chalk43, import_redis18, toEpochMs2, resolveWindow, parseStrategyFilter, asRecord5, asArray2, sum, groupCount, compactMatched, resolveItemStrategy, summarizeReplayComparison, loadReplayResult, getReplayStrategies, loadRuntimePayload, replayRuntimeEvidence, main35;
+var import_promises27, import_node_path21, import_args27, import_chalk43, import_redis19, toEpochMs2, resolveWindow, parseStrategyFilter, asRecord5, asArray2, sum, groupCount, compactMatched, resolveItemStrategy, summarizeReplayComparison, loadReplayResult, getReplayStrategies, loadRuntimePayload, replayRuntimeEvidence, main36;
 var init_replayRuntimeEvidence = __esm({
   "src/scripts/replayRuntimeEvidence.ts"() {
     "use strict";
-    import_promises26 = __toESM(require("fs/promises"));
+    import_promises27 = __toESM(require("fs/promises"));
     import_node_path21 = __toESM(require("path"));
     import_args27 = __toESM(require("args"));
     import_chalk43 = __toESM(require("chalk"));
-    import_redis18 = require("@tradejs/infra/redis");
+    import_redis19 = require("@tradejs/infra/redis");
     init_runtimeDebugEvidence();
     init_support();
     import_args27.default.option(["u", "user"], "Use user config", "root");
@@ -31540,18 +31508,18 @@ var init_replayRuntimeEvidence = __esm({
         return {
           key: replayKey,
           availableKeys: void 0,
-          value: await (0, import_redis18.getData)(replayKey, null)
+          value: await (0, import_redis19.getData)(replayKey, null)
         };
       }
-      const prefix = import_redis18.redisKeys.backtestResults(userName3, REPLAY_RESULTS_CONFIG, "");
-      const keys = (await (0, import_redis18.getKeys)(prefix)).sort(
+      const prefix = import_redis19.redisKeys.backtestResults(userName3, REPLAY_RESULTS_CONFIG, "");
+      const keys = (await (0, import_redis19.getKeys)(prefix)).sort(
         (left, right) => left.localeCompare(right)
       );
       const key = keys[keys.length - 1] ?? null;
       return {
         key,
         availableKeys: keys.slice(-10),
-        value: key ? await (0, import_redis18.getData)(key, null) : null
+        value: key ? await (0, import_redis19.getData)(key, null) : null
       };
     };
     getReplayStrategies = (replayValue) => {
@@ -31579,7 +31547,7 @@ var init_replayRuntimeEvidence = __esm({
       const runtimeEvidencePath = typeof runtimeEvidenceFile === "string" && runtimeEvidenceFile.trim() ? import_node_path21.default.resolve(projectRoot18, runtimeEvidenceFile.trim()) : null;
       if (runtimeEvidencePath) {
         const artifact = JSON.parse(
-          await import_promises26.default.readFile(runtimeEvidencePath, "utf8")
+          await import_promises27.default.readFile(runtimeEvidencePath, "utf8")
         );
         return {
           source: "file",
@@ -31666,8 +31634,8 @@ var init_replayRuntimeEvidence = __esm({
         runtime: runtime.payload
       };
       const outPath = import_node_path21.default.resolve(projectRoot18, String(flags35.out));
-      await import_promises26.default.mkdir(import_node_path21.default.dirname(outPath), { recursive: true });
-      await import_promises26.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
+      await import_promises27.default.mkdir(import_node_path21.default.dirname(outPath), { recursive: true });
+      await import_promises27.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
 `, "utf8");
       console.log(import_chalk43.default.green(`Wrote ${outPath}`));
       console.log(
@@ -31685,574 +31653,45 @@ var init_replayRuntimeEvidence = __esm({
         )
       );
     };
-    main35 = replayRuntimeEvidence;
+    main36 = replayRuntimeEvidence;
   }
 });
 
 // src/lib/runtimeEvidenceArtifacts.ts
-var import_node_crypto13, import_promises27, import_node_path22, RUNTIME_EVIDENCE_MANIFEST_FILE, RUNTIME_EVIDENCE_PAYLOAD_FILE, RUNTIME_EVIDENCE_COMPLETE_FILE, asRecord6, sha256, runtimeEvidenceIdentitySha256, isExistingDestinationError, safeSegment, compactTimestamp, dateParts, assertFiniteTimestamp, parseManifest, publishRuntimeEvidenceBundle, verifyRuntimeEvidenceBundle, discoverRuntimeEvidenceBundles;
+var runtimeEvidenceArtifacts_exports = {};
 var init_runtimeEvidenceArtifacts = __esm({
   "src/lib/runtimeEvidenceArtifacts.ts"() {
     "use strict";
-    import_node_crypto13 = require("crypto");
-    import_promises27 = __toESM(require("fs/promises"));
-    import_node_path22 = __toESM(require("path"));
-    init_runtimeEvidenceDeployment();
-    RUNTIME_EVIDENCE_MANIFEST_FILE = "manifest.json";
-    RUNTIME_EVIDENCE_PAYLOAD_FILE = "runtime-evidence.json";
-    RUNTIME_EVIDENCE_COMPLETE_FILE = ".complete";
-    asRecord6 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
-    sha256 = (value) => (0, import_node_crypto13.createHash)("sha256").update(value).digest("hex");
-    runtimeEvidenceIdentitySha256 = (artifact) => {
-      const identityArtifact = { ...artifact };
-      delete identityArtifact.generatedAt;
-      const runtime = asRecord6(identityArtifact.runtime);
-      if (runtime) {
-        const identityRuntime = { ...runtime };
-        delete identityRuntime.generatedAt;
-        identityArtifact.runtime = identityRuntime;
-      }
-      return sha256(JSON.stringify(identityArtifact));
-    };
-    isExistingDestinationError = (error) => {
-      const code = error.code;
-      return code === "EEXIST" || code === "ENOTEMPTY";
-    };
-    safeSegment = (value, fallback) => {
-      const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
-      return normalized && normalized !== "." && normalized !== ".." ? normalized : fallback;
-    };
-    compactTimestamp = (timestamp) => new Date(timestamp).toISOString().replace(/[-:]/g, "").replace(/\.000Z$/, "Z");
-    dateParts = (timestamp) => {
-      const date = new Date(timestamp);
-      return [
-        String(date.getUTCFullYear()),
-        String(date.getUTCMonth() + 1).padStart(2, "0"),
-        String(date.getUTCDate()).padStart(2, "0")
-      ];
-    };
-    assertFiniteTimestamp = (value, label) => {
-      if (typeof value !== "number" || !Number.isFinite(value)) {
-        throw new Error(`Invalid runtime evidence ${label}`);
-      }
-      return value;
-    };
-    parseManifest = (value) => {
-      const manifest = asRecord6(value);
-      const window = asRecord6(manifest?.window);
-      const payload = asRecord6(manifest?.payload);
-      const counts = asRecord6(manifest?.counts);
-      if (manifest?.schemaVersion !== 1 || manifest.reportType !== "runtime-evidence" || typeof manifest.artifactId !== "string" || typeof manifest.deploymentId !== "string" || typeof manifest.userName !== "string" || typeof manifest.createdAt !== "number" || payload?.file !== RUNTIME_EVIDENCE_PAYLOAD_FILE || typeof payload.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(payload.sha256) || typeof payload.bytes !== "number" || !Array.isArray(manifest.lineageKeys)) {
-        throw new Error("Invalid runtime evidence manifest");
-      }
-      return {
-        schemaVersion: 1,
-        artifactId: manifest.artifactId,
-        reportType: "runtime-evidence",
-        deploymentId: manifest.deploymentId,
-        userName: manifest.userName,
-        createdAt: manifest.createdAt,
-        window: {
-          startTime: assertFiniteTimestamp(window?.startTime, "window.startTime"),
-          endTime: assertFiniteTimestamp(window?.endTime, "window.endTime")
-        },
-        payload: {
-          file: RUNTIME_EVIDENCE_PAYLOAD_FILE,
-          sha256: payload.sha256,
-          bytes: payload.bytes
-        },
-        counts: Object.fromEntries(
-          Object.entries(counts ?? {}).filter(
-            (entry) => typeof entry[1] === "number" && Number.isFinite(entry[1])
-          )
-        ),
-        lineageKeys: manifest.lineageKeys.filter(
-          (value2) => typeof value2 === "string" && value2.length > 0
-        )
-      };
-    };
-    publishRuntimeEvidenceBundle = async ({
-      publishRoot,
-      deploymentId,
-      userName: userName3,
-      startTime,
-      endTime,
-      artifact,
-      counts,
-      lineageKeys
-    }) => {
-      assertCurrentRuntimeEvidenceArtifact(artifact);
-      const payload = `${JSON.stringify(artifact, null, 2)}
-`;
-      const payloadSha256 = sha256(payload);
-      const identitySha256 = runtimeEvidenceIdentitySha256(artifact);
-      const safeDeploymentId = safeSegment(deploymentId, "default");
-      const artifactId = [
-        compactTimestamp(startTime),
-        compactTimestamp(endTime),
-        identitySha256.slice(0, 16)
-      ].join("_");
-      const createdAt = Date.now();
-      const manifest = {
-        schemaVersion: 1,
-        artifactId,
-        reportType: "runtime-evidence",
-        deploymentId: safeDeploymentId,
-        userName: userName3,
-        createdAt,
-        window: { startTime, endTime },
-        payload: {
-          file: RUNTIME_EVIDENCE_PAYLOAD_FILE,
-          sha256: payloadSha256,
-          bytes: Buffer.byteLength(payload)
-        },
-        counts,
-        lineageKeys: [...new Set(lineageKeys)].sort()
-      };
-      const incomingRoot = import_node_path22.default.join(publishRoot, "incoming");
-      const readyRoot = import_node_path22.default.join(
-        publishRoot,
-        "ready",
-        safeDeploymentId,
-        ...dateParts(endTime)
-      );
-      const bundleDir = import_node_path22.default.join(readyRoot, artifactId);
-      const temporaryDir = import_node_path22.default.join(
-        incomingRoot,
-        `${artifactId}.tmp-${(0, import_node_crypto13.randomUUID)()}`
-      );
-      await import_promises27.default.mkdir(temporaryDir, { recursive: true });
-      try {
-        await Promise.all([
-          import_promises27.default.writeFile(
-            import_node_path22.default.join(temporaryDir, RUNTIME_EVIDENCE_PAYLOAD_FILE),
-            payload,
-            "utf8"
-          ),
-          import_promises27.default.writeFile(
-            import_node_path22.default.join(temporaryDir, RUNTIME_EVIDENCE_MANIFEST_FILE),
-            `${JSON.stringify(manifest, null, 2)}
-`,
-            "utf8"
-          )
-        ]);
-        await import_promises27.default.writeFile(
-          import_node_path22.default.join(temporaryDir, RUNTIME_EVIDENCE_COMPLETE_FILE),
-          `${artifactId}
-`,
-          "utf8"
-        );
-        await import_promises27.default.mkdir(readyRoot, { recursive: true });
-        try {
-          await import_promises27.default.rename(temporaryDir, bundleDir);
-        } catch (error) {
-          if (!isExistingDestinationError(error)) {
-            throw error;
-          }
-          await import_promises27.default.rm(temporaryDir, { recursive: true, force: true });
-        }
-      } catch (error) {
-        await import_promises27.default.rm(temporaryDir, { recursive: true, force: true });
-        throw error;
-      }
-      return verifyRuntimeEvidenceBundle(bundleDir);
-    };
-    verifyRuntimeEvidenceBundle = async (bundleDir) => {
-      const manifestPath = import_node_path22.default.join(bundleDir, RUNTIME_EVIDENCE_MANIFEST_FILE);
-      const payloadPath = import_node_path22.default.join(bundleDir, RUNTIME_EVIDENCE_PAYLOAD_FILE);
-      const completePath = import_node_path22.default.join(bundleDir, RUNTIME_EVIDENCE_COMPLETE_FILE);
-      const [manifestText, payload, completeText] = await Promise.all([
-        import_promises27.default.readFile(manifestPath, "utf8"),
-        import_promises27.default.readFile(payloadPath),
-        import_promises27.default.readFile(completePath, "utf8")
-      ]);
-      const manifest = parseManifest(JSON.parse(manifestText));
-      if (completeText.trim() !== manifest.artifactId) {
-        throw new Error(`Invalid completion marker in ${bundleDir}`);
-      }
-      if (payload.byteLength !== manifest.payload.bytes) {
-        throw new Error(`Runtime evidence size mismatch in ${bundleDir}`);
-      }
-      if (sha256(payload) !== manifest.payload.sha256) {
-        throw new Error(`Runtime evidence checksum mismatch in ${bundleDir}`);
-      }
-      const artifact = asRecord6(JSON.parse(payload.toString("utf8")));
-      const artifactWindow = asRecord6(artifact?.window);
-      if (artifact?.reportType !== "runtime-evidence" || artifactWindow?.startTime !== manifest.window.startTime || artifactWindow.endTime !== manifest.window.endTime) {
-        throw new Error(`Runtime evidence payload mismatch in ${bundleDir}`);
-      }
-      const deployment = assertCurrentRuntimeEvidenceArtifact(artifact);
-      if (deployment.id !== manifest.deploymentId) {
-        throw new Error(`Runtime evidence deployment mismatch in ${bundleDir}`);
-      }
-      return {
-        bundleDir,
-        manifestPath,
-        payloadPath,
-        manifest,
-        artifact
-      };
-    };
-    discoverRuntimeEvidenceBundles = async (rootDir) => {
-      const bundles = [];
-      const visit = async (directory, depth) => {
-        if (depth > 8) return;
-        let entries;
-        try {
-          entries = await import_promises27.default.readdir(directory, { withFileTypes: true });
-        } catch (error) {
-          if (error.code === "ENOENT") return;
-          throw error;
-        }
-        const names = new Set(entries.map((entry) => entry.name));
-        if (names.has(RUNTIME_EVIDENCE_MANIFEST_FILE) && names.has(RUNTIME_EVIDENCE_PAYLOAD_FILE) && names.has(RUNTIME_EVIDENCE_COMPLETE_FILE)) {
-          bundles.push(directory);
-          return;
-        }
-        await Promise.all(
-          entries.filter(
-            (entry) => entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.includes(".tmp-")
-          ).map((entry) => visit(import_node_path22.default.join(directory, entry.name), depth + 1))
-        );
-      };
-      await visit(rootDir, 0);
-      return bundles.sort();
-    };
+    __reExport(runtimeEvidenceArtifacts_exports, require("@tradejs/node/diagnostics"));
   }
 });
 
 // src/lib/runtimeEvidenceProducer.ts
-var import_node_crypto14, import_promises28, import_node_path23, isRecord2, sha2562, parseRuntimeEvidenceProducer, resolveRuntimeEvidenceProducer;
+var runtimeEvidenceProducer_exports = {};
 var init_runtimeEvidenceProducer = __esm({
   "src/lib/runtimeEvidenceProducer.ts"() {
     "use strict";
-    import_node_crypto14 = require("crypto");
-    import_promises28 = __toESM(require("fs/promises"));
-    import_node_path23 = __toESM(require("path"));
-    isRecord2 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
-    sha2562 = (value) => (0, import_node_crypto14.createHash)("sha256").update(value).digest("hex");
-    parseRuntimeEvidenceProducer = (value) => {
-      const producer = isRecord2(value) ? value : null;
-      const runtimePackageManifest = isRecord2(producer?.runtimePackageManifest) ? producer.runtimePackageManifest : null;
-      if (producer?.schemaVersion !== 1 || typeof producer.projectSha !== "string" || !/^[a-f0-9]{40}$/.test(producer.projectSha) || typeof producer.imageDigest !== "string" || !/^sha256:[a-f0-9]{64}$/.test(producer.imageDigest) || runtimePackageManifest?.file !== "runtime-package-manifest.json" || typeof runtimePackageManifest.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(runtimePackageManifest.sha256)) {
-        throw new Error("Runtime evidence producer image identity is invalid");
-      }
-      return producer;
-    };
-    resolveRuntimeEvidenceProducer = async ({
-      projectRoot: projectRoot18,
-      required: required4
-    }) => {
-      const projectSha = String(process.env.TRADEJS_PROJECT_SHA ?? "").trim();
-      const imageDigest = String(
-        process.env.TRADEJS_PROJECT_IMAGE_DIGEST ?? ""
-      ).trim();
-      if (!projectSha && !imageDigest && !required4) {
-        return null;
-      }
-      if (!/^[a-f0-9]{40}$/.test(projectSha)) {
-        throw new Error(
-          "TRADEJS_PROJECT_SHA must be a full lowercase Git SHA before publishing runtime evidence"
-        );
-      }
-      if (!/^sha256:[a-f0-9]{64}$/.test(imageDigest)) {
-        throw new Error(
-          "TRADEJS_PROJECT_IMAGE_DIGEST must be an immutable sha256 digest before publishing runtime evidence"
-        );
-      }
-      const manifestPath = import_node_path23.default.join(projectRoot18, "runtime-package-manifest.json");
-      let manifest;
-      try {
-        manifest = await import_promises28.default.readFile(manifestPath);
-      } catch (error) {
-        if (!required4 && error.code === "ENOENT") {
-          return null;
-        }
-        throw new Error(
-          `Runtime package manifest is required for runtime evidence: ${manifestPath}`,
-          { cause: error }
-        );
-      }
-      return {
-        schemaVersion: 1,
-        projectSha,
-        imageDigest,
-        runtimePackageManifest: {
-          file: "runtime-package-manifest.json",
-          sha256: sha2562(manifest)
-        }
-      };
-    };
+    __reExport(runtimeEvidenceProducer_exports, require("@tradejs/node/diagnostics"));
   }
 });
 
 // src/lib/runtimeFeedbackArtifacts.ts
-var import_node_crypto15, import_promises29, import_node_path24, RUNTIME_FEEDBACK_MANIFEST_FILE, RUNTIME_FEEDBACK_REPLAY_FILE, RUNTIME_FEEDBACK_LOG_FILE, RUNTIME_FEEDBACK_COMPLETE_FILE, isRecord3, sha2563, safeSegment2, parsePayload, parseManifest2, assertReplayMatchesRuntimeEvidence, sealRuntimeFeedbackReplayBundle, verifyRuntimeFeedbackReplayBundle, discoverRuntimeFeedbackReplayBundles, verifyRuntimeFeedbackReplaySource;
+var runtimeFeedbackArtifacts_exports = {};
 var init_runtimeFeedbackArtifacts = __esm({
   "src/lib/runtimeFeedbackArtifacts.ts"() {
     "use strict";
-    import_node_crypto15 = require("crypto");
-    import_promises29 = __toESM(require("fs/promises"));
-    import_node_path24 = __toESM(require("path"));
-    init_runtimeEvidenceDeployment();
-    init_runtimeEvidenceArtifacts();
-    init_runtimeEvidenceProducer();
-    RUNTIME_FEEDBACK_MANIFEST_FILE = "manifest.json";
-    RUNTIME_FEEDBACK_REPLAY_FILE = "replay-runtime-evidence.json";
-    RUNTIME_FEEDBACK_LOG_FILE = "replay.log";
-    RUNTIME_FEEDBACK_COMPLETE_FILE = ".complete";
-    isRecord3 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
-    sha2563 = (value) => (0, import_node_crypto15.createHash)("sha256").update(value).digest("hex");
-    safeSegment2 = (value, fallback) => {
-      const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
-      return normalized && normalized !== "." && normalized !== ".." ? normalized : fallback;
-    };
-    parsePayload = (value, expectedFile) => {
-      const payload = isRecord3(value) ? value : null;
-      if (payload?.file !== expectedFile || typeof payload.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(payload.sha256) || typeof payload.bytes !== "number" || !Number.isFinite(payload.bytes) || payload.bytes < 0) {
-        throw new Error(`Invalid runtime feedback payload: ${expectedFile}`);
-      }
-      return payload;
-    };
-    parseManifest2 = (value) => {
-      const manifest = isRecord3(value) ? value : null;
-      const window = isRecord3(manifest?.window) ? manifest.window : null;
-      const runtimeEvidence2 = isRecord3(manifest?.runtimeEvidence) ? manifest.runtimeEvidence : null;
-      const safety = isRecord3(manifest?.safety) ? manifest.safety : null;
-      const payloads = isRecord3(manifest?.payloads) ? manifest.payloads : null;
-      if (manifest?.schemaVersion !== 1 || manifest.reportType !== "runtime-feedback-replay" || typeof manifest.artifactId !== "string" || !manifest.artifactId.trim() || typeof manifest.runId !== "string" || !manifest.runId.trim() || typeof manifest.deploymentId !== "string" || !manifest.deploymentId.trim() || typeof manifest.deploymentCompositionId !== "string" || !/^dc1:[a-f0-9]{16}$/.test(manifest.deploymentCompositionId) || typeof manifest.userName !== "string" || !manifest.userName.trim() || typeof manifest.createdAt !== "number" || typeof window?.startTime !== "number" || typeof window.endTime !== "number" || typeof runtimeEvidence2?.artifactId !== "string" || typeof runtimeEvidence2.payloadSha256 !== "string" || !/^[a-f0-9]{64}$/.test(runtimeEvidence2.payloadSha256) || !Array.isArray(manifest.activeStrategies) || manifest.activeStrategies.length === 0 || !manifest.activeStrategies.every(
-        (strategy) => typeof strategy === "string" && strategy.trim()
-      ) || typeof manifest.cycleCount !== "number" || !Number.isFinite(manifest.cycleCount) || manifest.cycleCount <= 0 || safety?.cacheOnly !== true || safety.externalOrderPlacement !== false || safety.redis !== "isolated" || safety.timescale !== "read_only") {
-        throw new Error("Invalid runtime feedback replay manifest");
-      }
-      const replayEvidence = parsePayload(
-        payloads?.replayEvidence,
-        RUNTIME_FEEDBACK_REPLAY_FILE
-      );
-      const log = parsePayload(payloads?.log, RUNTIME_FEEDBACK_LOG_FILE);
-      return {
-        ...manifest,
-        producer: parseRuntimeEvidenceProducer(manifest.producer),
-        payloads: {
-          replayEvidence: {
-            ...replayEvidence,
-            file: RUNTIME_FEEDBACK_REPLAY_FILE
-          },
-          log: { ...log, file: RUNTIME_FEEDBACK_LOG_FILE }
-        }
-      };
-    };
-    assertReplayMatchesRuntimeEvidence = ({
-      replayEvidence,
-      runtimeEvidence: runtimeEvidence2
-    }) => {
-      if (replayEvidence.reportType !== "replay-runtime-evidence") {
-        throw new Error("Runtime feedback replay payload has the wrong reportType");
-      }
-      const replayWindow = isRecord3(replayEvidence.window) ? replayEvidence.window : null;
-      if (replayWindow?.startTime !== runtimeEvidence2.manifest.window.startTime || replayWindow.endTime !== runtimeEvidence2.manifest.window.endTime) {
-        throw new Error("Runtime feedback replay window does not match evidence");
-      }
-      const runtimeDeployment = parseRuntimeEvidenceDeploymentSnapshot(
-        runtimeEvidence2.artifact.deployment
-      );
-      const replayDeployment = parseRuntimeEvidenceDeploymentSnapshot(
-        replayEvidence.deployment
-      );
-      if (replayDeployment.id !== runtimeDeployment.id || replayDeployment.deploymentCompositionId !== runtimeDeployment.deploymentCompositionId) {
-        throw new Error(
-          "Runtime feedback replay deployment does not match evidence"
-        );
-      }
-    };
-    sealRuntimeFeedbackReplayBundle = async ({
-      bundleDir,
-      runId,
-      runtimeEvidenceBundle
-    }) => {
-      const replayEvidencePath = import_node_path24.default.join(bundleDir, RUNTIME_FEEDBACK_REPLAY_FILE);
-      const logPath = import_node_path24.default.join(bundleDir, RUNTIME_FEEDBACK_LOG_FILE);
-      const [replayPayload, logPayload] = await Promise.all([
-        import_promises29.default.readFile(replayEvidencePath),
-        import_promises29.default.readFile(logPath)
-      ]);
-      const replayEvidence = JSON.parse(replayPayload.toString("utf8"));
-      assertReplayMatchesRuntimeEvidence({
-        replayEvidence,
-        runtimeEvidence: runtimeEvidenceBundle
-      });
-      const replay = isRecord3(replayEvidence.replay) ? replayEvidence.replay : null;
-      const cycleCount = Number(replay?.cycleCount);
-      if (!Number.isFinite(cycleCount) || cycleCount <= 0) {
-        throw new Error(
-          `Runtime feedback replay produced no comparable cycles: ${String(replay?.cycleCount ?? "missing")}`
-        );
-      }
-      const deployment = parseRuntimeEvidenceDeploymentSnapshot(
-        runtimeEvidenceBundle.artifact.deployment
-      );
-      const producer = parseRuntimeEvidenceProducer(
-        runtimeEvidenceBundle.artifact.producer
-      );
-      const safeRunId = safeSegment2(runId, "run");
-      const artifactId = `${runtimeEvidenceBundle.manifest.artifactId}_${safeRunId}`;
-      const manifest = {
-        schemaVersion: 1,
-        reportType: "runtime-feedback-replay",
-        artifactId,
-        runId: safeRunId,
-        deploymentId: deployment.id,
-        deploymentCompositionId: deployment.deploymentCompositionId,
-        userName: runtimeEvidenceBundle.manifest.userName,
-        createdAt: Date.now(),
-        window: { ...runtimeEvidenceBundle.manifest.window },
-        runtimeEvidence: {
-          artifactId: runtimeEvidenceBundle.manifest.artifactId,
-          payloadSha256: runtimeEvidenceBundle.manifest.payload.sha256
-        },
-        producer,
-        activeStrategies: activeRuntimeEvidenceStrategies(deployment).map(
-          ({ strategyName }) => strategyName
-        ),
-        cycleCount,
-        safety: {
-          cacheOnly: true,
-          externalOrderPlacement: false,
-          redis: "isolated",
-          timescale: "read_only"
-        },
-        payloads: {
-          replayEvidence: {
-            file: RUNTIME_FEEDBACK_REPLAY_FILE,
-            sha256: sha2563(replayPayload),
-            bytes: replayPayload.byteLength
-          },
-          log: {
-            file: RUNTIME_FEEDBACK_LOG_FILE,
-            sha256: sha2563(logPayload),
-            bytes: logPayload.byteLength
-          }
-        }
-      };
-      await import_promises29.default.writeFile(
-        import_node_path24.default.join(bundleDir, RUNTIME_FEEDBACK_MANIFEST_FILE),
-        `${JSON.stringify(manifest, null, 2)}
-`,
-        "utf8"
-      );
-      await import_promises29.default.writeFile(
-        import_node_path24.default.join(bundleDir, RUNTIME_FEEDBACK_COMPLETE_FILE),
-        `${artifactId}
-`,
-        "utf8"
-      );
-      return verifyRuntimeFeedbackReplayBundle(bundleDir);
-    };
-    verifyRuntimeFeedbackReplayBundle = async (bundleDir) => {
-      const manifestPath = import_node_path24.default.join(bundleDir, RUNTIME_FEEDBACK_MANIFEST_FILE);
-      const replayEvidencePath = import_node_path24.default.join(bundleDir, RUNTIME_FEEDBACK_REPLAY_FILE);
-      const logPath = import_node_path24.default.join(bundleDir, RUNTIME_FEEDBACK_LOG_FILE);
-      const completePath = import_node_path24.default.join(bundleDir, RUNTIME_FEEDBACK_COMPLETE_FILE);
-      const [manifestText, replayPayload, logPayload, completeText] = await Promise.all([
-        import_promises29.default.readFile(manifestPath, "utf8"),
-        import_promises29.default.readFile(replayEvidencePath),
-        import_promises29.default.readFile(logPath),
-        import_promises29.default.readFile(completePath, "utf8")
-      ]);
-      const manifest = parseManifest2(JSON.parse(manifestText));
-      if (completeText.trim() !== manifest.artifactId) {
-        throw new Error(`Invalid runtime feedback completion marker: ${bundleDir}`);
-      }
-      for (const [payload, descriptor] of [
-        [replayPayload, manifest.payloads.replayEvidence],
-        [logPayload, manifest.payloads.log]
-      ]) {
-        if (payload.byteLength !== descriptor.bytes) {
-          throw new Error(
-            `Runtime feedback payload size mismatch: ${descriptor.file}`
-          );
-        }
-        if (sha2563(payload) !== descriptor.sha256) {
-          throw new Error(
-            `Runtime feedback payload checksum mismatch: ${descriptor.file}`
-          );
-        }
-      }
-      const replayEvidence = JSON.parse(replayPayload.toString("utf8"));
-      if (replayEvidence.reportType !== "replay-runtime-evidence") {
-        throw new Error("Invalid runtime feedback replay evidence payload");
-      }
-      const replayWindow = isRecord3(replayEvidence.window) ? replayEvidence.window : null;
-      const replay = isRecord3(replayEvidence.replay) ? replayEvidence.replay : null;
-      const replayDeployment = parseRuntimeEvidenceDeploymentSnapshot(
-        replayEvidence.deployment
-      );
-      const replayStrategies = activeRuntimeEvidenceStrategies(replayDeployment).map(({ strategyName }) => strategyName).sort();
-      if (replayEvidence.userName !== manifest.userName || replayWindow?.startTime !== manifest.window.startTime || replayWindow.endTime !== manifest.window.endTime || replayDeployment.id !== manifest.deploymentId || replayDeployment.deploymentCompositionId !== manifest.deploymentCompositionId || Number(replay?.cycleCount) !== manifest.cycleCount || JSON.stringify(replayStrategies) !== JSON.stringify([...manifest.activeStrategies].sort())) {
-        throw new Error("Runtime feedback replay payload does not match manifest");
-      }
-      return {
-        bundleDir,
-        manifestPath,
-        replayEvidencePath,
-        logPath,
-        manifest,
-        replayEvidence
-      };
-    };
-    discoverRuntimeFeedbackReplayBundles = async (rootDir) => {
-      const bundles = [];
-      const visit = async (directory, depth) => {
-        if (depth > 10) return;
-        let entries;
-        try {
-          entries = await import_promises29.default.readdir(directory, { withFileTypes: true });
-        } catch (error) {
-          if (error.code === "ENOENT") return;
-          throw error;
-        }
-        const names = new Set(entries.map((entry) => entry.name));
-        if (names.has(RUNTIME_FEEDBACK_MANIFEST_FILE) && names.has(RUNTIME_FEEDBACK_REPLAY_FILE) && names.has(RUNTIME_FEEDBACK_LOG_FILE) && names.has(RUNTIME_FEEDBACK_COMPLETE_FILE)) {
-          bundles.push(directory);
-          return;
-        }
-        await Promise.all(
-          entries.filter(
-            (entry) => entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.includes(".tmp-")
-          ).map((entry) => visit(import_node_path24.default.join(directory, entry.name), depth + 1))
-        );
-      };
-      await visit(rootDir, 0);
-      return bundles.sort();
-    };
-    verifyRuntimeFeedbackReplaySource = async ({
-      bundleDir,
-      runtimeEvidenceBundleDir
-    }) => {
-      const [feedback, runtimeEvidence2] = await Promise.all([
-        verifyRuntimeFeedbackReplayBundle(bundleDir),
-        verifyRuntimeEvidenceBundle(runtimeEvidenceBundleDir)
-      ]);
-      if (feedback.manifest.runtimeEvidence.artifactId !== runtimeEvidence2.manifest.artifactId || feedback.manifest.runtimeEvidence.payloadSha256 !== runtimeEvidence2.manifest.payload.sha256) {
-        throw new Error("Runtime feedback bundle references different evidence");
-      }
-      assertReplayMatchesRuntimeEvidence({
-        replayEvidence: feedback.replayEvidence,
-        runtimeEvidence: runtimeEvidence2
-      });
-      return { feedback, runtimeEvidence: runtimeEvidence2 };
-    };
+    __reExport(runtimeFeedbackArtifacts_exports, require("@tradejs/node/diagnostics"));
   }
 });
 
 // src/lib/runtimeFeedbackReplay.ts
-var import_node_child_process6, import_promises30, import_node_path25, REQUIRED_ENV, FORBIDDEN_SECRET_ENV, unsafeRedisHosts, safeSegment3, assertRuntimeFeedbackReplaySafety, buildRuntimeFeedbackReplayCommands, runLoggedCommand, runRuntimeFeedbackReplay;
+var import_node_child_process7, import_promises28, import_node_path22, REQUIRED_ENV, FORBIDDEN_SECRET_ENV, unsafeRedisHosts, safeSegment, assertRuntimeFeedbackReplaySafety, buildRuntimeFeedbackReplayCommands, runLoggedCommand, runRuntimeFeedbackReplay;
 var init_runtimeFeedbackReplay = __esm({
   "src/lib/runtimeFeedbackReplay.ts"() {
     "use strict";
-    import_node_child_process6 = require("child_process");
-    import_promises30 = __toESM(require("fs/promises"));
-    import_node_path25 = __toESM(require("path"));
+    import_node_child_process7 = require("child_process");
+    import_promises28 = __toESM(require("fs/promises"));
+    import_node_path22 = __toESM(require("path"));
     init_runtimeEvidenceDeployment();
     init_runtimeEvidenceArtifacts();
     init_runtimeEvidenceProducer();
@@ -32287,7 +31726,7 @@ var init_runtimeFeedbackReplay = __esm({
       "localhost",
       "redis"
     ]);
-    safeSegment3 = (value, fallback) => {
+    safeSegment = (value, fallback) => {
       const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
       return normalized && normalized !== "." && normalized !== ".." ? normalized : fallback;
     };
@@ -32385,7 +31824,7 @@ $ ${[executable, ...command].join(" ")}
             await logHandle.write(chunk);
           });
         };
-        const child = (0, import_node_child_process6.spawn)(executable, command, {
+        const child = (0, import_node_child_process7.spawn)(executable, command, {
           cwd,
           env,
           stdio: ["ignore", "pipe", "pipe"]
@@ -32427,18 +31866,18 @@ $ ${[executable, ...command].join(" ")}
       if (!cliPath) {
         throw new Error("Cannot resolve the TradeJS CLI executable path");
       }
-      const runtimeEvidenceBundle = await verifyRuntimeEvidenceBundle(
-        import_node_path25.default.dirname(runtimeEvidencePath)
+      const runtimeEvidenceBundle = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(
+        import_node_path22.default.dirname(runtimeEvidencePath)
       );
-      if (import_node_path25.default.resolve(runtimeEvidenceBundle.payloadPath) !== runtimeEvidencePath) {
+      if (import_node_path22.default.resolve(runtimeEvidenceBundle.payloadPath) !== runtimeEvidencePath) {
         throw new Error(
           `Runtime evidence must be the verified bundle payload: ${runtimeEvidenceBundle.payloadPath}`
         );
       }
-      const deployedProducer = parseRuntimeEvidenceProducer(
+      const deployedProducer = (0, runtimeEvidenceProducer_exports.parseRuntimeEvidenceProducer)(
         runtimeEvidenceBundle.artifact.producer
       );
-      const currentProducer = await resolveRuntimeEvidenceProducer({
+      const currentProducer = await (0, runtimeEvidenceProducer_exports.resolveRuntimeEvidenceProducer)({
         projectRoot: projectRoot18,
         required: true
       });
@@ -32447,10 +31886,10 @@ $ ${[executable, ...command].join(" ")}
           "Runtime feedback replay image identity does not match runtime evidence"
         );
       }
-      const deployment = parseRuntimeEvidenceDeploymentSnapshot(
+      const deployment = (0, runtimeEvidenceDeployment_exports.parseRuntimeEvidenceDeploymentSnapshot)(
         runtimeEvidenceBundle.artifact.deployment
       );
-      const activeStrategies = activeRuntimeEvidenceStrategies(deployment);
+      const activeStrategies = (0, runtimeEvidenceDeployment_exports.activeRuntimeEvidenceStrategies)(deployment);
       const intervals = new Set(
         activeStrategies.map(({ interval: interval4 }) => String(interval4))
       );
@@ -32459,16 +31898,16 @@ $ ${[executable, ...command].join(" ")}
           `Runtime feedback replay requires one interval, received ${[...intervals].join(",")}`
         );
       }
-      await import_promises30.default.mkdir(outDir, { recursive: true });
-      const existing = await import_promises30.default.readdir(outDir);
+      await import_promises28.default.mkdir(outDir, { recursive: true });
+      const existing = await import_promises28.default.readdir(outDir);
       if (existing.length) {
         throw new Error(
           `Runtime feedback output directory must be empty: ${outDir}`
         );
       }
-      const replayEvidencePath = import_node_path25.default.join(outDir, RUNTIME_FEEDBACK_REPLAY_FILE);
-      const logHandle = await import_promises30.default.open(
-        import_node_path25.default.join(outDir, RUNTIME_FEEDBACK_LOG_FILE),
+      const replayEvidencePath = import_node_path22.default.join(outDir, runtimeFeedbackArtifacts_exports.RUNTIME_FEEDBACK_REPLAY_FILE);
+      const logHandle = await import_promises28.default.open(
+        import_node_path22.default.join(outDir, runtimeFeedbackArtifacts_exports.RUNTIME_FEEDBACK_LOG_FILE),
         "wx"
       );
       const commands = buildRuntimeFeedbackReplayCommands({
@@ -32495,9 +31934,9 @@ $ ${[executable, ...command].join(" ")}
       } finally {
         await logHandle.close();
       }
-      return sealRuntimeFeedbackReplayBundle({
+      return (0, runtimeFeedbackArtifacts_exports.sealRuntimeFeedbackReplayBundle)({
         bundleDir: outDir,
-        runId: safeSegment3(runId, "run"),
+        runId: safeSegment(runId, "run"),
         runtimeEvidenceBundle
       });
     };
@@ -32507,14 +31946,14 @@ $ ${[executable, ...command].join(" ")}
 // src/scripts/runtimeFeedbackReplay.ts
 var runtimeFeedbackReplay_exports = {};
 __export(runtimeFeedbackReplay_exports, {
-  main: () => main36,
+  main: () => main37,
   runtimeFeedbackReplay: () => runtimeFeedbackReplay
 });
-var import_node_path26, import_args28, import_chalk44, flags25, projectRoot9, runtimeFeedbackReplay, main36;
+var import_node_path23, import_args28, import_chalk44, flags25, projectRoot9, runtimeFeedbackReplay, main37;
 var init_runtimeFeedbackReplay2 = __esm({
   "src/scripts/runtimeFeedbackReplay.ts"() {
     "use strict";
-    import_node_path26 = __toESM(require("path"));
+    import_node_path23 = __toESM(require("path"));
     import_args28 = __toESM(require("args"));
     import_chalk44 = __toESM(require("chalk"));
     init_runtimeFeedbackReplay();
@@ -32532,8 +31971,8 @@ var init_runtimeFeedbackReplay2 = __esm({
         );
       }
       const verified = await runRuntimeFeedbackReplay({
-        runtimeEvidencePath: import_node_path26.default.resolve(projectRoot9, runtimeEvidence2),
-        outDir: import_node_path26.default.resolve(projectRoot9, outDir),
+        runtimeEvidencePath: import_node_path23.default.resolve(projectRoot9, runtimeEvidence2),
+        outDir: import_node_path23.default.resolve(projectRoot9, outDir),
         runId: String(flags25.runId ?? "").trim() || void 0,
         projectRoot: projectRoot9
       });
@@ -32554,20 +31993,20 @@ var init_runtimeFeedbackReplay2 = __esm({
         )
       );
     };
-    main36 = runtimeFeedbackReplay;
+    main37 = runtimeFeedbackReplay;
   }
 });
 
 // src/lib/runtimeFeedbackNotification.ts
-var isRecord4, asRecord7, asArray3, finiteNumber5, requiredTimestamp, escapeHtml5, formatMskDateTime2, formatConnectorName, sumRows, buildRuntimeFeedbackTelegramMessage, notifyRuntimeFeedbackBundle;
+var isRecord, asRecord6, asArray3, finiteNumber5, requiredTimestamp, escapeHtml5, formatMskDateTime2, formatConnectorName, sumRows, buildRuntimeFeedbackTelegramMessage, notifyRuntimeFeedbackBundle;
 var init_runtimeFeedbackNotification = __esm({
   "src/lib/runtimeFeedbackNotification.ts"() {
     "use strict";
     init_runtimeFeedbackArtifacts();
     init_telegramReports();
-    isRecord4 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
-    asRecord7 = (value) => isRecord4(value) ? value : {};
-    asArray3 = (value) => Array.isArray(value) ? value.map(asRecord7) : [];
+    isRecord = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+    asRecord6 = (value) => isRecord(value) ? value : {};
+    asArray3 = (value) => Array.isArray(value) ? value.map(asRecord6) : [];
     finiteNumber5 = (value, fallback = 0) => {
       const number = Number(value);
       return Number.isFinite(number) ? number : fallback;
@@ -32598,18 +32037,18 @@ var init_runtimeFeedbackNotification = __esm({
       if (replayEvidence.reportType !== "replay-runtime-evidence") {
         throw new Error("Invalid runtime feedback replay evidence payload");
       }
-      const window = asRecord7(replayEvidence.window);
+      const window = asRecord6(replayEvidence.window);
       const startTime = requiredTimestamp(window.startTime, "window.startTime");
       const endTime = requiredTimestamp(window.endTime, "window.endTime");
-      const deployment = asRecord7(replayEvidence.deployment);
-      const replay = asRecord7(replayEvidence.replay);
-      if (!isRecord4(replay.runtimeComparison) || !isRecord4(replay.runtimeComparison.counts) || !Array.isArray(replay.runtimeComparison.rows) || !isRecord4(replay.runtimeComparison.lineage)) {
+      const deployment = asRecord6(replayEvidence.deployment);
+      const replay = asRecord6(replayEvidence.replay);
+      if (!isRecord(replay.runtimeComparison) || !isRecord(replay.runtimeComparison.counts) || !Array.isArray(replay.runtimeComparison.rows) || !isRecord(replay.runtimeComparison.lineage)) {
         throw new Error("Runtime feedback replay comparison is missing");
       }
-      const comparison = asRecord7(replay.runtimeComparison);
-      const comparisonCounts = asRecord7(comparison.counts);
-      const runtimeCounts = asRecord7(asRecord7(replayEvidence.runtime).counts);
-      const lineage = asRecord7(comparison.lineage);
+      const comparison = asRecord6(replay.runtimeComparison);
+      const comparisonCounts = asRecord6(comparison.counts);
+      const runtimeCounts = asRecord6(asRecord6(replayEvidence.runtime).counts);
+      const lineage = asRecord6(comparison.lineage);
       const rows = asArray3(comparison.rows);
       const matched = finiteNumber5(comparisonCounts.matched);
       const runtimeOnly = finiteNumber5(comparisonCounts.runtimeOnly);
@@ -32673,7 +32112,7 @@ var init_runtimeFeedbackNotification = __esm({
       bundleDir,
       send = sendTelegramReport
     }) => {
-      const verified = await verifyRuntimeFeedbackReplayBundle(bundleDir);
+      const verified = await (0, runtimeFeedbackArtifacts_exports.verifyRuntimeFeedbackReplayBundle)(bundleDir);
       const message = buildRuntimeFeedbackTelegramMessage(verified.replayEvidence);
       await send(message, { userName: verified.manifest.userName });
       return {
@@ -32688,14 +32127,14 @@ var init_runtimeFeedbackNotification = __esm({
 // src/scripts/runtimeFeedbackNotify.ts
 var runtimeFeedbackNotify_exports = {};
 __export(runtimeFeedbackNotify_exports, {
-  main: () => main37,
+  main: () => main38,
   runtimeFeedbackNotify: () => runtimeFeedbackNotify
 });
-var import_node_path27, import_args29, import_chalk45, flags26, projectRoot10, runtimeFeedbackNotify, main37;
+var import_node_path24, import_args29, import_chalk45, flags26, projectRoot10, runtimeFeedbackNotify, main38;
 var init_runtimeFeedbackNotify = __esm({
   "src/scripts/runtimeFeedbackNotify.ts"() {
     "use strict";
-    import_node_path27 = __toESM(require("path"));
+    import_node_path24 = __toESM(require("path"));
     import_args29 = __toESM(require("args"));
     import_chalk45 = __toESM(require("chalk"));
     init_runtimeFeedbackNotification();
@@ -32709,9 +32148,9 @@ var init_runtimeFeedbackNotify = __esm({
       if (!bundle) {
         throw new Error("Provide --bundle for runtime feedback notification.");
       }
-      const bundleDir = import_node_path27.default.resolve(projectRoot10, bundle);
+      const bundleDir = import_node_path24.default.resolve(projectRoot10, bundle);
       if (flags26.dryRun) {
-        const verified = await verifyRuntimeFeedbackReplayBundle(bundleDir);
+        const verified = await (0, runtimeFeedbackArtifacts_exports.verifyRuntimeFeedbackReplayBundle)(bundleDir);
         console.log(buildRuntimeFeedbackTelegramMessage(verified.replayEvidence));
         return;
       }
@@ -32720,32 +32159,32 @@ var init_runtimeFeedbackNotify = __esm({
         import_chalk45.default.green(`Runtime feedback notification sent: ${result.artifactId}`)
       );
     };
-    main37 = runtimeFeedbackNotify;
+    main38 = runtimeFeedbackNotify;
   }
 });
 
 // src/lib/runtimeEvidenceSync.ts
-var import_node_child_process7, import_promises31, import_node_path28, import_node_util, execFileAsync, isExistingDestinationError2, safeSegment4, withTrailingSlash, dateParts2, buildRuntimeEvidenceRsyncArgs, receiptPath, compareBundles, listPendingRuntimeEvidenceBundles, markRuntimeEvidenceBundleProcessed, syncRuntimeEvidenceBundles;
+var import_node_child_process8, import_promises29, import_node_path25, import_node_util, execFileAsync, isExistingDestinationError, safeSegment2, withTrailingSlash, dateParts, buildRuntimeEvidenceRsyncArgs, receiptPath, compareBundles, listPendingRuntimeEvidenceBundles, markRuntimeEvidenceBundleProcessed, syncRuntimeEvidenceBundles;
 var init_runtimeEvidenceSync = __esm({
   "src/lib/runtimeEvidenceSync.ts"() {
     "use strict";
-    import_node_child_process7 = require("child_process");
-    import_promises31 = __toESM(require("fs/promises"));
-    import_node_path28 = __toESM(require("path"));
+    import_node_child_process8 = require("child_process");
+    import_promises29 = __toESM(require("fs/promises"));
+    import_node_path25 = __toESM(require("path"));
     import_node_util = require("util");
     init_runtimeEvidenceArtifacts();
     init_runtimeEvidenceDeployment();
-    execFileAsync = (0, import_node_util.promisify)(import_node_child_process7.execFile);
-    isExistingDestinationError2 = (error) => {
+    execFileAsync = (0, import_node_util.promisify)(import_node_child_process8.execFile);
+    isExistingDestinationError = (error) => {
       const code = error.code;
       return code === "EEXIST" || code === "ENOTEMPTY";
     };
-    safeSegment4 = (value, fallback) => {
+    safeSegment2 = (value, fallback) => {
       const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
       return normalized && normalized !== "." && normalized !== ".." ? normalized : fallback;
     };
     withTrailingSlash = (value) => value.endsWith("/") ? value : `${value}/`;
-    dateParts2 = (timestamp) => {
+    dateParts = (timestamp) => {
       const date = new Date(timestamp);
       return [
         String(date.getUTCFullYear()),
@@ -32765,23 +32204,23 @@ var init_runtimeEvidenceSync = __esm({
       withTrailingSlash(source),
       withTrailingSlash(destination)
     ];
-    receiptPath = (receiptsRoot, artifactId) => import_node_path28.default.join(receiptsRoot, `${safeSegment4(artifactId, "artifact")}.json`);
+    receiptPath = (receiptsRoot, artifactId) => import_node_path25.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 = safeSegment4(deploymentId, "production");
-      const artifactsRoot = import_node_path28.default.join(evidenceRoot, "artifacts", safeDeploymentId);
-      const receiptsRoot = import_node_path28.default.join(evidenceRoot, "receipts", safeDeploymentId);
-      const bundles = await discoverRuntimeEvidenceBundles(artifactsRoot);
+      const safeDeploymentId = safeSegment2(deploymentId, "production");
+      const artifactsRoot = import_node_path25.default.join(evidenceRoot, "artifacts", safeDeploymentId);
+      const receiptsRoot = import_node_path25.default.join(evidenceRoot, "receipts", safeDeploymentId);
+      const bundles = await (0, runtimeEvidenceArtifacts_exports.discoverRuntimeEvidenceBundles)(artifactsRoot);
       const pending = [];
       for (const bundleDir of bundles) {
-        const verified = await verifyRuntimeEvidenceBundle(bundleDir);
+        const verified = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(bundleDir);
         if (verified.manifest.deploymentId !== safeDeploymentId) continue;
-        assertCurrentRuntimeEvidenceArtifact(verified.artifact);
+        (0, runtimeEvidenceDeployment_exports.assertCurrentRuntimeEvidenceArtifact)(verified.artifact);
         try {
-          await import_promises31.default.access(receiptPath(receiptsRoot, verified.manifest.artifactId));
+          await import_promises29.default.access(receiptPath(receiptsRoot, verified.manifest.artifactId));
           continue;
         } catch (error) {
           if (error.code !== "ENOENT") throw error;
@@ -32797,14 +32236,14 @@ var init_runtimeEvidenceSync = __esm({
       scorecardPath,
       runtimeFeedback
     }) => {
-      const safeDeploymentId = safeSegment4(deploymentId, "production");
-      const verified = await verifyRuntimeEvidenceBundle(bundleDir);
+      const safeDeploymentId = safeSegment2(deploymentId, "production");
+      const verified = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(bundleDir);
       if (verified.manifest.deploymentId !== safeDeploymentId) {
         throw new Error(
           `Artifact deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
         );
       }
-      const receiptsRoot = import_node_path28.default.join(evidenceRoot, "receipts", safeDeploymentId);
+      const receiptsRoot = import_node_path25.default.join(evidenceRoot, "receipts", safeDeploymentId);
       const finalPath = receiptPath(receiptsRoot, verified.manifest.artifactId);
       const temporaryPath = `${finalPath}.tmp-${process.pid}`;
       const receipt = {
@@ -32818,14 +32257,14 @@ var init_runtimeEvidenceSync = __esm({
           replayEvidenceSha256: runtimeFeedback.replayEvidenceSha256
         } : {}
       };
-      await import_promises31.default.mkdir(receiptsRoot, { recursive: true });
-      await import_promises31.default.writeFile(
+      await import_promises29.default.mkdir(receiptsRoot, { recursive: true });
+      await import_promises29.default.writeFile(
         temporaryPath,
         `${JSON.stringify(receipt, null, 2)}
 `,
         "utf8"
       );
-      await import_promises31.default.rename(temporaryPath, finalPath);
+      await import_promises29.default.rename(temporaryPath, finalPath);
       return finalPath;
     };
     syncRuntimeEvidenceBundles = async ({
@@ -32839,47 +32278,47 @@ var init_runtimeEvidenceSync = __esm({
         return { stdout: result.stdout, stderr: result.stderr };
       }
     }) => {
-      const safeDeploymentId = safeSegment4(deploymentId, "production");
-      const inboxRoot = import_node_path28.default.join(evidenceRoot, "inbox", safeDeploymentId);
-      const artifactsRoot = import_node_path28.default.join(evidenceRoot, "artifacts", safeDeploymentId);
+      const safeDeploymentId = safeSegment2(deploymentId, "production");
+      const inboxRoot = import_node_path25.default.join(evidenceRoot, "inbox", safeDeploymentId);
+      const artifactsRoot = import_node_path25.default.join(evidenceRoot, "artifacts", safeDeploymentId);
       await Promise.all([
-        import_promises31.default.mkdir(inboxRoot, { recursive: true }),
-        import_promises31.default.mkdir(artifactsRoot, { recursive: true })
+        import_promises29.default.mkdir(inboxRoot, { recursive: true }),
+        import_promises29.default.mkdir(artifactsRoot, { recursive: true })
       ]);
       const rsyncArgs = buildRuntimeEvidenceRsyncArgs({
         source,
         destination: inboxRoot
       });
       const transfer = await runRsync(rsyncArgs);
-      const discovered = await discoverRuntimeEvidenceBundles(inboxRoot);
+      const discovered = await (0, runtimeEvidenceArtifacts_exports.discoverRuntimeEvidenceBundles)(inboxRoot);
       const received = [];
       for (const bundleDir of discovered) {
-        const verified = await verifyRuntimeEvidenceBundle(bundleDir);
+        const verified = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(bundleDir);
         if (verified.manifest.deploymentId !== safeDeploymentId) {
           throw new Error(
             `Artifact deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
           );
         }
-        assertCurrentRuntimeEvidenceArtifact(verified.artifact);
-        const destinationDir = import_node_path28.default.join(
+        (0, runtimeEvidenceDeployment_exports.assertCurrentRuntimeEvidenceArtifact)(verified.artifact);
+        const destinationDir = import_node_path25.default.join(
           artifactsRoot,
-          ...dateParts2(verified.manifest.window.endTime),
-          safeSegment4(verified.manifest.artifactId, "artifact")
+          ...dateParts(verified.manifest.window.endTime),
+          safeSegment2(verified.manifest.artifactId, "artifact")
         );
-        await import_promises31.default.mkdir(import_node_path28.default.dirname(destinationDir), { recursive: true });
+        await import_promises29.default.mkdir(import_node_path25.default.dirname(destinationDir), { recursive: true });
         try {
-          await import_promises31.default.rename(bundleDir, destinationDir);
+          await import_promises29.default.rename(bundleDir, destinationDir);
         } catch (error) {
-          if (!isExistingDestinationError2(error)) throw error;
-          const existing = await verifyRuntimeEvidenceBundle(destinationDir);
+          if (!isExistingDestinationError(error)) throw error;
+          const existing = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(destinationDir);
           if (existing.manifest.payload.sha256 !== verified.manifest.payload.sha256) {
             throw new Error(
               `Conflicting runtime evidence artifact ${verified.manifest.artifactId}`
             );
           }
-          await import_promises31.default.rm(bundleDir, { recursive: true, force: true });
+          await import_promises29.default.rm(bundleDir, { recursive: true, force: true });
         }
-        received.push(await verifyRuntimeEvidenceBundle(destinationDir));
+        received.push(await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(destinationDir));
       }
       const pending = await listPendingRuntimeEvidenceBundles({
         evidenceRoot,
@@ -32897,26 +32336,26 @@ var init_runtimeEvidenceSync = __esm({
 });
 
 // src/lib/runtimeFeedbackSync.ts
-var import_node_child_process8, import_promises32, import_node_path29, import_node_util2, execFileAsync2, isExistingDestinationError3, safeSegment5, dateParts3, syncRuntimeFeedbackReplayBundles;
+var import_node_child_process9, import_promises30, import_node_path26, import_node_util2, execFileAsync2, isExistingDestinationError2, safeSegment3, dateParts2, syncRuntimeFeedbackReplayBundles;
 var init_runtimeFeedbackSync = __esm({
   "src/lib/runtimeFeedbackSync.ts"() {
     "use strict";
-    import_node_child_process8 = require("child_process");
-    import_promises32 = __toESM(require("fs/promises"));
-    import_node_path29 = __toESM(require("path"));
+    import_node_child_process9 = require("child_process");
+    import_promises30 = __toESM(require("fs/promises"));
+    import_node_path26 = __toESM(require("path"));
     import_node_util2 = require("util");
     init_runtimeFeedbackArtifacts();
     init_runtimeEvidenceSync();
-    execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process8.execFile);
-    isExistingDestinationError3 = (error) => {
+    execFileAsync2 = (0, import_node_util2.promisify)(import_node_child_process9.execFile);
+    isExistingDestinationError2 = (error) => {
       const code = error.code;
       return code === "EEXIST" || code === "ENOTEMPTY";
     };
-    safeSegment5 = (value, fallback) => {
+    safeSegment3 = (value, fallback) => {
       const normalized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "-");
       return normalized && normalized !== "." && normalized !== ".." ? normalized : fallback;
     };
-    dateParts3 = (timestamp) => {
+    dateParts2 = (timestamp) => {
       const date = new Date(timestamp);
       return [
         String(date.getUTCFullYear()),
@@ -32935,47 +32374,47 @@ var init_runtimeFeedbackSync = __esm({
         return { stdout: result.stdout, stderr: result.stderr };
       }
     }) => {
-      const safeDeploymentId = safeSegment5(deploymentId, "production");
-      const inboxRoot = import_node_path29.default.join(feedbackRoot, "inbox", safeDeploymentId);
-      const artifactsRoot = import_node_path29.default.join(feedbackRoot, "artifacts", safeDeploymentId);
+      const safeDeploymentId = safeSegment3(deploymentId, "production");
+      const inboxRoot = import_node_path26.default.join(feedbackRoot, "inbox", safeDeploymentId);
+      const artifactsRoot = import_node_path26.default.join(feedbackRoot, "artifacts", safeDeploymentId);
       await Promise.all([
-        import_promises32.default.mkdir(inboxRoot, { recursive: true }),
-        import_promises32.default.mkdir(artifactsRoot, { recursive: true })
+        import_promises30.default.mkdir(inboxRoot, { recursive: true }),
+        import_promises30.default.mkdir(artifactsRoot, { recursive: true })
       ]);
       const rsyncArgs = buildRuntimeEvidenceRsyncArgs({
         source,
         destination: inboxRoot
       });
       const transfer = await runRsync(rsyncArgs);
-      const discovered = await discoverRuntimeFeedbackReplayBundles(inboxRoot);
+      const discovered = await (0, runtimeFeedbackArtifacts_exports.discoverRuntimeFeedbackReplayBundles)(inboxRoot);
       const received = [];
       for (const bundleDir of discovered) {
-        const verified = await verifyRuntimeFeedbackReplayBundle(bundleDir);
+        const verified = await (0, runtimeFeedbackArtifacts_exports.verifyRuntimeFeedbackReplayBundle)(bundleDir);
         if (verified.manifest.deploymentId !== safeDeploymentId) {
           throw new Error(
             `Runtime feedback deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
           );
         }
-        const destinationDir = import_node_path29.default.join(
+        const destinationDir = import_node_path26.default.join(
           artifactsRoot,
-          ...dateParts3(verified.manifest.window.endTime),
-          safeSegment5(verified.manifest.runtimeEvidence.artifactId, "artifact"),
-          safeSegment5(verified.manifest.runId, "run")
+          ...dateParts2(verified.manifest.window.endTime),
+          safeSegment3(verified.manifest.runtimeEvidence.artifactId, "artifact"),
+          safeSegment3(verified.manifest.runId, "run")
         );
-        await import_promises32.default.mkdir(import_node_path29.default.dirname(destinationDir), { recursive: true });
+        await import_promises30.default.mkdir(import_node_path26.default.dirname(destinationDir), { recursive: true });
         try {
-          await import_promises32.default.rename(bundleDir, destinationDir);
+          await import_promises30.default.rename(bundleDir, destinationDir);
         } catch (error) {
-          if (!isExistingDestinationError3(error)) throw error;
-          const existing = await verifyRuntimeFeedbackReplayBundle(destinationDir);
+          if (!isExistingDestinationError2(error)) throw error;
+          const existing = await (0, runtimeFeedbackArtifacts_exports.verifyRuntimeFeedbackReplayBundle)(destinationDir);
           if (existing.manifest.payloads.replayEvidence.sha256 !== verified.manifest.payloads.replayEvidence.sha256) {
             throw new Error(
               `Conflicting runtime feedback replay ${verified.manifest.artifactId}`
             );
           }
-          await import_promises32.default.rm(bundleDir, { recursive: true, force: true });
+          await import_promises30.default.rm(bundleDir, { recursive: true, force: true });
         }
-        received.push(await verifyRuntimeFeedbackReplayBundle(destinationDir));
+        received.push(await (0, runtimeFeedbackArtifacts_exports.verifyRuntimeFeedbackReplayBundle)(destinationDir));
       }
       return {
         rsyncArgs,
@@ -32990,14 +32429,14 @@ var init_runtimeFeedbackSync = __esm({
 // src/scripts/runtimeFeedbackSync.ts
 var runtimeFeedbackSync_exports = {};
 __export(runtimeFeedbackSync_exports, {
-  main: () => main38,
+  main: () => main39,
   runtimeFeedbackSync: () => runtimeFeedbackSync
 });
-var import_node_path30, import_args30, import_chalk46, flags27, projectRoot11, runtimeFeedbackSync, main38;
+var import_node_path27, import_args30, import_chalk46, flags27, projectRoot11, runtimeFeedbackSync, main39;
 var init_runtimeFeedbackSync2 = __esm({
   "src/scripts/runtimeFeedbackSync.ts"() {
     "use strict";
-    import_node_path30 = __toESM(require("path"));
+    import_node_path27 = __toESM(require("path"));
     import_args30 = __toESM(require("args"));
     import_chalk46 = __toESM(require("chalk"));
     init_runtimeFeedbackSync();
@@ -33025,7 +32464,7 @@ var init_runtimeFeedbackSync2 = __esm({
           "Provide --source or RUNTIME_FEEDBACK_RSYNC_SOURCE for runtime feedback sync."
         );
       }
-      const feedbackRoot = import_node_path30.default.resolve(projectRoot11, String(flags27.dir));
+      const feedbackRoot = import_node_path27.default.resolve(projectRoot11, String(flags27.dir));
       const result = await syncRuntimeFeedbackReplayBundles({
         source,
         feedbackRoot,
@@ -33052,18 +32491,18 @@ var init_runtimeFeedbackSync2 = __esm({
         )
       );
     };
-    main38 = runtimeFeedbackSync;
+    main39 = runtimeFeedbackSync;
   }
 });
 
 // src/lib/runtimeEvidenceCompositionSnapshots.ts
-var import_node_crypto16, import_promises33, import_node_path31, SNAPSHOT_FILE, MANIFEST_FILE, COMPLETE_FILE, createRuntimeEvidenceCompositionSnapshotRecorder, isRecord5, sha2564, safeSegment6, isExistingDestinationError4, parseManifest3, verifyRuntimeEvidenceCompositionSnapshot, sameSnapshot, publishRuntimeEvidenceCompositionSnapshot, captureRuntimeEvidenceCompositionSnapshot, discoverRuntimeEvidenceCompositionSnapshots;
+var import_node_crypto14, import_promises31, import_node_path28, SNAPSHOT_FILE, MANIFEST_FILE, COMPLETE_FILE, createRuntimeEvidenceCompositionSnapshotRecorder, isRecord2, sha256, safeSegment4, isExistingDestinationError3, parseManifest, verifyRuntimeEvidenceCompositionSnapshot, sameSnapshot, publishRuntimeEvidenceCompositionSnapshot, captureRuntimeEvidenceCompositionSnapshot, discoverRuntimeEvidenceCompositionSnapshots;
 var init_runtimeEvidenceCompositionSnapshots = __esm({
   "src/lib/runtimeEvidenceCompositionSnapshots.ts"() {
     "use strict";
-    import_node_crypto16 = require("crypto");
-    import_promises33 = __toESM(require("fs/promises"));
-    import_node_path31 = __toESM(require("path"));
+    import_node_crypto14 = require("crypto");
+    import_promises31 = __toESM(require("fs/promises"));
+    import_node_path28 = __toESM(require("path"));
     init_runtimeEvidenceDeployment();
     init_runtimeEvidenceProducer();
     SNAPSHOT_FILE = "snapshot.json";
@@ -33083,22 +32522,22 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
         }
       };
     };
-    isRecord5 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
-    sha2564 = (value) => (0, import_node_crypto16.createHash)("sha256").update(value).digest("hex");
-    safeSegment6 = (value, label) => {
+    isRecord2 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+    sha256 = (value) => (0, import_node_crypto14.createHash)("sha256").update(value).digest("hex");
+    safeSegment4 = (value, label) => {
       const normalized = value.trim();
       if (!normalized || !/^[a-zA-Z0-9._:-]+$/.test(normalized)) {
         throw new Error(`Invalid runtime evidence snapshot ${label}`);
       }
       return normalized;
     };
-    isExistingDestinationError4 = (error) => {
+    isExistingDestinationError3 = (error) => {
       const code = error.code;
       return code === "EEXIST" || code === "ENOTEMPTY";
     };
-    parseManifest3 = (value) => {
-      const manifest = isRecord5(value) ? value : null;
-      const payload = isRecord5(manifest?.payload) ? manifest.payload : null;
+    parseManifest = (value) => {
+      const manifest = isRecord2(value) ? value : null;
+      const payload = isRecord2(manifest?.payload) ? manifest.payload : null;
       if (manifest?.schemaVersion !== 1 || manifest.reportType !== "runtime-evidence-composition-snapshot" || typeof manifest.createdAt !== "number" || typeof manifest.userName !== "string" || typeof manifest.deploymentId !== "string" || typeof manifest.deploymentCompositionId !== "string" || payload?.file !== SNAPSHOT_FILE || typeof payload.sha256 !== "string" || !/^[a-f0-9]{64}$/.test(payload.sha256) || typeof payload.bytes !== "number") {
         throw new Error("Invalid runtime evidence composition snapshot manifest");
       }
@@ -33106,28 +32545,28 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
     };
     verifyRuntimeEvidenceCompositionSnapshot = async (bundleDir) => {
       const [manifestText, payload, completeText] = await Promise.all([
-        import_promises33.default.readFile(import_node_path31.default.join(bundleDir, MANIFEST_FILE), "utf8"),
-        import_promises33.default.readFile(import_node_path31.default.join(bundleDir, SNAPSHOT_FILE)),
-        import_promises33.default.readFile(import_node_path31.default.join(bundleDir, COMPLETE_FILE), "utf8")
+        import_promises31.default.readFile(import_node_path28.default.join(bundleDir, MANIFEST_FILE), "utf8"),
+        import_promises31.default.readFile(import_node_path28.default.join(bundleDir, SNAPSHOT_FILE)),
+        import_promises31.default.readFile(import_node_path28.default.join(bundleDir, COMPLETE_FILE), "utf8")
       ]);
-      const manifest = parseManifest3(JSON.parse(manifestText));
+      const manifest = parseManifest(JSON.parse(manifestText));
       if (completeText.trim() !== manifest.deploymentCompositionId) {
         throw new Error(`Invalid completion marker in ${bundleDir}`);
       }
-      if (payload.byteLength !== manifest.payload.bytes || sha2564(payload) !== manifest.payload.sha256) {
+      if (payload.byteLength !== manifest.payload.bytes || sha256(payload) !== manifest.payload.sha256) {
         throw new Error(
           `Runtime evidence snapshot checksum mismatch in ${bundleDir}`
         );
       }
       const value = JSON.parse(payload.toString("utf8"));
-      const record = isRecord5(value) ? value : null;
+      const record = isRecord2(value) ? value : null;
       if (record?.schemaVersion !== 1 || record.reportType !== "runtime-evidence-composition-snapshot" || record.userName !== manifest.userName) {
         throw new Error(
           `Invalid runtime evidence snapshot payload in ${bundleDir}`
         );
       }
-      const deployment = parseRuntimeEvidenceDeploymentSnapshot(record.deployment);
-      const producer = parseRuntimeEvidenceProducer(record.producer);
+      const deployment = (0, runtimeEvidenceDeployment_exports.parseRuntimeEvidenceDeploymentSnapshot)(record.deployment);
+      const producer = (0, runtimeEvidenceProducer_exports.parseRuntimeEvidenceProducer)(record.producer);
       if (deployment.id !== manifest.deploymentId || deployment.deploymentCompositionId !== manifest.deploymentCompositionId) {
         throw new Error(
           `Runtime evidence snapshot identity mismatch in ${bundleDir}`
@@ -33142,8 +32581,8 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
       deployment,
       producer
     }) => {
-      const deploymentId = safeSegment6(deployment.id, "deployment id");
-      const compositionId = safeSegment6(
+      const deploymentId = safeSegment4(deployment.id, "deployment id");
+      const compositionId = safeSegment4(
         deployment.deploymentCompositionId,
         "composition id"
       );
@@ -33167,43 +32606,43 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
         deploymentCompositionId: compositionId,
         payload: {
           file: SNAPSHOT_FILE,
-          sha256: sha2564(payload),
+          sha256: sha256(payload),
           bytes: Buffer.byteLength(payload)
         }
       };
-      const snapshotsRoot = import_node_path31.default.join(evidenceRoot, "snapshots", deploymentId);
-      const bundleDir = import_node_path31.default.join(snapshotsRoot, compositionId);
-      const temporaryDir = import_node_path31.default.join(
+      const snapshotsRoot = import_node_path28.default.join(evidenceRoot, "snapshots", deploymentId);
+      const bundleDir = import_node_path28.default.join(snapshotsRoot, compositionId);
+      const temporaryDir = import_node_path28.default.join(
         evidenceRoot,
         "incoming",
-        `snapshot-${compositionId}.tmp-${(0, import_node_crypto16.randomUUID)()}`
+        `snapshot-${compositionId}.tmp-${(0, import_node_crypto14.randomUUID)()}`
       );
-      await import_promises33.default.mkdir(temporaryDir, { recursive: true });
+      await import_promises31.default.mkdir(temporaryDir, { recursive: true });
       try {
         await Promise.all([
-          import_promises33.default.writeFile(import_node_path31.default.join(temporaryDir, SNAPSHOT_FILE), payload, "utf8"),
-          import_promises33.default.writeFile(
-            import_node_path31.default.join(temporaryDir, MANIFEST_FILE),
+          import_promises31.default.writeFile(import_node_path28.default.join(temporaryDir, SNAPSHOT_FILE), payload, "utf8"),
+          import_promises31.default.writeFile(
+            import_node_path28.default.join(temporaryDir, MANIFEST_FILE),
             `${JSON.stringify(manifest, null, 2)}
 `,
             "utf8"
           )
         ]);
-        await import_promises33.default.writeFile(
-          import_node_path31.default.join(temporaryDir, COMPLETE_FILE),
+        await import_promises31.default.writeFile(
+          import_node_path28.default.join(temporaryDir, COMPLETE_FILE),
           `${compositionId}
 `,
           "utf8"
         );
-        await import_promises33.default.mkdir(snapshotsRoot, { recursive: true });
+        await import_promises31.default.mkdir(snapshotsRoot, { recursive: true });
         try {
-          await import_promises33.default.rename(temporaryDir, bundleDir);
+          await import_promises31.default.rename(temporaryDir, bundleDir);
         } catch (error) {
-          if (!isExistingDestinationError4(error)) throw error;
-          await import_promises33.default.rm(temporaryDir, { recursive: true, force: true });
+          if (!isExistingDestinationError3(error)) throw error;
+          await import_promises31.default.rm(temporaryDir, { recursive: true, force: true });
         }
       } catch (error) {
-        await import_promises33.default.rm(temporaryDir, { recursive: true, force: true });
+        await import_promises31.default.rm(temporaryDir, { recursive: true, force: true });
         throw error;
       }
       const verified = await verifyRuntimeEvidenceCompositionSnapshot(bundleDir);
@@ -33221,12 +32660,12 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
       expectedCompositionId
     }) => {
       const [deployment, producer] = await Promise.all([
-        resolveRuntimeEvidenceDeploymentSnapshot({
+        (0, runtimeEvidenceDeployment_exports.resolveRuntimeEvidenceDeploymentSnapshot)({
           userName: userName3,
           projectRoot: projectRoot18,
           deploymentId
         }),
-        resolveRuntimeEvidenceProducer({ projectRoot: projectRoot18, required: true })
+        (0, runtimeEvidenceProducer_exports.resolveRuntimeEvidenceProducer)({ projectRoot: projectRoot18, required: true })
       ]);
       if (!producer) {
         throw new Error("Runtime evidence producer identity is required");
@@ -33237,31 +32676,31 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
         );
       }
       await publishRuntimeEvidenceCompositionSnapshot({
-        evidenceRoot: import_node_path31.default.join(projectRoot18, "data", "runtime-evidence"),
+        evidenceRoot: import_node_path28.default.join(projectRoot18, "data", "runtime-evidence"),
         userName: userName3,
         deployment,
         producer
       });
     };
     discoverRuntimeEvidenceCompositionSnapshots = async (evidenceRoot) => {
-      const rootDir = import_node_path31.default.join(evidenceRoot, "snapshots");
+      const rootDir = import_node_path28.default.join(evidenceRoot, "snapshots");
       const bundleDirs = [];
       let deployments;
       try {
-        deployments = await import_promises33.default.readdir(rootDir, { withFileTypes: true });
+        deployments = await import_promises31.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_path31.default.join(rootDir, deployment.name);
-        const compositions = await import_promises33.default.readdir(deploymentDir, {
+        const deploymentDir = import_node_path28.default.join(rootDir, deployment.name);
+        const compositions = await import_promises31.default.readdir(deploymentDir, {
           withFileTypes: true
         });
         bundleDirs.push(
           ...compositions.filter(
             (entry) => entry.isDirectory() && !entry.name.startsWith(".") && !entry.name.includes(".tmp-")
-          ).map((entry) => import_node_path31.default.join(deploymentDir, entry.name))
+          ).map((entry) => import_node_path28.default.join(deploymentDir, entry.name))
         );
       }
       return Promise.all(
@@ -33313,17 +32752,17 @@ var init_runtimeEvidenceCompositions = __esm({
           producer: snapshot.producer
         });
       }
-      const bundleDirs = await discoverRuntimeEvidenceBundles(publishRoot);
+      const bundleDirs = await (0, runtimeEvidenceArtifacts_exports.discoverRuntimeEvidenceBundles)(publishRoot);
       for (const bundleDir of bundleDirs) {
-        const bundle = await verifyRuntimeEvidenceBundle(bundleDir);
-        const deployment = parseRuntimeEvidenceDeploymentSnapshot(
+        const bundle = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(bundleDir);
+        const deployment = (0, runtimeEvidenceDeployment_exports.parseRuntimeEvidenceDeploymentSnapshot)(
           bundle.artifact.deployment
         );
         if (deployment.id !== currentDeployment.id) continue;
         if (bundle.artifact.producer == null) continue;
         register({
           deployment: { ...deployment, tickers: void 0 },
-          producer: parseRuntimeEvidenceProducer(bundle.artifact.producer),
+          producer: (0, runtimeEvidenceProducer_exports.parseRuntimeEvidenceProducer)(bundle.artifact.producer),
           // A historical composition may reappear through a position that closes
           // in this window even without current-window lineage scopes. Its latest
           // checksum-verified universe is only a fallback; fresh scopes win.
@@ -33358,11 +32797,11 @@ var init_runtimeEvidenceCompositions = __esm({
       return Number.POSITIVE_INFINITY;
     };
     belongsToSnapshot = (row, deployment) => {
-      const strategy = activeRuntimeEvidenceStrategies(deployment).find(
+      const strategy = (0, runtimeEvidenceDeployment_exports.activeRuntimeEvidenceStrategies)(deployment).find(
         (candidate) => candidate.strategyName === row.strategy
       );
       return Boolean(
-        strategy && row.deploymentId === deployment.id && row.accountId === deployment.accountId && runtimeLineageMatchesStrategySnapshot({
+        strategy && row.deploymentId === deployment.id && row.accountId === deployment.accountId && (0, runtimeEvidenceDeployment_exports.runtimeLineageMatchesStrategySnapshot)({
           lineage: row.runtimeLineage ?? row.lineage,
           deployment,
           strategy
@@ -33437,15 +32876,15 @@ var init_runtimeEvidenceCompositions = __esm({
 // src/scripts/runtimeEvidence.ts
 var runtimeEvidence_exports = {};
 __export(runtimeEvidence_exports, {
-  main: () => main39,
+  main: () => main40,
   runtimeEvidence: () => runtimeEvidence
 });
-var import_promises34, import_node_path32, import_args31, import_chalk47, flags28, projectRoot12, toEpochMs3, resolveWindow2, parseStrategyFilter2, runtimeEvidence, main39;
+var import_promises32, import_node_path29, import_args31, import_chalk47, flags28, projectRoot12, toEpochMs3, resolveWindow2, parseStrategyFilter2, runtimeEvidence, main40;
 var init_runtimeEvidence = __esm({
   "src/scripts/runtimeEvidence.ts"() {
     "use strict";
-    import_promises34 = __toESM(require("fs/promises"));
-    import_node_path32 = __toESM(require("path"));
+    import_promises32 = __toESM(require("fs/promises"));
+    import_node_path29 = __toESM(require("path"));
     import_args31 = __toESM(require("args"));
     import_chalk47 = __toESM(require("chalk"));
     init_runtimeDebugEvidence();
@@ -33534,11 +32973,11 @@ var init_runtimeEvidence = __esm({
       const { startTime, endTime, source } = resolveWindow2();
       const deploymentId = String(flags28.deployment);
       const publishDir = String(flags28.publishDir ?? "").trim();
-      const producer = await resolveRuntimeEvidenceProducer({
+      const producer = await (0, runtimeEvidenceProducer_exports.resolveRuntimeEvidenceProducer)({
         projectRoot: projectRoot12,
         required: Boolean(publishDir)
       });
-      const deploymentSnapshot = await resolveRuntimeEvidenceDeploymentSnapshot({
+      const deploymentSnapshot = await (0, runtimeEvidenceDeployment_exports.resolveRuntimeEvidenceDeploymentSnapshot)({
         userName: String(flags28.user),
         projectRoot: projectRoot12,
         deploymentId
@@ -33552,7 +32991,7 @@ var init_runtimeEvidence = __esm({
         deploymentId
       });
       const snapshots = publishDir && producer ? await loadRuntimeEvidenceCompositionSnapshots({
-        publishRoot: import_node_path32.default.resolve(projectRoot12, publishDir),
+        publishRoot: import_node_path29.default.resolve(projectRoot12, publishDir),
         currentDeployment: deploymentSnapshot,
         currentProducer: producer
       }) : /* @__PURE__ */ new Map([
@@ -33581,7 +33020,7 @@ var init_runtimeEvidence = __esm({
         ignoreUnknownCompositions: !publishDir
       });
       const artifacts = compositionRows.map((composition) => {
-        const strategies = activeRuntimeEvidenceStrategies(composition.deployment).map(({ strategyName }) => strategyName).filter(
+        const strategies = (0, runtimeEvidenceDeployment_exports.activeRuntimeEvidenceStrategies)(composition.deployment).map(({ strategyName }) => strategyName).filter(
           (strategyName) => !requestedStrategies.length || requestedStrategies.includes(strategyName)
         );
         const runtime = buildRuntimeEvidenceReportPayload({
@@ -33593,7 +33032,7 @@ var init_runtimeEvidence = __esm({
           trades: composition.trades,
           lineageScopes: composition.lineageScopes
         });
-        const deployment = resolveRuntimeEvidenceTickerUniverse({
+        const deployment = (0, runtimeEvidenceDeployment_exports.resolveRuntimeEvidenceTickerUniverse)({
           deployment: composition.deployment,
           lineageScopes: composition.lineageScopes,
           fallbackTickers: composition.fallbackTickers
@@ -33626,14 +33065,14 @@ var init_runtimeEvidence = __esm({
         throw new Error("Runtime evidence window has no versioned runtime rows");
       }
       const artifact = current.artifact;
-      const outPath = import_node_path32.default.resolve(projectRoot12, String(flags28.out));
-      await import_promises34.default.mkdir(import_node_path32.default.dirname(outPath), { recursive: true });
-      await import_promises34.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
+      const outPath = import_node_path29.default.resolve(projectRoot12, String(flags28.out));
+      await import_promises32.default.mkdir(import_node_path29.default.dirname(outPath), { recursive: true });
+      await import_promises32.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
 `, "utf8");
       const published = publishDir ? await Promise.all(
         artifacts.map(
-          ({ artifact: artifact2, composition }) => publishRuntimeEvidenceBundle({
-            publishRoot: import_node_path32.default.resolve(projectRoot12, publishDir),
+          ({ artifact: artifact2, composition }) => (0, runtimeEvidenceArtifacts_exports.publishRuntimeEvidenceBundle)({
+            publishRoot: import_node_path29.default.resolve(projectRoot12, publishDir),
             deploymentId,
             userName: String(flags28.user),
             startTime,
@@ -33669,21 +33108,21 @@ var init_runtimeEvidence = __esm({
         )
       );
     };
-    main39 = runtimeEvidence;
+    main40 = runtimeEvidence;
   }
 });
 
 // src/scripts/runtimeEvidenceSync.ts
 var runtimeEvidenceSync_exports = {};
 __export(runtimeEvidenceSync_exports, {
-  main: () => main40,
+  main: () => main41,
   runtimeEvidenceSync: () => runtimeEvidenceSync
 });
-var import_node_path33, import_args32, import_chalk48, flags29, projectRoot13, runtimeEvidenceSync, main40;
+var import_node_path30, import_args32, import_chalk48, flags29, projectRoot13, runtimeEvidenceSync, main41;
 var init_runtimeEvidenceSync2 = __esm({
   "src/scripts/runtimeEvidenceSync.ts"() {
     "use strict";
-    import_node_path33 = __toESM(require("path"));
+    import_node_path30 = __toESM(require("path"));
     import_args32 = __toESM(require("args"));
     import_chalk48 = __toESM(require("chalk"));
     init_runtimeEvidenceSync();
@@ -33711,7 +33150,7 @@ var init_runtimeEvidenceSync2 = __esm({
           "Provide --source or RUNTIME_EVIDENCE_RSYNC_SOURCE for runtime evidence sync."
         );
       }
-      const evidenceRoot = import_node_path33.default.resolve(projectRoot13, String(flags29.dir));
+      const evidenceRoot = import_node_path30.default.resolve(projectRoot13, String(flags29.dir));
       const result = await syncRuntimeEvidenceBundles({
         source,
         evidenceRoot,
@@ -33743,23 +33182,23 @@ var init_runtimeEvidenceSync2 = __esm({
         )
       );
     };
-    main40 = runtimeEvidenceSync;
+    main41 = runtimeEvidenceSync;
   }
 });
 
 // src/lib/runtimeScorecard.ts
-var asRecord8, asArray4, finiteNumber6, finiteString2, packageVersionMap, round3, unwrapRows2, runtimePayload, runtimeWindow, extractRuntimeRows, buildEmbeddedLineageScope, runtimeDeploymentBinding, belongsToRuntimeDeployment, belongsToStrategy, filterArtifactByStrategy, countBy2, resolveGateDecision, buildDistributions, buildDistributionDelta, sum2, tradeTimestamp, dedupeTrades, maxDrawdown2, buildRollingPerformance, getReplayComparison, replayCountsForStrategy, getProspectiveSummary, buildRuntimeScorecard, formatRuntimeScorecardMarkdown;
+var asRecord7, asArray4, finiteNumber6, finiteString2, packageVersionMap, round3, unwrapRows2, runtimePayload, runtimeWindow, extractRuntimeRows, buildEmbeddedLineageScope, runtimeDeploymentBinding, belongsToRuntimeDeployment, belongsToStrategy, filterArtifactByStrategy, countBy2, resolveGateDecision, buildDistributions, buildDistributionDelta, sum2, tradeTimestamp, dedupeTrades, maxDrawdown2, buildRollingPerformance, getReplayComparison, replayCountsForStrategy, getProspectiveSummary, buildRuntimeScorecard, formatRuntimeScorecardMarkdown;
 var init_runtimeScorecard = __esm({
   "src/lib/runtimeScorecard.ts"() {
     "use strict";
     init_runtimeLineage();
     init_runtimeEvidenceDeployment();
-    asRecord8 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
+    asRecord7 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
     asArray4 = (value) => Array.isArray(value) ? value : [];
     finiteNumber6 = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
     finiteString2 = (value) => typeof value === "string" && value.trim() ? value.trim() : null;
     packageVersionMap = (value) => {
-      const record = asRecord8(value);
+      const record = asRecord7(value);
       if (!record || Object.keys(record).length === 0) return null;
       const entries = Object.entries(record);
       if (entries.some(
@@ -33772,14 +33211,14 @@ var init_runtimeScorecard = __esm({
       );
     };
     round3 = (value, decimals = 6) => Number(value.toFixed(decimals));
-    unwrapRows2 = (value, key) => asArray4(value).map((item) => asRecord8(asRecord8(item)?.[key]) ?? asRecord8(item)).filter((item) => item != null);
+    unwrapRows2 = (value, key) => asArray4(value).map((item) => asRecord7(asRecord7(item)?.[key]) ?? asRecord7(item)).filter((item) => item != null);
     runtimePayload = (artifact) => {
-      const root = asRecord8(artifact) ?? {};
-      return asRecord8(root.runtime) ?? root;
+      const root = asRecord7(artifact) ?? {};
+      return asRecord7(root.runtime) ?? root;
     };
     runtimeWindow = (artifact) => {
-      const root = asRecord8(artifact) ?? {};
-      return asRecord8(root.window) ?? asRecord8(runtimePayload(artifact).window) ?? {};
+      const root = asRecord7(artifact) ?? {};
+      return asRecord7(root.window) ?? asRecord7(runtimePayload(artifact).window) ?? {};
     };
     extractRuntimeRows = (artifact) => {
       const runtime = runtimePayload(artifact);
@@ -33795,7 +33234,7 @@ var init_runtimeScorecard = __esm({
       rows,
       strategy
     }) => {
-      const deployment = asRecord8(asRecord8(artifact)?.deployment);
+      const deployment = asRecord7(asRecord7(artifact)?.deployment);
       if (finiteNumber6(deployment?.schemaVersion) !== 2) return null;
       const deploymentId = finiteString2(deployment?.id);
       const accountId = finiteString2(deployment?.accountId);
@@ -33803,7 +33242,7 @@ var init_runtimeScorecard = __esm({
         deployment?.deploymentCompositionId
       );
       if (!deploymentId || !accountId || !deploymentCompositionId) return null;
-      const snapshots = asArray4(deployment?.strategies).map(asRecord8).filter((item) => item != null).filter((item) => item.enabled === true).filter(
+      const snapshots = asArray4(deployment?.strategies).map(asRecord7).filter((item) => item != null).filter((item) => item.enabled === true).filter(
         (item) => !strategy || finiteString2(item.strategyName) === strategy
       );
       const targetSeeds = snapshots.map((snapshot) => {
@@ -33845,10 +33284,10 @@ var init_runtimeScorecard = __esm({
       const targets = /* @__PURE__ */ new Map();
       for (const seed of targetSeeds) {
         const matchingRows = lineageRows.filter(
-          (row) => finiteString2(row.strategy) === seed.strategyName && finiteString2(row.deploymentId) === deploymentId && finiteString2(row.accountId) === accountId && identityMatches(asRecord8(row.runtimeLineage), seed)
+          (row) => finiteString2(row.strategy) === seed.strategyName && finiteString2(row.deploymentId) === deploymentId && finiteString2(row.accountId) === accountId && identityMatches(asRecord7(row.runtimeLineage), seed)
         );
         const riskValues = new Set(
-          matchingRows.map((row) => finiteNumber6(asRecord8(row.runtimeLineage)?.maxLossValue)).filter((value) => value != null)
+          matchingRows.map((row) => finiteNumber6(asRecord7(row.runtimeLineage)?.maxLossValue)).filter((value) => value != null)
         );
         targets.set(seed.strategyName, {
           ...seed,
@@ -33860,7 +33299,7 @@ var init_runtimeScorecard = __esm({
       const belongs = (row) => {
         const strategyName = finiteString2(row.strategy);
         const target = strategyName ? targets.get(strategyName) : null;
-        const lineage = asRecord8(row.runtimeLineage);
+        const lineage = asRecord7(row.runtimeLineage);
         return Boolean(
           target && target.maxLossValue != null && identityMatches(lineage, target) && finiteNumber6(lineage?.maxLossValue) === target.maxLossValue
         );
@@ -33917,7 +33356,7 @@ var init_runtimeScorecard = __esm({
       };
     };
     runtimeDeploymentBinding = (artifact) => {
-      const deployment = asRecord8(asRecord8(artifact)?.deployment);
+      const deployment = asRecord7(asRecord7(artifact)?.deployment);
       return {
         deploymentId: finiteString2(deployment?.id),
         accountId: finiteString2(deployment?.accountId)
@@ -33927,7 +33366,7 @@ var init_runtimeScorecard = __esm({
     belongsToStrategy = (row, strategy) => strategy == null || finiteString2(row.strategy) === strategy;
     filterArtifactByStrategy = (artifact, strategy) => {
       if (!strategy) return artifact;
-      const root = asRecord8(artifact) ?? {};
+      const root = asRecord7(artifact) ?? {};
       const runtime = runtimePayload(artifact);
       return {
         ...root,
@@ -33935,24 +33374,24 @@ var init_runtimeScorecard = __esm({
           ...runtime,
           evaluations: asArray4(runtime.evaluations).filter(
             (item) => belongsToStrategy(
-              asRecord8(asRecord8(item)?.evaluation) ?? asRecord8(item) ?? {},
+              asRecord7(asRecord7(item)?.evaluation) ?? asRecord7(item) ?? {},
               strategy
             )
           ),
           signals: asArray4(runtime.signals).filter(
             (item) => belongsToStrategy(
-              asRecord8(asRecord8(item)?.signal) ?? asRecord8(item) ?? {},
+              asRecord7(asRecord7(item)?.signal) ?? asRecord7(item) ?? {},
               strategy
             )
           ),
           trades: asArray4(runtime.trades).filter(
             (item) => belongsToStrategy(
-              asRecord8(asRecord8(item)?.trade) ?? asRecord8(item) ?? {},
+              asRecord7(asRecord7(item)?.trade) ?? asRecord7(item) ?? {},
               strategy
             )
           ),
           lineageScopes: asArray4(runtime.lineageScopes).filter(
-            (item) => belongsToStrategy(asRecord8(item) ?? {}, strategy)
+            (item) => belongsToStrategy(asRecord7(item) ?? {}, strategy)
           )
         }
       };
@@ -33969,7 +33408,7 @@ var init_runtimeScorecard = __esm({
       );
     };
     resolveGateDecision = (evaluation) => {
-      const analysis = asRecord8(evaluation.aiAnalysis);
+      const analysis = asRecord7(evaluation.aiAnalysis);
       const explicit = finiteString2(analysis?.gateDecision);
       if (explicit === "approved" || explicit === "rejected") {
         return { decision: explicit, source: "gate_decision" };
@@ -34000,7 +33439,7 @@ var init_runtimeScorecard = __esm({
           (signal) => finiteString2(signal.orderSkipReason)
         ),
         aiQuality: countBy2(candidates, (evaluation) => {
-          const quality = finiteNumber6(asRecord8(evaluation.aiAnalysis)?.quality);
+          const quality = finiteNumber6(asRecord7(evaluation.aiAnalysis)?.quality);
           return quality == null ? null : String(quality);
         })
       };
@@ -34085,13 +33524,13 @@ var init_runtimeScorecard = __esm({
       };
     };
     getReplayComparison = (artifact) => {
-      const root = asRecord8(artifact) ?? {};
-      return asRecord8(asRecord8(root.replay)?.runtimeComparison) ?? null;
+      const root = asRecord7(artifact) ?? {};
+      return asRecord7(asRecord7(root.replay)?.runtimeComparison) ?? null;
     };
     replayCountsForStrategy = (replayComparison, strategy) => {
       if (strategy) {
-        const byStrategy = asRecord8(replayComparison?.byStrategy);
-        const strategyCounts = asRecord8(byStrategy?.[strategy]);
+        const byStrategy = asRecord7(replayComparison?.byStrategy);
+        const strategyCounts = asRecord7(byStrategy?.[strategy]);
         if (strategyCounts) {
           return {
             matched: finiteNumber6(strategyCounts.matched) ?? 0,
@@ -34100,7 +33539,7 @@ var init_runtimeScorecard = __esm({
           };
         }
       }
-      const counts = asRecord8(replayComparison?.counts);
+      const counts = asRecord7(replayComparison?.counts);
       return {
         matched: finiteNumber6(counts?.matched) ?? 0,
         backtestOnly: finiteNumber6(counts?.backtestOnly) ?? 0,
@@ -34108,7 +33547,7 @@ var init_runtimeScorecard = __esm({
       };
     };
     getProspectiveSummary = (artifact) => {
-      const root = asRecord8(artifact);
+      const root = asRecord7(artifact);
       if (!root || root.reportType !== "strategy-prospective-evidence") return null;
       return {
         rawCoreExpectancy: finiteNumber6(root.rawCoreExpectancy),
@@ -34132,9 +33571,9 @@ var init_runtimeScorecard = __esm({
       strategy = null,
       llmComparatorPolicy = "ai_approved_only"
     }) => {
-      assertCurrentRuntimeEvidenceArtifact(runtimeArtifact);
+      (0, runtimeEvidenceDeployment_exports.assertCurrentRuntimeEvidenceArtifact)(runtimeArtifact);
       for (const artifact of historyRuntimeArtifacts) {
-        assertCurrentRuntimeEvidenceArtifact(artifact);
+        (0, runtimeEvidenceDeployment_exports.assertCurrentRuntimeEvidenceArtifact)(artifact);
       }
       const scopedRuntimeArtifact = filterArtifactByStrategy(
         runtimeArtifact,
@@ -34169,7 +33608,7 @@ var init_runtimeScorecard = __esm({
         (evaluation) => resolveGateDecision(evaluation)?.decision === "approved"
       ) : signalEvaluations;
       const gateComparisons = llmEligibleEvaluations.map((evaluation) => {
-        const analysis = asRecord8(evaluation.aiAnalysis);
+        const analysis = asRecord7(evaluation.aiAnalysis);
         const gateDecision = resolveGateDecision(evaluation)?.decision ?? null;
         const llmDecision = finiteString2(analysis?.llmDecision);
         if (gateDecision !== "approved" && gateDecision !== "rejected" || llmDecision !== "approved" && llmDecision !== "rejected") {
@@ -34179,8 +33618,8 @@ var init_runtimeScorecard = __esm({
       }).filter(
         (comparison) => Boolean(comparison)
       );
-      const allocatorDecisions = signalEvaluations.map((evaluation) => asRecord8(evaluation.allocatorDecision)).filter((item) => item != null);
-      const riskDecisions = signalEvaluations.map((evaluation) => asRecord8(evaluation.riskDecision)).filter((item) => item != null);
+      const allocatorDecisions = signalEvaluations.map((evaluation) => asRecord7(evaluation.allocatorDecision)).filter((item) => item != null);
+      const riskDecisions = signalEvaluations.map((evaluation) => asRecord7(evaluation.riskDecision)).filter((item) => item != null);
       const orderAttempts = rows.signals.filter(
         (signal) => signal.orderStatus === "completed" || signal.orderStatus === "failed"
       );
@@ -34195,10 +33634,10 @@ var init_runtimeScorecard = __esm({
       const runtimeOnly = replayCounts.runtimeOnly;
       const comparisonTotal = matched + backtestOnly + runtimeOnly;
       const parityRatio = comparisonTotal > 0 ? matched / comparisonTotal : null;
-      const lineage = asRecord8(replayComparison?.lineage);
+      const lineage = asRecord7(replayComparison?.lineage);
       const lineageReason = finiteString2(lineage?.reason);
-      const calibrationRoot = asRecord8(calibrationArtifact) ?? {};
-      const calibrationSamples = asArray4(calibrationRoot.samples).map(asRecord8).filter((item) => item != null).filter((item) => !strategy || finiteString2(item.strategy) === strategy).filter((item) => embeddedLineageScope.belongs(item));
+      const calibrationRoot = asRecord7(calibrationArtifact) ?? {};
+      const calibrationSamples = asArray4(calibrationRoot.samples).map(asRecord7).filter((item) => item != null).filter((item) => !strategy || finiteString2(item.strategy) === strategy).filter((item) => embeddedLineageScope.belongs(item));
       const averageSampleMetric = (field) => {
         const values = calibrationSamples.map((sample) => finiteNumber6(sample[field])).filter((value) => value != null);
         return values.length ? round3(sum2(values) / values.length) : null;
@@ -34798,7 +34237,7 @@ async function collectReleaseEvidenceReferences(references) {
       let artifact;
       try {
         const parsed = JSON.parse(
-          await import_promises35.default.readFile(reference.path, "utf8")
+          await import_promises33.default.readFile(reference.path, "utf8")
         );
         assert3(
           parsed != null && typeof parsed === "object" && !Array.isArray(parsed),
@@ -34945,13 +34384,13 @@ async function collectReleaseEvidenceReferences(references) {
     })
   );
 }
-var import_node_crypto17, import_promises35, import_node_path34, import_types9, import_strategyReleaseEvidence2, SHA256_RE2, LINEAGE_FINGERPRINT_RE, STRATEGY_REVISION_RE, DEPLOYMENT_COMPOSITION_ID_RE, REQUIRED_LONG_WINDOWS, REQUIRED_DIAGNOSTIC_TERMINAL_WINDOWS, MIN_RECENT_DIRECTION_REPAIR_EVENTS, safeSegment7, compactTimestamp2, 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_crypto15, import_promises33, import_node_path31, import_types9, import_strategyReleaseEvidence2, SHA256_RE2, LINEAGE_FINGERPRINT_RE, STRATEGY_REVISION_RE, DEPLOYMENT_COMPOSITION_ID_RE, REQUIRED_LONG_WINDOWS, REQUIRED_DIAGNOSTIC_TERMINAL_WINDOWS, MIN_RECENT_DIRECTION_REPAIR_EVENTS, safeSegment5, compactTimestamp, verifyFullPeriodChartArtifact, readVerifiedJsonArtifact, verifyResearchDecisionLineage, hasExactRuntimeTarget, deriveStrategyReleaseResearchDecision, canonicalStrategyReleaseJson, strategyReleaseSha256, assertFingerprint, assertLineageFingerprint, releaseReasons, deriveReleaseGates, verifyEvidenceComposition, createStrategyReleaseManifest, createStrategyReleaseEnvelope, verifyStrategyReleaseEnvelope, verifyStrategyEvidenceMarkerEnvelope, releaseMarkers, writeJsonAtomic2, publishStrategyRelease, publishStrategyLiveDiagnosis, finiteString3, finiteNumber7, finiteDirectionPolicy, uniqueStrings, incompleteEvidenceLineage, extractEvidenceLineage, verifyCompletedCoreResearchBundle;
 var init_strategyRelease = __esm({
   "src/lib/strategyRelease.ts"() {
     "use strict";
-    import_node_crypto17 = require("crypto");
-    import_promises35 = __toESM(require("fs/promises"));
-    import_node_path34 = __toESM(require("path"));
+    import_node_crypto15 = require("crypto");
+    import_promises33 = __toESM(require("fs/promises"));
+    import_node_path31 = __toESM(require("path"));
     import_types9 = require("@tradejs/types");
     import_strategyReleaseEvidence2 = require("@tradejs/infra/strategyReleaseEvidence");
     init_liveDiagnosis();
@@ -34964,17 +34403,17 @@ var init_strategyRelease = __esm({
     REQUIRED_LONG_WINDOWS = [1095, 1460, 1825];
     REQUIRED_DIAGNOSTIC_TERMINAL_WINDOWS = [365, 180, 90];
     MIN_RECENT_DIRECTION_REPAIR_EVENTS = 20;
-    safeSegment7 = import_strategyReleaseEvidence2.safeStrategyEvidenceSegment;
-    compactTimestamp2 = import_strategyReleaseEvidence2.compactStrategyEvidenceTimestamp;
+    safeSegment5 = import_strategyReleaseEvidence2.safeStrategyEvidenceSegment;
+    compactTimestamp = import_strategyReleaseEvidence2.compactStrategyEvidenceTimestamp;
     verifyFullPeriodChartArtifact = async (input) => {
       const artifact = input.chartArtifact;
       if (!artifact?.path || !SHA256_RE2.test(artifact.sha256)) return false;
       try {
-        const artifactPath = import_node_path34.default.resolve(artifact.path);
+        const artifactPath = import_node_path31.default.resolve(artifact.path);
         if (await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(artifactPath) !== artifact.sha256) {
           return false;
         }
-        const report = JSON.parse(await import_promises35.default.readFile(artifactPath, "utf8"));
+        const report = JSON.parse(await import_promises33.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
         );
@@ -34985,11 +34424,11 @@ var init_strategyRelease = __esm({
     readVerifiedJsonArtifact = async (artifact) => {
       if (!artifact?.path || !SHA256_RE2.test(artifact.sha256)) return null;
       try {
-        const artifactPath = import_node_path34.default.resolve(artifact.path);
+        const artifactPath = import_node_path31.default.resolve(artifact.path);
         if (await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(artifactPath) !== artifact.sha256) {
           return null;
         }
-        return JSON.parse(await import_promises35.default.readFile(artifactPath, "utf8"));
+        return JSON.parse(await import_promises33.default.readFile(artifactPath, "utf8"));
       } catch {
         return null;
       }
@@ -35480,7 +34919,7 @@ var init_strategyRelease = __esm({
         maxLossValue: input.composition.maxLossValue,
         ...input.composition.directionPolicy == null ? {} : { directionPolicy: input.composition.directionPolicy }
       };
-      const compositionId = `${safeSegment7(input.strategy, "strategy")}_${strategyReleaseSha256(compositionIdentity).slice(0, 16)}`;
+      const compositionId = `${safeSegment5(input.strategy, "strategy")}_${strategyReleaseSha256(compositionIdentity).slice(0, 16)}`;
       const reasons = releaseReasons({ ...input, gates: evidenceGates });
       const economicFailure = reasons.some(
         (reason) => [
@@ -35502,16 +34941,16 @@ var init_strategyRelease = __esm({
         strategy: input.strategy,
         createdAt: input.createdAt,
         compositionId,
-        evidence: input.evidence.map(({ kind, artifactId, sha256: sha2565 }) => ({
+        evidence: input.evidence.map(({ kind, artifactId, sha256: sha2562 }) => ({
           kind,
           artifactId,
-          sha256: sha2565
+          sha256: sha2562
         })),
         verdict
       };
       return {
         schema: import_types9.STRATEGY_RELEASE_SCHEMA,
-        releaseId: `${safeSegment7(input.strategy, "strategy")}_${compactTimestamp2(input.createdAt)}_${strategyReleaseSha256(releaseIdentity).slice(0, 16)}`,
+        releaseId: `${safeSegment5(input.strategy, "strategy")}_${compactTimestamp(input.createdAt)}_${strategyReleaseSha256(releaseIdentity).slice(0, 16)}`,
         strategy: input.strategy,
         createdAt: input.createdAt,
         composition: { ...input.composition, compositionId },
@@ -35535,7 +34974,7 @@ var init_strategyRelease = __esm({
       manifest
     });
     verifyStrategyReleaseEnvelope = async (valueOrPath) => {
-      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises35.default.readFile(valueOrPath, "utf8")) : valueOrPath;
+      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises33.default.readFile(valueOrPath, "utf8")) : valueOrPath;
       const envelope = value;
       assert3(
         envelope?.schema === "tradejs-strategy-release-envelope/v1",
@@ -35586,7 +35025,7 @@ var init_strategyRelease = __esm({
       return envelope;
     };
     verifyStrategyEvidenceMarkerEnvelope = async (valueOrPath) => {
-      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises35.default.readFile(valueOrPath, "utf8")) : valueOrPath;
+      const value = typeof valueOrPath === "string" ? JSON.parse(await import_promises33.default.readFile(valueOrPath, "utf8")) : valueOrPath;
       return (0, import_strategyReleaseEvidence2.verifyStrategyEvidenceMarkerEnvelope)(value);
     };
     releaseMarkers = (manifest) => {
@@ -35648,14 +35087,14 @@ var init_strategyRelease = __esm({
     };
     writeJsonAtomic2 = async (filePath, value) => {
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-      await import_promises35.default.mkdir(import_node_path34.default.dirname(filePath), { recursive: true });
-      await import_promises35.default.writeFile(
+      await import_promises33.default.mkdir(import_node_path31.default.dirname(filePath), { recursive: true });
+      await import_promises33.default.writeFile(
         temporaryPath,
         `${canonicalStrategyReleaseJson(value)}
 `,
         "utf8"
       );
-      await import_promises35.default.rename(temporaryPath, filePath);
+      await import_promises33.default.rename(temporaryPath, filePath);
     };
     publishStrategyRelease = async ({
       rootDir,
@@ -35672,16 +35111,16 @@ var init_strategyRelease = __esm({
           path: entry.path
         }))
       });
-      const releasePath = import_node_path34.default.join(
+      const releasePath = import_node_path31.default.join(
         rootDir,
         "releases",
-        safeSegment7(manifest.strategy, "strategy"),
+        safeSegment5(manifest.strategy, "strategy"),
         `${manifest.releaseId}.json`
       );
-      const markerPath = import_node_path34.default.join(
+      const markerPath = import_node_path31.default.join(
         rootDir,
         "markers",
-        safeSegment7(manifest.strategy, "strategy"),
+        safeSegment5(manifest.strategy, "strategy"),
         `${markerEnvelope.artifactId}.json`
       );
       await Promise.all([
@@ -35701,7 +35140,7 @@ var init_strategyRelease = __esm({
       composition
     }) => {
       const diagnosisSha256 = strategyReleaseSha256(diagnosis);
-      const diagnosisId = `${safeSegment7(diagnosis.strategy, "strategy")}_${compactTimestamp2(diagnosis.createdAt)}_${diagnosisSha256.slice(0, 16)}`;
+      const diagnosisId = `${safeSegment5(diagnosis.strategy, "strategy")}_${compactTimestamp(diagnosis.createdAt)}_${diagnosisSha256.slice(0, 16)}`;
       const envelope = {
         schema: "tradejs-strategy-live-diagnosis-envelope/v1",
         diagnosisId,
@@ -35758,16 +35197,16 @@ var init_strategyRelease = __esm({
         markers,
         sourceArtifacts
       });
-      const diagnosisPath = import_node_path34.default.join(
+      const diagnosisPath = import_node_path31.default.join(
         rootDir,
         "diagnoses",
-        safeSegment7(diagnosis.strategy, "strategy"),
+        safeSegment5(diagnosis.strategy, "strategy"),
         `${diagnosisId}.json`
       );
-      const markerPath = import_node_path34.default.join(
+      const markerPath = import_node_path31.default.join(
         rootDir,
         "markers",
-        safeSegment7(diagnosis.strategy, "strategy"),
+        safeSegment5(diagnosis.strategy, "strategy"),
         `${markerEnvelope.artifactId}.json`
       );
       await Promise.all([
@@ -35954,11 +35393,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_path34.default.dirname(resultPath);
-      const manifestPath = import_node_path34.default.join(researchDir, "manifest.json");
-      const specPath = import_node_path34.default.join(researchDir, "spec.json");
-      const manifestBytes = await import_promises35.default.readFile(manifestPath).catch(() => null);
-      const specBytes = await import_promises35.default.readFile(specPath).catch(() => null);
+      const researchDir = import_node_path31.default.dirname(resultPath);
+      const manifestPath = import_node_path31.default.join(researchDir, "manifest.json");
+      const specPath = import_node_path31.default.join(researchDir, "spec.json");
+      const manifestBytes = await import_promises33.default.readFile(manifestPath).catch(() => null);
+      const specBytes = await import_promises33.default.readFile(specPath).catch(() => null);
       assert3(
         manifestBytes != null && specBytes != null,
         "core result must belong to a completed core research bundle"
@@ -35967,14 +35406,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_crypto17.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_crypto15.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_path34.default.isAbsolute(relativePath) && !relativePath.split(/[\\/]/).includes(".."),
+          !import_node_path31.default.isAbsolute(relativePath) && !relativePath.split(/[\\/]/).includes(".."),
           `core bundle artifact ${relativePath} escapes its research directory`
         );
         assert3(
@@ -35982,7 +35421,7 @@ var init_strategyRelease = __esm({
           `core bundle artifact ${relativePath} has an invalid checksum`
         );
         const actualSha256 = await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(
-          import_node_path34.default.join(researchDir, relativePath)
+          import_node_path31.default.join(researchDir, relativePath)
         );
         assert3(
           actualSha256 === expectedSha256,
@@ -35996,16 +35435,16 @@ var init_strategyRelease = __esm({
 // src/scripts/runtimeScorecard.ts
 var runtimeScorecard_exports = {};
 __export(runtimeScorecard_exports, {
-  main: () => main41,
+  main: () => main42,
   runtimeScorecard: () => runtimeScorecard
 });
-var import_promises36, import_node_crypto18, import_node_path35, import_args33, import_chalk49, flags30, projectRoot14, resolveOptionalPath, readJson, assertReportType, sha256File2, loadHistoryArtifacts, runtimeScorecard, main41;
+var import_promises34, import_node_crypto16, import_node_path32, import_args33, import_chalk49, flags30, projectRoot14, resolveOptionalPath, readJson, assertReportType, sha256File2, loadHistoryArtifacts, runtimeScorecard, main42;
 var init_runtimeScorecard2 = __esm({
   "src/scripts/runtimeScorecard.ts"() {
     "use strict";
-    import_promises36 = __toESM(require("fs/promises"));
-    import_node_crypto18 = require("crypto");
-    import_node_path35 = __toESM(require("path"));
+    import_promises34 = __toESM(require("fs/promises"));
+    import_node_crypto16 = require("crypto");
+    import_node_path32 = __toESM(require("path"));
     import_args33 = __toESM(require("args"));
     import_chalk49 = __toESM(require("chalk"));
     init_runtimeEvidenceArtifacts();
@@ -36075,21 +35514,21 @@ 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_path35.default.resolve(projectRoot14, raw) : null;
+      return raw ? import_node_path32.default.resolve(projectRoot14, raw) : null;
     };
-    readJson = async (filePath) => filePath ? JSON.parse(await import_promises36.default.readFile(filePath, "utf8")) : void 0;
+    readJson = async (filePath) => filePath ? JSON.parse(await import_promises34.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_crypto18.createHash)("sha256").update(await import_promises36.default.readFile(filePath)).digest("hex");
+    sha256File2 = async (filePath) => (0, import_node_crypto16.createHash)("sha256").update(await import_promises34.default.readFile(filePath)).digest("hex");
     loadHistoryArtifacts = async (historyDir) => {
       if (!historyDir) return [];
-      const bundleDirs = await discoverRuntimeEvidenceBundles(historyDir);
+      const bundleDirs = await (0, runtimeEvidenceArtifacts_exports.discoverRuntimeEvidenceBundles)(historyDir);
       const bundles = [];
       for (const bundleDir of bundleDirs) {
-        bundles.push(await verifyRuntimeEvidenceBundle(bundleDir));
+        bundles.push(await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(bundleDir));
       }
       return bundles.map((bundle) => bundle.artifact);
     };
@@ -36154,13 +35593,13 @@ var init_runtimeScorecard2 = __esm({
         strategy: scorecardStrategy,
         llmComparatorPolicy: verifiedRelease?.manifest.prospective.llmComparatorPolicy ?? "ai_approved_only"
       });
-      const outPath = import_node_path35.default.resolve(projectRoot14, String(flags30.out));
+      const outPath = import_node_path32.default.resolve(projectRoot14, String(flags30.out));
       const markdownPath = outPath.replace(/\.json$/i, "") + ".md";
-      await import_promises36.default.mkdir(import_node_path35.default.dirname(outPath), { recursive: true });
+      await import_promises34.default.mkdir(import_node_path32.default.dirname(outPath), { recursive: true });
       await Promise.all([
-        import_promises36.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
+        import_promises34.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
 `, "utf8"),
-        import_promises36.default.writeFile(
+        import_promises34.default.writeFile(
           markdownPath,
           formatRuntimeScorecardMarkdown(scorecard),
           "utf8"
@@ -36174,7 +35613,7 @@ var init_runtimeScorecard2 = __esm({
       const diagnosisPath = diagnosis ? outPath.replace(/\.json$/i, "") + ".diagnosis.json" : null;
       const strategyReleaseRoot = resolveOptionalPath(flags30.strategyReleaseRoot);
       if (diagnosis && diagnosisPath) {
-        await import_promises36.default.writeFile(
+        await import_promises34.default.writeFile(
           diagnosisPath,
           `${JSON.stringify(diagnosis, null, 2)}
 `,
@@ -36195,7 +35634,7 @@ var init_runtimeScorecard2 = __esm({
             composition: verifiedRelease?.manifest.composition,
             sourceArtifacts: await Promise.all(
               sourcePaths.map(async (sourcePath) => ({
-                artifactId: import_node_path35.default.basename(sourcePath),
+                artifactId: import_node_path32.default.basename(sourcePath),
                 path: sourcePath,
                 sha256: await sha256File2(sourcePath)
               }))
@@ -36205,12 +35644,12 @@ var init_runtimeScorecard2 = __esm({
       }
       let receiptPath2 = null;
       if (flags30.markProcessed) {
-        const runtimeEvidenceBundle = await verifyRuntimeEvidenceBundle(
-          import_node_path35.default.dirname(runtimeEvidencePath)
+        const runtimeEvidenceBundle = await (0, runtimeEvidenceArtifacts_exports.verifyRuntimeEvidenceBundle)(
+          import_node_path32.default.dirname(runtimeEvidencePath)
         );
-        const feedbackSource = replayEvidencePath ? await verifyRuntimeFeedbackReplaySource({
-          bundleDir: import_node_path35.default.dirname(replayEvidencePath),
-          runtimeEvidenceBundleDir: import_node_path35.default.dirname(runtimeEvidencePath)
+        const feedbackSource = replayEvidencePath ? await (0, runtimeFeedbackArtifacts_exports.verifyRuntimeFeedbackReplaySource)({
+          bundleDir: import_node_path32.default.dirname(replayEvidencePath),
+          runtimeEvidenceBundleDir: import_node_path32.default.dirname(runtimeEvidencePath)
         }).catch((error) => {
           if (runtimeEvidenceBundle.artifact.producer) throw error;
           return null;
@@ -36221,9 +35660,9 @@ var init_runtimeScorecard2 = __esm({
           );
         }
         receiptPath2 = await markRuntimeEvidenceBundleProcessed({
-          evidenceRoot: import_node_path35.default.resolve(projectRoot14, String(flags30.evidenceDir)),
+          evidenceRoot: import_node_path32.default.resolve(projectRoot14, String(flags30.evidenceDir)),
           deploymentId: String(flags30.deployment),
-          bundleDir: import_node_path35.default.dirname(runtimeEvidencePath),
+          bundleDir: import_node_path32.default.dirname(runtimeEvidencePath),
           scorecardPath: outPath,
           runtimeFeedback: feedbackSource ? {
             artifactId: feedbackSource.feedback.manifest.artifactId,
@@ -36251,7 +35690,7 @@ var init_runtimeScorecard2 = __esm({
         )
       );
     };
-    main41 = runtimeScorecard;
+    main42 = runtimeScorecard;
   }
 });
 
@@ -36259,16 +35698,16 @@ var init_runtimeScorecard2 = __esm({
 var runtimeControl_exports = {};
 __export(runtimeControl_exports, {
   RUNTIME_CONTROL_ACTIONS: () => RUNTIME_CONTROL_ACTIONS,
-  main: () => main42,
+  main: () => main43,
   runtimeControl: () => runtimeControl
 });
-var import_config9, import_runtimeControls, import_runtimeStrategies6, argv, RUNTIME_CONTROL_ACTIONS, action, option, required2, projectRoot15, userName2, verify, inspect, updateControlState, runtimeControl, main42;
+var import_config9, import_runtimeControls, import_runtimeStrategies5, argv, RUNTIME_CONTROL_ACTIONS, action, option, required2, projectRoot15, userName2, verify, inspect, updateControlState, runtimeControl, main43;
 var init_runtimeControl = __esm({
   "src/scripts/runtimeControl.ts"() {
     "use strict";
     import_config9 = require("dotenv/config");
     import_runtimeControls = require("@tradejs/infra/runtimeControls");
-    import_runtimeStrategies6 = require("@tradejs/node/runtimeStrategies");
+    import_runtimeStrategies5 = require("@tradejs/node/runtimeStrategies");
     argv = process.argv.slice(2);
     RUNTIME_CONTROL_ACTIONS = [
       "inspect",
@@ -36289,7 +35728,7 @@ var init_runtimeControl = __esm({
     projectRoot15 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     userName2 = String(option("user") ?? process.env.USER_NAME ?? "root");
     verify = async () => {
-      const deployments = await (0, import_runtimeStrategies6.listRuntimeDeployments)({ userName: userName2, projectRoot: projectRoot15 });
+      const deployments = await (0, import_runtimeStrategies5.listRuntimeDeployments)({ userName: userName2, projectRoot: projectRoot15 });
       const requestedDeployment = option("deployment");
       const selected = requestedDeployment ? deployments.filter((deployment) => deployment.id === requestedDeployment) : deployments;
       if (requestedDeployment && !selected.length) {
@@ -36298,7 +35737,7 @@ var init_runtimeControl = __esm({
       const results2 = [];
       for (const deployment of selected) {
         try {
-          const strategies = await (0, import_runtimeStrategies6.loadResolvedRuntimeStrategies)({
+          const strategies = await (0, import_runtimeStrategies5.loadResolvedRuntimeStrategies)({
             userName: userName2,
             projectRoot: projectRoot15,
             deploymentId: deployment.id
@@ -36333,7 +35772,7 @@ var init_runtimeControl = __esm({
     inspect = async () => {
       const requestedDeployment = option("deployment");
       const requestedStrategy = option("strategy");
-      const deployments = (await (0, import_runtimeStrategies6.listRuntimeDeployments)({ userName: userName2, projectRoot: projectRoot15 })).filter(
+      const deployments = (await (0, import_runtimeStrategies5.listRuntimeDeployments)({ userName: userName2, projectRoot: projectRoot15 })).filter(
         (deployment) => !requestedDeployment || deployment.id === requestedDeployment
       ).map((deployment) => ({
         ...deployment,
@@ -36346,7 +35785,7 @@ var init_runtimeControl = __esm({
     updateControlState = async (nextState) => {
       const deploymentId = required2("deployment");
       const strategyName = required2("strategy");
-      const deployment = await (0, import_runtimeStrategies6.getRuntimeDeployment)({
+      const deployment = await (0, import_runtimeStrategies5.getRuntimeDeployment)({
         userName: userName2,
         projectRoot: projectRoot15,
         deploymentId
@@ -36376,7 +35815,7 @@ var init_runtimeControl = __esm({
       } else {
         await (0, import_runtimeControls.resumeRuntimeStrategy)({ userName: userName2, deploymentId, strategyName });
       }
-      const updated = await (0, import_runtimeStrategies6.getRuntimeDeployment)({
+      const updated = await (0, import_runtimeStrategies5.getRuntimeDeployment)({
         userName: userName2,
         projectRoot: projectRoot15,
         deploymentId
@@ -36410,24 +35849,24 @@ var init_runtimeControl = __esm({
         `Usage: tradejs runtime-control ${RUNTIME_CONTROL_ACTIONS.join("|")}`
       );
     };
-    main42 = runtimeControl;
+    main43 = runtimeControl;
   }
 });
 
 // src/scripts/strategyRelease.ts
 var strategyRelease_exports = {};
 __export(strategyRelease_exports, {
-  main: () => main43,
+  main: () => main44,
   runStrategyReleaseCommand: () => runStrategyReleaseCommand
 });
-var import_promises37, import_node_fs6, import_node_readline3, import_node_path36, import_chalk50, valueAfter2, required3, writeJsonAtomic3, runStrategyReleaseCommand, printUsage2, main43;
+var import_promises35, import_node_fs6, import_node_readline3, import_node_path33, import_chalk50, valueAfter2, required3, writeJsonAtomic3, runStrategyReleaseCommand, printUsage2, main44;
 var init_strategyRelease2 = __esm({
   "src/scripts/strategyRelease.ts"() {
     "use strict";
-    import_promises37 = __toESM(require("fs/promises"));
+    import_promises35 = __toESM(require("fs/promises"));
     import_node_fs6 = require("fs");
     import_node_readline3 = require("readline");
-    import_node_path36 = __toESM(require("path"));
+    import_node_path33 = __toESM(require("path"));
     import_chalk50 = __toESM(require("chalk"));
     init_strategyRelease();
     valueAfter2 = (argv2, name) => {
@@ -36440,17 +35879,17 @@ var init_strategyRelease2 = __esm({
     };
     writeJsonAtomic3 = async (filePath, value) => {
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-      await import_promises37.default.mkdir(import_node_path36.default.dirname(filePath), { recursive: true });
-      await import_promises37.default.writeFile(
+      await import_promises35.default.mkdir(import_node_path33.default.dirname(filePath), { recursive: true });
+      await import_promises35.default.writeFile(
         temporaryPath,
         `${JSON.stringify(value, null, 2)}
 `,
         "utf8"
       );
-      await import_promises37.default.rename(temporaryPath, filePath);
+      await import_promises35.default.rename(temporaryPath, filePath);
     };
     runStrategyReleaseCommand = async (options) => {
-      const inputPath = import_node_path36.default.resolve(options.inputPath);
+      const inputPath = import_node_path33.default.resolve(options.inputPath);
       if (options.command === "verify") {
         const envelope = await verifyStrategyReleaseEnvelope(inputPath);
         return {
@@ -36488,7 +35927,7 @@ var init_strategyRelease2 = __esm({
           endTime,
           days: options.days?.length ? options.days : [7, 30, 90]
         });
-        const outputPath = import_node_path36.default.resolve(
+        const outputPath = import_node_path33.default.resolve(
           options.outputPath ?? "output/strategy-monitoring-profile.json"
         );
         await writeJsonAtomic3(outputPath, profile);
@@ -36499,22 +35938,22 @@ var init_strategyRelease2 = __esm({
           profile
         };
       }
-      const input = JSON.parse(await import_promises37.default.readFile(inputPath, "utf8"));
+      const input = JSON.parse(await import_promises35.default.readFile(inputPath, "utf8"));
       if (options.command === "decide") {
         const decision = await deriveStrategyReleaseResearchDecision(input);
         if (options.outputPath) {
-          await writeJsonAtomic3(import_node_path36.default.resolve(options.outputPath), decision);
+          await writeJsonAtomic3(import_node_path33.default.resolve(options.outputPath), decision);
         }
         return {
           kind: "decided",
           ...decision,
-          outputPath: options.outputPath ? import_node_path36.default.resolve(options.outputPath) : null
+          outputPath: options.outputPath ? import_node_path33.default.resolve(options.outputPath) : null
         };
       }
       if (options.command === "retention") {
         const plan = planStrategyEvidenceRetention(input);
         if (options.apply) {
-          await Promise.all(plan.delete.map((entry) => import_promises37.default.rm(entry.path)));
+          await Promise.all(plan.delete.map((entry) => import_promises35.default.rm(entry.path)));
         }
         return {
           kind: "retention",
@@ -36527,12 +35966,12 @@ var init_strategyRelease2 = __esm({
       }
       if (options.command === "diagnose") {
         const diagnosis = buildStrategyLiveDiagnosis(input);
-        const outputPath = import_node_path36.default.resolve(
+        const outputPath = import_node_path33.default.resolve(
           options.outputPath ?? "output/strategy-live-diagnosis.json"
         );
         await writeJsonAtomic3(outputPath, diagnosis);
         const published2 = options.rootDir ? await publishStrategyLiveDiagnosis({
-          rootDir: import_node_path36.default.resolve(options.rootDir),
+          rootDir: import_node_path33.default.resolve(options.rootDir),
           diagnosis,
           sourceArtifacts: input.sourceArtifacts ?? []
         }) : null;
@@ -36549,7 +35988,7 @@ var init_strategyRelease2 = __esm({
         evidence: await collectReleaseEvidenceReferences(input.evidence ?? [])
       });
       const published = await publishStrategyRelease({
-        rootDir: import_node_path36.default.resolve(options.rootDir ?? "data/strategy-release"),
+        rootDir: import_node_path33.default.resolve(options.rootDir ?? "data/strategy-release"),
         manifest
       });
       return {
@@ -36567,7 +36006,7 @@ var init_strategyRelease2 = __esm({
   yarn strategy:release profile --input <trades.jsonl> --variant <id> --startTime <ms> --endTime <ms> [--days 7,30,90] [--out <profile.json>]
   yarn strategy:release diagnose --input <diagnosis-input.json> [--out output/diagnosis.json]
   yarn strategy:release retention --input <inventory.json> [--apply]`);
-    main43 = async () => {
+    main44 = async () => {
       const argv2 = process.argv.slice(2);
       const command = argv2[0];
       if (!command || ![
@@ -36606,19 +36045,19 @@ __export(serverHealth_exports, {
   buildServerHealthDiagnostics: () => buildServerHealthDiagnostics,
   collectServerHealthSnapshot: () => collectServerHealthSnapshot,
   evaluateServerHealth: () => evaluateServerHealth,
-  main: () => main44,
+  main: () => main45,
   resolveServerHealthThresholds: () => resolveServerHealthThresholds
 });
-var import_config10, import_node_child_process9, import_node_os3, import_node_fs7, import_args34, import_redis19, DEFAULT_STATE, DEFAULT_THRESHOLDS, escapeHtml6, formatPctValue, formatLoadPerCore, formatGiB, formatDuration2, readDiskUsage, parseMeminfoBytes, readMemorySnapshot, runDiagnosticCommand, runDiagnosticCommands, collectServerHealthSnapshot, buildHumanSummaryLines, evaluateServerHealth, shouldRecover, buildAlertMessage, buildRecoveryMessage, buildServerHealthDiagnostics, getStateKey, toFiniteNumber3, resolveServerHealthThresholds, main44;
+var import_config10, import_node_child_process10, import_node_os3, import_node_fs7, import_args34, import_redis20, DEFAULT_STATE, DEFAULT_THRESHOLDS, escapeHtml6, formatPctValue, formatLoadPerCore, formatGiB, formatDuration2, readDiskUsage, parseMeminfoBytes, readMemorySnapshot, runDiagnosticCommand, runDiagnosticCommands, collectServerHealthSnapshot, buildHumanSummaryLines, evaluateServerHealth, shouldRecover, buildAlertMessage, buildRecoveryMessage, buildServerHealthDiagnostics, getStateKey, toFiniteNumber3, resolveServerHealthThresholds, main45;
 var init_serverHealth = __esm({
   "src/scripts/serverHealth.ts"() {
     "use strict";
     import_config10 = require("dotenv/config");
-    import_node_child_process9 = require("child_process");
+    import_node_child_process10 = require("child_process");
     import_node_os3 = __toESM(require("os"));
     import_node_fs7 = require("fs");
     import_args34 = __toESM(require("args"));
-    import_redis19 = require("@tradejs/infra/redis");
+    import_redis20 = require("@tradejs/infra/redis");
     init_telegramReports();
     DEFAULT_STATE = {
       status: "healthy",
@@ -36651,21 +36090,21 @@ var init_serverHealth = __esm({
       }
       return `${minutes}m`;
     };
-    readDiskUsage = (path47) => {
+    readDiskUsage = (path44) => {
       try {
-        const stats = (0, import_node_fs7.statfsSync)(path47);
+        const stats = (0, import_node_fs7.statfsSync)(path44);
         const totalBlocks = Number(stats.blocks ?? 0);
         const availableBlocks = Number(stats.bavail ?? 0);
         if (totalBlocks <= 0) {
-          return { path: path47, usedPct: null };
+          return { path: path44, usedPct: null };
         }
         const usedPct = (totalBlocks - Math.max(0, availableBlocks)) / totalBlocks * 100;
         return {
-          path: path47,
+          path: path44,
           usedPct: Number.isFinite(usedPct) ? usedPct : null
         };
       } catch {
-        return { path: path47, usedPct: null };
+        return { path: path44, usedPct: null };
       }
     };
     parseMeminfoBytes = (value) => {
@@ -36730,7 +36169,7 @@ var init_serverHealth = __esm({
       }
     };
     runDiagnosticCommand = (command, args39) => {
-      const output = (0, import_node_child_process9.execFileSync)(command, args39, {
+      const output = (0, import_node_child_process10.execFileSync)(command, args39, {
         encoding: "utf8",
         timeout: 5e3,
         maxBuffer: 1024 * 1024,
@@ -37022,13 +36461,13 @@ var init_serverHealth = __esm({
       "Recovery threshold for disk used percent",
       String(DEFAULT_THRESHOLDS.diskRecoverPct)
     );
-    main44 = async () => {
+    main45 = async () => {
       const flags35 = import_args34.default.parse(process.argv);
       const thresholds = resolveServerHealthThresholds(flags35);
       const diskPath = String(flags35.diskPath || "/");
       const snapshot = collectServerHealthSnapshot(diskPath);
       const stateKey = getStateKey(String(flags35.user), snapshot.hostname);
-      const prevState = await (0, import_redis19.getData)(stateKey, DEFAULT_STATE) ?? DEFAULT_STATE;
+      const prevState = await (0, import_redis20.getData)(stateKey, DEFAULT_STATE) ?? DEFAULT_STATE;
       const evaluation = evaluateServerHealth(snapshot, thresholds);
       const cooldownMs = Math.max(60, Number(flags35.cooldownSec)) * 1e3;
       const now2 = snapshot.timestamp;
@@ -37041,7 +36480,7 @@ var init_serverHealth = __esm({
           lastOkAt: prevState.lastOkAt,
           activeIssueCodes: evaluation.issues.map((issue) => issue.code)
         };
-        await (0, import_redis19.setData)(stateKey, nextState2, { expire: 0 });
+        await (0, import_redis20.setData)(stateKey, nextState2, { expire: 0 });
         if (shouldSend) {
           const message = buildAlertMessage({
             evaluation,
@@ -37070,7 +36509,7 @@ var init_serverHealth = __esm({
         lastOkAt: now2,
         activeIssueCodes: []
       };
-      await (0, import_redis19.setData)(stateKey, nextState, { expire: 0 });
+      await (0, import_redis20.setData)(stateKey, nextState, { expire: 0 });
       if (recovered) {
         const message = buildRecoveryMessage({ snapshot, prevState });
         if (flags35.printOnly) {
@@ -38414,21 +37853,21 @@ var init_reporting = __esm({
 var runtimeParity_exports = {};
 __export(runtimeParity_exports, {
   buildRuntimeParityMessage: () => buildRuntimeParityMessage,
-  main: () => main45,
+  main: () => main46,
   runtimeParity: () => runtimeParity
 });
-var import_config11, import_node_crypto19, import_args35, import_chalk52, import_constants19, import_time13, import_logger7, import_redis20, import_cli12, import_backtest7, import_connectors15, flags31, interval3, projectRoot16, DEFAULT_LOOKBACK_DAYS, DETAIL_LIMIT2, DEFAULT_REPLAY_ENV, resolveParityConnectorName, createConnector, buildReplayAiAnalyses, formatReplayEnvSummary, buildReplayConfig, warmReplayHistory, runtimeParity, main45;
+var import_config11, import_node_crypto17, import_args35, import_chalk52, import_constants19, import_time13, import_logger7, import_redis21, import_cli12, import_backtest7, import_connectors15, flags31, interval3, projectRoot16, DEFAULT_LOOKBACK_DAYS, DETAIL_LIMIT2, DEFAULT_REPLAY_ENV, resolveParityConnectorName, createConnector, buildReplayAiAnalyses, formatReplayEnvSummary, buildReplayConfig, warmReplayHistory, runtimeParity, main46;
 var init_runtimeParity2 = __esm({
   "src/scripts/runtimeParity.ts"() {
     "use strict";
     import_config11 = require("dotenv/config");
-    import_node_crypto19 = require("crypto");
+    import_node_crypto17 = require("crypto");
     import_args35 = __toESM(require("args"));
     import_chalk52 = __toESM(require("chalk"));
     import_constants19 = require("@tradejs/core/constants");
     import_time13 = require("@tradejs/core/time");
     import_logger7 = require("@tradejs/infra/logger");
-    import_redis20 = require("@tradejs/infra/redis");
+    import_redis21 = require("@tradejs/infra/redis");
     import_cli12 = require("@tradejs/node/cli");
     import_backtest7 = require("@tradejs/node/backtest");
     import_connectors15 = require("@tradejs/node/connectors");
@@ -38588,8 +38027,8 @@ var init_runtimeParity2 = __esm({
       toleranceMs
     }) => {
       const [userConfig, strategyResults] = await Promise.all([
-        (0, import_redis20.getData)(import_redis20.redisKeys.strategyConfig(userName3, strategy), {}),
-        (0, import_redis20.getData)(import_redis20.redisKeys.strategyResults(userName3, strategy), {})
+        (0, import_redis21.getData)(import_redis21.redisKeys.strategyConfig(userName3, strategy), {}),
+        (0, import_redis21.getData)(import_redis21.redisKeys.strategyResults(userName3, strategy), {})
       ]);
       const typedResults = strategyResults ?? {};
       const symbolResult = typedResults?.[symbol];
@@ -38805,9 +38244,9 @@ var init_runtimeParity2 = __esm({
                 start: window.start,
                 end: window.end
               },
-              name: `${target.symbol}_${target.strategy}_${(0, import_node_crypto19.randomUUID)().slice(0, 8)}`,
-              testId: (0, import_node_crypto19.randomUUID)().slice(0, 8),
-              testSuiteId: (0, import_node_crypto19.randomUUID)().slice(0, 8),
+              name: `${target.symbol}_${target.strategy}_${(0, import_node_crypto17.randomUUID)().slice(0, 8)}`,
+              testId: (0, import_node_crypto17.randomUUID)().slice(0, 8),
+              testSuiteId: (0, import_node_crypto17.randomUUID)().slice(0, 8),
               strategyName: target.strategy,
               strategyConfig: replayConfig,
               connectorName,
@@ -38956,16 +38395,16 @@ var init_runtimeParity2 = __esm({
         (0, import_backtest7.resetTestingKlineCache)(projectRoot16);
       }
     };
-    main45 = runtimeParity;
+    main46 = runtimeParity;
   }
 });
 
 // src/lib/signals/runtimeStrategies.ts
-var import_runtimeStrategies7;
+var import_runtimeStrategies6;
 var init_runtimeStrategies = __esm({
   "src/lib/signals/runtimeStrategies.ts"() {
     "use strict";
-    import_runtimeStrategies7 = require("@tradejs/node/runtimeStrategies");
+    import_runtimeStrategies6 = require("@tradejs/node/runtimeStrategies");
   }
 });
 
@@ -39025,11 +38464,11 @@ var init_skipStats = __esm({
 });
 
 // src/lib/signals/evaluations.ts
-var import_redis21, runtimeLineageScopeCache, runtimeLineageScopeCacheDayKey, runtimeLineageScopeCacheLoaded, buildRuntimeSignalEvaluationId, buildLineageField, flushRuntimeSignalEvaluations, createRuntimeSignalEvaluationBuffer;
+var import_redis22, runtimeLineageScopeCache, runtimeLineageScopeCacheDayKey, runtimeLineageScopeCacheLoaded, buildRuntimeSignalEvaluationId, buildLineageField, flushRuntimeSignalEvaluations, createRuntimeSignalEvaluationBuffer;
 var init_evaluations = __esm({
   "src/lib/signals/evaluations.ts"() {
     "use strict";
-    import_redis21 = require("@tradejs/infra/redis");
+    import_redis22 = require("@tradejs/infra/redis");
     init_runtimeSignalsStorage();
     init_runtimeLineage();
     runtimeLineageScopeCache = /* @__PURE__ */ new Map();
@@ -39080,7 +38519,7 @@ var init_evaluations = __esm({
           runtimeLineageScopeCacheDayKey = dayKey;
           runtimeLineageScopeCacheLoaded = false;
         }
-        const lineageBucket = import_redis21.redisKeys.runtimeLineageScopeBucket(
+        const lineageBucket = import_redis22.redisKeys.runtimeLineageScopeBucket(
           dayEvaluations[0].userName,
           dayKey
         );
@@ -39088,7 +38527,7 @@ var init_evaluations = __esm({
           (evaluation) => evaluation.runtimeLineage != null
         );
         if (lineageEvaluations.length > 0 && !runtimeLineageScopeCacheLoaded) {
-          const storedScopes = await (0, import_redis21.getHashJsonValues)(lineageBucket);
+          const storedScopes = await (0, import_redis22.getHashJsonValues)(lineageBucket);
           for (const scope of storedScopes) {
             const lineageField = buildLineageField(scope);
             runtimeLineageScopeCache.set(`${lineageBucket}:${lineageField}`, scope);
@@ -39133,7 +38572,7 @@ var init_evaluations = __esm({
           lineageWrites.set(lineageField, scope);
         }
         if (lineageWrites.size > 0) {
-          await (0, import_redis21.setHashJsonFields)(
+          await (0, import_redis22.setHashJsonFields)(
             lineageBucket,
             [...lineageWrites].map(([field, data]) => ({ field, data })),
             {
@@ -39145,7 +38584,7 @@ var init_evaluations = __esm({
         const statsIncrements = /* @__PURE__ */ new Map();
         for (const evaluation of dayEvaluations) {
           if (shouldStoreDetailedRuntimeSignalEvaluation(evaluation)) {
-            const bucket = import_redis21.redisKeys.runtimeSignalEvaluationBucket(
+            const bucket = import_redis22.redisKeys.runtimeSignalEvaluationBucket(
               evaluation.userName,
               dayKey,
               evaluation.strategy
@@ -39157,7 +38596,7 @@ var init_evaluations = __esm({
             });
             detailedWrites.set(bucket, entries);
           }
-          const statsBucket = import_redis21.redisKeys.runtimeSignalEvaluationStatsBucket(
+          const statsBucket = import_redis22.redisKeys.runtimeSignalEvaluationStatsBucket(
             evaluation.userName,
             dayKey,
             evaluation.strategy,
@@ -39173,12 +38612,12 @@ var init_evaluations = __esm({
         }
         await Promise.all([
           ...[...detailedWrites].map(
-            ([bucket, entries]) => (0, import_redis21.setHashJsonFields)(bucket, entries, {
+            ([bucket, entries]) => (0, import_redis22.setHashJsonFields)(bucket, entries, {
               expire: runtimeSignalRetentionTtl
             })
           ),
           ...[...statsIncrements].map(
-            ([bucket, increments]) => (0, import_redis21.incrHashFields)(bucket, increments, {
+            ([bucket, increments]) => (0, import_redis22.incrHashFields)(bucket, increments, {
               expire: runtimeSignalRetentionTtl
             })
           )
@@ -39194,7 +38633,7 @@ var init_evaluations = __esm({
         const runtimeSignalRetentionTtl = getRuntimeSignalRetentionTtlSeconds();
         const signalRefsByBucket = /* @__PURE__ */ new Map();
         for (const { userName: userName3, signal } of pendingSignals) {
-          const bucket = import_redis21.redisKeys.runtimeSignalBucket(
+          const bucket = import_redis22.redisKeys.runtimeSignalBucket(
             userName3,
             (0, import_time5.getRuntimeStorageDayKey)(signal.timestamp),
             signal.strategy
@@ -39208,14 +38647,14 @@ var init_evaluations = __esm({
         }
         await Promise.all([
           ...pendingSignals.map(
-            ({ signal }) => (0, import_redis21.setData)(
-              import_redis21.redisKeys.storeSignal(signal.symbol, signal.signalId),
+            ({ signal }) => (0, import_redis22.setData)(
+              import_redis22.redisKeys.storeSignal(signal.symbol, signal.signalId),
               toStoredRuntimeSignal(signal),
               { expire: runtimeSignalRetentionTtl }
             )
           ),
           ...[...signalRefsByBucket].map(
-            ([bucket, entries]) => (0, import_redis21.setHashJsonFields)(bucket, entries, {
+            ([bucket, entries]) => (0, import_redis22.setHashJsonFields)(bucket, entries, {
               expire: runtimeSignalRetentionTtl
             })
           )
@@ -40016,7 +39455,7 @@ var init_configuredScopes = __esm({
 });
 
 // src/lib/signals/runner.ts
-var import_progress12, import_chalk54, import_connectors17, import_cli13, import_async5, import_strategies14, import_constants20, import_time14, import_logger11, import_runtimeDeploymentEvents, import_runtimeHeartbeats, import_runtimeStrategies8, SLOW_SIGNALS_WARNING_MS, formatDuration3, resolvePositiveInteger2, resolveNonNegativeInteger, createSignalsRunner;
+var import_progress12, import_chalk54, import_connectors17, import_cli13, import_async5, import_strategies14, import_constants20, import_time14, import_logger11, import_runtimeDeploymentEvents, import_runtimeHeartbeats, import_runtimeStrategies7, SLOW_SIGNALS_WARNING_MS, formatDuration3, resolvePositiveInteger2, resolveNonNegativeInteger, createSignalsRunner;
 var init_runner = __esm({
   "src/lib/signals/runner.ts"() {
     "use strict";
@@ -40031,7 +39470,7 @@ var init_runner = __esm({
     import_logger11 = require("@tradejs/infra/logger");
     import_runtimeDeploymentEvents = require("@tradejs/infra/runtimeDeploymentEvents");
     import_runtimeHeartbeats = require("@tradejs/infra/runtimeHeartbeats");
-    import_runtimeStrategies8 = require("@tradejs/node/runtimeStrategies");
+    import_runtimeStrategies7 = require("@tradejs/node/runtimeStrategies");
     init_windows();
     init_runtimeRedis();
     init_runFormatting();
@@ -40122,7 +39561,7 @@ var init_runner = __esm({
         return connectorName;
       };
       const createSignalsSession2 = async (lifecycle, scope = {}) => {
-        const deployment = config2.deploymentId ? await (0, import_runtimeStrategies8.getRuntimeDeployment)({
+        const deployment = config2.deploymentId ? await (0, import_runtimeStrategies7.getRuntimeDeployment)({
           userName: config2.userName,
           projectRoot: projectRoot18,
           deploymentId: config2.deploymentId
@@ -40372,7 +39811,7 @@ var init_runner = __esm({
           const primaryEthByTimestamp = new Map(
             primaryEthClosedData.map((candle) => [candle.timestamp, candle])
           );
-          const configuredRuntimeStrategies = await (0, import_runtimeStrategies7.loadResolvedRuntimeStrategies)({
+          const configuredRuntimeStrategies = await (0, import_runtimeStrategies6.loadResolvedRuntimeStrategies)({
             userName: config2.userName,
             projectRoot: projectRoot18,
             deploymentId: deployment?.id ?? "",
@@ -40613,7 +40052,7 @@ var init_runner = __esm({
         }
       };
       const loadConfiguredSignalsScopes = async (deployment) => {
-        const configuredStrategies = await (0, import_runtimeStrategies7.loadResolvedRuntimeStrategies)({
+        const configuredStrategies = await (0, import_runtimeStrategies6.loadResolvedRuntimeStrategies)({
           userName: config2.userName,
           projectRoot: projectRoot18,
           deploymentId: deployment.id
@@ -40639,7 +40078,7 @@ var init_runner = __esm({
         if (!config2.deploymentId) {
           throw new Error("Runtime deployment id is required");
         }
-        const configuredDeployment = await (0, import_runtimeStrategies8.getRuntimeDeployment)({
+        const configuredDeployment = await (0, import_runtimeStrategies7.getRuntimeDeployment)({
           userName: config2.userName,
           projectRoot: projectRoot18,
           deploymentId: config2.deploymentId
@@ -40673,7 +40112,7 @@ var init_runner = __esm({
           throw new Error("Runtime deployment id is required");
         }
         const deploymentId = config2.deploymentId;
-        const initialDeployment = await (0, import_runtimeStrategies8.getRuntimeDeployment)({
+        const initialDeployment = await (0, import_runtimeStrategies7.getRuntimeDeployment)({
           userName: config2.userName,
           projectRoot: projectRoot18,
           deploymentId
@@ -40698,7 +40137,7 @@ var init_runner = __esm({
             settleDelayMs: resolveNonNegativeInteger(config2.settleDelayMs, 5e3),
             signal: abortController.signal,
             runCycle: async () => {
-              const currentDeployment = await (0, import_runtimeStrategies8.getRuntimeDeployment)({
+              const currentDeployment = await (0, import_runtimeStrategies7.getRuntimeDeployment)({
                 userName: config2.userName,
                 projectRoot: projectRoot18,
                 deploymentId
@@ -40823,12 +40262,12 @@ var init_runner = __esm({
 var signals_exports = {};
 __export(signals_exports, {
   createSignalsSession: () => createSignalsSession,
-  main: () => main46,
+  main: () => main47,
   signals: () => signals,
   signalsConfiguredScopesOnce: () => signalsConfiguredScopesOnce,
   signalsDaemon: () => signalsDaemon
 });
-var import_config12, import_args36, flags32, config, runner, createSignalsSession, signals, signalsConfiguredScopesOnce, signalsDaemon, main46;
+var import_config12, import_args36, flags32, config, runner, createSignalsSession, signals, signalsConfiguredScopesOnce, signalsDaemon, main47;
 var init_signals = __esm({
   "src/scripts/signals.ts"() {
     "use strict";
@@ -40900,31 +40339,31 @@ var init_signals = __esm({
     signals = runner.runCycle;
     signalsConfiguredScopesOnce = runner.runConfiguredScopesOnce;
     signalsDaemon = runner.runDaemon;
-    main46 = () => config.watch ? signalsDaemon() : signalsConfiguredScopesOnce();
+    main47 = () => config.watch ? signalsDaemon() : signalsConfiguredScopesOnce();
   }
 });
 
 // src/scripts/signalsDaemon.ts
 var signalsDaemon_exports = {};
 __export(signalsDaemon_exports, {
-  main: () => main47
+  main: () => main48
 });
-var main47;
+var main48;
 var init_signalsDaemon = __esm({
   "src/scripts/signalsDaemon.ts"() {
     "use strict";
     init_signals();
-    main47 = signalsDaemon;
+    main48 = signalsDaemon;
   }
 });
 
 // src/scripts/signalsSummary.ts
 var signalsSummary_exports = {};
 __export(signalsSummary_exports, {
-  main: () => main48,
+  main: () => main49,
   signalsSummary: () => signalsSummary
 });
-var import_config13, import_args37, import_logger12, import_connectors18, import_runtimeStrategies10, flags33, projectRoot17, SUMMARY_TIMEZONE2, SUMMARY_TIMEZONE_LABEL2, escapeHtml8, formatMskDateTime4, formatSigned3, formatPnlMoneyText, formatWinRateText, resolveSummaryTitle, normalizeStatus, shouldAttachDebugReport, getSummaryDateParts, formatSummaryIsoDayKey, unescapeHtml, stripTelegramHtml, buildSignalsSummaryAttachment, appendReportAttachmentSummary, resolveSummaryConnectorName, groupRuntimeTradesByConnectorScope, syncRuntimeTradeScopes, createRuntimeSignalStats, mergeRuntimeSignalStats, buildSummaryPrelude, resolveTradeStatusEmoji, isTimestampInWindow, isRuntimeTradeClosedInWindow, buildSummaryMessages, signalsSummary, main48;
+var import_config13, import_args37, import_logger12, import_connectors18, import_runtimeStrategies9, flags33, projectRoot17, SUMMARY_TIMEZONE2, SUMMARY_TIMEZONE_LABEL2, escapeHtml8, formatMskDateTime4, formatSigned3, formatPnlMoneyText, formatWinRateText, resolveSummaryTitle, normalizeStatus, shouldAttachDebugReport, getSummaryDateParts, formatSummaryIsoDayKey, unescapeHtml, stripTelegramHtml, buildSignalsSummaryAttachment, appendReportAttachmentSummary, resolveSummaryConnectorName, groupRuntimeTradesByConnectorScope, syncRuntimeTradeScopes, createRuntimeSignalStats, mergeRuntimeSignalStats, buildSummaryPrelude, resolveTradeStatusEmoji, isTimestampInWindow, isRuntimeTradeClosedInWindow, buildSummaryMessages, signalsSummary, main49;
 var init_signalsSummary = __esm({
   "src/scripts/signalsSummary.ts"() {
     "use strict";
@@ -40938,7 +40377,7 @@ var init_signalsSummary = __esm({
     init_runtimeSignalsLoader();
     init_runtimeSignalsStorage();
     init_runtimeDebugEvidence();
-    import_runtimeStrategies10 = require("@tradejs/node/runtimeStrategies");
+    import_runtimeStrategies9 = require("@tradejs/node/runtimeStrategies");
     import_args37.default.option(["u", "user"], "Use user config", "root");
     import_args37.default.option(
       "connector",
@@ -41482,7 +40921,7 @@ none`
         loadRuntimeSignals(flags33.user, { startTime, endTime }),
         loadRuntimeSignalEvaluationStatsBuckets(flags33.user),
         loadRuntimeTrades(flags33.user),
-        (0, import_runtimeStrategies10.listRuntimeDeployments)({ userName: flags33.user, projectRoot: projectRoot17 })
+        (0, import_runtimeStrategies9.listRuntimeDeployments)({ userName: flags33.user, projectRoot: projectRoot17 })
       ]);
       const {
         trades: syncedTrades,
@@ -41612,16 +41051,16 @@ none`
         });
       }
     };
-    main48 = signalsSummary;
+    main49 = signalsSummary;
   }
 });
 
 // src/scripts/test-ml.ts
 var test_ml_exports = {};
 __export(test_ml_exports, {
-  main: () => main49
+  main: () => main50
 });
-var import_config14, import_constants21, import_ml3, import_registry5, now, INTERVAL_MIN, CANDLES, makeSeries, makeCandles, buildTrendline, main49;
+var import_config14, import_constants21, import_ml3, import_registry5, now, INTERVAL_MIN, CANDLES, makeSeries, makeCandles, buildTrendline, main50;
 var init_test_ml = __esm({
   "src/scripts/test-ml.ts"() {
     "use strict";
@@ -41671,7 +41110,7 @@ var init_test_ml = __esm({
         { timestamp: entryTs - 2 * INTERVAL_MIN * 6e4, value: price * 0.995 }
       ]
     });
-    main49 = async () => {
+    main50 = async () => {
       const defaultConfig = await (0, import_registry5.getStrategyDefaults)("TrendLine", process.cwd());
       if (!defaultConfig) {
         throw new Error(
@@ -41764,9 +41203,9 @@ var init_test_ml = __esm({
 // src/scripts/test.ts
 var test_exports = {};
 __export(test_exports, {
-  main: () => main50
+  main: () => main51
 });
-var import_config15, import_connectors19, getPositions, main50;
+var import_config15, import_connectors19, getPositions, main51;
 var init_test = __esm({
   "src/scripts/test.ts"() {
     "use strict";
@@ -41776,7 +41215,7 @@ var init_test = __esm({
       const res = await connector.getPositions();
       console.log("res", res);
     };
-    main50 = async () => {
+    main51 = async () => {
       const byBitConnector = await import_connectors19.connectors.ByBit({
         userName: "root"
       });
@@ -41788,21 +41227,21 @@ var init_test = __esm({
 // src/scripts/user-add.ts
 var user_add_exports = {};
 __export(user_add_exports, {
-  main: () => main51
+  main: () => main52
 });
-var import_args38, import_chalk55, import_bcryptjs, import_redis22, flags34, main51;
+var import_args38, import_chalk55, import_bcryptjs, import_redis23, flags34, main52;
 var init_user_add = __esm({
   "src/scripts/user-add.ts"() {
     "use strict";
     import_args38 = __toESM(require("args"));
     import_chalk55 = __toESM(require("chalk"));
     import_bcryptjs = __toESM(require("bcryptjs"));
-    import_redis22 = require("@tradejs/infra/redis");
+    import_redis23 = require("@tradejs/infra/redis");
     import_args38.default.example("yarn user-add -u myname -p 123456", "Create or update user");
     import_args38.default.option(["u", "user"], "Username", "");
     import_args38.default.option(["p", "password"], "Password (plain text)", "");
     flags34 = import_args38.default.parse(process.argv);
-    main51 = async () => {
+    main52 = async () => {
       const userName3 = String(flags34.user || "").trim();
       const password = String(flags34.password || "");
       if (!userName3 || !password) {
@@ -41810,14 +41249,14 @@ var init_user_add = __esm({
         process.exit(1);
       }
       const passwordHash = await import_bcryptjs.default.hash(password, 10);
-      const existing = await (0, import_redis22.getData)(import_redis22.redisKeys.user(userName3), null);
+      const existing = await (0, import_redis23.getData)(import_redis23.redisKeys.user(userName3), null);
       const next = {
         ...existing ?? {},
         passwordHash,
         userName: userName3,
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
-      await (0, import_redis22.setData)(import_redis22.redisKeys.user(userName3), next, {
+      await (0, import_redis23.setData)(import_redis23.redisKeys.user(userName3), next, {
         expire: 0
       });
       console.log(import_chalk55.default.green(`User ${userName3} updated`));
@@ -41830,13 +41269,13 @@ var init_user_add = __esm({
 var cli_exports = {};
 __export(cli_exports, {
   cleanupCliResources: () => cleanupCliResources,
-  main: () => main52,
+  main: () => main53,
   printUsage: () => printUsage3,
   runLoadedModule: () => runLoadedModule
 });
 module.exports = __toCommonJS(cli_exports);
 var import_config16 = require("dotenv/config");
-var import_redis23 = require("@tradejs/infra/redis");
+var import_redis24 = require("@tradejs/infra/redis");
 var import_client9 = require("@tradejs/infra/timescale/client");
 var scriptLoaders = {
   "agent-run": () => Promise.resolve().then(() => (init_agentRun(), agentRun_exports)),
@@ -41864,6 +41303,7 @@ var scriptLoaders = {
   "maintenance:cleanup-market-context": () => Promise.resolve().then(() => (init_cleanupMarketContext(), cleanupMarketContext_exports)),
   migration: () => Promise.resolve().then(() => (init_migration(), migration_exports)),
   "market-ws": () => Promise.resolve().then(() => (init_marketWs(), marketWs_exports)),
+  "mcp-worker": () => Promise.resolve().then(() => (init_mcpWorker(), mcpWorker_exports)),
   "hyperliquid:whale-backfill": () => Promise.resolve().then(() => (init_hyperliquidWhaleBackfill2(), hyperliquidWhaleBackfill_exports)),
   "hyperliquid:whale-ingest": () => Promise.resolve().then(() => (init_hyperliquidWhaleIngest(), hyperliquidWhaleIngest_exports)),
   "hyperliquid:whales:update": () => Promise.resolve().then(() => (init_hyperliquidWhalesUpdate(), hyperliquidWhalesUpdate_exports)),
@@ -41906,9 +41346,9 @@ var runLoadedModule = async (loaded) => {
   }
 };
 var cleanupCliResources = async () => {
-  await Promise.allSettled([(0, import_redis23.closeRedisConnection)(), (0, import_client9.closeTimescalePool)()]);
+  await Promise.allSettled([(0, import_redis24.closeRedisConnection)(), (0, import_client9.closeTimescalePool)()]);
 };
-var main52 = async () => {
+var main53 = async () => {
   const [, scriptPath, command = "", ...args39] = process.argv;
   const loader = scriptLoaders[command];
   if (!loader) {
@@ -41939,7 +41379,7 @@ var main52 = async () => {
   }
 };
 if (require.main === module) {
-  main52().catch((error) => {
+  main53().catch((error) => {
     console.error(error);
     process.exit(1);
   });