@tradejs/cli 3.1.28-beta.257 → 3.1.28-beta.258

package/dist/cli.js

@@ -255,7 +255,7 @@ var init_researchRoots = __esm({
     resolveResearchRoots = (options = {}) => {
       const cwd = import_node_path.default.resolve(options.cwd || process.cwd());
       const env = options.env || process.env;
-      const projectRoot17 = import_node_path.default.resolve(
+      const projectRoot18 = import_node_path.default.resolve(
         firstNonEmpty(options.projectRoot, env.PROJECT_CWD, cwd) || cwd
       );
       const sourceRepositoryRoot = firstNonEmpty(
@@ -263,7 +263,7 @@ var init_researchRoots = __esm({
         env[SOURCE_REPOSITORY_ROOT_ENV]
       );
       return {
-        projectRoot: projectRoot17,
+        projectRoot: projectRoot18,
         ...sourceRepositoryRoot ? { sourceRepositoryRoot: import_node_path.default.resolve(sourceRepositoryRoot) } : {}
       };
     };
@@ -1967,32 +1967,32 @@ var init_commandOptions = __esm({
       (arg) => arg === `--${longName}` || arg.startsWith(`--${longName}=`) || (shortName ? arg === `-${shortName}` : false)
     );
     resolveAiPocketSearchCommandOptions = ({
-      flags: flags34,
+      flags: flags35,
       argv: argv2
     }) => {
-      const outDir = String(flags34.outDir || "data/ai/export");
-      const strategyName = String(flags34.strategy || "").trim() || void 0;
-      const explicitFile = String(flags34.file || "").trim();
-      const skip = normalizeInt(flags34.skip, 0);
-      const minQuality = normalizeInt(flags34.minQuality, 4);
-      const sinceInput = parseTimestampFilter(flags34.since);
-      const untilTimestamp = parseTimestampFilter(flags34.until);
-      const trailingPeriodMs = parseTrailingPeriodMs(flags34.period);
-      const periodLabel = String(flags34.period || "").trim() || null;
+      const outDir = String(flags35.outDir || "data/ai/export");
+      const strategyName = String(flags35.strategy || "").trim() || void 0;
+      const explicitFile = String(flags35.file || "").trim();
+      const skip = normalizeInt(flags35.skip, 0);
+      const minQuality = normalizeInt(flags35.minQuality, 4);
+      const sinceInput = parseTimestampFilter(flags35.since);
+      const untilTimestamp = parseTimestampFilter(flags35.until);
+      const trailingPeriodMs = parseTrailingPeriodMs(flags35.period);
+      const periodLabel = String(flags35.period || "").trim() || null;
       const hasDateFilter = trailingPeriodMs != null || sinceInput != null || untilTimestamp != null;
       const recent = resolveAiTrainRecentLimit({
         argv: argv2,
-        recentValue: flags34.recent,
+        recentValue: flags35.recent,
         hasDateFilter
       });
-      const qualityThresholds = parseQualityThresholds(flags34.qualityThresholds);
-      const scope = String(flags34.scope || "all").trim().toLowerCase();
+      const qualityThresholds = parseQualityThresholds(flags35.qualityThresholds);
+      const scope = String(flags35.scope || "all").trim().toLowerCase();
       if (!["all", "approved", "rejected", "candidates"].includes(scope)) {
         throw new Error(
           `Unsupported --scope "${scope}". Use all, approved, rejected, or candidates.`
         );
       }
-      const direction = String(flags34.direction || "").trim().toUpperCase();
+      const direction = String(flags35.direction || "").trim().toUpperCase();
       if (direction && !["LONG", "SHORT"].includes(direction)) {
         throw new Error(
           `Unsupported --direction "${direction}". Use LONG or SHORT.`
@@ -2003,14 +2003,14 @@ var init_commandOptions = __esm({
         "maxEventCountShare",
         "U"
       );
-      const maxDepth = normalizePositiveInt(flags34.maxDepth, 2);
-      const explicitMinSupport = hasCliOption2(argv2, "minSupport", "m") ? normalizePositiveInt(flags34.minSupport, 20) : void 0;
+      const maxDepth = normalizePositiveInt(flags35.maxDepth, 2);
+      const explicitMinSupport = hasCliOption2(argv2, "minSupport", "m") ? normalizePositiveInt(flags35.minSupport, 20) : void 0;
       const minProfitFactor = normalizeNonNegativeNumber(
         readAiPocketSearchCliOption({
           argv: argv2,
           longName: "minProfitFactor",
           shortName: "F"
-        }) ?? flags34.minProfitFactor,
+        }) ?? flags35.minProfitFactor,
         1.2
       );
       const minWinRate = normalizeNonNegativeNumber(
@@ -2018,21 +2018,21 @@ var init_commandOptions = __esm({
           argv: argv2,
           longName: "minWinRate",
           shortName: "W"
-        }) ?? flags34.minWinRate,
+        }) ?? flags35.minWinRate,
         0
       );
       const minTotalProfitValue = readAiPocketSearchCliOption({
         argv: argv2,
         longName: "minTotalProfit",
         shortName: "R"
-      }) ?? flags34.minTotalProfit;
+      }) ?? flags35.minTotalProfit;
       const minTotalProfit = Number.isFinite(Number(minTotalProfitValue)) ? Number(minTotalProfitValue) : 0;
       const validationSplit = hasCliOption2(argv2, "validationSplit", "V") ? normalizeRatio(
         readAiPocketSearchCliOption({
           argv: argv2,
           longName: "validationSplit",
           shortName: "V"
-        }) ?? flags34.validationSplit,
+        }) ?? flags35.validationSplit,
         0.25
       ) : 0.25;
       const testSplit = hasCliOption2(argv2, "testSplit", "T") ? normalizeRatio(
@@ -2040,10 +2040,10 @@ var init_commandOptions = __esm({
           argv: argv2,
           longName: "testSplit",
           shortName: "T"
-        }) ?? flags34.testSplit,
+        }) ?? flags35.testSplit,
         0
       ) : 0;
-      const sealTest = Boolean(flags34.sealTest);
+      const sealTest = Boolean(flags35.sealTest);
       if (sealTest && testSplit <= 0) {
         throw new Error("--sealTest requires a positive --testSplit");
       }
@@ -2052,7 +2052,7 @@ var init_commandOptions = __esm({
           argv: argv2,
           longName: "maxEventCountShare",
           shortName: "U"
-        }) ?? flags34.maxEventCountShare,
+        }) ?? flags35.maxEventCountShare,
         0.25
       );
       const maxSymbolCountShare = normalizeUnitRatio(
@@ -2060,10 +2060,10 @@ var init_commandOptions = __esm({
           argv: argv2,
           longName: "maxSymbolCountShare",
           shortName: "Z"
-        }) ?? flags34.maxSymbolCountShare,
+        }) ?? flags35.maxSymbolCountShare,
         0.5
       );
-      const objective = normalizeObjective(flags34.objective, scope);
+      const objective = normalizeObjective(flags35.objective, scope);
       return {
         outDir,
         strategyName,
@@ -2083,36 +2083,36 @@ var init_commandOptions = __esm({
         minProfitFactor,
         minWinRate,
         minTotalProfit,
-        maxAtomicPredicates: normalizePositiveInt(flags34.maxAtomicPredicates, 180),
-        maxCombinations: normalizePositiveInt(flags34.maxCombinations, 6e4),
+        maxAtomicPredicates: normalizePositiveInt(flags35.maxAtomicPredicates, 180),
+        maxCombinations: normalizePositiveInt(flags35.maxCombinations, 6e4),
         validationSplit,
         testSplit,
         sealTest,
-        explicitMinValidationSupport: normalizeInt(flags34.minValidationSupport, 0),
-        explicitMinEvents: normalizeInt(flags34.minEvents, 0),
-        explicitMinValidationEvents: normalizeInt(flags34.minValidationEvents, 0),
-        maxBatch: normalizeInt(flags34.maxBatch, 5),
+        explicitMinValidationSupport: normalizeInt(flags35.minValidationSupport, 0),
+        explicitMinEvents: normalizeInt(flags35.minEvents, 0),
+        explicitMinValidationEvents: normalizeInt(flags35.minValidationEvents, 0),
+        maxBatch: normalizeInt(flags35.maxBatch, 5),
         maxEventCountShare,
         explicitMaxEventCountShare,
         maxSymbolCountShare,
         objective,
-        allowRiskRegression: Boolean(flags34.allowRiskRegression),
-        requireValidationEligibility: !Boolean(flags34.allowValidationRegression),
-        dedupeEquivalentSelections: Boolean(flags34.dedupeEquivalentSelections),
-        top: normalizePositiveInt(flags34.top, 30),
-        includeSymbol: Boolean(flags34.includeSymbol),
-        includeGateContext: Boolean(flags34.includeGateContext),
-        featureProfile: normalizeFeatureProfile(flags34.featureProfile),
-        featurePolicy: normalizeFeaturePolicy(flags34.featurePolicy),
+        allowRiskRegression: Boolean(flags35.allowRiskRegression),
+        requireValidationEligibility: !Boolean(flags35.allowValidationRegression),
+        dedupeEquivalentSelections: Boolean(flags35.dedupeEquivalentSelections),
+        top: normalizePositiveInt(flags35.top, 30),
+        includeSymbol: Boolean(flags35.includeSymbol),
+        includeGateContext: Boolean(flags35.includeGateContext),
+        featureProfile: normalizeFeatureProfile(flags35.featureProfile),
+        featurePolicy: normalizeFeaturePolicy(flags35.featurePolicy),
         excludeFeaturePattern: normalizeExcludeFeaturePattern(
-          flags34.excludeFeaturePattern
+          flags35.excludeFeaturePattern
         ),
-        coverageMode: normalizeCoverageMode(flags34.coverageMode),
-        cadenceMode: normalizeCadenceMode(flags34.cadenceMode),
-        jsonOutput: Boolean(flags34.json),
-        outputPath: String(flags34.output || "").trim(),
-        reportDir: String(flags34.reportDir || "data/ai/output").trim(),
-        explicitReportFile: String(flags34.reportFile || "").trim()
+        coverageMode: normalizeCoverageMode(flags35.coverageMode),
+        cadenceMode: normalizeCadenceMode(flags35.cadenceMode),
+        jsonOutput: Boolean(flags35.json),
+        outputPath: String(flags35.output || "").trim(),
+        reportDir: String(flags35.reportDir || "data/ai/output").trim(),
+        explicitReportFile: String(flags35.reportFile || "").trim()
       };
     };
   }
@@ -2212,9 +2212,9 @@ var init_features = __esm({
       "targetsymbol",
       "universe"
     ]);
-    normalizeFeaturePath = (path44) => (Array.isArray(path44) ? path44 : path44.split(".")).filter(Boolean).map((segment) => segment.toLowerCase());
-    classifyAiPocketCoverageFeaturePath = (path44) => {
-      const segments = normalizeFeaturePath(path44);
+    normalizeFeaturePath = (path45) => (Array.isArray(path45) ? path45 : path45.split(".")).filter(Boolean).map((segment) => segment.toLowerCase());
+    classifyAiPocketCoverageFeaturePath = (path45) => {
+      const segments = normalizeFeaturePath(path45);
       const normalizedPath = segments.join(".");
       if (segments.some(
         (segment) => segment.includes("cmc") || segment.includes("coinmarketcap")
@@ -2388,8 +2388,8 @@ var init_features = __esm({
       "volumeusd",
       "vwap"
     ]);
-    classifyAiPocketFeaturePath = (path44) => {
-      const segments = (Array.isArray(path44) ? path44 : path44.split(".")).filter(
+    classifyAiPocketFeaturePath = (path45) => {
+      const segments = (Array.isArray(path45) ? path45 : path45.split(".")).filter(
         Boolean
       );
       const normalized = segments.map((segment) => segment.toLowerCase());
@@ -2706,11 +2706,11 @@ var init_features = __esm({
         excludeFeaturePattern.source,
         excludeFeaturePattern.flags.replace(/[gy]/g, "")
       ) : void 0;
-      const isOperatorExcluded = (path44) => {
-        if (!exclusion?.test(path44)) {
+      const isOperatorExcluded = (path45) => {
+        if (!exclusion?.test(path45)) {
           return false;
         }
-        onFeatureExcluded?.({ path: path44, classification: "operator-excluded" });
+        onFeatureExcluded?.({ path: path45, classification: "operator-excluded" });
         return true;
       };
       const signal = payload.signal ?? {};
@@ -6043,10 +6043,10 @@ var init_command = __esm({
     init_dataset();
     init_research();
     runAiPocketSearchCommand = async ({
-      flags: flags34
+      flags: flags35
     }) => {
       const options = resolveAiPocketSearchCommandOptions({
-        flags: flags34,
+        flags: flags35,
         argv: process.argv
       });
       const {
@@ -6958,11 +6958,11 @@ var init_strategyGateFingerprint = __esm({
       "@tradejs/core/strategies"
     ];
     resolveStrategyGateFingerprint = async ({
-      projectRoot: projectRoot17,
+      projectRoot: projectRoot18,
       strategyName,
       gitSha
     }) => {
-      const projectManifestPath = import_node_path3.default.join(projectRoot17, "package.json");
+      const projectManifestPath = import_node_path3.default.join(projectRoot18, "package.json");
       const projectExists = await import_promises6.default.access(projectManifestPath).then(() => true).catch(() => false);
       const requireFromProject = projectExists ? (0, import_node_module.createRequire)(projectManifestPath) : null;
       const candidates = requireFromProject ? await Promise.all(
@@ -7141,10 +7141,10 @@ var init_aiTrainResearch = __esm({
         };
       });
     };
-    getGitLineage = (projectRoot17) => {
+    getGitLineage = (projectRoot18) => {
       try {
         const gitSha = (0, import_node_child_process2.execFileSync)("git", ["rev-parse", "HEAD"], {
-          cwd: projectRoot17,
+          cwd: projectRoot18,
           encoding: "utf8",
           stdio: ["ignore", "pipe", "ignore"]
         }).trim();
@@ -7152,7 +7152,7 @@ var init_aiTrainResearch = __esm({
           "git",
           ["status", "--porcelain", "--untracked-files=no"],
           {
-            cwd: projectRoot17,
+            cwd: projectRoot18,
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"]
           }
@@ -7163,16 +7163,16 @@ var init_aiTrainResearch = __esm({
       }
     };
     buildAiTrainLineage = async ({
-      projectRoot: projectRoot17,
+      projectRoot: projectRoot18,
       strategyName,
       configIds,
       runContext,
       sourceSha256s = [],
       env = process.env
     }) => {
-      const { gitSha, gitDirty } = getGitLineage(projectRoot17);
+      const { gitSha, gitDirty } = getGitLineage(projectRoot18);
       const gate = await resolveStrategyGateFingerprint({
-        projectRoot: projectRoot17,
+        projectRoot: projectRoot18,
         strategyName,
         gitSha
       });
@@ -9203,12 +9203,12 @@ var init_binanceMarketContextBackfill = __esm({
       return rows;
     };
     getBinanceConnector = async ({
-      projectRoot: projectRoot17,
+      projectRoot: projectRoot18,
       userName: userName3
     }) => {
       const creator = await (0, import_connectors2.getConnectorCreatorByName)(
         import_connectors.ConnectorNames.Binance,
-        projectRoot17
+        projectRoot18
       );
       if (!creator) {
         throw new Error(
@@ -10755,27 +10755,27 @@ var init_coinMarketCapContextBackfill = __esm({
       totalCredits: 0,
       byPath: /* @__PURE__ */ new Map()
     });
-    getCoinMarketCapPathLabel = (path44) => {
-      if (path44.includes("global-metrics")) return "global";
-      if (path44.includes("cryptocurrency/quotes")) return "reference";
-      if (path44.includes("exchange/quotes")) return "exchangeLiquidity";
-      if (path44.includes("fear-and-greed")) return "fearGreed";
-      if (path44.includes("cmc100")) return "cmc100";
-      if (path44.includes("cmc20")) return "cmc20";
-      return path44;
-    };
-    recordCoinMarketCapFetchStats = (stats, path44, creditCount) => {
+    getCoinMarketCapPathLabel = (path45) => {
+      if (path45.includes("global-metrics")) return "global";
+      if (path45.includes("cryptocurrency/quotes")) return "reference";
+      if (path45.includes("exchange/quotes")) return "exchangeLiquidity";
+      if (path45.includes("fear-and-greed")) return "fearGreed";
+      if (path45.includes("cmc100")) return "cmc100";
+      if (path45.includes("cmc20")) return "cmc20";
+      return path45;
+    };
+    recordCoinMarketCapFetchStats = (stats, path45, creditCount) => {
       if (!stats) return;
-      const existing = stats.byPath.get(path44) ?? { requests: 0, credits: 0 };
+      const existing = stats.byPath.get(path45) ?? { requests: 0, credits: 0 };
       existing.requests += 1;
       existing.credits += creditCount ?? 0;
       stats.requests += 1;
       stats.totalCredits += creditCount ?? 0;
-      stats.byPath.set(path44, existing);
+      stats.byPath.set(path45, existing);
     };
     formatCoinMarketCapFetchStats = (stats) => {
       const byPath = [...stats.byPath.entries()].map(
-        ([path44, item]) => `${getCoinMarketCapPathLabel(path44)}=${item.requests}req/${item.credits}cr`
+        ([path45, item]) => `${getCoinMarketCapPathLabel(path45)}=${item.requests}req/${item.credits}cr`
       ).join(" ");
       return `apiRequests=${stats.requests} apiCredits=${stats.totalCredits}${byPath ? ` ${byPath}` : ""}`;
     };
@@ -12533,7 +12533,7 @@ var init_historyPrepare = __esm({
       connectorName,
       marketConnector,
       userName: userName3,
-      projectRoot: projectRoot17,
+      projectRoot: projectRoot18,
       shouldUseDedicatedReferences,
       requireDedicatedReferences = false,
       warn
@@ -12545,8 +12545,8 @@ var init_historyPrepare = __esm({
         };
       }
       const [binanceFactory, coinbaseFactory] = await Promise.all([
-        (0, import_connectors4.getConnectorCreatorByName)(import_connectors3.ConnectorNames.Binance, projectRoot17),
-        (0, import_connectors4.getConnectorCreatorByName)(import_connectors3.ConnectorNames.Coinbase, projectRoot17)
+        (0, import_connectors4.getConnectorCreatorByName)(import_connectors3.ConnectorNames.Binance, projectRoot18),
+        (0, import_connectors4.getConnectorCreatorByName)(import_connectors3.ConnectorNames.Coinbase, projectRoot18)
       ]);
       const binance = binanceFactory ? await binanceFactory({ userName: userName3 }) : marketConnector;
       if (!binanceFactory) {
@@ -12804,9 +12804,9 @@ var init_runEnvironment = __esm({
     };
     resolveRunConnectorName = async ({
       value,
-      projectRoot: projectRoot17
+      projectRoot: projectRoot18
     }) => {
-      const connectorName = await (0, import_connectors5.resolveConnectorName)(value, projectRoot17);
+      const connectorName = await (0, import_connectors5.resolveConnectorName)(value, projectRoot18);
       if (connectorName) {
         return connectorName;
       }
@@ -12831,12 +12831,12 @@ var init_runEnvironment = __esm({
     };
     loadDeploymentReplayStrategies = async ({
       userName: userName3,
-      projectRoot: projectRoot17,
+      projectRoot: projectRoot18,
       deploymentId
     }) => {
       const [deployment, runtimeStrategies] = await Promise.all([
-        (0, import_runtimeStrategies.getRuntimeDeployment)({ userName: userName3, projectRoot: projectRoot17, deploymentId }),
-        (0, import_runtimeStrategies.loadResolvedRuntimeStrategies)({ userName: userName3, projectRoot: projectRoot17, deploymentId })
+        (0, import_runtimeStrategies.getRuntimeDeployment)({ userName: userName3, projectRoot: projectRoot18, deploymentId }),
+        (0, import_runtimeStrategies.loadResolvedRuntimeStrategies)({ userName: userName3, projectRoot: projectRoot18, deploymentId })
       ]);
       if (!deployment) {
         throw new Error(`Runtime deployment not found: ${deploymentId}`);
@@ -12885,7 +12885,7 @@ var init_runEnvironment = __esm({
       endTime,
       cacheOnly,
       interval: interval4,
-      projectRoot: projectRoot17,
+      projectRoot: projectRoot18,
       universe = "crypto",
       accountId,
       deploymentId,
@@ -12895,11 +12895,11 @@ var init_runEnvironment = __esm({
     }) => {
       const connectorName = await resolveRunConnectorName({
         value: connector,
-        projectRoot: projectRoot17
+        projectRoot: projectRoot18
       });
       const connectorFactory = await (0, import_connectors5.getConnectorCreatorByName)(
         connectorName,
-        projectRoot17
+        projectRoot18
       );
       if (!connectorFactory) {
         throw new Error(`Connector "${connectorName}" is not registered`);
@@ -12966,7 +12966,7 @@ var init_runEnvironment = __esm({
           connectorName,
           marketConnector,
           userName: userName3,
-          projectRoot: projectRoot17,
+          projectRoot: projectRoot18,
           shouldUseDedicatedReferences: universe === "crypto",
           requireDedicatedReferences: universe === "crypto",
           warn: (message) => console.log(import_chalk12.default.yellow(message))
@@ -15063,12 +15063,12 @@ var init_runtimeEvidenceDeployment = __esm({
     });
     resolveRuntimeEvidenceDeploymentSnapshot = async ({
       userName: userName3,
-      projectRoot: projectRoot17,
+      projectRoot: projectRoot18,
       deploymentId
     }) => {
       const [deployment, strategies] = await Promise.all([
-        (0, import_runtimeStrategies3.getRuntimeDeployment)({ userName: userName3, projectRoot: projectRoot17, deploymentId }),
-        (0, import_runtimeStrategies3.loadResolvedRuntimeStrategies)({ userName: userName3, projectRoot: projectRoot17, deploymentId })
+        (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}`);
@@ -15155,9 +15155,9 @@ var init_runtimeEvidenceSource = __esm({
     };
     readRuntimeEvidenceArtifact = async ({
       filePath,
-      projectRoot: projectRoot17
+      projectRoot: projectRoot18
     }) => {
-      const resolvedPath = import_node_path5.default.resolve(projectRoot17, filePath);
+      const resolvedPath = import_node_path5.default.resolve(projectRoot18, filePath);
       const root = asRecord2(
         JSON.parse(await import_promises9.default.readFile(resolvedPath, "utf8"))
       );
@@ -15256,11 +15256,11 @@ var init_runtimeEvidenceSource = __esm({
     };
     loadReplayRuntimeEvidenceSource = async ({
       filePath,
-      projectRoot: projectRoot17,
+      projectRoot: projectRoot18,
       expectedUserName,
       expectedWindow
     }) => {
-      const { resolvedPath, runtime, userName: userName3, startTime, endTime, deployment } = await readRuntimeEvidenceArtifact({ filePath, projectRoot: projectRoot17 });
+      const { resolvedPath, runtime, userName: userName3, startTime, endTime, deployment } = await readRuntimeEvidenceArtifact({ filePath, projectRoot: projectRoot18 });
       if (!userName3 || userName3 !== expectedUserName) {
         throw new Error(
           `Runtime evidence user mismatch: expected=${expectedUserName}, actual=${userName3 || "missing"}`
@@ -15993,7 +15993,7 @@ var init_historicalSignalsReplayPreparation = __esm({
     prepareHistoricalReplay = async (context, adapters) => {
       const {
         userName: userName3,
-        projectRoot: projectRoot17,
+        projectRoot: projectRoot18,
         preparedRun,
         interval: interval4,
         connectorName,
@@ -16047,7 +16047,7 @@ var init_historicalSignalsReplayPreparation = __esm({
               interval: interval4
             });
             const runtimeLineage = await adapters.buildLineage({
-              projectRoot: projectRoot17,
+              projectRoot: projectRoot18,
               strategyName: strategy.strategyName,
               strategyRevision: strategy.strategyRevision,
               deploymentCompositionId: strategy.deploymentCompositionId,
@@ -20110,7 +20110,7 @@ var init_outputReport = __esm({
       ) : "_No replay lineage records._";
     };
     writeReplayOutputReport = async ({
-      projectRoot: projectRoot17,
+      projectRoot: projectRoot18,
       timestamp,
       replayKey,
       userName: userName3,
@@ -20123,7 +20123,7 @@ var init_outputReport = __esm({
       strategySnapshot,
       runtimeComparison
     }) => {
-      const outputDir = import_node_path7.default.resolve(projectRoot17, "data/replay/output");
+      const outputDir = import_node_path7.default.resolve(projectRoot18, "data/replay/output");
       await import_promises10.default.mkdir(outputDir, { recursive: true });
       const perTradeAnalysis = buildPerTradeAnalysis(runtimeComparison);
       const report = {
@@ -20416,14 +20416,14 @@ var init_portfolioReport = __esm({
       )
     ].join("\n");
     writePortfolioReport = async ({
-      projectRoot: projectRoot17,
+      projectRoot: projectRoot18,
       timestamp,
       replayResult,
       window,
       lineage,
       command
     }) => {
-      const outputDir = import_node_path8.default.resolve(projectRoot17, "data/replay/output");
+      const outputDir = import_node_path8.default.resolve(projectRoot18, "data/replay/output");
       await import_promises11.default.mkdir(outputDir, { recursive: true });
       const trades = replayResult.strategies.flatMap(
         (strategy) => tradesFromPositionLog(strategy.strategyName, strategy.positionLog)
@@ -21122,10 +21122,10 @@ var init_binanceBreadthUniversesUpdate = __esm({
     flags6 = import_args7.default.parse(process.argv);
     BINANCE_BREADTH_UNIVERSES_RELATIVE_PATH = "packages/node/src/config/binanceBreadthUniverses.json";
     main7 = async () => {
-      const projectRoot17 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+      const projectRoot18 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
       const connectorCreator = await (0, import_connectors8.getConnectorCreatorByName)(
         import_connectors7.ConnectorNames.Binance,
-        projectRoot17
+        projectRoot18
       );
       if (!connectorCreator) {
         throw new Error("Binance connector is not registered");
@@ -21158,7 +21158,7 @@ var init_binanceBreadthUniversesUpdate = __esm({
         return snapshot;
       }
       const outputPath = import_node_path9.default.join(
-        projectRoot17,
+        projectRoot18,
         BINANCE_BREADTH_UNIVERSES_RELATIVE_PATH
       );
       await import_promises12.default.writeFile(outputPath, serialized, "utf8");
@@ -21992,14 +21992,14 @@ var init_cleanTests = __esm({
     cleanUserTests = async (userName3) => {
       const testsPrefix = `users:${userName3}:tests:`;
       const testsCachePrefix = `users:${userName3}:cache:tests:`;
-      const projectRoot17 = process.env.PROJECT_CWD || process.cwd();
+      const projectRoot18 = process.env.PROJECT_CWD || process.cwd();
       const persistedArtifactsDir = import_path7.default.relative(
-        projectRoot17,
-        (0, import_backtestArtifacts2.getPersistedBacktestArtifactsDirForUser)(userName3, projectRoot17)
+        projectRoot18,
+        (0, import_backtestArtifacts2.getPersistedBacktestArtifactsDirForUser)(userName3, projectRoot18)
       );
       const cacheArtifactsDir = import_path7.default.relative(
-        projectRoot17,
-        (0, import_backtestArtifacts2.getBacktestCacheArtifactsDirForUser)(userName3, projectRoot17)
+        projectRoot18,
+        (0, import_backtestArtifacts2.getBacktestCacheArtifactsDirForUser)(userName3, projectRoot18)
       );
       if (flags11.cache) {
         console.log(import_chalk25.default.yellow(`clean user cache: ${userName3}`));
@@ -22012,11 +22012,11 @@ var init_cleanTests = __esm({
       await (0, import_cli8.cleanRedis)(testsCachePrefix);
       await (0, import_cli8.cleanFiles)(persistedArtifactsDir);
       await (0, import_cli8.cleanFiles)(cacheArtifactsDir);
-      await import_promises13.default.rm(import_path7.default.join(projectRoot17, persistedArtifactsDir), {
+      await import_promises13.default.rm(import_path7.default.join(projectRoot18, persistedArtifactsDir), {
         recursive: true,
         force: true
       });
-      await import_promises13.default.rm(import_path7.default.join(projectRoot17, cacheArtifactsDir), {
+      await import_promises13.default.rm(import_path7.default.join(projectRoot18, cacheArtifactsDir), {
         recursive: true,
         force: true
       });
@@ -23853,8 +23853,8 @@ volumes:
         `${DEV_COMPOSE_FILE} not found in project root. Run "npx @tradejs/cli infra-init" first.`
       );
     };
-    runDockerCompose = (composePath, args37) => {
-      const result = (0, import_node_child_process3.spawnSync)("docker", ["compose", "-f", composePath, ...args37], {
+    runDockerCompose = (composePath, args38) => {
+      const result = (0, import_node_child_process3.spawnSync)("docker", ["compose", "-f", composePath, ...args38], {
         stdio: "inherit"
       });
       if (result.error) {
@@ -30166,11 +30166,11 @@ var init_coreResearch = __esm({
       if (!Number.isFinite(numeric)) throw new Error(`${name} is invalid: ${text}`);
       return numeric;
     };
-    readSymbols = async (argv2, projectRoot17) => {
+    readSymbols = async (argv2, projectRoot18) => {
       const symbolsFile = valueAfter(argv2, "--symbolsFile");
       if (symbolsFile) {
         const parsed = JSON.parse(
-          await import_promises23.default.readFile(import_node_path18.default.resolve(projectRoot17, symbolsFile), "utf8")
+          await import_promises23.default.readFile(import_node_path18.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");
@@ -30940,13 +30940,13 @@ var init_replayRuntimeEvidence = __esm({
       const parsed = Date.parse(raw);
       return Number.isFinite(parsed) ? parsed : null;
     };
-    resolveWindow = (flags34) => {
-      const endTime = toEpochMs2(flags34.endTime) ?? Date.now();
+    resolveWindow = (flags35) => {
+      const endTime = toEpochMs2(flags35.endTime) ?? Date.now();
       const hours = Math.max(
         1,
-        Number.parseInt(String(flags34.hours ?? 24), 10) || 24
+        Number.parseInt(String(flags35.hours ?? 24), 10) || 24
       );
-      const startTime = toEpochMs2(flags34.startTime) ?? endTime - hours * 60 * 60 * 1e3;
+      const startTime = toEpochMs2(flags35.startTime) ?? endTime - hours * 60 * 60 * 1e3;
       if (startTime >= endTime) {
         throw new Error(
           `Invalid window: startTime (${startTime}) must be less than endTime (${endTime})`
@@ -30955,7 +30955,7 @@ var init_replayRuntimeEvidence = __esm({
       return {
         startTime,
         endTime,
-        source: flags34.startTime != null || flags34.endTime != null ? "explicit" : "hours"
+        source: flags35.startTime != null || flags35.endTime != null ? "explicit" : "hours"
       };
     };
     parseStrategyFilter = (value) => String(value ?? "").split(",").map((item) => item.trim()).filter(Boolean);
@@ -31157,9 +31157,9 @@ var init_replayRuntimeEvidence = __esm({
       strategies,
       userName: userName3,
       runtimeEvidenceFile,
-      projectRoot: projectRoot17
+      projectRoot: projectRoot18
     }) => {
-      const runtimeEvidencePath = typeof runtimeEvidenceFile === "string" && runtimeEvidenceFile.trim() ? import_node_path19.default.resolve(projectRoot17, runtimeEvidenceFile.trim()) : null;
+      const runtimeEvidencePath = typeof runtimeEvidenceFile === "string" && runtimeEvidenceFile.trim() ? import_node_path19.default.resolve(projectRoot18, runtimeEvidenceFile.trim()) : null;
       if (runtimeEvidencePath) {
         const artifact = JSON.parse(
           await import_promises24.default.readFile(runtimeEvidencePath, "utf8")
@@ -31193,23 +31193,23 @@ var init_replayRuntimeEvidence = __esm({
       };
     };
     replayRuntimeEvidence = async () => {
-      const flags34 = import_args26.default.parse(process.argv);
-      const projectRoot17 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
-      const userName3 = String(flags34.user ?? "root");
-      const { startTime, endTime, source } = resolveWindow(flags34);
+      const flags35 = import_args26.default.parse(process.argv);
+      const projectRoot18 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+      const userName3 = String(flags35.user ?? "root");
+      const { startTime, endTime, source } = resolveWindow(flags35);
       const replay = await loadReplayResult({
         userName: userName3,
-        replayKey: typeof flags34.replayKey === "string" && flags34.replayKey.trim() ? flags34.replayKey.trim() : void 0
+        replayKey: typeof flags35.replayKey === "string" && flags35.replayKey.trim() ? flags35.replayKey.trim() : void 0
       });
-      const explicitStrategies = parseStrategyFilter(flags34.strategy);
+      const explicitStrategies = parseStrategyFilter(flags35.strategy);
       const strategies = explicitStrategies.length ? explicitStrategies : getReplayStrategies(replay.value);
       const runtime = await loadRuntimePayload({
         startTime,
         endTime,
         strategies,
         userName: userName3,
-        runtimeEvidenceFile: flags34.runtimeEvidence,
-        projectRoot: projectRoot17
+        runtimeEvidenceFile: flags35.runtimeEvidence,
+        projectRoot: projectRoot18
       });
       const replayValue = asRecord5(replay.value);
       const artifact = {
@@ -31248,7 +31248,7 @@ var init_replayRuntimeEvidence = __esm({
         },
         runtime: runtime.payload
       };
-      const outPath = import_node_path19.default.resolve(projectRoot17, String(flags34.out));
+      const outPath = import_node_path19.default.resolve(projectRoot18, String(flags35.out));
       await import_promises24.default.mkdir(import_node_path19.default.dirname(outPath), { recursive: true });
       await import_promises24.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
 `, "utf8");
@@ -31523,7 +31523,7 @@ var init_runtimeEvidenceProducer = __esm({
       return producer;
     };
     resolveRuntimeEvidenceProducer = async ({
-      projectRoot: projectRoot17,
+      projectRoot: projectRoot18,
       required: required4
     }) => {
       const projectSha = String(process.env.TRADEJS_PROJECT_SHA ?? "").trim();
@@ -31543,7 +31543,7 @@ var init_runtimeEvidenceProducer = __esm({
           "TRADEJS_PROJECT_IMAGE_DIGEST must be an immutable sha256 digest before publishing runtime evidence"
         );
       }
-      const manifestPath = import_node_path21.default.join(projectRoot17, "runtime-package-manifest.json");
+      const manifestPath = import_node_path21.default.join(projectRoot18, "runtime-package-manifest.json");
       let manifest;
       try {
         manifest = await import_promises26.default.readFile(manifestPath);
@@ -32001,7 +32001,7 @@ $ ${[executable, ...command].join(" ")}
       runtimeEvidencePath,
       outDir,
       runId = `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}-${process.pid}`,
-      projectRoot: projectRoot17,
+      projectRoot: projectRoot18,
       env = process.env,
       executable = process.execPath,
       cliPath = process.argv[1]
@@ -32022,7 +32022,7 @@ $ ${[executable, ...command].join(" ")}
         runtimeEvidenceBundle.artifact.producer
       );
       const currentProducer = await resolveRuntimeEvidenceProducer({
-        projectRoot: projectRoot17,
+        projectRoot: projectRoot18,
         required: true
       });
       if (!currentProducer || currentProducer.projectSha !== deployedProducer.projectSha || currentProducer.imageDigest !== deployedProducer.imageDigest || currentProducer.runtimePackageManifest.sha256 !== deployedProducer.runtimePackageManifest.sha256) {
@@ -32070,7 +32070,7 @@ $ ${[executable, ...command].join(" ")}
           await runLoggedCommand({
             executable,
             command,
-            cwd: projectRoot17,
+            cwd: projectRoot18,
             env,
             logHandle
           });
@@ -32141,14 +32141,180 @@ var init_runtimeFeedbackReplay2 = __esm({
   }
 });
 
+// src/lib/runtimeFeedbackNotification.ts
+var isRecord4, asRecord7, 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) : [];
+    finiteNumber5 = (value, fallback = 0) => {
+      const number = Number(value);
+      return Number.isFinite(number) ? number : fallback;
+    };
+    requiredTimestamp = (value, field) => {
+      const timestamp = Number(value);
+      if (!Number.isFinite(timestamp)) {
+        throw new Error(`Runtime feedback replay is missing ${field}`);
+      }
+      return timestamp;
+    };
+    escapeHtml5 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    formatMskDateTime2 = (timestamp) => new Intl.DateTimeFormat("ru-RU", {
+      timeZone: "Europe/Moscow",
+      year: "numeric",
+      month: "2-digit",
+      day: "2-digit",
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: false
+    }).format(new Date(timestamp));
+    formatConnectorName = (value) => {
+      const connectorName = String(value ?? "unknown").trim() || "unknown";
+      return connectorName.toLowerCase() === "bybit" ? "ByBit" : connectorName;
+    };
+    sumRows = (rows, field) => rows.reduce((total, row) => total + finiteNumber5(row[field]), 0);
+    buildRuntimeFeedbackTelegramMessage = (replayEvidence) => {
+      if (replayEvidence.reportType !== "replay-runtime-evidence") {
+        throw new Error("Invalid runtime feedback replay evidence payload");
+      }
+      const window = asRecord7(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)) {
+        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 rows = asArray3(comparison.rows);
+      const matched = finiteNumber5(comparisonCounts.matched);
+      const runtimeOnly = finiteNumber5(comparisonCounts.runtimeOnly);
+      const backtestOnly = finiteNumber5(comparisonCounts.backtestOnly);
+      const orderFailed = sumRows(rows, "orderFailed");
+      const runtimeEntries = sumRows(rows, "runtimeTrades");
+      const backtestEntries = sumRows(rows, "backtestEntries");
+      const replayScopes = finiteNumber5(lineage.replayScopes);
+      const comparableScopes = finiteNumber5(lineage.comparableScopes);
+      const excludedRuntimeTrades = finiteNumber5(lineage.excludedRuntimeTrades);
+      const issueRows = rows.filter(
+        (row) => finiteNumber5(row.runtimeOnly) > 0 || finiteNumber5(row.backtestOnly) > 0 || finiteNumber5(row.orderFailed) > 0
+      );
+      const lines = [
+        "\u{1F9EA} <b>TradeJS runtime parity</b>",
+        "",
+        "\u{1F552} <b>Window</b>",
+        `<b>${escapeHtml5(formatMskDateTime2(startTime))} - ${escapeHtml5(formatMskDateTime2(endTime))} MSK</b>`,
+        "",
+        `\u{1F50C} Connector: <b>${escapeHtml5(formatConnectorName(deployment.connectorName ?? deployment.provider))}</b>`,
+        "\u{1F9EC} Source: <b>verified runtime feedback</b>",
+        `\u{1F4E6} Deployment: <b>${escapeHtml5(String(deployment.id ?? "unknown"))}</b>`,
+        `\u{1F510} Composition: <code>${escapeHtml5(String(deployment.deploymentCompositionId ?? "unknown"))}</code>`,
+        "",
+        "\u{1F4CC} <b>Overview</b>",
+        `\u2022 Runtime evidence: trades=<b>${finiteNumber5(runtimeCounts.trades)}</b>, signals=<b>${finiteNumber5(runtimeCounts.signals)}</b>, evaluations=<b>${finiteNumber5(runtimeCounts.evaluations)}</b>`,
+        `\u2022 Comparable entries: runtime=<b>${runtimeEntries}</b> / backtest=<b>${backtestEntries}</b>`,
+        `\u2022 Matched: <b>${matched}</b> / order failed: <b>${orderFailed}</b>`,
+        `\u2022 Runtime only: <b>${runtimeOnly}</b> / Backtest only: <b>${backtestOnly}</b>`,
+        `\u2022 Lineage scopes: <b>${comparableScopes} / ${replayScopes}</b>`
+      ];
+      if (excludedRuntimeTrades > 0) {
+        lines.push(
+          `\u2022 Excluded runtime trades outside comparable lineage: <b>${excludedRuntimeTrades}</b>`
+        );
+      }
+      if (issueRows.length) {
+        lines.push("", "\u{1F4CA} <b>Strategy issues</b>");
+        for (const row of issueRows.slice(0, 10)) {
+          const issues = [
+            finiteNumber5(row.orderFailed) > 0 ? `orderFailed=${finiteNumber5(row.orderFailed)}` : null,
+            finiteNumber5(row.runtimeOnly) > 0 ? `runtimeOnly=${finiteNumber5(row.runtimeOnly)}` : null,
+            finiteNumber5(row.backtestOnly) > 0 ? `backtestOnly=${finiteNumber5(row.backtestOnly)}` : null
+          ].filter((value) => value != null);
+          lines.push(
+            `\u2022 ${escapeHtml5(String(row.strategyName ?? "[unknown]"))}: ${issues.join(", ")}`
+          );
+        }
+        if (issueRows.length > 10) {
+          lines.push(`... <b>${issueRows.length - 10}</b> more`);
+        }
+      } else if (rows.length) {
+        lines.push(
+          "",
+          `\u{1F4CA} <b>Strategies</b>: clean <b>${rows.length}</b> / total <b>${rows.length}</b>`
+        );
+      }
+      return lines.join("\n");
+    };
+    notifyRuntimeFeedbackBundle = async ({
+      bundleDir,
+      send = sendTelegramReport
+    }) => {
+      const verified = await verifyRuntimeFeedbackReplayBundle(bundleDir);
+      const message = buildRuntimeFeedbackTelegramMessage(verified.replayEvidence);
+      await send(message, { userName: verified.manifest.userName });
+      return {
+        artifactId: verified.manifest.artifactId,
+        userName: verified.manifest.userName,
+        message
+      };
+    };
+  }
+});
+
+// src/scripts/runtimeFeedbackNotify.ts
+var runtimeFeedbackNotify_exports = {};
+__export(runtimeFeedbackNotify_exports, {
+  main: () => main36,
+  runtimeFeedbackNotify: () => runtimeFeedbackNotify
+});
+var import_node_path25, import_args28, import_chalk45, flags26, projectRoot10, runtimeFeedbackNotify, main36;
+var init_runtimeFeedbackNotify = __esm({
+  "src/scripts/runtimeFeedbackNotify.ts"() {
+    "use strict";
+    import_node_path25 = __toESM(require("path"));
+    import_args28 = __toESM(require("args"));
+    import_chalk45 = __toESM(require("chalk"));
+    init_runtimeFeedbackNotification();
+    init_runtimeFeedbackArtifacts();
+    import_args28.default.option("bundle", "Verified runtime feedback replay bundle directory");
+    import_args28.default.option("dryRun", "Verify and print the message without sending it", false);
+    flags26 = import_args28.default.parse(process.argv);
+    projectRoot10 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    runtimeFeedbackNotify = async () => {
+      const bundle = String(flags26.bundle ?? "").trim();
+      if (!bundle) {
+        throw new Error("Provide --bundle for runtime feedback notification.");
+      }
+      const bundleDir = import_node_path25.default.resolve(projectRoot10, bundle);
+      if (flags26.dryRun) {
+        const verified = await verifyRuntimeFeedbackReplayBundle(bundleDir);
+        console.log(buildRuntimeFeedbackTelegramMessage(verified.replayEvidence));
+        return;
+      }
+      const result = await notifyRuntimeFeedbackBundle({ bundleDir });
+      console.log(
+        import_chalk45.default.green(`Runtime feedback notification sent: ${result.artifactId}`)
+      );
+    };
+    main36 = runtimeFeedbackNotify;
+  }
+});
+
 // src/lib/runtimeEvidenceSync.ts
-var import_node_child_process7, import_promises29, import_node_path25, import_node_util, execFileAsync, isExistingDestinationError2, safeSegment4, withTrailingSlash, dateParts2, buildRuntimeEvidenceRsyncArgs, receiptPath, compareBundles, listPendingRuntimeEvidenceBundles, markRuntimeEvidenceBundleProcessed, syncRuntimeEvidenceBundles;
+var import_node_child_process7, import_promises29, import_node_path26, import_node_util, execFileAsync, isExistingDestinationError2, safeSegment4, withTrailingSlash, dateParts2, buildRuntimeEvidenceRsyncArgs, receiptPath, compareBundles, listPendingRuntimeEvidenceBundles, markRuntimeEvidenceBundleProcessed, syncRuntimeEvidenceBundles;
 var init_runtimeEvidenceSync = __esm({
   "src/lib/runtimeEvidenceSync.ts"() {
     "use strict";
     import_node_child_process7 = require("child_process");
     import_promises29 = __toESM(require("fs/promises"));
-    import_node_path25 = __toESM(require("path"));
+    import_node_path26 = __toESM(require("path"));
     import_node_util = require("util");
     init_runtimeEvidenceArtifacts();
     init_runtimeEvidenceDeployment();
@@ -32182,15 +32348,15 @@ var init_runtimeEvidenceSync = __esm({
       withTrailingSlash(source),
       withTrailingSlash(destination)
     ];
-    receiptPath = (receiptsRoot, artifactId) => import_node_path25.default.join(receiptsRoot, `${safeSegment4(artifactId, "artifact")}.json`);
+    receiptPath = (receiptsRoot, artifactId) => import_node_path26.default.join(receiptsRoot, `${safeSegment4(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_path25.default.join(evidenceRoot, "artifacts", safeDeploymentId);
-      const receiptsRoot = import_node_path25.default.join(evidenceRoot, "receipts", safeDeploymentId);
+      const artifactsRoot = import_node_path26.default.join(evidenceRoot, "artifacts", safeDeploymentId);
+      const receiptsRoot = import_node_path26.default.join(evidenceRoot, "receipts", safeDeploymentId);
       const bundles = await discoverRuntimeEvidenceBundles(artifactsRoot);
       const pending = [];
       for (const bundleDir of bundles) {
@@ -32221,7 +32387,7 @@ var init_runtimeEvidenceSync = __esm({
           `Artifact deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
         );
       }
-      const receiptsRoot = import_node_path25.default.join(evidenceRoot, "receipts", safeDeploymentId);
+      const receiptsRoot = import_node_path26.default.join(evidenceRoot, "receipts", safeDeploymentId);
       const finalPath = receiptPath(receiptsRoot, verified.manifest.artifactId);
       const temporaryPath = `${finalPath}.tmp-${process.pid}`;
       const receipt = {
@@ -32249,16 +32415,16 @@ var init_runtimeEvidenceSync = __esm({
       source,
       evidenceRoot,
       deploymentId,
-      runRsync = async (args37) => {
-        const result = await execFileAsync("rsync", args37, {
+      runRsync = async (args38) => {
+        const result = await execFileAsync("rsync", args38, {
           maxBuffer: 10 * 1024 * 1024
         });
         return { stdout: result.stdout, stderr: result.stderr };
       }
     }) => {
       const safeDeploymentId = safeSegment4(deploymentId, "production");
-      const inboxRoot = import_node_path25.default.join(evidenceRoot, "inbox", safeDeploymentId);
-      const artifactsRoot = import_node_path25.default.join(evidenceRoot, "artifacts", safeDeploymentId);
+      const inboxRoot = import_node_path26.default.join(evidenceRoot, "inbox", safeDeploymentId);
+      const artifactsRoot = import_node_path26.default.join(evidenceRoot, "artifacts", safeDeploymentId);
       await Promise.all([
         import_promises29.default.mkdir(inboxRoot, { recursive: true }),
         import_promises29.default.mkdir(artifactsRoot, { recursive: true })
@@ -32278,12 +32444,12 @@ var init_runtimeEvidenceSync = __esm({
           );
         }
         assertCurrentRuntimeEvidenceArtifact(verified.artifact);
-        const destinationDir = import_node_path25.default.join(
+        const destinationDir = import_node_path26.default.join(
           artifactsRoot,
           ...dateParts2(verified.manifest.window.endTime),
           safeSegment4(verified.manifest.artifactId, "artifact")
         );
-        await import_promises29.default.mkdir(import_node_path25.default.dirname(destinationDir), { recursive: true });
+        await import_promises29.default.mkdir(import_node_path26.default.dirname(destinationDir), { recursive: true });
         try {
           await import_promises29.default.rename(bundleDir, destinationDir);
         } catch (error) {
@@ -32314,13 +32480,13 @@ var init_runtimeEvidenceSync = __esm({
 });
 
 // src/lib/runtimeFeedbackSync.ts
-var import_node_child_process8, import_promises30, import_node_path26, import_node_util2, execFileAsync2, isExistingDestinationError3, safeSegment5, dateParts3, syncRuntimeFeedbackReplayBundles;
+var import_node_child_process8, import_promises30, import_node_path27, import_node_util2, execFileAsync2, isExistingDestinationError3, safeSegment5, dateParts3, syncRuntimeFeedbackReplayBundles;
 var init_runtimeFeedbackSync = __esm({
   "src/lib/runtimeFeedbackSync.ts"() {
     "use strict";
     import_node_child_process8 = require("child_process");
     import_promises30 = __toESM(require("fs/promises"));
-    import_node_path26 = __toESM(require("path"));
+    import_node_path27 = __toESM(require("path"));
     import_node_util2 = require("util");
     init_runtimeFeedbackArtifacts();
     init_runtimeEvidenceSync();
@@ -32345,16 +32511,16 @@ var init_runtimeFeedbackSync = __esm({
       source,
       feedbackRoot,
       deploymentId,
-      runRsync = async (args37) => {
-        const result = await execFileAsync2("rsync", args37, {
+      runRsync = async (args38) => {
+        const result = await execFileAsync2("rsync", args38, {
           maxBuffer: 10 * 1024 * 1024
         });
         return { stdout: result.stdout, stderr: result.stderr };
       }
     }) => {
       const safeDeploymentId = safeSegment5(deploymentId, "production");
-      const inboxRoot = import_node_path26.default.join(feedbackRoot, "inbox", safeDeploymentId);
-      const artifactsRoot = import_node_path26.default.join(feedbackRoot, "artifacts", safeDeploymentId);
+      const inboxRoot = import_node_path27.default.join(feedbackRoot, "inbox", safeDeploymentId);
+      const artifactsRoot = import_node_path27.default.join(feedbackRoot, "artifacts", safeDeploymentId);
       await Promise.all([
         import_promises30.default.mkdir(inboxRoot, { recursive: true }),
         import_promises30.default.mkdir(artifactsRoot, { recursive: true })
@@ -32373,13 +32539,13 @@ var init_runtimeFeedbackSync = __esm({
             `Runtime feedback deployment mismatch: expected ${safeDeploymentId}, received ${verified.manifest.deploymentId}`
           );
         }
-        const destinationDir = import_node_path26.default.join(
+        const destinationDir = import_node_path27.default.join(
           artifactsRoot,
           ...dateParts3(verified.manifest.window.endTime),
           safeSegment5(verified.manifest.runtimeEvidence.artifactId, "artifact"),
           safeSegment5(verified.manifest.runId, "run")
         );
-        await import_promises30.default.mkdir(import_node_path26.default.dirname(destinationDir), { recursive: true });
+        await import_promises30.default.mkdir(import_node_path27.default.dirname(destinationDir), { recursive: true });
         try {
           await import_promises30.default.rename(bundleDir, destinationDir);
         } catch (error) {
@@ -32407,49 +32573,49 @@ var init_runtimeFeedbackSync = __esm({
 // src/scripts/runtimeFeedbackSync.ts
 var runtimeFeedbackSync_exports = {};
 __export(runtimeFeedbackSync_exports, {
-  main: () => main36,
+  main: () => main37,
   runtimeFeedbackSync: () => runtimeFeedbackSync
 });
-var import_node_path27, import_args28, import_chalk45, flags26, projectRoot10, runtimeFeedbackSync, main36;
+var import_node_path28, import_args29, import_chalk46, flags27, projectRoot11, runtimeFeedbackSync, main37;
 var init_runtimeFeedbackSync2 = __esm({
   "src/scripts/runtimeFeedbackSync.ts"() {
     "use strict";
-    import_node_path27 = __toESM(require("path"));
-    import_args28 = __toESM(require("args"));
-    import_chalk45 = __toESM(require("chalk"));
+    import_node_path28 = __toESM(require("path"));
+    import_args29 = __toESM(require("args"));
+    import_chalk46 = __toESM(require("chalk"));
     init_runtimeFeedbackSync();
-    import_args28.default.option(
+    import_args29.default.option(
       "source",
       "Rsync source ending at the runtime feedback ready directory",
       process.env.RUNTIME_FEEDBACK_RSYNC_SOURCE
     );
-    import_args28.default.option(
+    import_args29.default.option(
       "deployment",
       "Deployment id expected in runtime feedback manifests",
       process.env.RUNTIME_EVIDENCE_DEPLOYMENT_ID || "production"
     );
-    import_args28.default.option(
+    import_args29.default.option(
       "dir",
       "Local runtime feedback storage root",
       process.env.RUNTIME_FEEDBACK_LOCAL_DIR || "data/runtime-feedback"
     );
-    flags26 = import_args28.default.parse(process.argv);
-    projectRoot10 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    flags27 = import_args29.default.parse(process.argv);
+    projectRoot11 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     runtimeFeedbackSync = async () => {
-      const source = String(flags26.source ?? "").trim();
+      const source = String(flags27.source ?? "").trim();
       if (!source) {
         throw new Error(
           "Provide --source or RUNTIME_FEEDBACK_RSYNC_SOURCE for runtime feedback sync."
         );
       }
-      const feedbackRoot = import_node_path27.default.resolve(projectRoot10, String(flags26.dir));
+      const feedbackRoot = import_node_path28.default.resolve(projectRoot11, String(flags27.dir));
       const result = await syncRuntimeFeedbackReplayBundles({
         source,
         feedbackRoot,
-        deploymentId: String(flags26.deployment)
+        deploymentId: String(flags27.deployment)
       });
       console.log(
-        import_chalk45.default.green(
+        import_chalk46.default.green(
           `Runtime feedback sync completed: received=${result.received.length}`
         )
       );
@@ -32469,18 +32635,18 @@ var init_runtimeFeedbackSync2 = __esm({
         )
       );
     };
-    main36 = runtimeFeedbackSync;
+    main37 = runtimeFeedbackSync;
   }
 });
 
 // src/lib/runtimeEvidenceCompositionSnapshots.ts
-var import_node_crypto15, import_promises31, import_node_path28, SNAPSHOT_FILE, MANIFEST_FILE, COMPLETE_FILE, createRuntimeEvidenceCompositionSnapshotRecorder, isRecord4, sha2564, safeSegment6, isExistingDestinationError4, parseManifest3, verifyRuntimeEvidenceCompositionSnapshot, sameSnapshot, publishRuntimeEvidenceCompositionSnapshot, captureRuntimeEvidenceCompositionSnapshot, discoverRuntimeEvidenceCompositionSnapshots;
+var import_node_crypto15, import_promises31, import_node_path29, SNAPSHOT_FILE, MANIFEST_FILE, COMPLETE_FILE, createRuntimeEvidenceCompositionSnapshotRecorder, isRecord5, sha2564, safeSegment6, isExistingDestinationError4, parseManifest3, verifyRuntimeEvidenceCompositionSnapshot, sameSnapshot, publishRuntimeEvidenceCompositionSnapshot, captureRuntimeEvidenceCompositionSnapshot, discoverRuntimeEvidenceCompositionSnapshots;
 var init_runtimeEvidenceCompositionSnapshots = __esm({
   "src/lib/runtimeEvidenceCompositionSnapshots.ts"() {
     "use strict";
     import_node_crypto15 = require("crypto");
     import_promises31 = __toESM(require("fs/promises"));
-    import_node_path28 = __toESM(require("path"));
+    import_node_path29 = __toESM(require("path"));
     init_runtimeEvidenceDeployment();
     init_runtimeEvidenceProducer();
     SNAPSHOT_FILE = "snapshot.json";
@@ -32500,7 +32666,7 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
         }
       };
     };
-    isRecord4 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
+    isRecord5 = (value) => value != null && typeof value === "object" && !Array.isArray(value);
     sha2564 = (value) => (0, import_node_crypto15.createHash)("sha256").update(value).digest("hex");
     safeSegment6 = (value, label) => {
       const normalized = value.trim();
@@ -32514,8 +32680,8 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
       return code === "EEXIST" || code === "ENOTEMPTY";
     };
     parseManifest3 = (value) => {
-      const manifest = isRecord4(value) ? value : null;
-      const payload = isRecord4(manifest?.payload) ? manifest.payload : null;
+      const manifest = isRecord5(value) ? value : null;
+      const payload = isRecord5(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");
       }
@@ -32523,9 +32689,9 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
     };
     verifyRuntimeEvidenceCompositionSnapshot = async (bundleDir) => {
       const [manifestText, payload, completeText] = await Promise.all([
-        import_promises31.default.readFile(import_node_path28.default.join(bundleDir, MANIFEST_FILE), "utf8"),
-        import_promises31.default.readFile(import_node_path28.default.join(bundleDir, SNAPSHOT_FILE)),
-        import_promises31.default.readFile(import_node_path28.default.join(bundleDir, COMPLETE_FILE), "utf8")
+        import_promises31.default.readFile(import_node_path29.default.join(bundleDir, MANIFEST_FILE), "utf8"),
+        import_promises31.default.readFile(import_node_path29.default.join(bundleDir, SNAPSHOT_FILE)),
+        import_promises31.default.readFile(import_node_path29.default.join(bundleDir, COMPLETE_FILE), "utf8")
       ]);
       const manifest = parseManifest3(JSON.parse(manifestText));
       if (completeText.trim() !== manifest.deploymentCompositionId) {
@@ -32537,7 +32703,7 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
         );
       }
       const value = JSON.parse(payload.toString("utf8"));
-      const record = isRecord4(value) ? value : null;
+      const record = isRecord5(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}`
@@ -32588,9 +32754,9 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
           bytes: Buffer.byteLength(payload)
         }
       };
-      const snapshotsRoot = import_node_path28.default.join(evidenceRoot, "snapshots", deploymentId);
-      const bundleDir = import_node_path28.default.join(snapshotsRoot, compositionId);
-      const temporaryDir = import_node_path28.default.join(
+      const snapshotsRoot = import_node_path29.default.join(evidenceRoot, "snapshots", deploymentId);
+      const bundleDir = import_node_path29.default.join(snapshotsRoot, compositionId);
+      const temporaryDir = import_node_path29.default.join(
         evidenceRoot,
         "incoming",
         `snapshot-${compositionId}.tmp-${(0, import_node_crypto15.randomUUID)()}`
@@ -32598,16 +32764,16 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
       await import_promises31.default.mkdir(temporaryDir, { recursive: true });
       try {
         await Promise.all([
-          import_promises31.default.writeFile(import_node_path28.default.join(temporaryDir, SNAPSHOT_FILE), payload, "utf8"),
+          import_promises31.default.writeFile(import_node_path29.default.join(temporaryDir, SNAPSHOT_FILE), payload, "utf8"),
           import_promises31.default.writeFile(
-            import_node_path28.default.join(temporaryDir, MANIFEST_FILE),
+            import_node_path29.default.join(temporaryDir, MANIFEST_FILE),
             `${JSON.stringify(manifest, null, 2)}
 `,
             "utf8"
           )
         ]);
         await import_promises31.default.writeFile(
-          import_node_path28.default.join(temporaryDir, COMPLETE_FILE),
+          import_node_path29.default.join(temporaryDir, COMPLETE_FILE),
           `${compositionId}
 `,
           "utf8"
@@ -32632,7 +32798,7 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
       return verified;
     };
     captureRuntimeEvidenceCompositionSnapshot = async ({
-      projectRoot: projectRoot17,
+      projectRoot: projectRoot18,
       userName: userName3,
       deploymentId,
       expectedCompositionId
@@ -32640,10 +32806,10 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
       const [deployment, producer] = await Promise.all([
         resolveRuntimeEvidenceDeploymentSnapshot({
           userName: userName3,
-          projectRoot: projectRoot17,
+          projectRoot: projectRoot18,
           deploymentId
         }),
-        resolveRuntimeEvidenceProducer({ projectRoot: projectRoot17, required: true })
+        resolveRuntimeEvidenceProducer({ projectRoot: projectRoot18, required: true })
       ]);
       if (!producer) {
         throw new Error("Runtime evidence producer identity is required");
@@ -32654,14 +32820,14 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
         );
       }
       await publishRuntimeEvidenceCompositionSnapshot({
-        evidenceRoot: import_node_path28.default.join(projectRoot17, "data", "runtime-evidence"),
+        evidenceRoot: import_node_path29.default.join(projectRoot18, "data", "runtime-evidence"),
         userName: userName3,
         deployment,
         producer
       });
     };
     discoverRuntimeEvidenceCompositionSnapshots = async (evidenceRoot) => {
-      const rootDir = import_node_path28.default.join(evidenceRoot, "snapshots");
+      const rootDir = import_node_path29.default.join(evidenceRoot, "snapshots");
       const bundleDirs = [];
       let deployments;
       try {
@@ -32671,14 +32837,14 @@ var init_runtimeEvidenceCompositionSnapshots = __esm({
         throw error;
       }
       for (const deployment of deployments.filter((entry) => entry.isDirectory())) {
-        const deploymentDir = import_node_path28.default.join(rootDir, deployment.name);
+        const deploymentDir = import_node_path29.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_path28.default.join(deploymentDir, entry.name))
+          ).map((entry) => import_node_path29.default.join(deploymentDir, entry.name))
         );
       }
       return Promise.all(
@@ -32847,52 +33013,52 @@ var init_runtimeEvidenceCompositions = __esm({
 // src/scripts/runtimeEvidence.ts
 var runtimeEvidence_exports = {};
 __export(runtimeEvidence_exports, {
-  main: () => main37,
+  main: () => main38,
   runtimeEvidence: () => runtimeEvidence
 });
-var import_promises32, import_node_path29, import_args29, import_chalk46, flags27, projectRoot11, toEpochMs3, resolveWindow2, parseStrategyFilter2, runtimeEvidence, main37;
+var import_promises32, import_node_path30, import_args30, import_chalk47, flags28, projectRoot12, toEpochMs3, resolveWindow2, parseStrategyFilter2, runtimeEvidence, main38;
 var init_runtimeEvidence = __esm({
   "src/scripts/runtimeEvidence.ts"() {
     "use strict";
     import_promises32 = __toESM(require("fs/promises"));
-    import_node_path29 = __toESM(require("path"));
-    import_args29 = __toESM(require("args"));
-    import_chalk46 = __toESM(require("chalk"));
+    import_node_path30 = __toESM(require("path"));
+    import_args30 = __toESM(require("args"));
+    import_chalk47 = __toESM(require("chalk"));
     init_runtimeDebugEvidence();
     init_runtimeEvidenceArtifacts();
     init_runtimeEvidenceCompositions();
     init_runtimeLineage();
     init_runtimeEvidenceProducer();
     init_runtimeEvidenceDeployment();
-    import_args29.default.option(["u", "user"], "Use user config", "root");
-    import_args29.default.option(
+    import_args30.default.option(["u", "user"], "Use user config", "root");
+    import_args30.default.option(
       ["S", "startTime"],
       "Window start timestamp, seconds/ms, or ISO date"
     );
-    import_args29.default.option(["E", "endTime"], "Window end timestamp, seconds/ms, or ISO date");
-    import_args29.default.option(
+    import_args30.default.option(["E", "endTime"], "Window end timestamp, seconds/ms, or ISO date");
+    import_args30.default.option(
       ["H", "hours"],
       "Fallback window in hours when start/end are omitted",
       24
     );
-    import_args29.default.option(
+    import_args30.default.option(
       "daily",
       "Use the latest complete 21:00 MSK to 21:00 MSK window",
       false
     );
-    import_args29.default.option(["s", "strategy"], "Strategy filter, comma-separated");
-    import_args29.default.option(["o", "out"], "Output JSON path", "output/runtime-evidence.json");
-    import_args29.default.option(
+    import_args30.default.option(["s", "strategy"], "Strategy filter, comma-separated");
+    import_args30.default.option(["o", "out"], "Output JSON path", "output/runtime-evidence.json");
+    import_args30.default.option(
       "publishDir",
       "Publish an immutable bundle under <dir>/ready/<deployment>"
     );
-    import_args29.default.option(
+    import_args30.default.option(
       "deployment",
       "Deployment id used by immutable evidence bundles",
       process.env.RUNTIME_EVIDENCE_DEPLOYMENT_ID || "production"
     );
-    flags27 = import_args29.default.parse(process.argv);
-    projectRoot11 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    flags28 = import_args30.default.parse(process.argv);
+    projectRoot12 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     toEpochMs3 = (value) => {
       if (value == null || value === "") {
         return null;
@@ -32906,11 +33072,11 @@ var init_runtimeEvidence = __esm({
       return Number.isFinite(parsed) ? parsed : null;
     };
     resolveWindow2 = () => {
-      const explicitStartTime = toEpochMs3(flags27.startTime);
-      const explicitEndTime = toEpochMs3(flags27.endTime);
+      const explicitStartTime = toEpochMs3(flags28.startTime);
+      const explicitEndTime = toEpochMs3(flags28.endTime);
       const now2 = Date.now();
       const dailyEndTime = (() => {
-        if (!flags27.daily || explicitStartTime != null || explicitEndTime != null) {
+        if (!flags28.daily || explicitStartTime != null || explicitEndTime != null) {
           return null;
         }
         const date = new Date(now2);
@@ -32925,7 +33091,7 @@ var init_runtimeEvidence = __esm({
       const endTime = explicitEndTime ?? dailyEndTime ?? now2;
       const hours = Math.max(
         1,
-        Number.parseInt(String(flags27.hours ?? 24), 10) || 24
+        Number.parseInt(String(flags28.hours ?? 24), 10) || 24
       );
       const startTime = explicitStartTime ?? endTime - hours * 60 * 60 * 1e3;
       if (startTime >= endTime) {
@@ -32942,27 +33108,27 @@ var init_runtimeEvidence = __esm({
     parseStrategyFilter2 = (value) => String(value ?? "").split(",").map((item) => item.trim()).filter(Boolean);
     runtimeEvidence = async () => {
       const { startTime, endTime, source } = resolveWindow2();
-      const deploymentId = String(flags27.deployment);
-      const publishDir = String(flags27.publishDir ?? "").trim();
+      const deploymentId = String(flags28.deployment);
+      const publishDir = String(flags28.publishDir ?? "").trim();
       const producer = await resolveRuntimeEvidenceProducer({
-        projectRoot: projectRoot11,
+        projectRoot: projectRoot12,
         required: Boolean(publishDir)
       });
       const deploymentSnapshot = await resolveRuntimeEvidenceDeploymentSnapshot({
-        userName: String(flags27.user),
-        projectRoot: projectRoot11,
+        userName: String(flags28.user),
+        projectRoot: projectRoot12,
         deploymentId
       });
-      const requestedStrategies = parseStrategyFilter2(flags27.strategy);
+      const requestedStrategies = parseStrategyFilter2(flags28.strategy);
       const evidence = await collectRuntimeDebugEvidence({
-        userName: flags27.user,
+        userName: flags28.user,
         startTime,
         endTime,
         strategies: requestedStrategies.length ? requestedStrategies : void 0,
         deploymentId
       });
       const snapshots = publishDir && producer ? await loadRuntimeEvidenceCompositionSnapshots({
-        publishRoot: import_node_path29.default.resolve(projectRoot11, publishDir),
+        publishRoot: import_node_path30.default.resolve(projectRoot12, publishDir),
         currentDeployment: deploymentSnapshot,
         currentProducer: producer
       }) : /* @__PURE__ */ new Map([
@@ -32995,7 +33161,7 @@ var init_runtimeEvidence = __esm({
           (strategyName) => !requestedStrategies.length || requestedStrategies.includes(strategyName)
         );
         const runtime = buildRuntimeEvidenceReportPayload({
-          userName: flags27.user,
+          userName: flags28.user,
           startTime,
           endTime,
           signals: composition.signals,
@@ -33014,7 +33180,7 @@ var init_runtimeEvidence = __esm({
             generatedAt: Date.now(),
             ...composition.producer ? { producer: composition.producer } : {},
             ...producer && composition.producer && composition.producer !== producer ? { collector: producer } : {},
-            userName: flags27.user,
+            userName: flags28.user,
             window: {
               startTime,
               endTime,
@@ -33036,16 +33202,16 @@ var init_runtimeEvidence = __esm({
         throw new Error("Runtime evidence window has no versioned runtime rows");
       }
       const artifact = current.artifact;
-      const outPath = import_node_path29.default.resolve(projectRoot11, String(flags27.out));
-      await import_promises32.default.mkdir(import_node_path29.default.dirname(outPath), { recursive: true });
+      const outPath = import_node_path30.default.resolve(projectRoot12, String(flags28.out));
+      await import_promises32.default.mkdir(import_node_path30.default.dirname(outPath), { recursive: true });
       await import_promises32.default.writeFile(outPath, `${JSON.stringify(artifact, null, 2)}
 `, "utf8");
       const published = publishDir ? await Promise.all(
         artifacts.map(
           ({ artifact: artifact2, composition }) => publishRuntimeEvidenceBundle({
-            publishRoot: import_node_path29.default.resolve(projectRoot11, publishDir),
+            publishRoot: import_node_path30.default.resolve(projectRoot12, publishDir),
             deploymentId,
-            userName: String(flags27.user),
+            userName: String(flags28.user),
             startTime,
             endTime,
             artifact: artifact2,
@@ -33061,9 +33227,9 @@ var init_runtimeEvidence = __esm({
           })
         )
       ) : [];
-      console.log(import_chalk46.default.green(`Wrote ${outPath}`));
+      console.log(import_chalk47.default.green(`Wrote ${outPath}`));
       for (const bundle of published) {
-        console.log(import_chalk46.default.green(`Published ${bundle.bundleDir}`));
+        console.log(import_chalk47.default.green(`Published ${bundle.bundleDir}`));
       }
       console.log(
         JSON.stringify(
@@ -33079,56 +33245,56 @@ var init_runtimeEvidence = __esm({
         )
       );
     };
-    main37 = runtimeEvidence;
+    main38 = runtimeEvidence;
   }
 });
 
 // src/scripts/runtimeEvidenceSync.ts
 var runtimeEvidenceSync_exports = {};
 __export(runtimeEvidenceSync_exports, {
-  main: () => main38,
+  main: () => main39,
   runtimeEvidenceSync: () => runtimeEvidenceSync
 });
-var import_node_path30, import_args30, import_chalk47, flags28, projectRoot12, runtimeEvidenceSync, main38;
+var import_node_path31, import_args31, import_chalk48, flags29, projectRoot13, runtimeEvidenceSync, main39;
 var init_runtimeEvidenceSync2 = __esm({
   "src/scripts/runtimeEvidenceSync.ts"() {
     "use strict";
-    import_node_path30 = __toESM(require("path"));
-    import_args30 = __toESM(require("args"));
-    import_chalk47 = __toESM(require("chalk"));
+    import_node_path31 = __toESM(require("path"));
+    import_args31 = __toESM(require("args"));
+    import_chalk48 = __toESM(require("chalk"));
     init_runtimeEvidenceSync();
-    import_args30.default.option(
+    import_args31.default.option(
       "source",
       "Rsync source ending at the deployment ready directory",
       process.env.RUNTIME_EVIDENCE_RSYNC_SOURCE
     );
-    import_args30.default.option(
+    import_args31.default.option(
       "deployment",
       "Deployment id expected in artifact manifests",
       process.env.RUNTIME_EVIDENCE_DEPLOYMENT_ID || "production"
     );
-    import_args30.default.option(
+    import_args31.default.option(
       "dir",
       "Local evidence storage root",
       process.env.RUNTIME_EVIDENCE_LOCAL_DIR || "data/runtime-evidence"
     );
-    flags28 = import_args30.default.parse(process.argv);
-    projectRoot12 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    flags29 = import_args31.default.parse(process.argv);
+    projectRoot13 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     runtimeEvidenceSync = async () => {
-      const source = String(flags28.source ?? "").trim();
+      const source = String(flags29.source ?? "").trim();
       if (!source) {
         throw new Error(
           "Provide --source or RUNTIME_EVIDENCE_RSYNC_SOURCE for runtime evidence sync."
         );
       }
-      const evidenceRoot = import_node_path30.default.resolve(projectRoot12, String(flags28.dir));
+      const evidenceRoot = import_node_path31.default.resolve(projectRoot13, String(flags29.dir));
       const result = await syncRuntimeEvidenceBundles({
         source,
         evidenceRoot,
-        deploymentId: String(flags28.deployment)
+        deploymentId: String(flags29.deployment)
       });
       console.log(
-        import_chalk47.default.green(
+        import_chalk48.default.green(
           `Runtime evidence sync completed: received=${result.received.length} pending=${result.pending.length}`
         )
       );
@@ -33153,23 +33319,23 @@ var init_runtimeEvidenceSync2 = __esm({
         )
       );
     };
-    main38 = runtimeEvidenceSync;
+    main39 = runtimeEvidenceSync;
   }
 });
 
 // src/lib/runtimeScorecard.ts
-var asRecord7, asArray3, finiteNumber5, 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 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 init_runtimeScorecard = __esm({
   "src/lib/runtimeScorecard.ts"() {
     "use strict";
     init_runtimeLineage();
     init_runtimeEvidenceDeployment();
-    asRecord7 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
-    asArray3 = (value) => Array.isArray(value) ? value : [];
-    finiteNumber5 = (value) => typeof value === "number" && Number.isFinite(value) ? value : null;
+    asRecord8 = (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 = asRecord7(value);
+      const record = asRecord8(value);
       if (!record || Object.keys(record).length === 0) return null;
       const entries = Object.entries(record);
       if (entries.some(
@@ -33182,14 +33348,14 @@ var init_runtimeScorecard = __esm({
       );
     };
     round3 = (value, decimals = 6) => Number(value.toFixed(decimals));
-    unwrapRows2 = (value, key) => asArray3(value).map((item) => asRecord7(asRecord7(item)?.[key]) ?? asRecord7(item)).filter((item) => item != null);
+    unwrapRows2 = (value, key) => asArray4(value).map((item) => asRecord8(asRecord8(item)?.[key]) ?? asRecord8(item)).filter((item) => item != null);
     runtimePayload = (artifact) => {
-      const root = asRecord7(artifact) ?? {};
-      return asRecord7(root.runtime) ?? root;
+      const root = asRecord8(artifact) ?? {};
+      return asRecord8(root.runtime) ?? root;
     };
     runtimeWindow = (artifact) => {
-      const root = asRecord7(artifact) ?? {};
-      return asRecord7(root.window) ?? asRecord7(runtimePayload(artifact).window) ?? {};
+      const root = asRecord8(artifact) ?? {};
+      return asRecord8(root.window) ?? asRecord8(runtimePayload(artifact).window) ?? {};
     };
     extractRuntimeRows = (artifact) => {
       const runtime = runtimePayload(artifact);
@@ -33205,15 +33371,15 @@ var init_runtimeScorecard = __esm({
       rows,
       strategy
     }) => {
-      const deployment = asRecord7(asRecord7(artifact)?.deployment);
-      if (finiteNumber5(deployment?.schemaVersion) !== 2) return null;
+      const deployment = asRecord8(asRecord8(artifact)?.deployment);
+      if (finiteNumber6(deployment?.schemaVersion) !== 2) return null;
       const deploymentId = finiteString2(deployment?.id);
       const accountId = finiteString2(deployment?.accountId);
       const deploymentCompositionId = finiteString2(
         deployment?.deploymentCompositionId
       );
       if (!deploymentId || !accountId || !deploymentCompositionId) return null;
-      const snapshots = asArray3(deployment?.strategies).map(asRecord7).filter((item) => item != null).filter((item) => item.enabled === true).filter(
+      const snapshots = asArray4(deployment?.strategies).map(asRecord8).filter((item) => item != null).filter((item) => item.enabled === true).filter(
         (item) => !strategy || finiteString2(item.strategyName) === strategy
       );
       const targetSeeds = snapshots.map((snapshot) => {
@@ -33251,14 +33417,14 @@ var init_runtimeScorecard = __esm({
           runtimeLineage: scope.lineage
         }))
       ];
-      const identityMatches = (lineage, target) => finiteNumber5(lineage?.schemaVersion) === 3 && finiteString2(lineage?.strategyRevision) === target.strategyRevision && finiteString2(lineage?.deploymentCompositionId) === target.deploymentCompositionId && finiteString2(lineage?.strategyPackageVersion) === target.strategyPackageVersion && JSON.stringify(packageVersionMap(lineage?.strategyDependencyVersions)) === JSON.stringify(target.strategyDependencyVersions) && finiteString2(lineage?.runtimePackageVersion) === target.runtimePackageVersion;
+      const identityMatches = (lineage, target) => finiteNumber6(lineage?.schemaVersion) === 3 && finiteString2(lineage?.strategyRevision) === target.strategyRevision && finiteString2(lineage?.deploymentCompositionId) === target.deploymentCompositionId && finiteString2(lineage?.strategyPackageVersion) === target.strategyPackageVersion && JSON.stringify(packageVersionMap(lineage?.strategyDependencyVersions)) === JSON.stringify(target.strategyDependencyVersions) && finiteString2(lineage?.runtimePackageVersion) === target.runtimePackageVersion;
       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(asRecord7(row.runtimeLineage), seed)
+          (row) => finiteString2(row.strategy) === seed.strategyName && finiteString2(row.deploymentId) === deploymentId && finiteString2(row.accountId) === accountId && identityMatches(asRecord8(row.runtimeLineage), seed)
         );
         const riskValues = new Set(
-          matchingRows.map((row) => finiteNumber5(asRecord7(row.runtimeLineage)?.maxLossValue)).filter((value) => value != null)
+          matchingRows.map((row) => finiteNumber6(asRecord8(row.runtimeLineage)?.maxLossValue)).filter((value) => value != null)
         );
         targets.set(seed.strategyName, {
           ...seed,
@@ -33270,9 +33436,9 @@ var init_runtimeScorecard = __esm({
       const belongs = (row) => {
         const strategyName = finiteString2(row.strategy);
         const target = strategyName ? targets.get(strategyName) : null;
-        const lineage = asRecord7(row.runtimeLineage);
+        const lineage = asRecord8(row.runtimeLineage);
         return Boolean(
-          target && target.maxLossValue != null && identityMatches(lineage, target) && finiteNumber5(lineage?.maxLossValue) === target.maxLossValue
+          target && target.maxLossValue != null && identityMatches(lineage, target) && finiteNumber6(lineage?.maxLossValue) === target.maxLossValue
         );
       };
       const targetValues = [...targets.values()];
@@ -33327,7 +33493,7 @@ var init_runtimeScorecard = __esm({
       };
     };
     runtimeDeploymentBinding = (artifact) => {
-      const deployment = asRecord7(asRecord7(artifact)?.deployment);
+      const deployment = asRecord8(asRecord8(artifact)?.deployment);
       return {
         deploymentId: finiteString2(deployment?.id),
         accountId: finiteString2(deployment?.accountId)
@@ -33337,32 +33503,32 @@ var init_runtimeScorecard = __esm({
     belongsToStrategy = (row, strategy) => strategy == null || finiteString2(row.strategy) === strategy;
     filterArtifactByStrategy = (artifact, strategy) => {
       if (!strategy) return artifact;
-      const root = asRecord7(artifact) ?? {};
+      const root = asRecord8(artifact) ?? {};
       const runtime = runtimePayload(artifact);
       return {
         ...root,
         runtime: {
           ...runtime,
-          evaluations: asArray3(runtime.evaluations).filter(
+          evaluations: asArray4(runtime.evaluations).filter(
             (item) => belongsToStrategy(
-              asRecord7(asRecord7(item)?.evaluation) ?? asRecord7(item) ?? {},
+              asRecord8(asRecord8(item)?.evaluation) ?? asRecord8(item) ?? {},
               strategy
             )
           ),
-          signals: asArray3(runtime.signals).filter(
+          signals: asArray4(runtime.signals).filter(
             (item) => belongsToStrategy(
-              asRecord7(asRecord7(item)?.signal) ?? asRecord7(item) ?? {},
+              asRecord8(asRecord8(item)?.signal) ?? asRecord8(item) ?? {},
               strategy
             )
           ),
-          trades: asArray3(runtime.trades).filter(
+          trades: asArray4(runtime.trades).filter(
             (item) => belongsToStrategy(
-              asRecord7(asRecord7(item)?.trade) ?? asRecord7(item) ?? {},
+              asRecord8(asRecord8(item)?.trade) ?? asRecord8(item) ?? {},
               strategy
             )
           ),
-          lineageScopes: asArray3(runtime.lineageScopes).filter(
-            (item) => belongsToStrategy(asRecord7(item) ?? {}, strategy)
+          lineageScopes: asArray4(runtime.lineageScopes).filter(
+            (item) => belongsToStrategy(asRecord8(item) ?? {}, strategy)
           )
         }
       };
@@ -33379,7 +33545,7 @@ var init_runtimeScorecard = __esm({
       );
     };
     resolveGateDecision = (evaluation) => {
-      const analysis = asRecord7(evaluation.aiAnalysis);
+      const analysis = asRecord8(evaluation.aiAnalysis);
       const explicit = finiteString2(analysis?.gateDecision);
       if (explicit === "approved" || explicit === "rejected") {
         return { decision: explicit, source: "gate_decision" };
@@ -33410,7 +33576,7 @@ var init_runtimeScorecard = __esm({
           (signal) => finiteString2(signal.orderSkipReason)
         ),
         aiQuality: countBy2(candidates, (evaluation) => {
-          const quality = finiteNumber5(asRecord7(evaluation.aiAnalysis)?.quality);
+          const quality = finiteNumber6(asRecord8(evaluation.aiAnalysis)?.quality);
           return quality == null ? null : String(quality);
         })
       };
@@ -33447,7 +33613,7 @@ var init_runtimeScorecard = __esm({
       );
     };
     sum2 = (values) => round3(values.reduce((total, value) => total + (value ?? 0), 0));
-    tradeTimestamp = (trade) => finiteNumber5(trade.exitTimestamp) ?? finiteNumber5(trade.lastSyncedAt) ?? finiteNumber5(trade.entryTimestamp) ?? 0;
+    tradeTimestamp = (trade) => finiteNumber6(trade.exitTimestamp) ?? finiteNumber6(trade.lastSyncedAt) ?? finiteNumber6(trade.entryTimestamp) ?? 0;
     dedupeTrades = (artifacts) => {
       const tradesByOrderId = /* @__PURE__ */ new Map();
       for (const artifact of artifacts) {
@@ -33469,7 +33635,7 @@ var init_runtimeScorecard = __esm({
       for (const trade of trades.sort(
         (left, right) => tradeTimestamp(left) - tradeTimestamp(right)
       )) {
-        cumulative += finiteNumber5(trade.closedPnl) ?? 0;
+        cumulative += finiteNumber6(trade.closedPnl) ?? 0;
         peak = Math.max(peak, cumulative);
         drawdown = Math.max(drawdown, peak - cumulative);
       }
@@ -33482,10 +33648,10 @@ var init_runtimeScorecard = __esm({
     }) => {
       const startTime = anchorTime - days * 24 * 60 * 60 * 1e3;
       const closed = trades.filter((trade) => {
-        const exitTimestamp = finiteNumber5(trade.exitTimestamp);
+        const exitTimestamp = finiteNumber6(trade.exitTimestamp);
         return trade.status === "closed" && exitTimestamp != null && exitTimestamp >= startTime && exitTimestamp < anchorTime;
       });
-      const realizedPnl = sum2(closed.map((trade) => finiteNumber5(trade.closedPnl)));
+      const realizedPnl = sum2(closed.map((trade) => finiteNumber6(trade.closedPnl)));
       return {
         days,
         closedTrades: closed.length,
@@ -33495,35 +33661,35 @@ var init_runtimeScorecard = __esm({
       };
     };
     getReplayComparison = (artifact) => {
-      const root = asRecord7(artifact) ?? {};
-      return asRecord7(asRecord7(root.replay)?.runtimeComparison) ?? null;
+      const root = asRecord8(artifact) ?? {};
+      return asRecord8(asRecord8(root.replay)?.runtimeComparison) ?? null;
     };
     replayCountsForStrategy = (replayComparison, strategy) => {
       if (strategy) {
-        const byStrategy = asRecord7(replayComparison?.byStrategy);
-        const strategyCounts = asRecord7(byStrategy?.[strategy]);
+        const byStrategy = asRecord8(replayComparison?.byStrategy);
+        const strategyCounts = asRecord8(byStrategy?.[strategy]);
         if (strategyCounts) {
           return {
-            matched: finiteNumber5(strategyCounts.matched) ?? 0,
-            backtestOnly: finiteNumber5(strategyCounts.backtestOnly) ?? 0,
-            runtimeOnly: finiteNumber5(strategyCounts.runtimeOnly) ?? 0
+            matched: finiteNumber6(strategyCounts.matched) ?? 0,
+            backtestOnly: finiteNumber6(strategyCounts.backtestOnly) ?? 0,
+            runtimeOnly: finiteNumber6(strategyCounts.runtimeOnly) ?? 0
           };
         }
       }
-      const counts = asRecord7(replayComparison?.counts);
+      const counts = asRecord8(replayComparison?.counts);
       return {
-        matched: finiteNumber5(counts?.matched) ?? 0,
-        backtestOnly: finiteNumber5(counts?.backtestOnly) ?? 0,
-        runtimeOnly: finiteNumber5(counts?.runtimeOnly) ?? 0
+        matched: finiteNumber6(counts?.matched) ?? 0,
+        backtestOnly: finiteNumber6(counts?.backtestOnly) ?? 0,
+        runtimeOnly: finiteNumber6(counts?.runtimeOnly) ?? 0
       };
     };
     getProspectiveSummary = (artifact) => {
-      const root = asRecord7(artifact);
+      const root = asRecord8(artifact);
       if (!root || root.reportType !== "strategy-prospective-evidence") return null;
       return {
-        rawCoreExpectancy: finiteNumber5(root.rawCoreExpectancy),
-        aiGateExpectancy: finiteNumber5(root.aiGateExpectancy),
-        regimeCoverage: finiteNumber5(root.regimeCoverage)
+        rawCoreExpectancy: finiteNumber6(root.rawCoreExpectancy),
+        aiGateExpectancy: finiteNumber6(root.aiGateExpectancy),
+        regimeCoverage: finiteNumber6(root.regimeCoverage)
       };
     };
     buildRuntimeScorecard = ({
@@ -33567,8 +33733,8 @@ var init_runtimeScorecard = __esm({
       }
       const runtimeLineage = embeddedLineageScope.summary;
       const window = runtimeWindow(runtimeArtifact);
-      const startTime = finiteNumber5(window.startTime) ?? generatedAt - 864e5;
-      const endTime = finiteNumber5(window.endTime) ?? generatedAt;
+      const startTime = finiteNumber6(window.startTime) ?? generatedAt - 864e5;
+      const endTime = finiteNumber6(window.endTime) ?? generatedAt;
       const signalEvaluations = rows.evaluations.filter(
         (evaluation) => evaluation.status === "signal"
       );
@@ -33579,7 +33745,7 @@ var init_runtimeScorecard = __esm({
         (evaluation) => resolveGateDecision(evaluation)?.decision === "approved"
       ) : signalEvaluations;
       const gateComparisons = llmEligibleEvaluations.map((evaluation) => {
-        const analysis = asRecord7(evaluation.aiAnalysis);
+        const analysis = asRecord8(evaluation.aiAnalysis);
         const gateDecision = resolveGateDecision(evaluation)?.decision ?? null;
         const llmDecision = finiteString2(analysis?.llmDecision);
         if (gateDecision !== "approved" && gateDecision !== "rejected" || llmDecision !== "approved" && llmDecision !== "rejected") {
@@ -33589,13 +33755,13 @@ var init_runtimeScorecard = __esm({
       }).filter(
         (comparison) => Boolean(comparison)
       );
-      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 allocatorDecisions = signalEvaluations.map((evaluation) => asRecord8(evaluation.allocatorDecision)).filter((item) => item != null);
+      const riskDecisions = signalEvaluations.map((evaluation) => asRecord8(evaluation.riskDecision)).filter((item) => item != null);
       const orderAttempts = rows.signals.filter(
         (signal) => signal.orderStatus === "completed" || signal.orderStatus === "failed"
       );
       const currentClosedTrades = rows.trades.filter((trade) => {
-        const exitTimestamp = finiteNumber5(trade.exitTimestamp);
+        const exitTimestamp = finiteNumber6(trade.exitTimestamp);
         return trade.status === "closed" && exitTimestamp != null && exitTimestamp >= startTime && exitTimestamp < endTime;
       });
       const replayComparison = getReplayComparison(replayEvidenceArtifact);
@@ -33605,12 +33771,12 @@ var init_runtimeScorecard = __esm({
       const runtimeOnly = replayCounts.runtimeOnly;
       const comparisonTotal = matched + backtestOnly + runtimeOnly;
       const parityRatio = comparisonTotal > 0 ? matched / comparisonTotal : null;
-      const lineage = asRecord7(replayComparison?.lineage);
+      const lineage = asRecord8(replayComparison?.lineage);
       const lineageReason = finiteString2(lineage?.reason);
-      const calibrationRoot = asRecord7(calibrationArtifact) ?? {};
-      const calibrationSamples = asArray3(calibrationRoot.samples).map(asRecord7).filter((item) => item != null).filter((item) => !strategy || finiteString2(item.strategy) === strategy).filter((item) => embeddedLineageScope.belongs(item));
+      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 averageSampleMetric = (field) => {
-        const values = calibrationSamples.map((sample) => finiteNumber5(sample[field])).filter((value) => value != null);
+        const values = calibrationSamples.map((sample) => finiteNumber6(sample[field])).filter((value) => value != null);
         return values.length ? round3(sum2(values) / values.length) : null;
       };
       const actualSlippageBps = averageSampleMetric("signalToFillAdverseBps");
@@ -33629,7 +33795,7 @@ var init_runtimeScorecard = __esm({
         (sample) => finiteString2(sample.telemetryQuality) === "full"
       ).length;
       const arrivalQuoteTrades = calibrationSamples.filter(
-        (sample) => finiteNumber5(sample.arrivalMid) != null
+        (sample) => finiteNumber6(sample.arrivalMid) != null
       ).length;
       const arrivalQuoteCoverage = calibrationSamples.length ? round3(arrivalQuoteTrades / calibrationSamples.length) : null;
       const hasTelemetryQuality = calibrationSamples.some(
@@ -33652,10 +33818,10 @@ var init_runtimeScorecard = __esm({
       );
       const currentDistributions = buildDistributions(rows);
       const previousArtifact = scopedHistoryArtifacts.map((artifact) => ({ artifact, window: runtimeWindow(artifact) })).filter(({ window: candidateWindow }) => {
-        const candidateEndTime = finiteNumber5(candidateWindow.endTime);
+        const candidateEndTime = finiteNumber6(candidateWindow.endTime);
         return candidateEndTime != null && candidateEndTime <= startTime;
       }).sort(
-        (left, right) => (finiteNumber5(right.window.endTime) ?? 0) - (finiteNumber5(left.window.endTime) ?? 0)
+        (left, right) => (finiteNumber6(right.window.endTime) ?? 0) - (finiteNumber6(left.window.endTime) ?? 0)
       )[0];
       const previousDistributions = previousArtifact ? buildDistributions(extractRuntimeRows(previousArtifact.artifact)) : null;
       const rolling = [7, 30, 90].map(
@@ -33808,17 +33974,17 @@ var init_runtimeScorecard = __esm({
         realized: {
           pnl: sum2(
             comparableCurrentClosedTrades.map(
-              (trade) => finiteNumber5(trade.closedPnl)
+              (trade) => finiteNumber6(trade.closedPnl)
             )
           ),
           fees: sum2(
             comparableCurrentClosedTrades.map(
-              (trade) => finiteNumber5(trade.totalFee)
+              (trade) => finiteNumber6(trade.totalFee)
             )
           ),
           funding: sum2(
             comparableCurrentClosedTrades.map(
-              (trade) => finiteNumber5(trade.fundingFee)
+              (trade) => finiteNumber6(trade.fundingFee)
             )
           )
         },
@@ -33867,8 +34033,8 @@ var init_runtimeScorecard = __esm({
         distributionChanges: {
           available: previousDistributions != null,
           baselineWindow: previousArtifact ? {
-            startTime: finiteNumber5(previousArtifact.window.startTime),
-            endTime: finiteNumber5(previousArtifact.window.endTime)
+            startTime: finiteNumber6(previousArtifact.window.startTime),
+            endTime: finiteNumber6(previousArtifact.window.endTime)
           } : null,
           metrics: previousDistributions ? Object.fromEntries(
             Object.entries(currentDistributions).map(([name, current]) => [
@@ -34355,13 +34521,13 @@ async function collectReleaseEvidenceReferences(references) {
     })
   );
 }
-var import_node_crypto16, 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, safeSegment7, compactTimestamp2, verifyFullPeriodChartArtifact, readVerifiedJsonArtifact, verifyResearchDecisionLineage, hasExactRuntimeTarget, deriveStrategyReleaseResearchDecision, canonicalStrategyReleaseJson, strategyReleaseSha256, assertFingerprint, assertLineageFingerprint, releaseReasons, deriveReleaseGates, verifyEvidenceComposition, createStrategyReleaseManifest, createStrategyReleaseEnvelope, verifyStrategyReleaseEnvelope, verifyStrategyEvidenceMarkerEnvelope, releaseMarkers, writeJsonAtomic2, publishStrategyRelease, publishStrategyLiveDiagnosis, finiteString3, finiteNumber6, finiteDirectionPolicy, uniqueStrings, incompleteEvidenceLineage, extractEvidenceLineage, verifyCompletedCoreResearchBundle;
+var import_node_crypto16, import_promises33, import_node_path32, import_types9, import_strategyReleaseEvidence2, SHA256_RE2, LINEAGE_FINGERPRINT_RE, STRATEGY_REVISION_RE, DEPLOYMENT_COMPOSITION_ID_RE, REQUIRED_LONG_WINDOWS, REQUIRED_DIAGNOSTIC_TERMINAL_WINDOWS, MIN_RECENT_DIRECTION_REPAIR_EVENTS, 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 init_strategyRelease = __esm({
   "src/lib/strategyRelease.ts"() {
     "use strict";
     import_node_crypto16 = require("crypto");
     import_promises33 = __toESM(require("fs/promises"));
-    import_node_path31 = __toESM(require("path"));
+    import_node_path32 = __toESM(require("path"));
     import_types9 = require("@tradejs/types");
     import_strategyReleaseEvidence2 = require("@tradejs/infra/strategyReleaseEvidence");
     init_liveDiagnosis();
@@ -34380,7 +34546,7 @@ var init_strategyRelease = __esm({
       const artifact = input.chartArtifact;
       if (!artifact?.path || !SHA256_RE2.test(artifact.sha256)) return false;
       try {
-        const artifactPath = import_node_path31.default.resolve(artifact.path);
+        const artifactPath = import_node_path32.default.resolve(artifact.path);
         if (await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(artifactPath) !== artifact.sha256) {
           return false;
         }
@@ -34395,7 +34561,7 @@ var init_strategyRelease = __esm({
     readVerifiedJsonArtifact = async (artifact) => {
       if (!artifact?.path || !SHA256_RE2.test(artifact.sha256)) return null;
       try {
-        const artifactPath = import_node_path31.default.resolve(artifact.path);
+        const artifactPath = import_node_path32.default.resolve(artifact.path);
         if (await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(artifactPath) !== artifact.sha256) {
           return null;
         }
@@ -35058,7 +35224,7 @@ var init_strategyRelease = __esm({
     };
     writeJsonAtomic2 = async (filePath, value) => {
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-      await import_promises33.default.mkdir(import_node_path31.default.dirname(filePath), { recursive: true });
+      await import_promises33.default.mkdir(import_node_path32.default.dirname(filePath), { recursive: true });
       await import_promises33.default.writeFile(
         temporaryPath,
         `${canonicalStrategyReleaseJson(value)}
@@ -35082,13 +35248,13 @@ var init_strategyRelease = __esm({
           path: entry.path
         }))
       });
-      const releasePath = import_node_path31.default.join(
+      const releasePath = import_node_path32.default.join(
         rootDir,
         "releases",
         safeSegment7(manifest.strategy, "strategy"),
         `${manifest.releaseId}.json`
       );
-      const markerPath = import_node_path31.default.join(
+      const markerPath = import_node_path32.default.join(
         rootDir,
         "markers",
         safeSegment7(manifest.strategy, "strategy"),
@@ -35168,13 +35334,13 @@ var init_strategyRelease = __esm({
         markers,
         sourceArtifacts
       });
-      const diagnosisPath = import_node_path31.default.join(
+      const diagnosisPath = import_node_path32.default.join(
         rootDir,
         "diagnoses",
         safeSegment7(diagnosis.strategy, "strategy"),
         `${diagnosisId}.json`
       );
-      const markerPath = import_node_path31.default.join(
+      const markerPath = import_node_path32.default.join(
         rootDir,
         "markers",
         safeSegment7(diagnosis.strategy, "strategy"),
@@ -35188,7 +35354,7 @@ var init_strategyRelease = __esm({
       return { diagnosisPath, markerPath, envelope, markerEnvelope };
     };
     finiteString3 = (value) => typeof value === "string" && value.trim() ? value.trim() : null;
-    finiteNumber6 = (value) => {
+    finiteNumber7 = (value) => {
       const number = Number(value);
       return Number.isFinite(number) ? number : null;
     };
@@ -35235,7 +35401,7 @@ var init_strategyRelease = __esm({
         const maxLossValues = [
           ...new Set(
             selectedVariants.map(
-              (variant) => finiteNumber6(
+              (variant) => finiteNumber7(
                 nested(nested(variant.variant)?.resolvedConfig)?.MAX_LOSS_VALUE
               )
             ).filter((value) => value != null)
@@ -35285,7 +35451,7 @@ var init_strategyRelease = __esm({
         };
         const maxLossValues = [
           ...new Set(
-            replayLineages.map((entry) => finiteNumber6(entry.maxLossValue)).filter((value) => value != null)
+            replayLineages.map((entry) => finiteNumber7(entry.maxLossValue)).filter((value) => value != null)
           )
         ];
         const dirtyValues = [
@@ -35329,7 +35495,7 @@ var init_strategyRelease = __esm({
         ];
         const maxLossValues = [
           ...new Set(
-            lineages.map((lineage) => finiteNumber6(lineage.maxLossValue)).filter((value) => value != null)
+            lineages.map((lineage) => finiteNumber7(lineage.maxLossValue)).filter((value) => value != null)
           )
         ];
         return {
@@ -35364,9 +35530,9 @@ var init_strategyRelease = __esm({
       const specSha256 = finiteString3(artifact.specSha256);
       assert3(researchId != null, "core result researchId is required");
       assert3(specSha256 != null, "core result specSha256 is required");
-      const researchDir = import_node_path31.default.dirname(resultPath);
-      const manifestPath = import_node_path31.default.join(researchDir, "manifest.json");
-      const specPath = import_node_path31.default.join(researchDir, "spec.json");
+      const researchDir = import_node_path32.default.dirname(resultPath);
+      const manifestPath = import_node_path32.default.join(researchDir, "manifest.json");
+      const specPath = import_node_path32.default.join(researchDir, "spec.json");
       const manifestBytes = await import_promises33.default.readFile(manifestPath).catch(() => null);
       const specBytes = await import_promises33.default.readFile(specPath).catch(() => null);
       assert3(
@@ -35384,7 +35550,7 @@ var init_strategyRelease = __esm({
         artifactHashes ?? {}
       )) {
         assert3(
-          !import_node_path31.default.isAbsolute(relativePath) && !relativePath.split(/[\\/]/).includes(".."),
+          !import_node_path32.default.isAbsolute(relativePath) && !relativePath.split(/[\\/]/).includes(".."),
           `core bundle artifact ${relativePath} escapes its research directory`
         );
         assert3(
@@ -35392,7 +35558,7 @@ var init_strategyRelease = __esm({
           `core bundle artifact ${relativePath} has an invalid checksum`
         );
         const actualSha256 = await (0, import_strategyReleaseEvidence2.strategyEvidenceFileSha256)(
-          import_node_path31.default.join(researchDir, relativePath)
+          import_node_path32.default.join(researchDir, relativePath)
         );
         assert3(
           actualSha256 === expectedSha256,
@@ -35406,86 +35572,86 @@ var init_strategyRelease = __esm({
 // src/scripts/runtimeScorecard.ts
 var runtimeScorecard_exports = {};
 __export(runtimeScorecard_exports, {
-  main: () => main39,
+  main: () => main40,
   runtimeScorecard: () => runtimeScorecard
 });
-var import_promises34, import_node_crypto17, import_node_path32, import_args31, import_chalk48, flags29, projectRoot13, resolveOptionalPath, readJson, assertReportType, sha256File2, loadHistoryArtifacts, runtimeScorecard, main39;
+var import_promises34, import_node_crypto17, import_node_path33, import_args32, import_chalk49, flags30, projectRoot14, resolveOptionalPath, readJson, assertReportType, sha256File2, loadHistoryArtifacts, runtimeScorecard, main40;
 var init_runtimeScorecard2 = __esm({
   "src/scripts/runtimeScorecard.ts"() {
     "use strict";
     import_promises34 = __toESM(require("fs/promises"));
     import_node_crypto17 = require("crypto");
-    import_node_path32 = __toESM(require("path"));
-    import_args31 = __toESM(require("args"));
-    import_chalk48 = __toESM(require("chalk"));
+    import_node_path33 = __toESM(require("path"));
+    import_args32 = __toESM(require("args"));
+    import_chalk49 = __toESM(require("chalk"));
     init_runtimeEvidenceArtifacts();
     init_runtimeFeedbackArtifacts();
     init_runtimeEvidenceSync();
     init_runtimeScorecard();
     init_strategyRelease();
-    import_args31.default.option(["u", "runtimeEvidence"], "Verified runtime evidence JSON");
-    import_args31.default.option(["r", "replayEvidence"], "Replay runtime evidence JSON");
-    import_args31.default.option(["c", "calibration"], "Execution calibration JSON");
-    import_args31.default.option(
+    import_args32.default.option(["u", "runtimeEvidence"], "Verified runtime evidence JSON");
+    import_args32.default.option(["r", "replayEvidence"], "Replay runtime evidence JSON");
+    import_args32.default.option(["c", "calibration"], "Execution calibration JSON");
+    import_args32.default.option(
       ["q", "prospectiveEvidence"],
       "Verified prospective raw-core/gate/regime summary JSON"
     );
-    import_args31.default.option(["s", "strategy"], "Exact strategy to isolate in the scorecard");
-    import_args31.default.option(
+    import_args32.default.option(["s", "strategy"], "Exact strategy to isolate in the scorecard");
+    import_args32.default.option(
       ["H", "historyDir"],
       "Directory containing verified evidence bundles"
     );
-    import_args31.default.option(
+    import_args32.default.option(
       ["E", "evidenceDir"],
       "Local evidence storage root used for processing receipts",
       process.env.RUNTIME_EVIDENCE_LOCAL_DIR || "data/runtime-evidence"
     );
-    import_args31.default.option(
+    import_args32.default.option(
       ["d", "deployment"],
       "Deployment id used for processing receipts",
       process.env.RUNTIME_EVIDENCE_DEPLOYMENT_ID || "production"
     );
-    import_args31.default.option(
+    import_args32.default.option(
       ["M", "markProcessed"],
       "Write a processing receipt on success",
       false
     );
-    import_args31.default.option(
+    import_args32.default.option(
       ["P", "minimumParityRatio"],
       "Minimum acceptable replay parity",
       0.95
     );
-    import_args31.default.option(
+    import_args32.default.option(
       ["S", "maximumSlippageResidualBps"],
       "Maximum acceptable execution residual in bps",
       3
     );
-    import_args31.default.option(
+    import_args32.default.option(
       ["L", "maximumSignalCloseToSubmitMs"],
       "Maximum acceptable average signal-close-to-submit latency in milliseconds",
       3e4
     );
-    import_args31.default.option(
+    import_args32.default.option(
       ["T", "minimumClosedTrades"],
       "Minimum 7d closed trades for expectancy reactions",
       20
     );
-    import_args31.default.option(["X", "minimumExpectancy"], "Minimum acceptable 7d expectancy", 0);
-    import_args31.default.option(["o", "out"], "Output JSON path", "output/runtime-scorecard.json");
-    import_args31.default.option(
+    import_args32.default.option(["X", "minimumExpectancy"], "Minimum acceptable 7d expectancy", 0);
+    import_args32.default.option(["o", "out"], "Output JSON path", "output/runtime-scorecard.json");
+    import_args32.default.option(
       ["m", "releaseManifest"],
       "Verified strategy release envelope JSON"
     );
-    import_args31.default.option(["D", "diagnosisDays"], "Equal-length release drawdown window", 7);
-    import_args31.default.option(
+    import_args32.default.option(["D", "diagnosisDays"], "Equal-length release drawdown window", 7);
+    import_args32.default.option(
       ["z", "strategyReleaseRoot"],
       "Publish advisory diagnosis and immutable chart markers under this root"
     );
-    flags29 = import_args31.default.parse(process.argv);
-    projectRoot13 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    flags30 = import_args32.default.parse(process.argv);
+    projectRoot14 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     resolveOptionalPath = (value) => {
       const raw = String(value ?? "").trim();
-      return raw ? import_node_path32.default.resolve(projectRoot13, raw) : null;
+      return raw ? import_node_path33.default.resolve(projectRoot14, raw) : null;
     };
     readJson = async (filePath) => filePath ? JSON.parse(await import_promises34.default.readFile(filePath, "utf8")) : void 0;
     assertReportType = (artifact, expected, label) => {
@@ -35504,17 +35670,17 @@ var init_runtimeScorecard2 = __esm({
       return bundles.map((bundle) => bundle.artifact);
     };
     runtimeScorecard = async () => {
-      const runtimeEvidencePath = resolveOptionalPath(flags29.runtimeEvidence);
+      const runtimeEvidencePath = resolveOptionalPath(flags30.runtimeEvidence);
       if (!runtimeEvidencePath) {
         throw new Error("Provide --runtimeEvidence for the runtime scorecard.");
       }
-      const replayEvidencePath = resolveOptionalPath(flags29.replayEvidence);
-      const calibrationPath = resolveOptionalPath(flags29.calibration);
+      const replayEvidencePath = resolveOptionalPath(flags30.replayEvidence);
+      const calibrationPath = resolveOptionalPath(flags30.calibration);
       const prospectiveEvidencePath = resolveOptionalPath(
-        flags29.prospectiveEvidence
+        flags30.prospectiveEvidence
       );
-      const historyDir = resolveOptionalPath(flags29.historyDir);
-      const releaseManifestPath = resolveOptionalPath(flags29.releaseManifest);
+      const historyDir = resolveOptionalPath(flags30.historyDir);
+      const releaseManifestPath = resolveOptionalPath(flags30.releaseManifest);
       const [
         runtimeArtifact,
         replayEvidenceArtifact,
@@ -35541,7 +35707,7 @@ var init_runtimeScorecard2 = __esm({
         "prospectiveEvidence"
       );
       const verifiedRelease = releaseManifestPath ? await verifyStrategyReleaseEnvelope(releaseManifestPath) : null;
-      const requestedStrategy = String(flags29.strategy ?? "").trim() || null;
+      const requestedStrategy = String(flags30.strategy ?? "").trim() || null;
       if (verifiedRelease && requestedStrategy && requestedStrategy !== verifiedRelease.manifest.strategy) {
         throw new Error(
           `Requested strategy ${requestedStrategy} does not match release ${verifiedRelease.manifest.strategy}`
@@ -35555,18 +35721,18 @@ var init_runtimeScorecard2 = __esm({
         prospectiveEvidenceArtifact,
         historyRuntimeArtifacts: history,
         thresholds: {
-          minimumParityRatio: Number(flags29.minimumParityRatio),
-          maximumSlippageResidualBps: Number(flags29.maximumSlippageResidualBps),
-          maximumSignalCloseToSubmitMs: Number(flags29.maximumSignalCloseToSubmitMs),
-          minimumClosedTrades: Number(flags29.minimumClosedTrades),
-          minimumExpectancy: Number(flags29.minimumExpectancy)
+          minimumParityRatio: Number(flags30.minimumParityRatio),
+          maximumSlippageResidualBps: Number(flags30.maximumSlippageResidualBps),
+          maximumSignalCloseToSubmitMs: Number(flags30.maximumSignalCloseToSubmitMs),
+          minimumClosedTrades: Number(flags30.minimumClosedTrades),
+          minimumExpectancy: Number(flags30.minimumExpectancy)
         },
         strategy: scorecardStrategy,
         llmComparatorPolicy: verifiedRelease?.manifest.prospective.llmComparatorPolicy ?? "ai_approved_only"
       });
-      const outPath = import_node_path32.default.resolve(projectRoot13, String(flags29.out));
+      const outPath = import_node_path33.default.resolve(projectRoot14, String(flags30.out));
       const markdownPath = outPath.replace(/\.json$/i, "") + ".md";
-      await import_promises34.default.mkdir(import_node_path32.default.dirname(outPath), { recursive: true });
+      await import_promises34.default.mkdir(import_node_path33.default.dirname(outPath), { recursive: true });
       await Promise.all([
         import_promises34.default.writeFile(outPath, `${JSON.stringify(scorecard, null, 2)}
 `, "utf8"),
@@ -35579,10 +35745,10 @@ var init_runtimeScorecard2 = __esm({
       const diagnosis = verifiedRelease ? buildStrategyLiveDiagnosisFromScorecard({
         manifest: verifiedRelease.manifest,
         scorecard,
-        days: Number(flags29.diagnosisDays)
+        days: Number(flags30.diagnosisDays)
       }) : null;
       const diagnosisPath = diagnosis ? outPath.replace(/\.json$/i, "") + ".diagnosis.json" : null;
-      const strategyReleaseRoot = resolveOptionalPath(flags29.strategyReleaseRoot);
+      const strategyReleaseRoot = resolveOptionalPath(flags30.strategyReleaseRoot);
       if (diagnosis && diagnosisPath) {
         await import_promises34.default.writeFile(
           diagnosisPath,
@@ -35605,7 +35771,7 @@ var init_runtimeScorecard2 = __esm({
             composition: verifiedRelease?.manifest.composition,
             sourceArtifacts: await Promise.all(
               sourcePaths.map(async (sourcePath) => ({
-                artifactId: import_node_path32.default.basename(sourcePath),
+                artifactId: import_node_path33.default.basename(sourcePath),
                 path: sourcePath,
                 sha256: await sha256File2(sourcePath)
               }))
@@ -35614,13 +35780,13 @@ var init_runtimeScorecard2 = __esm({
         }
       }
       let receiptPath2 = null;
-      if (flags29.markProcessed) {
+      if (flags30.markProcessed) {
         const runtimeEvidenceBundle = await verifyRuntimeEvidenceBundle(
-          import_node_path32.default.dirname(runtimeEvidencePath)
+          import_node_path33.default.dirname(runtimeEvidencePath)
         );
         const feedbackSource = replayEvidencePath ? await verifyRuntimeFeedbackReplaySource({
-          bundleDir: import_node_path32.default.dirname(replayEvidencePath),
-          runtimeEvidenceBundleDir: import_node_path32.default.dirname(runtimeEvidencePath)
+          bundleDir: import_node_path33.default.dirname(replayEvidencePath),
+          runtimeEvidenceBundleDir: import_node_path33.default.dirname(runtimeEvidencePath)
         }).catch((error) => {
           if (runtimeEvidenceBundle.artifact.producer) throw error;
           return null;
@@ -35631,9 +35797,9 @@ var init_runtimeScorecard2 = __esm({
           );
         }
         receiptPath2 = await markRuntimeEvidenceBundleProcessed({
-          evidenceRoot: import_node_path32.default.resolve(projectRoot13, String(flags29.evidenceDir)),
-          deploymentId: String(flags29.deployment),
-          bundleDir: import_node_path32.default.dirname(runtimeEvidencePath),
+          evidenceRoot: import_node_path33.default.resolve(projectRoot14, String(flags30.evidenceDir)),
+          deploymentId: String(flags30.deployment),
+          bundleDir: import_node_path33.default.dirname(runtimeEvidencePath),
           scorecardPath: outPath,
           runtimeFeedback: feedbackSource ? {
             artifactId: feedbackSource.feedback.manifest.artifactId,
@@ -35641,8 +35807,8 @@ var init_runtimeScorecard2 = __esm({
           } : null
         });
       }
-      console.log(import_chalk48.default.green(`Wrote ${outPath}`));
-      console.log(import_chalk48.default.green(`Wrote ${markdownPath}`));
+      console.log(import_chalk49.default.green(`Wrote ${outPath}`));
+      console.log(import_chalk49.default.green(`Wrote ${markdownPath}`));
       console.log(
         JSON.stringify(
           {
@@ -35661,7 +35827,7 @@ var init_runtimeScorecard2 = __esm({
         )
       );
     };
-    main39 = runtimeScorecard;
+    main40 = runtimeScorecard;
   }
 });
 
@@ -35669,10 +35835,10 @@ var init_runtimeScorecard2 = __esm({
 var runtimeControl_exports = {};
 __export(runtimeControl_exports, {
   RUNTIME_CONTROL_ACTIONS: () => RUNTIME_CONTROL_ACTIONS,
-  main: () => main40,
+  main: () => main41,
   runtimeControl: () => runtimeControl
 });
-var import_config9, import_runtimeControls, import_runtimeStrategies6, argv, RUNTIME_CONTROL_ACTIONS, action, option, required2, projectRoot14, userName2, verify, inspect, updateControlState, runtimeControl, main40;
+var import_config9, import_runtimeControls, import_runtimeStrategies6, argv, RUNTIME_CONTROL_ACTIONS, action, option, required2, projectRoot15, userName2, verify, inspect, updateControlState, runtimeControl, main41;
 var init_runtimeControl = __esm({
   "src/scripts/runtimeControl.ts"() {
     "use strict";
@@ -35696,10 +35862,10 @@ var init_runtimeControl = __esm({
       if (!value) throw new Error(`--${name} is required`);
       return value;
     };
-    projectRoot14 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    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: projectRoot14 });
+      const deployments = await (0, import_runtimeStrategies6.listRuntimeDeployments)({ userName: userName2, projectRoot: projectRoot15 });
       const requestedDeployment = option("deployment");
       const selected = requestedDeployment ? deployments.filter((deployment) => deployment.id === requestedDeployment) : deployments;
       if (requestedDeployment && !selected.length) {
@@ -35710,7 +35876,7 @@ var init_runtimeControl = __esm({
         try {
           const strategies = await (0, import_runtimeStrategies6.loadResolvedRuntimeStrategies)({
             userName: userName2,
-            projectRoot: projectRoot14,
+            projectRoot: projectRoot15,
             deploymentId: deployment.id
           });
           results2.push({
@@ -35743,7 +35909,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: projectRoot14 })).filter(
+      const deployments = (await (0, import_runtimeStrategies6.listRuntimeDeployments)({ userName: userName2, projectRoot: projectRoot15 })).filter(
         (deployment) => !requestedDeployment || deployment.id === requestedDeployment
       ).map((deployment) => ({
         ...deployment,
@@ -35758,7 +35924,7 @@ var init_runtimeControl = __esm({
       const strategyName = required2("strategy");
       const deployment = await (0, import_runtimeStrategies6.getRuntimeDeployment)({
         userName: userName2,
-        projectRoot: projectRoot14,
+        projectRoot: projectRoot15,
         deploymentId
       });
       if (!deployment) {
@@ -35788,7 +35954,7 @@ var init_runtimeControl = __esm({
       }
       const updated = await (0, import_runtimeStrategies6.getRuntimeDeployment)({
         userName: userName2,
-        projectRoot: projectRoot14,
+        projectRoot: projectRoot15,
         deploymentId
       });
       const updatedReference = updated?.strategies.find(
@@ -35820,25 +35986,25 @@ var init_runtimeControl = __esm({
         `Usage: tradejs runtime-control ${RUNTIME_CONTROL_ACTIONS.join("|")}`
       );
     };
-    main40 = runtimeControl;
+    main41 = runtimeControl;
   }
 });
 
 // src/scripts/strategyRelease.ts
 var strategyRelease_exports = {};
 __export(strategyRelease_exports, {
-  main: () => main41,
+  main: () => main42,
   runStrategyReleaseCommand: () => runStrategyReleaseCommand
 });
-var import_promises35, import_node_fs5, import_node_readline2, import_node_path33, import_chalk49, valueAfter2, required3, writeJsonAtomic3, runStrategyReleaseCommand, printUsage2, main41;
+var import_promises35, import_node_fs5, import_node_readline2, import_node_path34, import_chalk50, valueAfter2, required3, writeJsonAtomic3, runStrategyReleaseCommand, printUsage2, main42;
 var init_strategyRelease2 = __esm({
   "src/scripts/strategyRelease.ts"() {
     "use strict";
     import_promises35 = __toESM(require("fs/promises"));
     import_node_fs5 = require("fs");
     import_node_readline2 = require("readline");
-    import_node_path33 = __toESM(require("path"));
-    import_chalk49 = __toESM(require("chalk"));
+    import_node_path34 = __toESM(require("path"));
+    import_chalk50 = __toESM(require("chalk"));
     init_strategyRelease();
     valueAfter2 = (argv2, name) => {
       const index = argv2.indexOf(name);
@@ -35850,7 +36016,7 @@ var init_strategyRelease2 = __esm({
     };
     writeJsonAtomic3 = async (filePath, value) => {
       const temporaryPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-      await import_promises35.default.mkdir(import_node_path33.default.dirname(filePath), { recursive: true });
+      await import_promises35.default.mkdir(import_node_path34.default.dirname(filePath), { recursive: true });
       await import_promises35.default.writeFile(
         temporaryPath,
         `${JSON.stringify(value, null, 2)}
@@ -35860,7 +36026,7 @@ var init_strategyRelease2 = __esm({
       await import_promises35.default.rename(temporaryPath, filePath);
     };
     runStrategyReleaseCommand = async (options) => {
-      const inputPath = import_node_path33.default.resolve(options.inputPath);
+      const inputPath = import_node_path34.default.resolve(options.inputPath);
       if (options.command === "verify") {
         const envelope = await verifyStrategyReleaseEnvelope(inputPath);
         return {
@@ -35898,7 +36064,7 @@ var init_strategyRelease2 = __esm({
           endTime,
           days: options.days?.length ? options.days : [7, 30, 90]
         });
-        const outputPath = import_node_path33.default.resolve(
+        const outputPath = import_node_path34.default.resolve(
           options.outputPath ?? "output/strategy-monitoring-profile.json"
         );
         await writeJsonAtomic3(outputPath, profile);
@@ -35913,12 +36079,12 @@ var init_strategyRelease2 = __esm({
       if (options.command === "decide") {
         const decision = await deriveStrategyReleaseResearchDecision(input);
         if (options.outputPath) {
-          await writeJsonAtomic3(import_node_path33.default.resolve(options.outputPath), decision);
+          await writeJsonAtomic3(import_node_path34.default.resolve(options.outputPath), decision);
         }
         return {
           kind: "decided",
           ...decision,
-          outputPath: options.outputPath ? import_node_path33.default.resolve(options.outputPath) : null
+          outputPath: options.outputPath ? import_node_path34.default.resolve(options.outputPath) : null
         };
       }
       if (options.command === "retention") {
@@ -35937,12 +36103,12 @@ var init_strategyRelease2 = __esm({
       }
       if (options.command === "diagnose") {
         const diagnosis = buildStrategyLiveDiagnosis(input);
-        const outputPath = import_node_path33.default.resolve(
+        const outputPath = import_node_path34.default.resolve(
           options.outputPath ?? "output/strategy-live-diagnosis.json"
         );
         await writeJsonAtomic3(outputPath, diagnosis);
         const published2 = options.rootDir ? await publishStrategyLiveDiagnosis({
-          rootDir: import_node_path33.default.resolve(options.rootDir),
+          rootDir: import_node_path34.default.resolve(options.rootDir),
           diagnosis,
           sourceArtifacts: input.sourceArtifacts ?? []
         }) : null;
@@ -35959,7 +36125,7 @@ var init_strategyRelease2 = __esm({
         evidence: await collectReleaseEvidenceReferences(input.evidence ?? [])
       });
       const published = await publishStrategyRelease({
-        rootDir: import_node_path33.default.resolve(options.rootDir ?? "data/strategy-release"),
+        rootDir: import_node_path34.default.resolve(options.rootDir ?? "data/strategy-release"),
         manifest
       });
       return {
@@ -35977,7 +36143,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]`);
-    main41 = async () => {
+    main42 = async () => {
       const argv2 = process.argv.slice(2);
       const command = argv2[0];
       if (!command || ![
@@ -36003,7 +36169,7 @@ var init_strategyRelease2 = __esm({
         endTime: Number(valueAfter2(argv2, "--endTime")),
         days: valueAfter2(argv2, "--days")?.split(",").map((entry) => Number(entry.trim()))
       });
-      console.log(import_chalk49.default.green(JSON.stringify(result, null, 2)));
+      console.log(import_chalk50.default.green(JSON.stringify(result, null, 2)));
     };
   }
 });
@@ -36016,10 +36182,10 @@ __export(serverHealth_exports, {
   buildServerHealthDiagnostics: () => buildServerHealthDiagnostics,
   collectServerHealthSnapshot: () => collectServerHealthSnapshot,
   evaluateServerHealth: () => evaluateServerHealth,
-  main: () => main42,
+  main: () => main43,
   resolveServerHealthThresholds: () => resolveServerHealthThresholds
 });
-var import_config10, import_node_child_process9, import_node_os3, import_node_fs6, import_args32, import_redis19, DEFAULT_STATE, DEFAULT_THRESHOLDS, escapeHtml5, formatPctValue, formatLoadPerCore, formatGiB, formatDuration2, readDiskUsage, parseMeminfoBytes, readMemorySnapshot, runDiagnosticCommand, runDiagnosticCommands, collectServerHealthSnapshot, buildHumanSummaryLines, evaluateServerHealth, shouldRecover, buildAlertMessage, buildRecoveryMessage, buildServerHealthDiagnostics, getStateKey, toFiniteNumber3, resolveServerHealthThresholds, main42;
+var import_config10, import_node_child_process9, import_node_os3, import_node_fs6, import_args33, 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, main43;
 var init_serverHealth = __esm({
   "src/scripts/serverHealth.ts"() {
     "use strict";
@@ -36027,7 +36193,7 @@ var init_serverHealth = __esm({
     import_node_child_process9 = require("child_process");
     import_node_os3 = __toESM(require("os"));
     import_node_fs6 = require("fs");
-    import_args32 = __toESM(require("args"));
+    import_args33 = __toESM(require("args"));
     import_redis19 = require("@tradejs/infra/redis");
     init_telegramReports();
     DEFAULT_STATE = {
@@ -36044,7 +36210,7 @@ var init_serverHealth = __esm({
       diskWarnPct: 95,
       diskRecoverPct: 92
     };
-    escapeHtml5 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    escapeHtml6 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
     formatPctValue = (value) => `${value.toFixed(1)}%`;
     formatLoadPerCore = (value) => value.toFixed(2);
     formatGiB = (bytes) => `${(bytes / 1024 ** 3).toFixed(1)} GB`;
@@ -36061,21 +36227,21 @@ var init_serverHealth = __esm({
       }
       return `${minutes}m`;
     };
-    readDiskUsage = (path44) => {
+    readDiskUsage = (path45) => {
       try {
-        const stats = (0, import_node_fs6.statfsSync)(path44);
+        const stats = (0, import_node_fs6.statfsSync)(path45);
         const totalBlocks = Number(stats.blocks ?? 0);
         const availableBlocks = Number(stats.bavail ?? 0);
         if (totalBlocks <= 0) {
-          return { path: path44, usedPct: null };
+          return { path: path45, usedPct: null };
         }
         const usedPct = (totalBlocks - Math.max(0, availableBlocks)) / totalBlocks * 100;
         return {
-          path: path44,
+          path: path45,
           usedPct: Number.isFinite(usedPct) ? usedPct : null
         };
       } catch {
-        return { path: path44, usedPct: null };
+        return { path: path45, usedPct: null };
       }
     };
     parseMeminfoBytes = (value) => {
@@ -36139,8 +36305,8 @@ var init_serverHealth = __esm({
         };
       }
     };
-    runDiagnosticCommand = (command, args37) => {
-      const output = (0, import_node_child_process9.execFileSync)(command, args37, {
+    runDiagnosticCommand = (command, args38) => {
+      const output = (0, import_node_child_process9.execFileSync)(command, args38, {
         encoding: "utf8",
         timeout: 5e3,
         maxBuffer: 1024 * 1024,
@@ -36187,11 +36353,11 @@ var init_serverHealth = __esm({
         snapshot.memory.totalBytes - snapshot.memory.availableBytes
       );
       return [
-        `\u2022 vCPU: <b>${escapeHtml5(formatPctValue(Math.min(100, snapshot.loadPerCpu1 * 100)))}</b>`,
-        `\u2022 RAM: <b>${escapeHtml5(formatPctValue(snapshot.memoryUsedPct))}</b> (${escapeHtml5(
+        `\u2022 vCPU: <b>${escapeHtml6(formatPctValue(Math.min(100, snapshot.loadPerCpu1 * 100)))}</b>`,
+        `\u2022 RAM: <b>${escapeHtml6(formatPctValue(snapshot.memoryUsedPct))}</b> (${escapeHtml6(
           `${formatGiB(usedMem)} / ${formatGiB(snapshot.memory.totalBytes)}`
         )})`,
-        `\u2022 Storage: <b>${escapeHtml5(
+        `\u2022 Storage: <b>${escapeHtml6(
           snapshot.disk.usedPct == null ? "n/a" : formatPctValue(snapshot.disk.usedPct)
         )}</b>`
       ];
@@ -36235,22 +36401,22 @@ var init_serverHealth = __esm({
       return [
         title,
         "",
-        `Host: <b>${escapeHtml5(snapshot.hostname)}</b>`,
-        `Time: <b>${escapeHtml5(new Date(snapshot.timestamp).toISOString())}</b>`,
-        `Uptime: <b>${escapeHtml5(formatDuration2(snapshot.uptimeSec))}</b>`,
+        `Host: <b>${escapeHtml6(snapshot.hostname)}</b>`,
+        `Time: <b>${escapeHtml6(new Date(snapshot.timestamp).toISOString())}</b>`,
+        `Uptime: <b>${escapeHtml6(formatDuration2(snapshot.uptimeSec))}</b>`,
         "",
         "Summary:",
         ...buildHumanSummaryLines(snapshot),
         "",
         "Issues:",
-        ...issues.map((issue) => `\u2022 ${escapeHtml5(issue.summary)}`),
+        ...issues.map((issue) => `\u2022 ${escapeHtml6(issue.summary)}`),
         "",
         "Pressure:",
         `\u2022 Load avg: <b>${snapshot.load1.toFixed(2)} / ${snapshot.load5.toFixed(2)} / ${snapshot.load15.toFixed(2)}</b>`,
         `\u2022 Load per core: <b>${formatLoadPerCore(
           snapshot.loadPerCpu1
         )}</b> (1m), <b>${formatLoadPerCore(snapshot.loadPerCpu5)}</b> (5m)`,
-        prevState.lastAlertAt ? `\u2022 Previous alert: <b>${escapeHtml5(new Date(prevState.lastAlertAt).toISOString())}</b>` : "\u2022 Previous alert: <b>none</b>"
+        prevState.lastAlertAt ? `\u2022 Previous alert: <b>${escapeHtml6(new Date(prevState.lastAlertAt).toISOString())}</b>` : "\u2022 Previous alert: <b>none</b>"
       ].join("\n");
     };
     buildRecoveryMessage = ({
@@ -36259,9 +36425,9 @@ var init_serverHealth = __esm({
     }) => [
       "\u2705 <b>TradeJS server health recovered</b>",
       "",
-      `Host: <b>${escapeHtml5(snapshot.hostname)}</b>`,
-      `Time: <b>${escapeHtml5(new Date(snapshot.timestamp).toISOString())}</b>`,
-      `Uptime: <b>${escapeHtml5(formatDuration2(snapshot.uptimeSec))}</b>`,
+      `Host: <b>${escapeHtml6(snapshot.hostname)}</b>`,
+      `Time: <b>${escapeHtml6(new Date(snapshot.timestamp).toISOString())}</b>`,
+      `Uptime: <b>${escapeHtml6(formatDuration2(snapshot.uptimeSec))}</b>`,
       "",
       "Summary:",
       ...buildHumanSummaryLines(snapshot),
@@ -36271,7 +36437,7 @@ var init_serverHealth = __esm({
       `\u2022 Load per core: <b>${formatLoadPerCore(
         snapshot.loadPerCpu1
       )}</b> (1m), <b>${formatLoadPerCore(snapshot.loadPerCpu5)}</b> (5m)`,
-      prevState.lastAlertAt ? `\u2022 Alert started: <b>${escapeHtml5(new Date(prevState.lastAlertAt).toISOString())}</b>` : "\u2022 Alert started: <b>unknown</b>"
+      prevState.lastAlertAt ? `\u2022 Alert started: <b>${escapeHtml6(new Date(prevState.lastAlertAt).toISOString())}</b>` : "\u2022 Alert started: <b>unknown</b>"
     ].join("\n");
     buildServerHealthDiagnostics = ({
       snapshot,
@@ -36390,57 +36556,57 @@ var init_serverHealth = __esm({
         diskRecoverPct: diskRecoverPct != null && diskRecoverPct > 0 ? diskRecoverPct : DEFAULT_THRESHOLDS.diskRecoverPct
       };
     };
-    import_args32.default.option(["u", "user"], "Use user config", "root");
-    import_args32.default.option(["P", "printOnly"], "Print report instead of Telegram", false);
-    import_args32.default.option(
+    import_args33.default.option(["u", "user"], "Use user config", "root");
+    import_args33.default.option(["P", "printOnly"], "Print report instead of Telegram", false);
+    import_args33.default.option(
       ["d", "diskPath"],
       "Filesystem path to inspect for disk pressure",
       "/"
     );
-    import_args32.default.option(
+    import_args33.default.option(
       ["c", "cooldownSec"],
       "Minimum seconds between repeated unhealthy reminders",
       900
     );
-    import_args32.default.option(
+    import_args33.default.option(
       ["l", "loadPerCpuWarn"],
       "Alert when 1m load per CPU reaches this value",
       String(DEFAULT_THRESHOLDS.loadPerCpuWarn)
     );
-    import_args32.default.option(
+    import_args33.default.option(
       ["L", "loadPerCpuRecover"],
       "Recovery threshold for 1m load per CPU",
       String(DEFAULT_THRESHOLDS.loadPerCpuRecover)
     );
-    import_args32.default.option(
+    import_args33.default.option(
       ["m", "memoryWarnPct"],
       "Alert when memory used percent reaches this value",
       String(DEFAULT_THRESHOLDS.memoryWarnPct)
     );
-    import_args32.default.option(
+    import_args33.default.option(
       ["M", "memoryRecoverPct"],
       "Recovery threshold for memory used percent",
       String(DEFAULT_THRESHOLDS.memoryRecoverPct)
     );
-    import_args32.default.option(
+    import_args33.default.option(
       ["D", "diskWarnPct"],
       "Alert when disk used percent reaches this value",
       String(DEFAULT_THRESHOLDS.diskWarnPct)
     );
-    import_args32.default.option(
+    import_args33.default.option(
       ["R", "diskRecoverPct"],
       "Recovery threshold for disk used percent",
       String(DEFAULT_THRESHOLDS.diskRecoverPct)
     );
-    main42 = async () => {
-      const flags34 = import_args32.default.parse(process.argv);
-      const thresholds = resolveServerHealthThresholds(flags34);
-      const diskPath = String(flags34.diskPath || "/");
+    main43 = async () => {
+      const flags35 = import_args33.default.parse(process.argv);
+      const thresholds = resolveServerHealthThresholds(flags35);
+      const diskPath = String(flags35.diskPath || "/");
       const snapshot = collectServerHealthSnapshot(diskPath);
-      const stateKey = getStateKey(String(flags34.user), snapshot.hostname);
+      const stateKey = getStateKey(String(flags35.user), snapshot.hostname);
       const prevState = await (0, import_redis19.getData)(stateKey, DEFAULT_STATE) ?? DEFAULT_STATE;
       const evaluation = evaluateServerHealth(snapshot, thresholds);
-      const cooldownMs = Math.max(60, Number(flags34.cooldownSec)) * 1e3;
+      const cooldownMs = Math.max(60, Number(flags35.cooldownSec)) * 1e3;
       const now2 = snapshot.timestamp;
       if (!evaluation.isHealthy) {
         const reminder = prevState.status === "alerting" && typeof prevState.lastAlertAt === "number" && now2 - prevState.lastAlertAt < cooldownMs ? false : prevState.status === "alerting";
@@ -36458,7 +36624,7 @@ var init_serverHealth = __esm({
             prevState,
             reminder
           });
-          if (flags34.printOnly) {
+          if (flags35.printOnly) {
             console.log(message);
             console.log("");
             console.log(
@@ -36468,7 +36634,7 @@ var init_serverHealth = __esm({
               })
             );
           } else {
-            await sendTelegramReport(message, { userName: flags34.user });
+            await sendTelegramReport(message, { userName: flags35.user });
           }
         }
         return;
@@ -36483,10 +36649,10 @@ var init_serverHealth = __esm({
       await (0, import_redis19.setData)(stateKey, nextState, { expire: 0 });
       if (recovered) {
         const message = buildRecoveryMessage({ snapshot, prevState });
-        if (flags34.printOnly) {
+        if (flags35.printOnly) {
           console.log(message);
         } else {
-          await sendTelegramReport(message, { userName: flags34.user });
+          await sendTelegramReport(message, { userName: flags35.user });
         }
       }
     };
@@ -37533,11 +37699,11 @@ var init_reportingJson = __esm({
 });
 
 // src/lib/runtimeParity/reportingTerminal.ts
-var import_chalk50, import_time12, DETAIL_LIMIT, buildRuntimeParityTerminalReport, writeRuntimeParityTerminalReport, printRuntimeDuplicateDetails, printClassifiedBacktestOnlyDetails, printClassifiedRuntimeOnlyDetails;
+var import_chalk51, import_time12, DETAIL_LIMIT, buildRuntimeParityTerminalReport, writeRuntimeParityTerminalReport, printRuntimeDuplicateDetails, printClassifiedBacktestOnlyDetails, printClassifiedRuntimeOnlyDetails;
 var init_reportingTerminal = __esm({
   "src/lib/runtimeParity/reportingTerminal.ts"() {
     "use strict";
-    import_chalk50 = __toESM(require("chalk"));
+    import_chalk51 = __toESM(require("chalk"));
     import_time12 = require("@tradejs/core/time");
     init_classification();
     init_reportingShared();
@@ -37546,7 +37712,7 @@ var init_reportingTerminal = __esm({
       const mismatchRows = buildMismatchSummaryRows(context);
       const strategyIssueRows = buildStrategyIssueRows(context.strategyRows);
       const lines = [
-        import_chalk50.default.cyan("TradeJS runtime parity"),
+        import_chalk51.default.cyan("TradeJS runtime parity"),
         `Window: ${(0, import_time12.formatUnix)(context.window.start)} -> ${(0, import_time12.formatUnix)(context.window.end)} (${context.window.source})`,
         `Connector: ${context.connectorName}`,
         `Replay env: ${context.replayEnv}${context.runtimeGatesEnabled ? " (runtime AI/ML gates enabled)" : " (core/backtest gates only)"}`,
@@ -37575,7 +37741,7 @@ var init_reportingTerminal = __esm({
         lines.push(`Runtime evaluations: ${context.runtimeSignalEvaluationsCount}`);
       }
       if (mismatchRows.length) {
-        lines.push("", import_chalk50.default.yellow("Signal mismatches"));
+        lines.push("", import_chalk51.default.yellow("Signal mismatches"));
         for (const item of mismatchRows.slice(0, context.detailLimit)) {
           lines.push(`- ${item.line}`);
         }
@@ -37585,14 +37751,14 @@ var init_reportingTerminal = __esm({
       }
       lines.push("");
       if (strategyIssueRows.length) {
-        lines.push(import_chalk50.default.cyan("Strategy issues"), ...strategyIssueRows);
+        lines.push(import_chalk51.default.cyan("Strategy issues"), ...strategyIssueRows);
       } else if (context.strategyRows.length) {
         lines.push(
           `Strategies: clean ${context.strategyRows.length}/${context.strategyRows.length}`
         );
       }
       if (context.runtimeGateWarningCounts.size && !context.runtimeGatesRequested) {
-        lines.push("", import_chalk50.default.yellow("Warnings"));
+        lines.push("", import_chalk51.default.yellow("Warnings"));
         for (const [strategy, count] of [
           ...context.runtimeGateWarningCounts.entries()
         ].sort(([left], [right]) => left.localeCompare(right))) {
@@ -37602,7 +37768,7 @@ var init_reportingTerminal = __esm({
         }
       }
       if (context.replayErrors.length) {
-        lines.push("", import_chalk50.default.red("Replay errors"));
+        lines.push("", import_chalk51.default.red("Replay errors"));
         for (const error of context.replayErrors.slice(0, context.detailLimit)) {
           lines.push(`- ${error.strategy} ${error.symbol}: ${error.message}`);
         }
@@ -37620,7 +37786,7 @@ var init_reportingTerminal = __esm({
     printRuntimeDuplicateDetails = (groups) => {
       if (!groups.length) return;
       console.log("");
-      console.log(import_chalk50.default.yellow("Runtime duplicates"));
+      console.log(import_chalk51.default.yellow("Runtime duplicates"));
       for (const group of groups.slice(0, DETAIL_LIMIT)) {
         const ids = group.entries.map((entry) => entry.orderId ?? entry.id);
         console.log(
@@ -37634,7 +37800,7 @@ var init_reportingTerminal = __esm({
     printClassifiedBacktestOnlyDetails = (classifiedEntries) => {
       if (!classifiedEntries.length) return;
       console.log("");
-      console.log(import_chalk50.default.yellow("Backtest only"));
+      console.log(import_chalk51.default.yellow("Backtest only"));
       for (const item of classifiedEntries.slice(0, DETAIL_LIMIT)) {
         const evidenceSuffix = item.signal ? ` signalId=${item.signal.signalId} signalDrift=${formatMinutes2(item.signalTimestampDiffMs ?? null)}` : item.evaluation ? ` evaluationId=${item.evaluation.evaluationId} evaluationDrift=${formatMinutes2(item.evaluationTimestampDiffMs ?? null)}` : "";
         const price = item.entry.price == null ? "n/a" : item.entry.price.toFixed(6);
@@ -37649,7 +37815,7 @@ var init_reportingTerminal = __esm({
     printClassifiedRuntimeOnlyDetails = (classifiedEntries) => {
       if (!classifiedEntries.length) return;
       console.log("");
-      console.log(import_chalk50.default.yellow("Runtime only"));
+      console.log(import_chalk51.default.yellow("Runtime only"));
       for (const item of classifiedEntries.slice(0, DETAIL_LIMIT)) {
         const evidenceSuffix = item.nearestBacktestEntry ? ` nearestBacktestId=${item.nearestBacktestEntry.id} backtestDrift=${formatMinutes2(item.nearestBacktestEntryTimestampDiffMs ?? null)}` : item.evaluation ? ` replayEvaluationId=${item.evaluation.evaluationId} replayDrift=${formatMinutes2(item.evaluationTimestampDiffMs ?? null)} status=${item.evaluation.status}` : "";
         const price = item.entry.price == null ? "n/a" : item.entry.price.toFixed(6);
@@ -37665,7 +37831,7 @@ var init_reportingTerminal = __esm({
 });
 
 // src/lib/runtimeParity/reportingTelegram.ts
-var TELEGRAM_DETAIL_LIMIT, SUMMARY_TIMEZONE, SUMMARY_TIMEZONE_LABEL, escapeHtml6, formatMskDateTime2, buildRuntimeParityMessage, buildRuntimeParityNoTargetsMessage;
+var TELEGRAM_DETAIL_LIMIT, SUMMARY_TIMEZONE, SUMMARY_TIMEZONE_LABEL, escapeHtml7, formatMskDateTime3, buildRuntimeParityMessage, buildRuntimeParityNoTargetsMessage;
 var init_reportingTelegram = __esm({
   "src/lib/runtimeParity/reportingTelegram.ts"() {
     "use strict";
@@ -37674,8 +37840,8 @@ var init_reportingTelegram = __esm({
     TELEGRAM_DETAIL_LIMIT = 5;
     SUMMARY_TIMEZONE = "Europe/Moscow";
     SUMMARY_TIMEZONE_LABEL = "MSK";
-    escapeHtml6 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-    formatMskDateTime2 = (timestamp) => new Intl.DateTimeFormat("ru-RU", {
+    escapeHtml7 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    formatMskDateTime3 = (timestamp) => new Intl.DateTimeFormat("ru-RU", {
       timeZone: SUMMARY_TIMEZONE,
       year: "numeric",
       month: "2-digit",
@@ -37694,11 +37860,11 @@ var init_reportingTelegram = __esm({
       lines.push("");
       lines.push("\u{1F552} <b>Window</b>");
       lines.push(
-        `<b>${escapeHtml6(formatMskDateTime2(context.window.start))} - ${escapeHtml6(formatMskDateTime2(context.window.end))} ${SUMMARY_TIMEZONE_LABEL}</b>`
+        `<b>${escapeHtml7(formatMskDateTime3(context.window.start))} - ${escapeHtml7(formatMskDateTime3(context.window.end))} ${SUMMARY_TIMEZONE_LABEL}</b>`
       );
       lines.push("");
-      lines.push(`\u{1F50C} Connector: <b>${escapeHtml6(context.connectorName)}</b>`);
-      lines.push(`\u{1F9EC} Replay env: <b>${escapeHtml6(context.replayEnv)}</b>`);
+      lines.push(`\u{1F50C} Connector: <b>${escapeHtml7(context.connectorName)}</b>`);
+      lines.push(`\u{1F9EC} Replay env: <b>${escapeHtml7(context.replayEnv)}</b>`);
       lines.push(
         `\u{1F3AF} Tolerance: <b>${context.toleranceBars} bar(s) / ${(context.toleranceMs / 6e4).toFixed(0)}m</b>`
       );
@@ -37708,28 +37874,28 @@ var init_reportingTelegram = __esm({
         `\u2022 Targets: <b>${context.replayTargetsCount}</b> / compared <b>${context.comparedTargetsCount}</b> / errors <b>${context.replayErrors.length}</b>`
       );
       lines.push(
-        `\u2022 Sources: <b>${escapeHtml6(formatSourceCountsSummary(context.sourceCounts))}</b>`
+        `\u2022 Sources: <b>${escapeHtml7(formatSourceCountsSummary(context.sourceCounts))}</b>`
       );
       lines.push("");
       lines.push("\u{1F4C8} <b>Entries</b>");
       lines.push(
-        `\u2022 Runtime: <b>${escapeHtml6(formatRuntimeEntriesSummary(context))}</b>`
+        `\u2022 Runtime: <b>${escapeHtml7(formatRuntimeEntriesSummary(context))}</b>`
       );
       lines.push(`\u2022 Backtest: <b>${context.backtestEntriesCount}</b>`);
       lines.push(
         `\u2022 Runtime only: <b>${context.runtimeOnlyCount}</b> / Backtest only: <b>${context.backtestOnlyCount}</b>`
       );
       lines.push(
-        `\u2022 Matched deltas: price avg/max=<b>${escapeHtml6(formatPercent5(context.matchedSummary.avgPriceDeltaPct))} / ${escapeHtml6(formatPercent5(context.matchedSummary.maxPriceDeltaPct))}</b>, time avg/max=<b>${escapeHtml6(formatMinutes2(context.matchedSummary.avgTimestampDiffMs))} / ${escapeHtml6(formatMinutes2(context.matchedSummary.maxTimestampDiffMs))}</b>`
+        `\u2022 Matched deltas: price avg/max=<b>${escapeHtml7(formatPercent5(context.matchedSummary.avgPriceDeltaPct))} / ${escapeHtml7(formatPercent5(context.matchedSummary.maxPriceDeltaPct))}</b>, time avg/max=<b>${escapeHtml7(formatMinutes2(context.matchedSummary.avgTimestampDiffMs))} / ${escapeHtml7(formatMinutes2(context.matchedSummary.maxTimestampDiffMs))}</b>`
       );
       if (context.classifiedRuntimeOnly.length) {
         lines.push(
-          `\u2022 Runtime-only classes: <code>${escapeHtml6(summarizeRuntimeOnlyClassifications(context.classifiedRuntimeOnly))}</code>`
+          `\u2022 Runtime-only classes: <code>${escapeHtml7(summarizeRuntimeOnlyClassifications(context.classifiedRuntimeOnly))}</code>`
         );
       }
       if (context.classifiedBacktestOnly.length) {
         lines.push(
-          `\u2022 Backtest-only classes: <code>${escapeHtml6(summarizeBacktestOnlyClassifications(context.classifiedBacktestOnly))}</code>`
+          `\u2022 Backtest-only classes: <code>${escapeHtml7(summarizeBacktestOnlyClassifications(context.classifiedBacktestOnly))}</code>`
         );
       }
       if (context.runtimeSignalEvaluationsCount) {
@@ -37742,7 +37908,7 @@ var init_reportingTelegram = __esm({
         lines.push("");
         lines.push("\u{1F50E} <b>Mismatches</b>");
         for (const item of mismatchRows.slice(0, TELEGRAM_DETAIL_LIMIT)) {
-          lines.push(`\u2022 <code>${escapeHtml6(item.line)}</code>`);
+          lines.push(`\u2022 <code>${escapeHtml7(item.line)}</code>`);
         }
         if (mismatchRows.length > TELEGRAM_DETAIL_LIMIT) {
           lines.push(
@@ -37755,7 +37921,7 @@ var init_reportingTelegram = __esm({
         lines.push("");
         lines.push("\u{1F4CA} <b>Strategy issues</b>");
         for (const line of strategyIssueRows) {
-          lines.push(`\u2022 ${escapeHtml6(line.slice(2))}`);
+          lines.push(`\u2022 ${escapeHtml7(line.slice(2))}`);
         }
       } else if (context.strategyRows.length) {
         lines.push("");
@@ -37770,7 +37936,7 @@ var init_reportingTelegram = __esm({
           ...runtimeGateWarningCounts.entries()
         ].sort(([left], [right]) => left.localeCompare(right))) {
           lines.push(
-            `\u2022 <b>${escapeHtml6(strategy)}</b>: AI/ML runtime gates configured on <b>${count}</b> target(s); BACKTEST replay covers core execution only.`
+            `\u2022 <b>${escapeHtml7(strategy)}</b>: AI/ML runtime gates configured on <b>${count}</b> target(s); BACKTEST replay covers core execution only.`
           );
         }
       }
@@ -37779,7 +37945,7 @@ var init_reportingTelegram = __esm({
         lines.push("\u274C <b>Replay errors</b>");
         for (const error of context.replayErrors.slice(0, TELEGRAM_DETAIL_LIMIT)) {
           lines.push(
-            `\u2022 <b>${escapeHtml6(error.strategy)}</b> ${escapeHtml6(error.symbol)}: <code>${escapeHtml6(error.message)}</code>`
+            `\u2022 <b>${escapeHtml7(error.strategy)}</b> ${escapeHtml7(error.symbol)}: <code>${escapeHtml7(error.message)}</code>`
           );
         }
         if (context.replayErrors.length > TELEGRAM_DETAIL_LIMIT) {
@@ -37799,12 +37965,12 @@ var init_reportingTelegram = __esm({
       "\u{1F9EA} <b>TradeJS runtime parity</b>",
       "",
       "\u{1F552} <b>Window</b>",
-      `<b>${escapeHtml6(formatMskDateTime2(window.start))} - ${escapeHtml6(formatMskDateTime2(window.end))} ${SUMMARY_TIMEZONE_LABEL}</b>`,
+      `<b>${escapeHtml7(formatMskDateTime3(window.start))} - ${escapeHtml7(formatMskDateTime3(window.end))} ${SUMMARY_TIMEZONE_LABEL}</b>`,
       "",
-      `\u{1F50C} Connector: <b>${escapeHtml6(connectorName)}</b>`,
-      `\u{1F9EC} Replay env: <b>${escapeHtml6(replayEnv)}</b>`,
+      `\u{1F50C} Connector: <b>${escapeHtml7(connectorName)}</b>`,
+      `\u{1F9EC} Replay env: <b>${escapeHtml7(replayEnv)}</b>`,
       "",
-      `\u26A0\uFE0F No replay targets found for user <b>${escapeHtml6(userName3)}</b>.`
+      `\u26A0\uFE0F No replay targets found for user <b>${escapeHtml7(userName3)}</b>.`
     ].join("\n");
   }
 });
@@ -37824,17 +37990,17 @@ var init_reporting = __esm({
 var runtimeParity_exports = {};
 __export(runtimeParity_exports, {
   buildRuntimeParityMessage: () => buildRuntimeParityMessage,
-  main: () => main43,
+  main: () => main44,
   runtimeParity: () => runtimeParity
 });
-var import_config11, import_node_crypto18, import_args33, import_chalk51, import_constants19, import_time13, import_logger7, import_redis20, import_cli12, import_backtest7, import_connectors15, flags30, interval3, projectRoot15, DEFAULT_LOOKBACK_DAYS, DETAIL_LIMIT2, DEFAULT_REPLAY_ENV, resolveParityConnectorName, createConnector, buildReplayAiAnalyses, formatReplayEnvSummary, buildReplayConfig, warmReplayHistory, runtimeParity, main43;
+var import_config11, import_node_crypto18, import_args34, 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, main44;
 var init_runtimeParity2 = __esm({
   "src/scripts/runtimeParity.ts"() {
     "use strict";
     import_config11 = require("dotenv/config");
     import_node_crypto18 = require("crypto");
-    import_args33 = __toESM(require("args"));
-    import_chalk51 = __toESM(require("chalk"));
+    import_args34 = __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");
@@ -37857,45 +38023,45 @@ var init_runtimeParity2 = __esm({
     init_reporting();
     init_reporting();
     init_runtimeModeConfig();
-    import_args33.default.option(["u", "user"], "Use user config", "root");
-    import_args33.default.option(
+    import_args34.default.option(["u", "user"], "Use user config", "root");
+    import_args34.default.option(
       ["o", "connector"],
       "Connector provider or name for parity replay (e.g. bybit, binance, coinbase, custom)",
       "bybit"
     );
-    import_args33.default.option(["d", "days"], "Replay window in days", 3);
-    import_args33.default.option(
+    import_args34.default.option(["d", "days"], "Replay window in days", 3);
+    import_args34.default.option(
       ["b", "startTime"],
       "Explicit replay start timestamp (ms or seconds)"
     );
-    import_args33.default.option(["e", "endTime"], "Explicit replay end timestamp (ms or seconds)");
-    import_args33.default.option(["s", "strategy"], "Only compare one strategy");
-    import_args33.default.option(
+    import_args34.default.option(["e", "endTime"], "Explicit replay end timestamp (ms or seconds)");
+    import_args34.default.option(["s", "strategy"], "Only compare one strategy");
+    import_args34.default.option(
       ["t", "tickers"],
       "Replay comma-separated symbols for all configured strategies"
     );
-    import_args33.default.option(
+    import_args34.default.option(
       ["C", "cacheOnly"],
       "Do not refresh market history before replay",
       false
     );
-    import_args33.default.option(
+    import_args34.default.option(
       ["a", "toleranceBars"],
       "Allowed entry timestamp drift in bars when matching runtime vs backtest",
       1
     );
-    import_args33.default.option(
+    import_args34.default.option(
       "fullUniverse",
       "Replay every configured strategy across the full connector universe. By default parity replays only runtime-traded and strategy-results symbols unless --tickers is provided.",
       false
     );
-    import_args33.default.option(
+    import_args34.default.option(
       "runtimeGates",
       "Force runtime AI/ML gates for all replay targets. Runtime-gated configs are replayed with gates by default.",
       false
     );
-    import_args33.default.option(["N", "notify"], "Send parity summary to Telegram", false);
-    import_args33.default.option(["D", "details"], "Print unmatched entry details (capped)", false);
+    import_args34.default.option(["N", "notify"], "Send parity summary to Telegram", false);
+    import_args34.default.option(["D", "details"], "Print unmatched entry details (capped)", false);
     process.argv = normalizeCliArgv(process.argv, {
       "-C": "--cacheOnly",
       "-D": "--details",
@@ -37904,14 +38070,14 @@ var init_runtimeParity2 = __esm({
       "-S": "--startTime",
       "-T": "--toleranceBars"
     });
-    flags30 = import_args33.default.parse(process.argv);
+    flags31 = import_args34.default.parse(process.argv);
     interval3 = "15";
-    projectRoot15 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    projectRoot16 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     DEFAULT_LOOKBACK_DAYS = 3;
     DETAIL_LIMIT2 = 10;
-    DEFAULT_REPLAY_ENV = flags30.runtimeGates ? "PARITY" : "BACKTEST";
+    DEFAULT_REPLAY_ENV = flags31.runtimeGates ? "PARITY" : "BACKTEST";
     resolveParityConnectorName = async (value) => {
-      const connectorName = await (0, import_connectors15.resolveConnectorName)(value, projectRoot15);
+      const connectorName = await (0, import_connectors15.resolveConnectorName)(value, projectRoot16);
       if (connectorName) {
         return connectorName;
       }
@@ -37928,7 +38094,7 @@ var init_runtimeParity2 = __esm({
     }) => {
       const connectorFactory = await (0, import_connectors15.getConnectorCreatorByName)(
         connectorName,
-        projectRoot15
+        projectRoot16
       );
       if (!connectorFactory) {
         throw new Error(`Connector "${connectorName}" is not registered`);
@@ -38020,7 +38186,7 @@ var init_runtimeParity2 = __esm({
         strategyConfig,
         env: resolveReplayStrategyEnv({
           strategyConfig,
-          forceRuntimeGates: Boolean(flags30.runtimeGates)
+          forceRuntimeGates: Boolean(flags31.runtimeGates)
         }),
         interval: interval3,
         makeOrders: true,
@@ -38039,7 +38205,7 @@ var init_runtimeParity2 = __esm({
       const symbols = [...new Set(targets.map((target) => target.symbol))];
       const warmStartedAt = Date.now();
       console.log(
-        import_chalk51.default.gray(
+        import_chalk52.default.gray(
           `Warm history: ${symbols.length} symbol(s) on ${connectorName}, preload ${(0, import_time13.formatUnix)(preloadStart)} -> ${(0, import_time13.formatUnix)(preloadEnd)}`
         )
       );
@@ -38047,7 +38213,7 @@ var init_runtimeParity2 = __esm({
         connectorName,
         marketConnector: connector,
         userName: userName3,
-        projectRoot: projectRoot15,
+        projectRoot: projectRoot16,
         shouldUseDedicatedReferences: true,
         warn: (message) => import_logger7.logger.warn(message)
       });
@@ -38059,39 +38225,39 @@ var init_runtimeParity2 = __esm({
         symbols,
         preloadStart,
         preloadEnd,
-        log: (message) => console.log(import_chalk51.default.gray(message))
+        log: (message) => console.log(import_chalk52.default.gray(message))
       });
       console.log(
-        import_chalk51.default.gray(`Warm history: done in ${formatDuration(warmStartedAt)}`)
+        import_chalk52.default.gray(`Warm history: done in ${formatDuration(warmStartedAt)}`)
       );
     };
     runtimeParity = async () => {
       const window = resolveTimeWindow({
-        days: flags30.days ?? DEFAULT_LOOKBACK_DAYS,
-        startTime: flags30.startTime,
-        endTime: flags30.endTime,
+        days: flags31.days ?? DEFAULT_LOOKBACK_DAYS,
+        startTime: flags31.startTime,
+        endTime: flags31.endTime,
         defaultStartMs: Date.now() - DEFAULT_LOOKBACK_DAYS * 24 * 60 * 60 * 1e3,
         defaultEndMs: Date.now()
       });
       const toleranceBars = Math.max(
         0,
-        Number.parseInt(String(flags30.toleranceBars ?? 1), 10) || 0
+        Number.parseInt(String(flags31.toleranceBars ?? 1), 10) || 0
       );
       const toleranceMs = toleranceBars * 15 * 60 * 1e3;
-      const connectorName = await resolveParityConnectorName(flags30.connector);
-      const requestedSymbols = parseSymbolsFromCLI2(String(flags30.tickers || ""));
+      const connectorName = await resolveParityConnectorName(flags31.connector);
+      const requestedSymbols = parseSymbolsFromCLI2(String(flags31.tickers || ""));
       const requestedSymbolSet = requestedSymbols.length ? new Set(requestedSymbols) : null;
       let replayErrors = [];
       try {
         const parityConnector = await createConnector({
-          userName: flags30.user,
+          userName: flags31.user,
           connectorName
         });
         const { runtimeTrades, runtimeSignals, runtimeSignalEvaluations } = await loadRuntimeParityEvidence(
           {
-            userName: flags30.user,
+            userName: flags31.user,
             window,
-            strategy: flags30.strategy,
+            strategy: flags31.strategy,
             symbols: requestedSymbolSet
           },
           {
@@ -38106,29 +38272,29 @@ var init_runtimeParity2 = __esm({
           runtimeSignalEvaluations
         });
         const replayTargets = await buildReplayTargets({
-          userName: flags30.user,
+          userName: flags31.user,
           runtimeTrades,
           connectorSymbols,
-          strategyFilter: String(flags30.strategy || "").trim() || void 0,
+          strategyFilter: String(flags31.strategy || "").trim() || void 0,
           explicitSymbols: requestedSymbols,
-          includeConnectorUniverse: Boolean(flags30.fullUniverse)
+          includeConnectorUniverse: Boolean(flags31.fullUniverse)
         });
         if (!replayTargets.length) {
           console.log(
-            import_chalk51.default.yellow(
-              `No replay targets found for ${flags30.user} in ${(0, import_time13.formatUnix)(window.start)} -> ${(0, import_time13.formatUnix)(window.end)}.`
+            import_chalk52.default.yellow(
+              `No replay targets found for ${flags31.user} in ${(0, import_time13.formatUnix)(window.start)} -> ${(0, import_time13.formatUnix)(window.end)}.`
             )
           );
-          if (flags30.notify) {
+          if (flags31.notify) {
             await sendTelegramReport(
               buildRuntimeParityNoTargetsMessage({
                 window,
                 connectorName,
                 replayEnv: DEFAULT_REPLAY_ENV,
-                runtimeGatesEnabled: Boolean(flags30.runtimeGates),
-                userName: String(flags30.user)
+                runtimeGatesEnabled: Boolean(flags31.runtimeGates),
+                userName: String(flags31.user)
               }),
-              { userName: flags30.user }
+              { userName: flags31.user }
             );
           }
           return;
@@ -38143,14 +38309,14 @@ var init_runtimeParity2 = __esm({
           replayTargets.map((target) => target.symbol)
         ).size;
         console.log(
-          import_chalk51.default.gray(
-            `Replay queue: ${replayTargets.length} target(s), ${replaySymbolsCount} symbol(s), mode=${flags30.fullUniverse ? "full-universe" : requestedSymbols.length ? "explicit-tickers" : "runtime+results"}`
+          import_chalk52.default.gray(
+            `Replay queue: ${replayTargets.length} target(s), ${replaySymbolsCount} symbol(s), mode=${flags31.fullUniverse ? "full-universe" : requestedSymbols.length ? "explicit-tickers" : "runtime+results"}`
           )
         );
         const replayConfigs = /* @__PURE__ */ new Map();
         for (const target of replayTargets) {
           const replayConfig = await buildReplayConfig({
-            userName: flags30.user,
+            userName: flags31.user,
             strategy: target.strategy,
             symbol: target.symbol,
             replayInputsIndex,
@@ -38167,22 +38333,22 @@ var init_runtimeParity2 = __esm({
         );
         await prepareMarketContextForRun({
           mode: "parity",
-          userName: flags30.user,
-          projectRoot: projectRoot15,
+          userName: flags31.user,
+          projectRoot: projectRoot16,
           symbols: replayTargets.map((target) => target.symbol),
           interval: interval3,
           startMs: window.start,
           endMs: window.end,
           preloadStartMs: preloadStart,
-          cacheOnly: Boolean(flags30.cacheOnly),
+          cacheOnly: Boolean(flags31.cacheOnly),
           aiEnabled: hasParityAiTargets,
           mlEnabled: hasParityMlTargets,
           strategyNames: replayTargets.map((target) => target.strategy),
-          log: (message) => console.log(import_chalk51.default.gray(message))
+          log: (message) => console.log(import_chalk52.default.gray(message))
         });
-        if (!flags30.cacheOnly) {
+        if (!flags31.cacheOnly) {
           await warmReplayHistory({
-            userName: flags30.user,
+            userName: flags31.user,
             connectorName,
             targets: replayTargets,
             preloadStart,
@@ -38209,7 +38375,7 @@ var init_runtimeParity2 = __esm({
               );
             }
             const result = await (0, import_backtest7.testing)({
-              userName: flags30.user,
+              userName: flags31.user,
               symbol: target.symbol,
               options: {
                 start: window.start,
@@ -38238,15 +38404,15 @@ var init_runtimeParity2 = __esm({
             });
           } finally {
             (0, import_backtest7.releaseTestingSymbolCache)({
-              cwd: projectRoot15,
-              userName: flags30.user,
+              cwd: projectRoot16,
+              userName: flags31.user,
               connectorName,
               symbol: target.symbol
             });
           }
           if (progressPosition === 1 || progressPosition === replayTargets.length || progressPosition % 25 === 0) {
             console.log(
-              import_chalk51.default.gray(
+              import_chalk52.default.gray(
                 `Replay progress: ${progressPosition}/${replayTargets.length}, ok=${successfulTargetKeys.size}, errors=${replayErrors.length}, current=${target.strategy} ${target.symbol}, elapsed=${formatDuration(replayStartedAt)}`
               )
             );
@@ -38277,8 +38443,8 @@ var init_runtimeParity2 = __esm({
             window,
             connectorName,
             replayEnv: replayEnvSummary,
-            runtimeGatesEnabled: Boolean(flags30.runtimeGates) || replayEnvSummary.includes("PARITY"),
-            runtimeGatesRequested: Boolean(flags30.runtimeGates),
+            runtimeGatesEnabled: Boolean(flags31.runtimeGates) || replayEnvSummary.includes("PARITY"),
+            runtimeGatesRequested: Boolean(flags31.runtimeGates),
             toleranceBars,
             toleranceMs,
             replayTargetsCount: replayTargets.length,
@@ -38301,12 +38467,12 @@ var init_runtimeParity2 = __esm({
             detailLimit: DETAIL_LIMIT2
           })
         );
-        if (flags30.details) {
+        if (flags31.details) {
           printRuntimeDuplicateDetails(runtimeDedupe.duplicateGroups);
           printClassifiedRuntimeOnlyDetails(classifiedRuntimeOnly);
           printClassifiedBacktestOnlyDetails(classifiedBacktestOnly);
         }
-        if (flags30.notify) {
+        if (flags31.notify) {
           const mismatchAttachment = buildRuntimeParityMismatchAttachment({
             window,
             connectorName,
@@ -38335,7 +38501,7 @@ var init_runtimeParity2 = __esm({
               window,
               connectorName,
               replayEnv: replayEnvSummary,
-              runtimeGatesEnabled: Boolean(flags30.runtimeGates) || replayEnvSummary.includes("PARITY"),
+              runtimeGatesEnabled: Boolean(flags31.runtimeGates) || replayEnvSummary.includes("PARITY"),
               toleranceBars,
               toleranceMs,
               replayTargetsCount: replayTargets.length,
@@ -38357,16 +38523,16 @@ var init_runtimeParity2 = __esm({
               runtimeGateWarningCounts
             }),
             {
-              userName: flags30.user,
+              userName: flags31.user,
               attachments: mismatchAttachment ? [mismatchAttachment] : void 0
             }
           );
         }
       } finally {
-        (0, import_backtest7.resetTestingKlineCache)(projectRoot15);
+        (0, import_backtest7.resetTestingKlineCache)(projectRoot16);
       }
     };
-    main43 = runtimeParity;
+    main44 = runtimeParity;
   }
 });
 
@@ -38380,11 +38546,11 @@ var init_runtimeStrategies = __esm({
 });
 
 // src/lib/signals/skipStats.ts
-var import_chalk52, import_logger8, createStrategySkipStats, recordStrategyReason, logStrategySkipStats;
+var import_chalk53, import_logger8, createStrategySkipStats, recordStrategyReason, logStrategySkipStats;
 var init_skipStats = __esm({
   "src/lib/signals/skipStats.ts"() {
     "use strict";
-    import_chalk52 = __toESM(require("chalk"));
+    import_chalk53 = __toESM(require("chalk"));
     import_logger8 = require("@tradejs/infra/logger");
     init_runtimeSignalsStorage();
     createStrategySkipStats = (runtimeStrategies) => new Map(
@@ -38410,7 +38576,7 @@ var init_skipStats = __esm({
       );
     };
     logStrategySkipStats = (runtimeStrategies, strategyStats) => {
-      import_logger8.logger.info(import_chalk52.default.yellow("skip stats:"));
+      import_logger8.logger.info(import_chalk53.default.yellow("skip stats:"));
       for (const { strategyName } of runtimeStrategies) {
         const stats = strategyStats.get(strategyName);
         if (!stats) {
@@ -39425,12 +39591,12 @@ var init_configuredScopes = __esm({
 });
 
 // src/lib/signals/runner.ts
-var import_progress12, import_chalk53, 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_runtimeStrategies8, SLOW_SIGNALS_WARNING_MS, formatDuration3, resolvePositiveInteger2, resolveNonNegativeInteger, createSignalsRunner;
 var init_runner = __esm({
   "src/lib/signals/runner.ts"() {
     "use strict";
     import_progress12 = __toESM(require("progress"));
-    import_chalk53 = __toESM(require("chalk"));
+    import_chalk54 = __toESM(require("chalk"));
     import_connectors17 = require("@tradejs/node/connectors");
     import_cli13 = require("@tradejs/node/cli");
     import_async5 = require("@tradejs/core/async");
@@ -39476,10 +39642,10 @@ var init_runner = __esm({
     };
     createSignalsRunner = (config2) => {
       const interval4 = config2.interval;
-      const projectRoot17 = config2.projectRoot?.trim() || String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+      const projectRoot18 = config2.projectRoot?.trim() || String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
       const compositionSnapshotRecorder = process.env.TRADEJS_PROJECT_SHA && process.env.TRADEJS_PROJECT_IMAGE_DIGEST && config2.deploymentId ? createRuntimeEvidenceCompositionSnapshotRecorder({
         persist: (compositionId) => captureRuntimeEvidenceCompositionSnapshot({
-          projectRoot: projectRoot17,
+          projectRoot: projectRoot18,
           userName: config2.userName,
           deploymentId: config2.deploymentId,
           expectedCompositionId: compositionId
@@ -39512,7 +39678,7 @@ var init_runner = __esm({
       const timeOperation3 = (label, operation) => timeOperation(
         label,
         operation,
-        (message) => import_logger11.logger.info(import_chalk53.default.gray(message))
+        (message) => import_logger11.logger.info(import_chalk54.default.gray(message))
       );
       const formatSlowSignalsWarning = (params) => [
         "<b>Slow yarn signals run</b>",
@@ -39522,7 +39688,7 @@ var init_runner = __esm({
         `Found signals: <b>${params.found}</b>`
       ].join("\n");
       const resolveSignalsConnectorName = async (value) => {
-        const connectorName = await (0, import_connectors17.resolveConnectorName)(value, projectRoot17);
+        const connectorName = await (0, import_connectors17.resolveConnectorName)(value, projectRoot18);
         if (!connectorName) {
           throw new Error(
             `Unknown runtime connector: ${String(value || "").trim() || String(value)}`
@@ -39533,7 +39699,7 @@ var init_runner = __esm({
       const createSignalsSession2 = async (lifecycle, scope = {}) => {
         const deployment = config2.deploymentId ? await (0, import_runtimeStrategies8.getRuntimeDeployment)({
           userName: config2.userName,
-          projectRoot: projectRoot17,
+          projectRoot: projectRoot18,
           deploymentId: config2.deploymentId
         }) : null;
         if (config2.deploymentId && !deployment) {
@@ -39552,7 +39718,7 @@ var init_runner = __esm({
         const requestedAccountId = deployment?.accountId ?? scope.accountId ?? config2.accountId;
         const connectorFactory = await (0, import_connectors17.getConnectorCreatorByName)(
           connectorName,
-          projectRoot17
+          projectRoot18
         );
         if (!connectorFactory) {
           throw new Error(`Connector "${connectorName}" is not registered`);
@@ -39567,7 +39733,7 @@ var init_runner = __esm({
           connectorName,
           marketConnector,
           userName: config2.userName,
-          projectRoot: projectRoot17,
+          projectRoot: projectRoot18,
           shouldUseDedicatedReferences: universe === "crypto" && connectorName.toLowerCase() === import_connectors17.DEFAULT_CONNECTOR_NAME.toLowerCase(),
           warn: (message) => import_logger11.logger.warn(message)
         });
@@ -39629,7 +39795,7 @@ var init_runner = __esm({
           const selectedTickers = selection?.tickers ? [.../* @__PURE__ */ new Set([...selection.tickers, ...selectedActiveSymbols])] : void 0;
           if (selectedActiveSymbols.length) {
             import_logger11.logger.info(
-              import_chalk53.default.gray(
+              import_chalk54.default.gray(
                 `runtime scope retained active symbols: ${selectedActiveSymbols.join(", ")}`
               )
             );
@@ -39660,10 +39826,10 @@ var init_runner = __esm({
             instruments.map((instrument) => [instrument.symbol, instrument])
           );
           if (config2.showTickersList) {
-            console.log(import_chalk53.default.gray(JSON.stringify(tickers.sort(), null, 2)));
+            console.log(import_chalk54.default.gray(JSON.stringify(tickers.sort(), null, 2)));
             return;
           }
-          const projectConfig = await (0, import_cli13.loadTradejsConfig)(projectRoot17);
+          const projectConfig = await (0, import_cli13.loadTradejsConfig)(projectRoot18);
           projectHooks = projectConfig.hooks;
           const currentTimestamp = (0, import_time14.getTimestamp)();
           const preloadStart = (0, import_time14.getTimestamp)(import_constants20.SIGNALS_CLI_PRELOAD_DAYS);
@@ -39681,7 +39847,7 @@ var init_runner = __esm({
             );
             await session.klineFeed.flush();
             import_logger11.logger.info(
-              import_chalk53.default.gray(
+              import_chalk54.default.gray(
                 `websocket candles: ready=${expectedSymbols.length - missingSymbols.length}/${expectedSymbols.length} missing=${missingSymbols.length}`
               )
             );
@@ -39692,7 +39858,7 @@ var init_runner = __esm({
               symbols: missingSymbols,
               preloadDays: import_constants20.SIGNALS_CLI_PRELOAD_DAYS,
               universe,
-              log: (message) => import_logger11.logger.info(import_chalk53.default.gray(message))
+              log: (message) => import_logger11.logger.info(import_chalk54.default.gray(message))
             });
             await updateBtcReferenceHistory({
               marketConnector,
@@ -39700,7 +39866,7 @@ var init_runner = __esm({
               interval: interval5,
               preloadDays: import_constants20.SIGNALS_CLI_PRELOAD_DAYS,
               universe,
-              log: (message) => import_logger11.logger.info(import_chalk53.default.gray(message))
+              log: (message) => import_logger11.logger.info(import_chalk54.default.gray(message))
             });
           } else if (!config2.cacheOnly) {
             await updateMarketHistoryWithBtcReferences({
@@ -39711,13 +39877,13 @@ var init_runner = __esm({
               symbols: tickers,
               preloadDays: import_constants20.SIGNALS_CLI_PRELOAD_DAYS,
               universe,
-              log: (message) => import_logger11.logger.info(import_chalk53.default.gray(message))
+              log: (message) => import_logger11.logger.info(import_chalk54.default.gray(message))
             });
           }
           await prepareMarketContextForRun({
             mode: "signals",
             userName: config2.userName,
-            projectRoot: projectRoot17,
+            projectRoot: projectRoot18,
             symbols: tickers,
             universe,
             interval: interval5,
@@ -39725,7 +39891,7 @@ var init_runner = __esm({
             endMs: currentTimestamp,
             preloadStartMs: preloadStart,
             cacheOnly: config2.cacheOnly,
-            log: (message) => import_logger11.logger.info(import_chalk53.default.gray(message))
+            log: (message) => import_logger11.logger.info(import_chalk54.default.gray(message))
           });
           if (config2.updateOnly) {
             return;
@@ -39783,7 +39949,7 @@ var init_runner = __esm({
           );
           const configuredRuntimeStrategies = await (0, import_runtimeStrategies7.loadResolvedRuntimeStrategies)({
             userName: config2.userName,
-            projectRoot: projectRoot17,
+            projectRoot: projectRoot18,
             deploymentId: deployment?.id ?? "",
             universe,
             accountId,
@@ -39829,7 +39995,7 @@ var init_runner = __esm({
             )
           );
           import_logger11.logger.info(
-            import_chalk53.default.yellow(
+            import_chalk54.default.yellow(
               `loaded strategies (user=${config2.userName}): ${runtimeStrategies.map(formatConfiguredStrategyIdentity).join(", ")}`
             )
           );
@@ -39865,9 +40031,9 @@ var init_runner = __esm({
               width: 30
             }
           );
-          import_logger11.logger.info(import_chalk53.default.yellow(`tickers: ${tickers.length}`));
+          import_logger11.logger.info(import_chalk54.default.yellow(`tickers: ${tickers.length}`));
           const signalsParallel = resolvePositiveInteger2(config2.parallel, 4);
-          import_logger11.logger.info(import_chalk53.default.yellow(`signal workers: ${signalsParallel}`));
+          import_logger11.logger.info(import_chalk54.default.yellow(`signal workers: ${signalsParallel}`));
           const evaluateTicker = createSignalsTickerEvaluator({
             userName: config2.userName,
             makeOrders: config2.makeOrders,
@@ -39907,8 +40073,8 @@ var init_runner = __esm({
                 signals3.push(...strategySignals);
               }
               bar.tick(1, {
-                found: import_chalk53.default.cyan(signals3.length),
-                symbol: import_chalk53.default.gray(symbol)
+                found: import_chalk54.default.cyan(signals3.length),
+                symbol: import_chalk54.default.gray(symbol)
               });
             });
           });
@@ -40012,7 +40178,7 @@ var init_runner = __esm({
             }
           }
           import_logger11.logger.info(
-            import_chalk53.default.yellow(
+            import_chalk54.default.yellow(
               `signals ${status} in ${formatDuration3(durationMs)} (found=${signals3.length})`
             )
           );
@@ -40024,7 +40190,7 @@ var init_runner = __esm({
       const loadConfiguredSignalsScopes = async (deployment) => {
         const configuredStrategies = await (0, import_runtimeStrategies7.loadResolvedRuntimeStrategies)({
           userName: config2.userName,
-          projectRoot: projectRoot17,
+          projectRoot: projectRoot18,
           deploymentId: deployment.id
         });
         const connectorName = await resolveSignalsConnectorName(
@@ -40050,7 +40216,7 @@ var init_runner = __esm({
         }
         const configuredDeployment = await (0, import_runtimeStrategies8.getRuntimeDeployment)({
           userName: config2.userName,
-          projectRoot: projectRoot17,
+          projectRoot: projectRoot18,
           deploymentId: config2.deploymentId
         });
         if (!configuredDeployment) {
@@ -40084,7 +40250,7 @@ var init_runner = __esm({
         const deploymentId = config2.deploymentId;
         const initialDeployment = await (0, import_runtimeStrategies8.getRuntimeDeployment)({
           userName: config2.userName,
-          projectRoot: projectRoot17,
+          projectRoot: projectRoot18,
           deploymentId
         });
         if (!initialDeployment) {
@@ -40109,7 +40275,7 @@ var init_runner = __esm({
             runCycle: async () => {
               const currentDeployment = await (0, import_runtimeStrategies8.getRuntimeDeployment)({
                 userName: config2.userName,
-                projectRoot: projectRoot17,
+                projectRoot: projectRoot18,
                 deploymentId
               });
               if (!currentDeployment) {
@@ -40232,113 +40398,113 @@ var init_runner = __esm({
 var signals_exports = {};
 __export(signals_exports, {
   createSignalsSession: () => createSignalsSession,
-  main: () => main44,
+  main: () => main45,
   signals: () => signals,
   signalsConfiguredScopesOnce: () => signalsConfiguredScopesOnce,
   signalsDaemon: () => signalsDaemon
 });
-var import_config12, import_args34, flags31, config, runner, createSignalsSession, signals, signalsConfiguredScopesOnce, signalsDaemon, main44;
+var import_config12, import_args35, flags32, config, runner, createSignalsSession, signals, signalsConfiguredScopesOnce, signalsDaemon, main45;
 var init_signals = __esm({
   "src/scripts/signals.ts"() {
     "use strict";
     import_config12 = require("dotenv/config");
-    import_args34 = __toESM(require("args"));
+    import_args35 = __toESM(require("args"));
     init_runner();
-    import_args34.default.option(["t", "tickers"], "Selected tickers");
-    import_args34.default.option(["e", "exclude"], "Exclude tickers from tests");
-    import_args34.default.option(["l", "tickersLimit"], "Tickers limit");
-    import_args34.default.option(["f", "timeframe"], "Timeframe", 15);
-    import_args34.default.option(["m", "makeOrders"], "Make orders");
-    import_args34.default.option(["N", "notify"], "Send message in Telegram", false);
-    import_args34.default.option(["S", "skipScreenshots"], "Skip screenshot generation", false);
-    import_args34.default.option(["u", "updateOnly"], "Only update tickers history", false);
-    import_args34.default.option(["C", "cacheOnly"], "Do not update tickers history", false);
-    import_args34.default.option(["L", "showTickersList"], "Just show only ticker list", false);
-    import_args34.default.option(
+    import_args35.default.option(["t", "tickers"], "Selected tickers");
+    import_args35.default.option(["e", "exclude"], "Exclude tickers from tests");
+    import_args35.default.option(["l", "tickersLimit"], "Tickers limit");
+    import_args35.default.option(["f", "timeframe"], "Timeframe", 15);
+    import_args35.default.option(["m", "makeOrders"], "Make orders");
+    import_args35.default.option(["N", "notify"], "Send message in Telegram", false);
+    import_args35.default.option(["S", "skipScreenshots"], "Skip screenshot generation", false);
+    import_args35.default.option(["u", "updateOnly"], "Only update tickers history", false);
+    import_args35.default.option(["C", "cacheOnly"], "Do not update tickers history", false);
+    import_args35.default.option(["L", "showTickersList"], "Just show only ticker list", false);
+    import_args35.default.option(
       ["p", "parallel"],
       "Signal evaluation worker count",
       Number(process.env.SIGNALS_PARALLEL || 4)
     );
-    import_args34.default.option(
+    import_args35.default.option(
       ["R", "showSkipStats"],
       "Show aggregated skip stats by strategy",
       false
     );
-    import_args34.default.option(["c", "chunk"], "Split by chunks, ex. 1/3");
-    import_args34.default.option(["U", "user"], "Use user confg", "root");
-    import_args34.default.option(["w", "watch"], "Keep signals running on candle boundaries", false);
-    import_args34.default.option(
+    import_args35.default.option(["c", "chunk"], "Split by chunks, ex. 1/3");
+    import_args35.default.option(["U", "user"], "Use user confg", "root");
+    import_args35.default.option(["w", "watch"], "Keep signals running on candle boundaries", false);
+    import_args35.default.option(
       ["d", "settleDelayMs"],
       "Delay after candle close before a daemon cycle",
       Number(process.env.SIGNALS_DAEMON_SETTLE_DELAY_MS || 5e3)
     );
-    import_args34.default.option(
+    import_args35.default.option(
       ["o", "connector"],
       "Connector provider or name for signals (e.g. bybit, binance, coinbase, custom)",
       "bybit"
     );
-    import_args34.default.option(["V", "universe"], "Market universe (crypto or tradfi)", "crypto");
-    import_args34.default.option(["A", "account"], "Trading account id");
-    import_args34.default.option(["D", "deployment"], "Runtime deployment id");
-    flags31 = import_args34.default.parse(process.argv);
+    import_args35.default.option(["V", "universe"], "Market universe (crypto or tradfi)", "crypto");
+    import_args35.default.option(["A", "account"], "Trading account id");
+    import_args35.default.option(["D", "deployment"], "Runtime deployment id");
+    flags32 = import_args35.default.parse(process.argv);
     config = {
       projectRoot: String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd(),
-      userName: String(flags31.user || "root"),
-      interval: String(flags31.timeframe ?? 15),
-      connectorName: String(flags31.connector || "bybit"),
-      universe: flags31.universe,
-      accountId: flags31.account ? String(flags31.account) : void 0,
-      deploymentId: flags31.deployment ? String(flags31.deployment) : void 0,
-      tickers: flags31.tickers,
-      exclude: flags31.exclude,
-      tickersLimit: flags31.tickersLimit,
-      chunk: flags31.chunk,
-      makeOrders: Boolean(flags31.makeOrders),
-      notify: Boolean(flags31.notify),
-      skipScreenshots: Boolean(flags31.skipScreenshots),
-      updateOnly: Boolean(flags31.updateOnly),
-      cacheOnly: Boolean(flags31.cacheOnly),
-      showTickersList: Boolean(flags31.showTickersList),
-      showSkipStats: Boolean(flags31.showSkipStats),
-      parallel: flags31.parallel,
-      watch: Boolean(flags31.watch),
-      settleDelayMs: flags31.settleDelayMs
+      userName: String(flags32.user || "root"),
+      interval: String(flags32.timeframe ?? 15),
+      connectorName: String(flags32.connector || "bybit"),
+      universe: flags32.universe,
+      accountId: flags32.account ? String(flags32.account) : void 0,
+      deploymentId: flags32.deployment ? String(flags32.deployment) : void 0,
+      tickers: flags32.tickers,
+      exclude: flags32.exclude,
+      tickersLimit: flags32.tickersLimit,
+      chunk: flags32.chunk,
+      makeOrders: Boolean(flags32.makeOrders),
+      notify: Boolean(flags32.notify),
+      skipScreenshots: Boolean(flags32.skipScreenshots),
+      updateOnly: Boolean(flags32.updateOnly),
+      cacheOnly: Boolean(flags32.cacheOnly),
+      showTickersList: Boolean(flags32.showTickersList),
+      showSkipStats: Boolean(flags32.showSkipStats),
+      parallel: flags32.parallel,
+      watch: Boolean(flags32.watch),
+      settleDelayMs: flags32.settleDelayMs
     };
     runner = createSignalsRunner(config);
     createSignalsSession = runner.createSession;
     signals = runner.runCycle;
     signalsConfiguredScopesOnce = runner.runConfiguredScopesOnce;
     signalsDaemon = runner.runDaemon;
-    main44 = () => config.watch ? signalsDaemon() : signalsConfiguredScopesOnce();
+    main45 = () => config.watch ? signalsDaemon() : signalsConfiguredScopesOnce();
   }
 });
 
 // src/scripts/signalsDaemon.ts
 var signalsDaemon_exports = {};
 __export(signalsDaemon_exports, {
-  main: () => main45
+  main: () => main46
 });
-var main45;
+var main46;
 var init_signalsDaemon = __esm({
   "src/scripts/signalsDaemon.ts"() {
     "use strict";
     init_signals();
-    main45 = signalsDaemon;
+    main46 = signalsDaemon;
   }
 });
 
 // src/scripts/signalsSummary.ts
 var signalsSummary_exports = {};
 __export(signalsSummary_exports, {
-  main: () => main46,
+  main: () => main47,
   signalsSummary: () => signalsSummary
 });
-var import_config13, import_args35, import_logger12, import_connectors18, import_runtimeStrategies10, flags32, projectRoot16, SUMMARY_TIMEZONE2, SUMMARY_TIMEZONE_LABEL2, escapeHtml7, formatMskDateTime3, formatSigned3, formatPnlMoneyText, formatWinRateText, resolveSummaryTitle, normalizeStatus, shouldAttachDebugReport, getSummaryDateParts, formatSummaryIsoDayKey, unescapeHtml, stripTelegramHtml, buildSignalsSummaryAttachment, appendReportAttachmentSummary, resolveSummaryConnectorName, groupRuntimeTradesByConnectorScope, syncRuntimeTradeScopes, createRuntimeSignalStats, mergeRuntimeSignalStats, buildSummaryPrelude, resolveTradeStatusEmoji, isTimestampInWindow, isRuntimeTradeClosedInWindow, buildSummaryMessages, signalsSummary, main46;
+var import_config13, import_args36, 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, main47;
 var init_signalsSummary = __esm({
   "src/scripts/signalsSummary.ts"() {
     "use strict";
     import_config13 = require("dotenv/config");
-    import_args35 = __toESM(require("args"));
+    import_args36 = __toESM(require("args"));
     import_logger12 = require("@tradejs/infra/logger");
     import_connectors18 = require("@tradejs/node/connectors");
     init_runtimeRedis();
@@ -40348,25 +40514,25 @@ var init_signalsSummary = __esm({
     init_runtimeSignalsStorage();
     init_runtimeDebugEvidence();
     import_runtimeStrategies10 = require("@tradejs/node/runtimeStrategies");
-    import_args35.default.option(["u", "user"], "Use user config", "root");
-    import_args35.default.option(
+    import_args36.default.option(["u", "user"], "Use user config", "root");
+    import_args36.default.option(
       "connector",
       "Connector provider or name for summary (e.g. bybit, binance, coinbase, custom)",
       "bybit"
     );
-    import_args35.default.option(["H", "hours"], "Summary window in hours", 24);
-    import_args35.default.option(["P", "printOnly"], "Print summary instead of Telegram", false);
-    import_args35.default.option(
+    import_args36.default.option(["H", "hours"], "Summary window in hours", 24);
+    import_args36.default.option(["P", "printOnly"], "Print summary instead of Telegram", false);
+    import_args36.default.option(
       "debugAttachment",
       "Attach runtime Redis debug JSON for replay diagnostics",
       true
     );
-    flags32 = import_args35.default.parse(process.argv);
-    projectRoot16 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    flags33 = import_args36.default.parse(process.argv);
+    projectRoot17 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     SUMMARY_TIMEZONE2 = "Europe/Moscow";
     SUMMARY_TIMEZONE_LABEL2 = "MSK";
-    escapeHtml7 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-    formatMskDateTime3 = (timestamp) => new Intl.DateTimeFormat("ru-RU", {
+    escapeHtml8 = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+    formatMskDateTime4 = (timestamp) => new Intl.DateTimeFormat("ru-RU", {
       timeZone: SUMMARY_TIMEZONE2,
       year: "numeric",
       month: "2-digit",
@@ -40435,13 +40601,13 @@ var init_signalsSummary = __esm({
         message,
         "",
         "\u{1F4CE} <b>Signal report file</b>",
-        `File: <code>${escapeHtml7(signalsFilename)}</code>`
+        `File: <code>${escapeHtml8(signalsFilename)}</code>`
       ];
       if (filename) {
         lines.push(
           "",
           "\u{1F4CE} <b>Replay debug file</b>",
-          `File: <code>${escapeHtml7(filename)}</code>`,
+          `File: <code>${escapeHtml8(filename)}</code>`,
           `Inside: trades=<b>${tradesCount ?? 0}</b>, signals=<b>${signalsCount ?? 0}</b>, evaluations=<b>${evaluationsCount ?? 0}</b>`,
           "Redis refs: <code>trade</code>, <code>tradeBucket</code>, <code>activeTrade</code>, <code>signal</code>, <code>evaluation</code>"
         );
@@ -40449,7 +40615,7 @@ var init_signalsSummary = __esm({
       return lines.join("\n");
     };
     resolveSummaryConnectorName = async (value) => {
-      const connectorName = await (0, import_connectors18.resolveConnectorName)(value, projectRoot16);
+      const connectorName = await (0, import_connectors18.resolveConnectorName)(value, projectRoot17);
       if (connectorName) {
         return connectorName;
       }
@@ -40514,7 +40680,7 @@ var init_signalsSummary = __esm({
         );
         const connectorFactory = await (0, import_connectors18.getConnectorCreatorByName)(
           connectorName,
-          projectRoot16
+          projectRoot17
         );
         if (!connectorFactory) {
           throw new Error(`Connector "${connectorName}" is not registered`);
@@ -40591,16 +40757,16 @@ var init_signalsSummary = __esm({
     }) => {
       const windowPnlLabel = hours === 24 ? "24h Realized PnL" : `${hours}h Realized PnL`;
       return [
-        `\u{1F4CB} <b>${escapeHtml7(resolveSummaryTitle(hours))}</b>`,
+        `\u{1F4CB} <b>${escapeHtml8(resolveSummaryTitle(hours))}</b>`,
         "",
         "\u{1F552} <b>Window</b>",
-        `<b>${escapeHtml7(formatMskDateTime3(startTime))} - ${escapeHtml7(formatMskDateTime3(endTime))} ${SUMMARY_TIMEZONE_LABEL2}</b>`,
+        `<b>${escapeHtml8(formatMskDateTime4(startTime))} - ${escapeHtml8(formatMskDateTime4(endTime))} ${SUMMARY_TIMEZONE_LABEL2}</b>`,
         "",
         `\u23F1 Range: <b>${hours}h</b>`,
-        `\u{1F4B0} <b>${windowPnlLabel}:</b> <b>${escapeHtml7(realizedWindowPnlText)}</b>`,
-        `\u{1F3C6} <b>WinRate:</b> <b>${escapeHtml7(winRateText)}</b>`,
+        `\u{1F4B0} <b>${windowPnlLabel}:</b> <b>${escapeHtml8(realizedWindowPnlText)}</b>`,
+        `\u{1F3C6} <b>WinRate:</b> <b>${escapeHtml8(winRateText)}</b>`,
         `\u2197\uFE0F <b>LONG:</b> <b>${longCount}</b>, \u2198\uFE0F <b>SHORT:</b> <b>${shortCount}</b>`,
-        `\u{1F4CD} <b>Open positions:</b> <b>${openCount}</b>, Unrealized PnL: <b>${escapeHtml7(openPnlText)}</b>`
+        `\u{1F4CD} <b>Open positions:</b> <b>${openCount}</b>, Unrealized PnL: <b>${escapeHtml8(openPnlText)}</b>`
       ];
     };
     resolveTradeStatusEmoji = (status, pnl) => {
@@ -40781,12 +40947,12 @@ var init_signalsSummary = __esm({
           }
         );
         for (const [source, reasons] of sortedReasonGroups) {
-          signalLines.push(`<b>${escapeHtml7(source)}</b>:`);
+          signalLines.push(`<b>${escapeHtml8(source)}</b>:`);
           const sortedReasons = [...reasons.entries()].sort(
             (left, right) => right[1] - left[1] || left[0].localeCompare(right[0])
           );
           for (const [reason, count] of sortedReasons) {
-            signalLines.push(`${escapeHtml7(reason)}: <b>${count}</b>`);
+            signalLines.push(`${escapeHtml8(reason)}: <b>${count}</b>`);
           }
         }
       };
@@ -40796,8 +40962,8 @@ var init_signalsSummary = __esm({
           const evaluation = evaluationStatsByStrategy.get(strategyName);
           signalLines.push("");
           signalLines.push(
-            evaluation?.evaluated ? `<b>${escapeHtml7(strategyName)}</b>
-signals=<b>0</b>` : `<b>${escapeHtml7(strategyName)}</b>
+            evaluation?.evaluated ? `<b>${escapeHtml8(strategyName)}</b>
+signals=<b>0</b>` : `<b>${escapeHtml8(strategyName)}</b>
 none`
           );
           appendEvaluationDetails(strategyName);
@@ -40808,7 +40974,7 @@ none`
           return count > 0 ? `${status}=<b>${count}</b>` : null;
         }).filter(Boolean);
         signalLines.push("");
-        signalLines.push(`<b>${escapeHtml7(strategyName)}</b>`);
+        signalLines.push(`<b>${escapeHtml8(strategyName)}</b>`);
         signalLines.push(parts.join(", "));
         appendEvaluationDetails(strategyName);
       }
@@ -40821,17 +40987,17 @@ none`
         if (!stats) continue;
         tradeLines.push("");
         tradeLines.push(
-          `<b>${escapeHtml7(strategyName)}</b> (<b>${stats.closed}</b>)`
+          `<b>${escapeHtml8(strategyName)}</b> (<b>${stats.closed}</b>)`
         );
         tradeLines.push(
-          `Closed PnL: <b>${escapeHtml7(formatPnlMoneyText(stats.closedPnl, stats.closedPnlKnown))}</b> (<b>${stats.closed}</b>)`
+          `Closed PnL: <b>${escapeHtml8(formatPnlMoneyText(stats.closedPnl, stats.closedPnlKnown))}</b> (<b>${stats.closed}</b>)`
         );
         const sortedTrades = stats.trades.filter((trade) => trade.status === "closed").sort(
           (left, right) => left.entryTimestamp - right.entryTimestamp || left.symbol.localeCompare(right.symbol) || left.orderId.localeCompare(right.orderId)
         );
         for (const trade of sortedTrades) {
           tradeLines.push(
-            `- ${escapeHtml7(trade.symbol)}: PnL <b>${escapeHtml7(trade.pnlText)}</b> ${resolveTradeStatusEmoji(trade.status, trade.pnl)}`
+            `- ${escapeHtml8(trade.symbol)}: PnL <b>${escapeHtml8(trade.pnlText)}</b> ${resolveTradeStatusEmoji(trade.status, trade.pnl)}`
           );
         }
       }
@@ -40845,17 +41011,17 @@ none`
         if (!stats) continue;
         tradeLines.push("");
         tradeLines.push(
-          `<b>${escapeHtml7(strategyName)}</b> (<b>${stats.active}</b>)`
+          `<b>${escapeHtml8(strategyName)}</b> (<b>${stats.active}</b>)`
         );
         tradeLines.push(
-          `Unrealized PnL: <b>${escapeHtml7(formatPnlMoneyText(stats.activePnl, stats.activePnlKnown))}</b> (<b>${stats.active}</b>)`
+          `Unrealized PnL: <b>${escapeHtml8(formatPnlMoneyText(stats.activePnl, stats.activePnlKnown))}</b> (<b>${stats.active}</b>)`
         );
         const sortedTrades = stats.trades.filter((trade) => trade.status === "active").sort(
           (left, right) => left.entryTimestamp - right.entryTimestamp || left.symbol.localeCompare(right.symbol) || left.orderId.localeCompare(right.orderId)
         );
         for (const trade of sortedTrades) {
           tradeLines.push(
-            `- ${escapeHtml7(trade.symbol)}: PnL <b>${escapeHtml7(trade.pnlText)}</b> ${resolveTradeStatusEmoji(trade.status, trade.pnl)}`
+            `- ${escapeHtml8(trade.symbol)}: PnL <b>${escapeHtml8(trade.pnlText)}</b> ${resolveTradeStatusEmoji(trade.status, trade.pnl)}`
           );
         }
       }
@@ -40867,12 +41033,12 @@ none`
     signalsSummary = async () => {
       const hours = Math.max(
         1,
-        Number.parseInt(String(flags32.hours ?? 24), 10) || 24
+        Number.parseInt(String(flags33.hours ?? 24), 10) || 24
       );
       const endTime = Date.now();
       const startTime = endTime - hours * 60 * 60 * 1e3;
       const fallbackConnectorName = await resolveSummaryConnectorName(
-        flags32.connector
+        flags33.connector
       );
       const [
         configuredStrategyNames,
@@ -40881,25 +41047,25 @@ none`
         trades,
         runtimeDeployments
       ] = await Promise.all([
-        (0, import_runtimeStrategyConfigs.loadRuntimeStrategyNames)(flags32.user),
-        loadRuntimeSignals(flags32.user, { startTime, endTime }),
-        loadRuntimeSignalEvaluationStatsBuckets(flags32.user),
-        loadRuntimeTrades(flags32.user),
-        (0, import_runtimeStrategies10.listRuntimeDeployments)({ userName: flags32.user, projectRoot: projectRoot16 })
+        (0, import_runtimeStrategyConfigs.loadRuntimeStrategyNames)(flags33.user),
+        loadRuntimeSignals(flags33.user, { startTime, endTime }),
+        loadRuntimeSignalEvaluationStatsBuckets(flags33.user),
+        loadRuntimeTrades(flags33.user),
+        (0, import_runtimeStrategies10.listRuntimeDeployments)({ userName: flags33.user, projectRoot: projectRoot17 })
       ]);
       const {
         trades: syncedTrades,
         connectorNames,
         scopesCount
       } = await syncRuntimeTradeScopes({
-        userName: flags32.user,
+        userName: flags33.user,
         startTime,
         endTime,
         fallbackConnectorName,
         trades,
         deployments: runtimeDeployments
       });
-      const activeTradeOrderIds = await loadRuntimeActiveTradeOrderIds(flags32.user);
+      const activeTradeOrderIds = await loadRuntimeActiveTradeOrderIds(flags33.user);
       const windowSignals = signals2.filter(
         (signal) => signal.timestamp >= startTime && signal.timestamp < endTime
       );
@@ -40947,10 +41113,10 @@ none`
         windowClosedTrades.length,
         connectorNames.join(",") || fallbackConnectorName,
         scopesCount,
-        flags32.user
+        flags33.user
       );
-      const debugAttachment = shouldAttachDebugReport(flags32.debugAttachment) ? await buildRuntimeDebugReportAttachment({
-        userName: flags32.user,
+      const debugAttachment = shouldAttachDebugReport(flags33.debugAttachment) ? await buildRuntimeDebugReportAttachment({
+        userName: flags33.user,
         startTime,
         endTime,
         signals: debugSignals,
@@ -40958,7 +41124,7 @@ none`
         trades: windowTrades
       }) : null;
       const signalsAttachment = buildSignalsSummaryAttachment({
-        userName: flags32.user,
+        userName: flags33.user,
         endTime,
         content: signalsMessage
       });
@@ -40974,7 +41140,7 @@ none`
         signalsAttachment,
         ...debugAttachment ? [debugAttachment] : []
       ];
-      if (flags32.printOnly) {
+      if (flags33.printOnly) {
         console.log(tradesMessageWithAttachmentSummary);
         console.log("");
         console.log(`Signals attachment: ${signalsAttachment.filename}`);
@@ -40987,20 +41153,20 @@ none`
         return;
       }
       await sendTelegramReport(tradesMessageWithAttachmentSummary, {
-        userName: flags32.user,
+        userName: flags33.user,
         attachments
       });
     };
-    main46 = signalsSummary;
+    main47 = signalsSummary;
   }
 });
 
 // src/scripts/test-ml.ts
 var test_ml_exports = {};
 __export(test_ml_exports, {
-  main: () => main47
+  main: () => main48
 });
-var import_config14, import_constants21, import_ml3, import_registry5, now, INTERVAL_MIN, CANDLES, makeSeries, makeCandles, buildTrendline, main47;
+var import_config14, import_constants21, import_ml3, import_registry5, now, INTERVAL_MIN, CANDLES, makeSeries, makeCandles, buildTrendline, main48;
 var init_test_ml = __esm({
   "src/scripts/test-ml.ts"() {
     "use strict";
@@ -41050,7 +41216,7 @@ var init_test_ml = __esm({
         { timestamp: entryTs - 2 * INTERVAL_MIN * 6e4, value: price * 0.995 }
       ]
     });
-    main47 = async () => {
+    main48 = async () => {
       const defaultConfig = await (0, import_registry5.getStrategyDefaults)("TrendLine", process.cwd());
       if (!defaultConfig) {
         throw new Error(
@@ -41143,9 +41309,9 @@ var init_test_ml = __esm({
 // src/scripts/test.ts
 var test_exports = {};
 __export(test_exports, {
-  main: () => main48
+  main: () => main49
 });
-var import_config15, import_connectors19, getPositions, main48;
+var import_config15, import_connectors19, getPositions, main49;
 var init_test = __esm({
   "src/scripts/test.ts"() {
     "use strict";
@@ -41155,7 +41321,7 @@ var init_test = __esm({
       const res = await connector.getPositions();
       console.log("res", res);
     };
-    main48 = async () => {
+    main49 = async () => {
       const byBitConnector = await import_connectors19.connectors.ByBit({
         userName: "root"
       });
@@ -41167,25 +41333,25 @@ var init_test = __esm({
 // src/scripts/user-add.ts
 var user_add_exports = {};
 __export(user_add_exports, {
-  main: () => main49
+  main: () => main50
 });
-var import_args36, import_chalk54, import_bcryptjs, import_redis22, flags33, main49;
+var import_args37, import_chalk55, import_bcryptjs, import_redis22, flags34, main50;
 var init_user_add = __esm({
   "src/scripts/user-add.ts"() {
     "use strict";
-    import_args36 = __toESM(require("args"));
-    import_chalk54 = __toESM(require("chalk"));
+    import_args37 = __toESM(require("args"));
+    import_chalk55 = __toESM(require("chalk"));
     import_bcryptjs = __toESM(require("bcryptjs"));
     import_redis22 = require("@tradejs/infra/redis");
-    import_args36.default.example("yarn user-add -u myname -p 123456", "Create or update user");
-    import_args36.default.option(["u", "user"], "Username", "");
-    import_args36.default.option(["p", "password"], "Password (plain text)", "");
-    flags33 = import_args36.default.parse(process.argv);
-    main49 = async () => {
-      const userName3 = String(flags33.user || "").trim();
-      const password = String(flags33.password || "");
+    import_args37.default.example("yarn user-add -u myname -p 123456", "Create or update user");
+    import_args37.default.option(["u", "user"], "Username", "");
+    import_args37.default.option(["p", "password"], "Password (plain text)", "");
+    flags34 = import_args37.default.parse(process.argv);
+    main50 = async () => {
+      const userName3 = String(flags34.user || "").trim();
+      const password = String(flags34.password || "");
       if (!userName3 || !password) {
-        console.error(import_chalk54.default.red("Missing -U <user> or -P <password>"));
+        console.error(import_chalk55.default.red("Missing -U <user> or -P <password>"));
         process.exit(1);
       }
       const passwordHash = await import_bcryptjs.default.hash(password, 10);
@@ -41199,7 +41365,7 @@ var init_user_add = __esm({
       await (0, import_redis22.setData)(import_redis22.redisKeys.user(userName3), next, {
         expire: 0
       });
-      console.log(import_chalk54.default.green(`User ${userName3} updated`));
+      console.log(import_chalk55.default.green(`User ${userName3} updated`));
       process.exit(0);
     };
   }
@@ -41209,7 +41375,7 @@ var init_user_add = __esm({
 var cli_exports = {};
 __export(cli_exports, {
   cleanupCliResources: () => cleanupCliResources,
-  main: () => main50,
+  main: () => main51,
   printUsage: () => printUsage3,
   runLoadedModule: () => runLoadedModule
 });
@@ -41253,6 +41419,7 @@ var scriptLoaders = {
   results: () => Promise.resolve().then(() => (init_results(), results_exports)),
   "replay-runtime-evidence": () => Promise.resolve().then(() => (init_replayRuntimeEvidence(), replayRuntimeEvidence_exports)),
   "runtime-feedback-replay": () => Promise.resolve().then(() => (init_runtimeFeedbackReplay2(), runtimeFeedbackReplay_exports)),
+  "runtime-feedback-notify": () => Promise.resolve().then(() => (init_runtimeFeedbackNotify(), runtimeFeedbackNotify_exports)),
   "runtime-feedback-sync": () => Promise.resolve().then(() => (init_runtimeFeedbackSync2(), runtimeFeedbackSync_exports)),
   "runtime-evidence": () => Promise.resolve().then(() => (init_runtimeEvidence(), runtimeEvidence_exports)),
   "runtime-evidence-sync": () => Promise.resolve().then(() => (init_runtimeEvidenceSync2(), runtimeEvidenceSync_exports)),
@@ -41285,14 +41452,14 @@ var runLoadedModule = async (loaded) => {
 var cleanupCliResources = async () => {
   await Promise.allSettled([(0, import_redis23.closeRedisConnection)(), (0, import_client9.closeTimescalePool)()]);
 };
-var main50 = async () => {
-  const [, scriptPath, command = "", ...args37] = process.argv;
+var main51 = async () => {
+  const [, scriptPath, command = "", ...args38] = process.argv;
   const loader = scriptLoaders[command];
   if (!loader) {
     printUsage3();
     process.exit(command ? 1 : 0);
   }
-  const nextArgs = [...args37];
+  const nextArgs = [...args38];
   if (command === "spread:ingest") {
     nextArgs.push("--provider", "binance_coinbase_spread");
   }
@@ -41316,7 +41483,7 @@ var main50 = async () => {
   }
 };
 if (require.main === module) {
-  main50().catch((error) => {
+  main51().catch((error) => {
     console.error(error);
     process.exit(1);
   });