@tradejs/cli 1.0.5 → 1.0.6

package/dist/cli.js

@@ -33,6 +33,321 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// src/scripts/selectStrategy.ts
+var import_readline, import_chalk, import_strategies, defaultStrategy, projectRoot, getStrategyChoices, selectStrategy;
+var init_selectStrategy = __esm({
+  "src/scripts/selectStrategy.ts"() {
+    "use strict";
+    import_readline = __toESM(require("readline"));
+    import_chalk = __toESM(require("chalk"));
+    import_strategies = require("@tradejs/node/strategies");
+    defaultStrategy = "TrendLine";
+    projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    getStrategyChoices = async () => {
+      try {
+        const loaded = await (0, import_strategies.getAvailableStrategyNames)(projectRoot);
+        if (loaded.length) {
+          return loaded;
+        }
+      } catch (error) {
+        console.warn(`Failed to load strategy list: ${String(error)}`);
+      }
+      return [
+        "Breakout",
+        "MaStrategy",
+        "AdaptiveMomentumRibbon",
+        "TrendLine",
+        "VolumeDivergence"
+      ];
+    };
+    selectStrategy = async (promptLabel = "Select strategy", options) => {
+      const strategies = options?.strategies && options.strategies.length ? options.strategies : await getStrategyChoices();
+      const preferredDefault = options?.defaultStrategy || defaultStrategy;
+      const fallbackStrategy = strategies.includes(preferredDefault) ? preferredDefault : strategies[0];
+      if (!process.stdin.isTTY) {
+        return fallbackStrategy;
+      }
+      console.log(import_chalk.default.cyan("Available strategies:"));
+      strategies.forEach((name, index) => {
+        const isDefault = name === defaultStrategy;
+        const label = isDefault ? import_chalk.default.green(name) : name;
+        const suffix = isDefault ? import_chalk.default.gray(" (default)") : "";
+        console.log(`  ${import_chalk.default.yellow(String(index + 1))}) ${label}${suffix}`);
+      });
+      const rl = import_readline.default.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      const question = (text) => new Promise((resolve) => rl.question(text, resolve));
+      const answer = await question(
+        `${promptLabel} [${import_chalk.default.green(fallbackStrategy)}]: `
+      );
+      rl.close();
+      const trimmed = answer.trim();
+      if (!trimmed) {
+        return fallbackStrategy;
+      }
+      const asNumber = Number(trimmed);
+      if (Number.isFinite(asNumber) && asNumber >= 1 && asNumber <= strategies.length) {
+        return strategies[asNumber - 1];
+      }
+      const byName = strategies.find(
+        (name) => name.toLowerCase() === trimmed.toLowerCase()
+      );
+      if (byName) {
+        return byName;
+      }
+      console.warn(`Unknown strategy "${trimmed}", using ${fallbackStrategy}.`);
+      return fallbackStrategy;
+    };
+  }
+});
+
+// src/scripts/resolveExportStrategy.ts
+var resolveExportStrategy;
+var init_resolveExportStrategy = __esm({
+  "src/scripts/resolveExportStrategy.ts"() {
+    "use strict";
+    init_selectStrategy();
+    resolveExportStrategy = async ({
+      explicitStrategy,
+      outDir,
+      datasetLabel,
+      promptLabel,
+      listStrategies
+    }) => {
+      const raw = String(explicitStrategy || "").trim();
+      if (raw) {
+        return raw;
+      }
+      const availableStrategies = await listStrategies({ outDir });
+      if (!availableStrategies.length) {
+        return null;
+      }
+      if (availableStrategies.length === 1) {
+        return availableStrategies[0];
+      }
+      if (!process.stdin.isTTY) {
+        throw new Error(
+          `Multiple ${datasetLabel} chunk strategies found in ${outDir}: ${availableStrategies.join(", ")}. Pass --strategy.`
+        );
+      }
+      return selectStrategy(promptLabel, {
+        strategies: availableStrategies,
+        defaultStrategy: availableStrategies[0]
+      });
+    };
+  }
+});
+
+// src/scripts/aiExport.ts
+var aiExport_exports = {};
+var import_args, import_chalk2, import_promises, import_path, import_ai, flags, main;
+var init_aiExport = __esm({
+  "src/scripts/aiExport.ts"() {
+    "use strict";
+    import_args = __toESM(require("args"));
+    import_chalk2 = __toESM(require("chalk"));
+    import_promises = __toESM(require("fs/promises"));
+    import_path = __toESM(require("path"));
+    import_ai = require("@tradejs/infra/ai");
+    init_resolveExportStrategy();
+    import_args.default.example(
+      "yarn ts-node ./src/scripts/aiExport --strategy trendline",
+      "Merge per-worker AI prompt chunks into one dataset JSONL"
+    );
+    import_args.default.option(["o", "outDir"], "Dataset directory", "data/ai/export");
+    import_args.default.option(["s", "strategy"], "Strategy name", "");
+    import_args.default.option(
+      ["k", "keepChunks"],
+      "Keep source chunk files after successful merge",
+      false
+    );
+    flags = import_args.default.parse(process.argv);
+    main = async () => {
+      const outDir = String(flags.outDir || "data/ai/export");
+      await import_promises.default.mkdir(outDir, { recursive: true });
+      const strategyName = await resolveExportStrategy({
+        explicitStrategy: String(flags.strategy || ""),
+        outDir,
+        datasetLabel: "AI",
+        promptLabel: "Select AI export strategy",
+        listStrategies: import_ai.listAiChunkStrategies
+      });
+      if (!strategyName) {
+        console.log(import_chalk2.default.yellow(`No AI chunk files found in ${outDir}`));
+        process.exit(0);
+      }
+      const chunkFiles = await (0, import_ai.listAiChunkFiles)({
+        strategyName,
+        outDir
+      });
+      if (!chunkFiles.length) {
+        console.log(
+          import_chalk2.default.yellow(
+            `No chunk files found for strategy "${strategyName}" in ${outDir}`
+          )
+        );
+        process.exit(0);
+      }
+      const mergedPath = import_path.default.join(
+        outDir,
+        `ai-dataset-${(0, import_ai.toFileToken)(strategyName)}-merged-${Date.now()}.jsonl`
+      );
+      await (0, import_ai.mergeAiJsonlFiles)({
+        filePaths: chunkFiles,
+        outPath: mergedPath
+      });
+      const shouldDeleteChunks = !Boolean(flags.keepChunks);
+      if (shouldDeleteChunks) {
+        for (const filePath of chunkFiles) {
+          await import_promises.default.rm(filePath, { force: true });
+        }
+      }
+      console.log(import_chalk2.default.green(`Merged AI dataset saved: ${mergedPath}`));
+      console.log(
+        import_chalk2.default.gray(
+          `strategy=${strategyName}, source_chunks=${chunkFiles.length}, deleteChunks=${Boolean(
+            shouldDeleteChunks
+          )}`
+        )
+      );
+      process.exit(0);
+    };
+    main().catch((error) => {
+      console.error(import_chalk2.default.red(error?.message || String(error)));
+      process.exit(1);
+    });
+  }
+});
+
+// src/lib/aiTrainMetrics.ts
+var divideOrNull, qualitySortKey, summarizeAiTrainEvaluations, getDirectionSortKey, summarizeAiTrainEvaluationsByDirection;
+var init_aiTrainMetrics = __esm({
+  "src/lib/aiTrainMetrics.ts"() {
+    "use strict";
+    divideOrNull = (num, denom) => {
+      if (denom <= 0) {
+        return null;
+      }
+      return num / denom;
+    };
+    qualitySortKey = (quality) => quality == null ? Number.POSITIVE_INFINITY : quality;
+    summarizeAiTrainEvaluations = (evaluations) => {
+      let approved = 0;
+      let rejected = 0;
+      let correct = 0;
+      let incorrect = 0;
+      let profitable = 0;
+      let unprofitable = 0;
+      let flat = 0;
+      let truePositive = 0;
+      let falsePositive = 0;
+      let trueNegative = 0;
+      let falseNegative = 0;
+      let totalProfitAll = 0;
+      let totalProfitApproved = 0;
+      const bucketMap = /* @__PURE__ */ new Map();
+      for (const evaluation of evaluations) {
+        const { profit, profitableTrade, aiApproved, quality } = evaluation;
+        totalProfitAll += profit;
+        if (profitableTrade) {
+          profitable += 1;
+        } else if (profit < 0) {
+          unprofitable += 1;
+        } else {
+          flat += 1;
+        }
+        if (aiApproved) {
+          approved += 1;
+          totalProfitApproved += profit;
+        } else {
+          rejected += 1;
+        }
+        const isCorrect = aiApproved === profitableTrade;
+        if (isCorrect) {
+          correct += 1;
+        } else {
+          incorrect += 1;
+        }
+        if (aiApproved && profitableTrade) {
+          truePositive += 1;
+        } else if (aiApproved && !profitableTrade) {
+          falsePositive += 1;
+        } else if (!aiApproved && profitableTrade) {
+          falseNegative += 1;
+        } else {
+          trueNegative += 1;
+        }
+        const bucket = bucketMap.get(quality) ?? {
+          quality,
+          count: 0,
+          approved: 0,
+          profitable: 0,
+          totalProfit: 0
+        };
+        bucket.count += 1;
+        bucket.totalProfit += profit;
+        if (aiApproved) {
+          bucket.approved += 1;
+        }
+        if (profitableTrade) {
+          bucket.profitable += 1;
+        }
+        bucketMap.set(quality, bucket);
+      }
+      const avgProfitAll = divideOrNull(totalProfitAll, evaluations.length);
+      const avgProfitApproved = divideOrNull(totalProfitApproved, approved);
+      const expectancyDelta = avgProfitAll == null || avgProfitApproved == null ? null : avgProfitApproved - avgProfitAll;
+      return {
+        approved,
+        rejected,
+        correct,
+        incorrect,
+        truePositive,
+        falsePositive,
+        trueNegative,
+        falseNegative,
+        profitable,
+        unprofitable,
+        flat,
+        precisionApproved: divideOrNull(truePositive, approved),
+        recallWinners: divideOrNull(truePositive, profitable),
+        avgProfitAll,
+        avgProfitApproved,
+        expectancyDelta,
+        qualityBuckets: [...bucketMap.values()].sort(
+          (a, b) => qualitySortKey(a.quality) - qualitySortKey(b.quality)
+        )
+      };
+    };
+    getDirectionSortKey = (direction) => {
+      if (direction === "LONG") {
+        return 0;
+      }
+      if (direction === "SHORT") {
+        return 1;
+      }
+      return 2;
+    };
+    summarizeAiTrainEvaluationsByDirection = (evaluations) => {
+      const grouped = /* @__PURE__ */ new Map();
+      for (const evaluation of evaluations) {
+        const direction = typeof evaluation.direction === "string" && evaluation.direction.trim() ? evaluation.direction : "UNKNOWN";
+        const bucket = grouped.get(direction) ?? [];
+        bucket.push(evaluation);
+        grouped.set(direction, bucket);
+      }
+      return [...grouped.entries()].sort(
+        ([leftDirection], [rightDirection]) => getDirectionSortKey(leftDirection) - getDirectionSortKey(rightDirection) || leftDirection.localeCompare(rightDirection)
+      ).map(([direction, directionEvaluations]) => ({
+        direction,
+        summary: summarizeAiTrainEvaluations(directionEvaluations)
+      }));
+    };
+  }
+});
+
 // ../../node_modules/debug/node_modules/ms/index.js
 var require_ms = __commonJS({
   "../../node_modules/debug/node_modules/ms/index.js"(exports2, module2) {
@@ -183,7 +498,7 @@ var require_common = __commonJS({
         let enableOverride = null;
         let namespacesCache;
         let enabledCache;
-        function debug(...args14) {
+        function debug(...args17) {
           if (!debug.enabled) {
             return;
           }
@@ -194,28 +509,28 @@ var require_common = __commonJS({
           self.prev = prevTime;
           self.curr = curr;
           prevTime = curr;
-          args14[0] = createDebug.coerce(args14[0]);
-          if (typeof args14[0] !== "string") {
-            args14.unshift("%O");
+          args17[0] = createDebug.coerce(args17[0]);
+          if (typeof args17[0] !== "string") {
+            args17.unshift("%O");
           }
           let index = 0;
-          args14[0] = args14[0].replace(/%([a-zA-Z%])/g, (match, format2) => {
+          args17[0] = args17[0].replace(/%([a-zA-Z%])/g, (match, format2) => {
             if (match === "%%") {
               return "%";
             }
             index++;
             const formatter = createDebug.formatters[format2];
             if (typeof formatter === "function") {
-              const val = args14[index];
+              const val = args17[index];
               match = formatter.call(self, val);
-              args14.splice(index, 1);
+              args17.splice(index, 1);
               index--;
             }
             return match;
           });
-          createDebug.formatArgs.call(self, args14);
+          createDebug.formatArgs.call(self, args17);
           const logFn = self.log || createDebug.log;
-          logFn.apply(self, args14);
+          logFn.apply(self, args17);
         }
         debug.namespace = namespace;
         debug.useColors = createDebug.useColors();
@@ -423,16 +738,16 @@ var require_browser = __commonJS({
       typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/firefox\/(\d+)/) && parseInt(RegExp.$1, 10) >= 31 || // Double check webkit in userAgent just in case we are in a worker
       typeof navigator !== "undefined" && navigator.userAgent && navigator.userAgent.toLowerCase().match(/applewebkit\/(\d+)/);
     }
-    function formatArgs(args14) {
-      args14[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args14[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff);
+    function formatArgs(args17) {
+      args17[0] = (this.useColors ? "%c" : "") + this.namespace + (this.useColors ? " %c" : " ") + args17[0] + (this.useColors ? "%c " : " ") + "+" + module2.exports.humanize(this.diff);
       if (!this.useColors) {
         return;
       }
       const c = "color: " + this.color;
-      args14.splice(1, 0, c, "color: inherit");
+      args17.splice(1, 0, c, "color: inherit");
       let index = 0;
       let lastC = 0;
-      args14[0].replace(/%[a-zA-Z%]/g, (match) => {
+      args17[0].replace(/%[a-zA-Z%]/g, (match) => {
         if (match === "%%") {
           return;
         }
@@ -441,7 +756,7 @@ var require_browser = __commonJS({
           lastC = index;
         }
       });
-      args14.splice(lastC, 0, c);
+      args17.splice(lastC, 0, c);
     }
     exports2.log = console.debug || console.log || (() => {
     });
@@ -723,16 +1038,16 @@ var require_node = __commonJS({
     function useColors() {
       return "colors" in exports2.inspectOpts ? Boolean(exports2.inspectOpts.colors) : tty.isatty(process.stderr.fd);
     }
-    function formatArgs(args14) {
+    function formatArgs(args17) {
       const { namespace: name, useColors: useColors2 } = this;
       if (useColors2) {
         const c = this.color;
         const colorCode = "\x1B[3" + (c < 8 ? c : "8;5;" + c);
         const prefix = `  ${colorCode};1m${name} \x1B[0m`;
-        args14[0] = prefix + args14[0].split("\n").join("\n" + prefix);
-        args14.push(colorCode + "m+" + module2.exports.humanize(this.diff) + "\x1B[0m");
+        args17[0] = prefix + args17[0].split("\n").join("\n" + prefix);
+        args17.push(colorCode + "m+" + module2.exports.humanize(this.diff) + "\x1B[0m");
       } else {
-        args14[0] = getDate() + name + " " + args14[0];
+        args17[0] = getDate() + name + " " + args17[0];
       }
     }
     function getDate() {
@@ -741,8 +1056,8 @@ var require_node = __commonJS({
       }
       return (/* @__PURE__ */ new Date()).toISOString() + " ";
     }
-    function log(...args14) {
-      return process.stderr.write(util.format(...args14) + "\n");
+    function log(...args17) {
+      return process.stderr.write(util.format(...args17) + "\n");
     }
     function save(namespaces) {
       if (namespaces) {
@@ -1602,34 +1917,548 @@ var require_list_it = __commonJS({
   "../../node_modules/list-it/index.js"(exports2, module2) {
     "use strict";
     var ListItBuffer = require_list_it_buffer();
-    function ListIt3(opt) {
+    function ListIt4(opt) {
       ListItBuffer.call(this, opt);
     }
-    ListIt3.prototype = new ListItBuffer();
-    ListIt3.buffer = function(opt) {
+    ListIt4.prototype = new ListItBuffer();
+    ListIt4.buffer = function(opt) {
       opt = opt || {};
       if (!("autoAlign" in opt)) {
         opt.autoAlign = false;
       }
-      return new ListIt3(opt);
+      return new ListIt4(opt);
+    };
+    module2.exports = ListIt4;
+  }
+});
+
+// src/scripts/aiTrain.ts
+var aiTrain_exports = {};
+var import_args2, import_chalk3, import_promises2, import_path2, import_progress, import_async, import_ai2, import_ai3, import_constants, ListIt, flags2, createListIt, createTable, formatRatio, formatProfit, colorizeRatio, colorizePercent, colorizeProfit, colorizeQuality, normalizeInt, normalizePositiveInt, normalizeQuality, isProfitableTrade, isAiApproval, listMergedFiles, deriveStrategyNameFromFile, extractSignalFromDatasetRow, resolvePromptRunContext, getDeterministicGateContext, resolveDeterministicGateEvaluation, summarizeDeterministicGateEvaluations, printSection, resolveDatasetFile, main2;
+var init_aiTrain = __esm({
+  "src/scripts/aiTrain.ts"() {
+    "use strict";
+    import_args2 = __toESM(require("args"));
+    import_chalk3 = __toESM(require("chalk"));
+    import_promises2 = __toESM(require("fs/promises"));
+    import_path2 = __toESM(require("path"));
+    import_progress = __toESM(require("progress"));
+    import_async = require("@tradejs/core/async");
+    import_ai2 = require("@tradejs/infra/ai");
+    import_ai3 = require("@tradejs/node/ai");
+    import_constants = require("@tradejs/node/constants");
+    init_aiTrainMetrics();
+    ListIt = require_list_it();
+    import_args2.default.example(
+      "yarn ai-train -n 50 --minQuality 4",
+      "Replay latest AI prompt dataset and measure approval accuracy"
+    );
+    import_args2.default.option(["o", "outDir"], "Dataset directory", "data/ai/export");
+    import_args2.default.option(["s", "strategy"], "Strategy name filter for merged file", "");
+    import_args2.default.option(["f", "file"], "Explicit merged dataset file path", "");
+    import_args2.default.option(
+      ["n", "recent"],
+      "How many recent trades to evaluate from the end (0 = all)",
+      50
+    );
+    import_args2.default.option(
+      "skip",
+      "How many recent trades to skip from the end before selecting replay rows",
+      0
+    );
+    import_args2.default.option(
+      ["p", "parallel"],
+      "Concurrent AI requests during replay",
+      import_constants.AI_CONCURRENCY_LIMIT
+    );
+    import_args2.default.option(
+      "model",
+      "OpenRouter model id override for this replay run",
+      import_ai3.DEFAULT_AI_MODEL
+    );
+    import_args2.default.option("minQuality", "Minimum AI quality required to approve entry", 4);
+    import_args2.default.option(
+      "localOnly",
+      "Replay deterministic adapter gate without AI provider calls",
+      false
+    );
+    flags2 = import_args2.default.parse(process.argv);
+    createListIt = () => new ListIt({
+      autoAlign: true,
+      headerUnderline: true
+    });
+    createTable = (headers, rows) => createListIt().setHeaderRow(headers).d(rows).toString();
+    formatRatio = (value) => value == null ? "n/a" : `${(value * 100).toFixed(1)}%`;
+    formatProfit = (value) => value == null ? "n/a" : value.toFixed(2);
+    colorizeRatio = (value) => {
+      const text = formatRatio(value);
+      if (value == null) {
+        return import_chalk3.default.gray(text);
+      }
+      if (value >= 0.6) {
+        return import_chalk3.default.green(text);
+      }
+      if (value >= 0.3) {
+        return import_chalk3.default.yellow(text);
+      }
+      return import_chalk3.default.red(text);
+    };
+    colorizePercent = (value, total) => {
+      const ratio = total > 0 ? value / total : null;
+      return colorizeRatio(ratio);
+    };
+    colorizeProfit = (value) => {
+      const text = formatProfit(value);
+      if (value == null) {
+        return import_chalk3.default.gray(text);
+      }
+      if (value > 0) {
+        return import_chalk3.default.green(text);
+      }
+      if (value < 0) {
+        return import_chalk3.default.red(text);
+      }
+      return import_chalk3.default.yellow(text);
+    };
+    colorizeQuality = (quality) => {
+      const text = quality == null ? "n/a" : String(quality);
+      if (quality == null) {
+        return import_chalk3.default.gray(text);
+      }
+      if (quality >= 4) {
+        return import_chalk3.default.green(text);
+      }
+      if (quality === 3) {
+        return import_chalk3.default.yellow(text);
+      }
+      return import_chalk3.default.red(text);
+    };
+    normalizeInt = (value, fallback) => {
+      const parsed = Number(value);
+      return Number.isFinite(parsed) ? Math.max(0, Math.trunc(parsed)) : fallback;
+    };
+    normalizePositiveInt = (value, fallback) => {
+      const parsed = Number(value);
+      return Number.isFinite(parsed) && parsed > 0 ? Math.trunc(parsed) : fallback;
+    };
+    normalizeQuality = (analysis) => {
+      const quality = Number(analysis?.quality);
+      return Number.isFinite(quality) ? Math.round(quality) : null;
+    };
+    isProfitableTrade = (row) => Number(row.profit) > 0;
+    isAiApproval = (row, analysis, minQuality) => {
+      const quality = normalizeQuality(analysis);
+      return analysis.direction === row.direction && quality != null && quality >= minQuality;
+    };
+    listMergedFiles = async (params) => {
+      const { outDir, strategyName } = params;
+      let entries = [];
+      try {
+        entries = await import_promises2.default.readdir(outDir);
+      } catch {
+        return [];
+      }
+      const prefix = strategyName ? `ai-dataset-${(0, import_ai2.toFileToken)(strategyName)}-merged-` : "ai-dataset-";
+      return entries.filter((name) => name.startsWith(prefix)).filter((name) => name.includes("-merged-") && name.endsWith(".jsonl")).sort().map((name) => import_path2.default.join(outDir, name));
+    };
+    deriveStrategyNameFromFile = (filePath) => {
+      const match = import_path2.default.basename(filePath).match(/^ai-dataset-(.+)-merged-\d+\.jsonl$/);
+      return match?.[1] ? match[1] : "unknown";
+    };
+    extractSignalFromDatasetRow = (row) => {
+      const { payload } = row;
+      return {
+        ...payload.signal,
+        strategy: payload.signal.strategy,
+        figures: payload.figures ?? {},
+        indicators: payload.indicators ?? {},
+        additionalIndicators: payload.additionalIndicators ?? {},
+        prices: payload.signal.prices
+      };
+    };
+    resolvePromptRunContext = (row) => {
+      const signal = extractSignalFromDatasetRow(row);
+      return {
+        signal,
+        promptPair: (0, import_ai3.buildAiPrompts)(signal)
+      };
+    };
+    getDeterministicGateContext = (signal) => {
+      const payload = (0, import_ai3.buildAiPayload)(signal);
+      return (0, import_ai3.getDeterministicAiGateContext)(payload);
+    };
+    resolveDeterministicGateEvaluation = (signal, fallbackDirection) => {
+      if (!signal) {
+        return {
+          direction: fallbackDirection || "UNKNOWN",
+          signalAvailable: false,
+          coreBlocked: false,
+          adapterBlocked: false,
+          modelCandidate: false
+        };
+      }
+      const gateContext = getDeterministicGateContext(signal);
+      const structuralHardBlockReasons = Array.isArray(
+        gateContext?.structuralHardBlockReasons
+      ) ? gateContext.structuralHardBlockReasons.filter(
+        (reason) => typeof reason === "string" && reason.trim().length > 0
+      ) : [];
+      const coreBlocked = structuralHardBlockReasons.length > 0;
+      const approvalAllowedNow = typeof gateContext?.approvalAllowedNow === "boolean" ? gateContext.approvalAllowedNow : null;
+      const adapterBlocked = !coreBlocked && approvalAllowedNow === false;
+      return {
+        direction: typeof signal.direction === "string" && signal.direction.trim() ? signal.direction : fallbackDirection || "UNKNOWN",
+        signalAvailable: true,
+        coreBlocked,
+        adapterBlocked,
+        modelCandidate: !coreBlocked && !adapterBlocked
+      };
+    };
+    summarizeDeterministicGateEvaluations = (deterministicEvaluations, evaluations) => {
+      const summary = {
+        selected: deterministicEvaluations.length,
+        signalAvailable: 0,
+        signalMissing: 0,
+        coreBlocked: 0,
+        adapterBlocked: 0,
+        modelCandidate: 0,
+        modelApproved: 0,
+        modelRejected: 0,
+        modelFailed: 0
+      };
+      for (const evaluation of deterministicEvaluations) {
+        if (evaluation.signalAvailable) {
+          summary.signalAvailable += 1;
+        } else {
+          summary.signalMissing += 1;
+        }
+        if (evaluation.coreBlocked) {
+          summary.coreBlocked += 1;
+        } else if (evaluation.adapterBlocked) {
+          summary.adapterBlocked += 1;
+        } else if (evaluation.modelCandidate) {
+          summary.modelCandidate += 1;
+        }
+      }
+      for (const evaluation of evaluations) {
+        if (!evaluation.modelCandidate) {
+          continue;
+        }
+        if (evaluation.aiApproved) {
+          summary.modelApproved += 1;
+        } else {
+          summary.modelRejected += 1;
+        }
+      }
+      summary.modelFailed = summary.modelCandidate - summary.modelApproved - summary.modelRejected;
+      return summary;
     };
-    module2.exports = ListIt3;
+    printSection = (title, table) => {
+      console.log(import_chalk3.default.gray(`${title}:`));
+      console.log(table);
+      console.log("");
+    };
+    resolveDatasetFile = async () => {
+      const explicitFile = String(flags2.file || "").trim();
+      if (explicitFile) {
+        return import_path2.default.resolve(explicitFile);
+      }
+      const outDir = String(flags2.outDir || "data/ai/export");
+      const strategyName = String(flags2.strategy || "").trim() || void 0;
+      const mergedFiles = await listMergedFiles({
+        outDir,
+        strategyName
+      });
+      if (!mergedFiles.length) {
+        throw new Error(
+          strategyName ? `No merged AI dataset found for strategy "${strategyName}" in ${outDir}. Run yarn ai-export first.` : `No merged AI dataset found in ${outDir}. Run yarn ai-export first.`
+        );
+      }
+      return mergedFiles[mergedFiles.length - 1];
+    };
+    main2 = async () => {
+      const recent = normalizeInt(flags2.recent, 50);
+      const skip = normalizeInt(flags2.skip, 0);
+      const minQuality = normalizeInt(flags2.minQuality, 4);
+      const localOnly = Boolean(flags2.localOnly);
+      const model = String(flags2.model || import_ai3.DEFAULT_AI_MODEL).trim() || import_ai3.DEFAULT_AI_MODEL;
+      const parallel = normalizePositiveInt(flags2.parallel, import_constants.AI_CONCURRENCY_LIMIT);
+      await (0, import_ai3.ensureAiStrategyPluginsLoaded)();
+      const filePath = await resolveDatasetFile();
+      const { rows, totalRows } = await (0, import_ai2.readAiDatasetRows)({
+        filePath,
+        limitFromEnd: recent,
+        skipFromEnd: skip
+      });
+      if (!rows.length) {
+        console.log(
+          import_chalk3.default.yellow(
+            `No AI prompt rows selected in ${filePath} (recent=${recent || "all"}, skip=${skip})`
+          )
+        );
+        process.exit(0);
+      }
+      const strategyName = rows[0]?.strategyName || deriveStrategyNameFromFile(filePath);
+      const preparedRows = rows.map((row) => {
+        const { promptPair, signal } = resolvePromptRunContext(row);
+        const payload = (0, import_ai3.buildAiPayload)(signal);
+        return {
+          row,
+          promptPair,
+          payload,
+          signal,
+          deterministic: resolveDeterministicGateEvaluation(signal, row.direction)
+        };
+      });
+      const concurrency = Math.max(1, Math.min(parallel, rows.length));
+      const bar = new import_progress.default(
+        ":current/:total [:bar][:percent] :symbol :status",
+        {
+          total: rows.length,
+          width: 20
+        }
+      );
+      let failed = 0;
+      const errorMessages2 = [];
+      const evaluations = [];
+      await (0, import_async.runWithConcurrency)(preparedRows, concurrency, async (preparedRow) => {
+        const { row, promptPair, payload, signal, deterministic } = preparedRow;
+        const profit = Number(row.profit);
+        const profitableTrade = isProfitableTrade(row);
+        try {
+          const analysis = localOnly ? await (0, import_ai3.runAiPromptLocal)(signal, { payload }) : await (0, import_ai3.runAiPrompt)(
+            promptPair,
+            signal ? {
+              model,
+              signal,
+              payload
+            } : { model }
+          );
+          const aiApproved = isAiApproval(row, analysis, minQuality);
+          const quality = normalizeQuality(analysis);
+          const isCorrect = aiApproved === profitableTrade;
+          evaluations.push({
+            profit,
+            profitableTrade,
+            aiApproved,
+            quality,
+            direction: row.direction,
+            modelCandidate: deterministic.modelCandidate
+          });
+          bar.tick(1, {
+            symbol: import_chalk3.default.gray(row.symbol),
+            status: isCorrect ? import_chalk3.default.green("ok") : import_chalk3.default.red("miss")
+          });
+        } catch (error) {
+          failed += 1;
+          if (errorMessages2.length < 5) {
+            errorMessages2.push(
+              `[${row.symbol}/${row.signalId}] ${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+          bar.tick(1, {
+            symbol: import_chalk3.default.gray(row.symbol),
+            status: import_chalk3.default.yellow("error")
+          });
+        }
+      });
+      const summary = summarizeAiTrainEvaluations(evaluations);
+      const directionSummaries = summarizeAiTrainEvaluationsByDirection(evaluations);
+      const deterministicSummary = summarizeDeterministicGateEvaluations(
+        preparedRows.map((preparedRow) => preparedRow.deterministic),
+        evaluations
+      );
+      const evaluated = summary.correct + summary.incorrect;
+      console.log("");
+      console.log(import_chalk3.default.green("AI train finished"));
+      console.log(import_chalk3.default.gray(filePath));
+      console.log("");
+      printSection(
+        "RUN",
+        createTable(
+          [import_chalk3.default.gray("FIELD"), import_chalk3.default.gray("VALUE")],
+          [
+            ["strategy", import_chalk3.default.yellow(strategyName)],
+            ["selected", import_chalk3.default.blue(String(rows.length))],
+            ["source_rows", import_chalk3.default.blue(String(totalRows))],
+            ["recent", import_chalk3.default.blue(recent === 0 ? "all" : String(recent))],
+            ["skip", import_chalk3.default.blue(String(skip))],
+            ["min_quality", import_chalk3.default.magenta(String(minQuality))],
+            [
+              "mode",
+              localOnly ? import_chalk3.default.green("local-deterministic") : import_chalk3.default.yellow("llm")
+            ],
+            ["model", import_chalk3.default.yellow(localOnly ? "local-deterministic" : model)],
+            ["parallel", import_chalk3.default.magenta(String(concurrency))]
+          ]
+        )
+      );
+      printSection(
+        "OUTCOME",
+        createTable(
+          [import_chalk3.default.gray("METRIC"), import_chalk3.default.gray("VALUE")],
+          [
+            ["accuracy", colorizePercent(summary.correct, evaluated)],
+            ["evaluated", import_chalk3.default.blue(String(evaluated))],
+            ["correct", import_chalk3.default.green(String(summary.correct))],
+            ["incorrect", import_chalk3.default.red(String(summary.incorrect))],
+            [
+              "failed",
+              failed > 0 ? import_chalk3.default.yellow(String(failed)) : import_chalk3.default.green("0")
+            ],
+            ["approved", import_chalk3.default.cyan(String(summary.approved))],
+            ["rejected", import_chalk3.default.cyan(String(summary.rejected))],
+            ["profitable", import_chalk3.default.green(String(summary.profitable))],
+            ["unprofitable", import_chalk3.default.red(String(summary.unprofitable))],
+            ["flat", import_chalk3.default.yellow(String(summary.flat))],
+            ["precision_approved", colorizeRatio(summary.precisionApproved)],
+            ["recall_winners", colorizeRatio(summary.recallWinners)],
+            ["avg_profit_all", colorizeProfit(summary.avgProfitAll)],
+            ["avg_profit_approved", colorizeProfit(summary.avgProfitApproved)],
+            ["expectancy_delta", colorizeProfit(summary.expectancyDelta)]
+          ]
+        )
+      );
+      printSection(
+        "CONFUSION",
+        createTable(
+          [import_chalk3.default.green("TP"), import_chalk3.default.red("FP"), import_chalk3.default.green("TN"), import_chalk3.default.red("FN")],
+          [
+            [
+              import_chalk3.default.green(String(summary.truePositive)),
+              import_chalk3.default.red(String(summary.falsePositive)),
+              import_chalk3.default.green(String(summary.trueNegative)),
+              import_chalk3.default.red(String(summary.falseNegative))
+            ]
+          ]
+        )
+      );
+      if (directionSummaries.length) {
+        printSection(
+          "BY DIRECTION",
+          createTable(
+            [
+              import_chalk3.default.gray("DIR"),
+              import_chalk3.default.gray("EVAL"),
+              import_chalk3.default.gray("ACCURACY"),
+              import_chalk3.default.gray("APPROVED"),
+              import_chalk3.default.green("TP"),
+              import_chalk3.default.red("FP"),
+              import_chalk3.default.green("TN"),
+              import_chalk3.default.red("FN"),
+              import_chalk3.default.gray("PRECISION"),
+              import_chalk3.default.gray("RECALL")
+            ],
+            directionSummaries.map(({ direction, summary: directionSummary }) => {
+              const directionEvaluated = directionSummary.correct + directionSummary.incorrect;
+              return [
+                import_chalk3.default.yellow(direction),
+                import_chalk3.default.blue(String(directionEvaluated)),
+                colorizePercent(directionSummary.correct, directionEvaluated),
+                import_chalk3.default.cyan(String(directionSummary.approved)),
+                import_chalk3.default.green(String(directionSummary.truePositive)),
+                import_chalk3.default.red(String(directionSummary.falsePositive)),
+                import_chalk3.default.green(String(directionSummary.trueNegative)),
+                import_chalk3.default.red(String(directionSummary.falseNegative)),
+                colorizeRatio(directionSummary.precisionApproved),
+                colorizeRatio(directionSummary.recallWinners)
+              ];
+            })
+          )
+        );
+      }
+      printSection(
+        "DETERMINISTIC FLOW",
+        createTable(
+          [import_chalk3.default.gray("METRIC"), import_chalk3.default.gray("VALUE")],
+          [
+            ["selected", import_chalk3.default.blue(String(deterministicSummary.selected))],
+            [
+              "signal_available",
+              import_chalk3.default.blue(String(deterministicSummary.signalAvailable))
+            ],
+            [
+              "signal_missing",
+              deterministicSummary.signalMissing > 0 ? import_chalk3.default.yellow(String(deterministicSummary.signalMissing)) : import_chalk3.default.green("0")
+            ],
+            [
+              "core_blocked_now",
+              deterministicSummary.coreBlocked > 0 ? import_chalk3.default.yellow(String(deterministicSummary.coreBlocked)) : import_chalk3.default.green("0")
+            ],
+            [
+              "adapter_blocked_now",
+              deterministicSummary.adapterBlocked > 0 ? import_chalk3.default.yellow(String(deterministicSummary.adapterBlocked)) : import_chalk3.default.green("0")
+            ],
+            [
+              "left_to_model_now",
+              import_chalk3.default.cyan(String(deterministicSummary.modelCandidate))
+            ],
+            [
+              "model_approved",
+              import_chalk3.default.green(String(deterministicSummary.modelApproved))
+            ],
+            [
+              "model_rejected",
+              import_chalk3.default.red(String(deterministicSummary.modelRejected))
+            ],
+            [
+              "model_failed",
+              deterministicSummary.modelFailed > 0 ? import_chalk3.default.yellow(String(deterministicSummary.modelFailed)) : import_chalk3.default.green("0")
+            ]
+          ]
+        )
+      );
+      if (summary.qualityBuckets.length) {
+        printSection(
+          "QUALITY BREAKDOWN",
+          createTable(
+            [
+              import_chalk3.default.gray("QUALITY"),
+              import_chalk3.default.gray("COUNT"),
+              import_chalk3.default.gray("APPROVED"),
+              import_chalk3.default.gray("APPROVAL_RATE"),
+              import_chalk3.default.gray("WINRATE"),
+              import_chalk3.default.gray("AVG_PROFIT")
+            ],
+            summary.qualityBuckets.map((bucket) => [
+              colorizeQuality(bucket.quality),
+              import_chalk3.default.blue(String(bucket.count)),
+              import_chalk3.default.cyan(String(bucket.approved)),
+              colorizeRatio(bucket.approved / bucket.count),
+              colorizeRatio(bucket.profitable / bucket.count),
+              colorizeProfit(bucket.totalProfit / bucket.count)
+            ])
+          )
+        );
+      }
+      if (errorMessages2.length) {
+        console.log(import_chalk3.default.yellow("AI provider errors:"));
+        errorMessages2.forEach((message) => {
+          console.log(import_chalk3.default.yellow(`- ${message}`));
+        });
+      }
+      process.exit(failed === rows.length ? 1 : 0);
+    };
+    main2().catch((error) => {
+      console.error(import_chalk3.default.red(error?.message || String(error)));
+      process.exit(1);
+    });
   }
 });
 
 // src/scripts/backtest.ts
 var backtest_exports = {};
-var import_args, import_progress, import_child_process, import_fs, import_path, import_os, import_chalk, import_lodash, import_date_fns, import_uuid, import_connectors, import_connectors2, import_cli, import_backtest, import_data, import_constants, import_redis, ListIt, MAX_PARALLEL, flags, interval, progressStep, uuid, projectRoot, testerWorkerPathCandidates, testerWorkerPath, testerNeedsTsRuntime, HEADERS_RESULTS, HEADERS_RESULTS_BY_TICKERS, successTests, errorTests, errorMessages, results, resultsByTickers, userName, runStartedAt, createListIt, createTable, createTimestamp, filterGoodTests, recordError, isStrategyConfigGrid, resolveBacktestConnectorName, getLogsById, setTestData, backtest, saveAndPrintResults, saveAndPrintResultsByTickers, finish;
+var import_args3, import_progress2, import_child_process, import_fs, import_path3, import_os, import_chalk4, import_lodash, import_date_fns, import_uuid, import_connectors, import_connectors2, import_cli, import_backtest, import_data, import_constants2, import_redis, ListIt2, MAX_PARALLEL, normalizedArgv, flags3, interval, progressStep, testsLimit, testsSkip, testItemTimeoutMs, uuid, projectRoot2, testerWorkerPathCandidates, testerWorkerPath, testerNeedsTsRuntime, HEADERS_RESULTS, HEADERS_RESULTS_BY_TICKERS, successTests, errorTests, errorMessages, results, resultsByTickers, resultArtifactsByTestName, artifactRefCountsByTestName, bestTickerTestNameBySymbol, topResultNames, userName, runStartedAt, createListIt2, createTable2, createTimestamp, isGoodTest, getResultAmount, recordError, stripInlineLogs, getInlineArtifacts, retainArtifacts, releaseArtifacts, insertTopResult, updateTopResults, updateBestTickerResult, isStrategyConfigGrid, resolveBacktestConnectorName, getLogsById, cacheArtifactsById, resolveResultArtifacts, setTestData, backtest, saveAndPrintResults, saveAndPrintResultsByTickers, finish;
 var init_backtest = __esm({
   "src/scripts/backtest.ts"() {
     "use strict";
-    import_args = __toESM(require("args"));
-    import_progress = __toESM(require("progress"));
+    import_args3 = __toESM(require("args"));
+    import_progress2 = __toESM(require("progress"));
     import_child_process = require("child_process");
     import_fs = __toESM(require("fs"));
-    import_path = __toESM(require("path"));
+    import_path3 = __toESM(require("path"));
     import_os = __toESM(require("os"));
-    import_chalk = __toESM(require("chalk"));
+    import_chalk4 = __toESM(require("chalk"));
     import_lodash = __toESM(require("lodash"));
     import_date_fns = require("date-fns");
     import_uuid = require("uuid");
@@ -1638,49 +2467,67 @@ var init_backtest = __esm({
     import_cli = require("@tradejs/node/cli");
     import_backtest = require("@tradejs/core/backtest");
     import_data = require("@tradejs/core/data");
-    import_constants = require("@tradejs/core/constants");
+    import_constants2 = require("@tradejs/core/constants");
     import_redis = require("@tradejs/infra/redis");
-    ListIt = require_list_it();
+    ListIt2 = require_list_it();
     MAX_PARALLEL = Math.min(import_os.default.cpus().length, 6);
-    import_args.default.example(
+    import_args3.default.example(
       " yarn backtest -t 400 --cacheOnly",
       "Run tests on uploaded data for 400 tickers"
     );
-    import_args.default.option(["t", "tickers"], "Selected tickers");
-    import_args.default.option(["e", "exclude"], "Exclude tickers from tests");
-    import_args.default.option(["l", "tickersLimit"], "Tickers limit");
-    import_args.default.option(["n", "tests"], "Tests limit", import_constants.TESTS_LIMIT);
-    import_args.default.option(["p", "parallel"], "Parallel tasks", MAX_PARALLEL);
-    import_args.default.option(["f", "timeframe"], "Timeframe", 15);
-    import_args.default.option(["T", "top"], "Return N best tests", import_constants.TESTS_TOP_LIMIT);
-    import_args.default.option(["u", "updateOnly"], "Only update tickers history", false);
-    import_args.default.option(["C", "cacheOnly"], "Do not update tickers history", false);
-    import_args.default.option(["c", "config"], "Backtest config", "breakout");
-    import_args.default.option(["L", "showTickersList"], "Just show only ticker list", false);
-    import_args.default.option(["S", "progressStep"], "Progress step", 100);
-    import_args.default.option(["U", "user"], "Use user config", "root");
-    import_args.default.option(
+    import_args3.default.option(["t", "tickers"], "Selected tickers");
+    import_args3.default.option(["e", "exclude"], "Exclude tickers from tests");
+    import_args3.default.option(["l", "tickersLimit"], "Tickers limit");
+    import_args3.default.option(["n", "tests"], "Tests limit", import_constants2.TESTS_LIMIT);
+    import_args3.default.option("skip", "Skip first N tests", 0);
+    import_args3.default.option(["p", "parallel"], "Parallel tasks", MAX_PARALLEL);
+    import_args3.default.option(["f", "timeframe"], "Timeframe", 15);
+    import_args3.default.option(["T", "top"], "Return N best tests", import_constants2.TESTS_TOP_LIMIT);
+    import_args3.default.option(["u", "updateOnly"], "Only update tickers history", false);
+    import_args3.default.option(["C", "cacheOnly"], "Do not update tickers history", false);
+    import_args3.default.option(["c", "config"], "Backtest config", "breakout");
+    import_args3.default.option(["L", "showTickersList"], "Just show only ticker list", false);
+    import_args3.default.option(["S", "progressStep"], "Progress step", 100);
+    import_args3.default.option(["U", "user"], "Use user config", "root");
+    import_args3.default.option(
       "connector",
       "Connector provider or name for backtest (e.g. bybit, binance, coinbase, custom)",
       "bybit"
     );
-    import_args.default.option(
+    import_args3.default.option(
       ["m", "ml"],
       "Write ML dataset rows to per-worker JSONL chunks",
       false
     );
-    flags = import_args.default.parse(process.argv);
-    interval = flags.timeframe.toString();
-    progressStep = flags.progressStep;
+    import_args3.default.option(
+      ["A", "ai"],
+      "Write AI prompt rows to per-worker JSONL chunks",
+      false
+    );
+    normalizedArgv = process.argv.map((arg) => {
+      if (arg === "--ML") {
+        return "--ml";
+      }
+      if (arg === "--AI") {
+        return "--ai";
+      }
+      return arg;
+    });
+    flags3 = import_args3.default.parse(normalizedArgv);
+    interval = flags3.timeframe.toString();
+    progressStep = Math.max(1, parseInt(String(flags3.progressStep), 10));
+    testsLimit = Math.max(0, parseInt(String(flags3.tests), 10));
+    testsSkip = Math.max(0, parseInt(String(flags3.skip ?? 0), 10));
+    testItemTimeoutMs = 12e4;
     uuid = (len = 12) => (0, import_uuid.v4)().slice(-len);
-    projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    projectRoot2 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     testerWorkerPathCandidates = [
       // `tradejs` bin runs from dist/cli.js, so bundled commands resolve from `dist`.
-      import_path.default.resolve(__dirname, "./workers/testerWorker.js"),
+      import_path3.default.resolve(__dirname, "./workers/testerWorker.js"),
       // Direct execution of dist/scripts/backtest.js resolves from `dist/scripts`.
-      import_path.default.resolve(__dirname, "../workers/testerWorker.js"),
+      import_path3.default.resolve(__dirname, "../workers/testerWorker.js"),
       // ts-node execution resolves from `src/scripts`.
-      import_path.default.resolve(__dirname, "../workers/testerWorker.ts")
+      import_path3.default.resolve(__dirname, "../workers/testerWorker.ts")
     ];
     testerWorkerPath = testerWorkerPathCandidates.find(
       (candidate) => import_fs.default.existsSync(candidate)
@@ -1692,40 +2539,142 @@ var init_backtest = __esm({
     }
     testerNeedsTsRuntime = testerWorkerPath.endsWith(".ts");
     HEADERS_RESULTS = [
-      import_chalk.default.blue("ID"),
-      import_chalk.default.yellow("SYMBOL"),
-      import_chalk.default.cyan("PROFIT"),
-      import_chalk.default.cyan("ORDERS"),
-      import_chalk.default.cyan("WIN/LOSS (%)"),
-      import_chalk.default.cyan("RISK"),
-      import_chalk.default.cyan("MAX DRAWDOWN (%)")
+      import_chalk4.default.blue("ID"),
+      import_chalk4.default.yellow("SYMBOL"),
+      import_chalk4.default.cyan("PROFIT"),
+      import_chalk4.default.cyan("ORDERS"),
+      import_chalk4.default.cyan("WIN/LOSS (%)"),
+      import_chalk4.default.cyan("RISK"),
+      import_chalk4.default.cyan("MAX DRAWDOWN (%)")
     ];
     HEADERS_RESULTS_BY_TICKERS = [
-      import_chalk.default.blue("ID"),
-      import_chalk.default.yellow("SYMBOL"),
-      import_chalk.default.cyan("PROFIT"),
-      import_chalk.default.cyan("ORDERS"),
-      import_chalk.default.cyan("WIN/LOSS (%)"),
-      import_chalk.default.cyan("RISK"),
-      import_chalk.default.cyan("MAX DRAWDOWN (%)")
+      import_chalk4.default.blue("ID"),
+      import_chalk4.default.yellow("SYMBOL"),
+      import_chalk4.default.cyan("PROFIT"),
+      import_chalk4.default.cyan("ORDERS"),
+      import_chalk4.default.cyan("WIN/LOSS (%)"),
+      import_chalk4.default.cyan("RISK"),
+      import_chalk4.default.cyan("MAX DRAWDOWN (%)")
     ];
     successTests = 0;
     errorTests = 0;
     errorMessages = [];
     results = [];
     resultsByTickers = /* @__PURE__ */ new Map();
-    userName = flags.user;
+    resultArtifactsByTestName = /* @__PURE__ */ new Map();
+    artifactRefCountsByTestName = /* @__PURE__ */ new Map();
+    bestTickerTestNameBySymbol = /* @__PURE__ */ new Map();
+    topResultNames = /* @__PURE__ */ new Set();
+    userName = flags3.user;
     runStartedAt = Date.now();
-    createListIt = () => new ListIt({
+    createListIt2 = () => new ListIt2({
       autoAlign: true,
       headerUnderline: true
     });
-    createTable = (headers, rows) => createListIt().setHeaderRow(headers).d(rows).toString();
+    createTable2 = (headers, rows) => createListIt2().setHeaderRow(headers).d(rows).toString();
     createTimestamp = (date) => (0, import_date_fns.format)(date, "yyyyMMddHHmm");
-    filterGoodTests = (tests) => tests.filter((res) => res.stat?.orders > 5 && res.stat?.profit > 10);
+    isGoodTest = (result) => result.stat?.orders > 5 && result.stat?.profit > 10;
+    getResultAmount = (result) => result.stat.amount ?? 0;
     recordError = (error) => {
       errorMessages.push(error);
     };
+    stripInlineLogs = (result) => {
+      const { inlineOrderLog, inlinePositionLog, ...resultWithoutLogs } = result;
+      return resultWithoutLogs;
+    };
+    getInlineArtifacts = (result) => {
+      if (!result.inlineOrderLog && !result.inlinePositionLog) {
+        return null;
+      }
+      return {
+        orderLog: result.inlineOrderLog,
+        positionLog: result.inlinePositionLog
+      };
+    };
+    retainArtifacts = (testName, artifacts) => {
+      if (artifacts) {
+        resultArtifactsByTestName.set(testName, artifacts);
+      }
+      artifactRefCountsByTestName.set(
+        testName,
+        (artifactRefCountsByTestName.get(testName) ?? 0) + 1
+      );
+    };
+    releaseArtifacts = (testName) => {
+      const nextCount = (artifactRefCountsByTestName.get(testName) ?? 0) - 1;
+      if (nextCount <= 0) {
+        artifactRefCountsByTestName.delete(testName);
+        resultArtifactsByTestName.delete(testName);
+        return;
+      }
+      artifactRefCountsByTestName.set(testName, nextCount);
+    };
+    insertTopResult = (currentResults, nextResult, limit) => {
+      if (limit <= 0) {
+        return {
+          results: [],
+          added: false
+        };
+      }
+      const nextResults = [...currentResults];
+      const nextAmount = getResultAmount(nextResult);
+      let insertIndex = nextResults.length;
+      for (let index = 0; index < nextResults.length; index += 1) {
+        if (nextAmount > getResultAmount(nextResults[index])) {
+          insertIndex = index;
+          break;
+        }
+      }
+      if (insertIndex === nextResults.length && nextResults.length >= limit) {
+        return {
+          results: currentResults,
+          added: false
+        };
+      }
+      nextResults.splice(insertIndex, 0, nextResult);
+      if (nextResults.length > limit) {
+        nextResults.length = limit;
+      }
+      return {
+        results: nextResults,
+        added: nextResults.some(
+          (candidate) => candidate.test.name === nextResult.test.name
+        )
+      };
+    };
+    updateTopResults = (nextResults, nextResult, artifacts) => {
+      const previousTopNames = topResultNames;
+      const nextTopNames = new Set(nextResults.map((result) => result.test.name));
+      if (artifacts && !previousTopNames.has(nextResult.test.name) && nextTopNames.has(nextResult.test.name)) {
+        retainArtifacts(nextResult.test.name, artifacts);
+      }
+      for (const testName of previousTopNames) {
+        if (!nextTopNames.has(testName)) {
+          releaseArtifacts(testName);
+        }
+      }
+      results = nextResults;
+      topResultNames = nextTopNames;
+    };
+    updateBestTickerResult = (result, artifacts) => {
+      if (!isGoodTest(result)) {
+        return false;
+      }
+      const previousResult = resultsByTickers.get(result.test.symbol);
+      if (previousResult && previousResult.stat.profit >= result.stat.profit) {
+        return false;
+      }
+      const previousTestName = bestTickerTestNameBySymbol.get(result.test.symbol);
+      if (previousTestName) {
+        releaseArtifacts(previousTestName);
+      }
+      resultsByTickers.set(result.test.symbol, result);
+      bestTickerTestNameBySymbol.set(result.test.symbol, result.test.name);
+      if (artifacts) {
+        retainArtifacts(result.test.name, artifacts);
+      }
+      return true;
+    };
     isStrategyConfigGrid = (value) => {
       if (!value || typeof value !== "object" || Array.isArray(value)) {
         return false;
@@ -1735,12 +2684,12 @@ var init_backtest = __esm({
       );
     };
     resolveBacktestConnectorName = async (value) => {
-      const connectorName = await (0, import_connectors2.resolveConnectorName)(value, projectRoot);
+      const connectorName = await (0, import_connectors2.resolveConnectorName)(value, projectRoot2);
       if (connectorName) {
         return connectorName;
       }
       console.log(
-        import_chalk.default.yellow(
+        import_chalk4.default.yellow(
           `Unknown connector "${String(value || "").trim() || String(value)}". Fallback to ${import_connectors2.DEFAULT_CONNECTOR_NAME}.`
         )
       );
@@ -1748,101 +2697,127 @@ var init_backtest = __esm({
     };
     getLogsById = async (orderLogId) => {
       const orderLog = await (0, import_redis.getData)(
-        import_redis.redisKeys.cacheOrders(userName, orderLogId)
+        import_redis.redisKeys.cacheOrders(userName, orderLogId),
+        null
       );
       const positionLog = await (0, import_redis.getData)(
-        import_redis.redisKeys.cachePositions(userName, orderLogId)
+        import_redis.redisKeys.cachePositions(userName, orderLogId),
+        null
       );
       return { orderLog, positionLog };
     };
+    cacheArtifactsById = async (orderLogId, artifacts) => {
+      if (!artifacts || !Array.isArray(artifacts.orderLog) || !Array.isArray(artifacts.positionLog)) {
+        return;
+      }
+      await Promise.all([
+        (0, import_redis.setData)(import_redis.redisKeys.cacheOrders(userName, orderLogId), artifacts.orderLog, {
+          expire: import_constants2.TTL_1D
+        }),
+        (0, import_redis.setData)(
+          import_redis.redisKeys.cachePositions(userName, orderLogId),
+          artifacts.positionLog,
+          {
+            expire: import_constants2.TTL_1D
+          }
+        )
+      ]);
+    };
+    resolveResultArtifacts = async (result) => {
+      const inlineArtifacts = resultArtifactsByTestName.get(result.test.name);
+      if (inlineArtifacts?.orderLog && inlineArtifacts?.positionLog) {
+        return inlineArtifacts;
+      }
+      return getLogsById(result.orderLogId);
+    };
     setTestData = async (test, stat, orderLog) => {
       await (0, import_redis.setData)(
         import_redis.redisKeys.testOrders(test.userName, test.strategyName, test.name),
         orderLog,
         {
-          expire: import_constants.TTL_1M
+          expire: import_constants2.TTL_1M
         }
       );
       await (0, import_redis.setData)(
         import_redis.redisKeys.testConfig(test.userName, test.strategyName, test.name),
         test,
         {
-          expire: import_constants.TTL_1M
+          expire: import_constants2.TTL_1M
         }
       );
       await (0, import_redis.setData)(
         import_redis.redisKeys.testStat(test.userName, test.strategyName, test.name),
         stat,
         {
-          expire: import_constants.TTL_1M
+          expire: import_constants2.TTL_1M
         }
       );
     };
     backtest = async () => {
-      if (!flags.config) {
+      if (!flags3.config) {
         throw new Error("Backtest config not send");
       }
-      const strategyName = flags.config.split(":")[0];
-      if (!flags.config) {
+      const strategyName = flags3.config.split(":")[0];
+      if (!flags3.config) {
         throw new Error("Strategy name not found");
       }
       const backtestConfig = await (0, import_redis.getData)(
-        import_redis.redisKeys.backtestConfig(userName, flags.config),
+        import_redis.redisKeys.backtestConfig(userName, flags3.config),
         null
       );
       if (!backtestConfig) {
-        throw new Error(`Backtest config "${flags.config}" not found`);
+        throw new Error(`Backtest config "${flags3.config}" not found`);
       }
       const typedBacktestConfig = backtestConfig;
       if (!isStrategyConfigGrid(typedBacktestConfig)) {
         throw new Error(
-          `Backtest config "${flags.config}" must include strategyName and strategyConfig grid`
+          `Backtest config "${flags3.config}" must include strategyName and strategyConfig grid`
         );
       }
-      const connectorName = await resolveBacktestConnectorName(flags.connector);
+      const connectorName = await resolveBacktestConnectorName(flags3.connector);
       const connectorFactory = await (0, import_connectors2.getConnectorCreatorByName)(
         connectorName,
-        projectRoot
+        projectRoot2
       );
       if (!connectorFactory) {
         throw new Error(`Connector "${connectorName}" is not registered`);
       }
       const marketConnector = await connectorFactory({
-        userName: flags.user
+        userName: flags3.user
       });
       const tickers = await (0, import_cli.getTickers)(
         marketConnector,
-        flags.tickers,
-        flags.exclude,
-        flags.tickersLimit
+        flags3.tickers,
+        flags3.exclude,
+        flags3.tickersLimit
       );
-      if (flags.showTickersList) {
-        console.log(import_chalk.default.gray(JSON.stringify(tickers.sort(), null, 2)));
+      if (flags3.showTickersList) {
+        console.log(import_chalk4.default.gray(JSON.stringify(tickers.sort(), null, 2)));
         return;
       }
-      if (!flags.cacheOnly) {
+      if (!flags3.cacheOnly) {
         await (0, import_cli.update)(marketConnector, interval, tickers);
         const binanceConnectorCreator = await (0, import_connectors2.getConnectorCreatorByName)(
           import_connectors.ConnectorNames.Binance,
-          projectRoot
+          projectRoot2
         );
         const coinbaseConnectorCreator = await (0, import_connectors2.getConnectorCreatorByName)(
           import_connectors.ConnectorNames.Coinbase,
-          projectRoot
+          projectRoot2
         );
         if (!binanceConnectorCreator || !coinbaseConnectorCreator) {
           throw new Error("Binance/Coinbase connectors are required");
         }
         const binanceConnector = await binanceConnectorCreator({
-          userName: flags.user
+          userName: flags3.user
         });
         const coinbaseConnector = await coinbaseConnectorCreator({
-          userName: flags.user
+          userName: flags3.user
         });
         await (0, import_cli.update)(binanceConnector, interval, ["BTCUSDT"]);
         await (0, import_cli.update)(coinbaseConnector, interval, ["BTCUSDT"]);
       }
-      if (flags.updateOnly) {
+      if (flags3.updateOnly) {
         return;
       }
       let testSuite = (0, import_backtest.createTestSuite)(
@@ -1851,15 +2826,38 @@ var init_backtest = __esm({
         strategyName,
         typedBacktestConfig,
         connectorName
-      ).slice(0, parseInt(flags.tests));
-      const mlEnabled = Boolean(flags.ml);
-      testSuite = testSuite.map((test) => ({ ...test, ml: mlEnabled }));
-      const chunkSize = Math.ceil(testSuite.length / parseInt(flags.parallel));
+      );
+      const mlEnabled = Boolean(flags3.ml);
+      const aiEnabled = Boolean(flags3.ai);
+      testSuite = testSuite.map((test) => ({
+        ...test,
+        ml: mlEnabled,
+        ai: aiEnabled,
+        timeoutMs: testItemTimeoutMs
+      })).slice(testsSkip, testsSkip + testsLimit);
+      if (!testSuite.length) {
+        console.log(
+          import_chalk4.default.yellow(
+            `No tests selected (skip=${testsSkip}, limit=${testsLimit}).`
+          )
+        );
+        return;
+      }
+      const chunkSize = Math.ceil(testSuite.length / parseInt(flags3.parallel));
       const chunks = import_lodash.default.chunk(testSuite, chunkSize);
-      let completedWorkers = 0;
       let completedTests = 0;
       let isFinishing = false;
       const workers = /* @__PURE__ */ new Set();
+      const maybeFinish = async () => {
+        if (isFinishing) {
+          return;
+        }
+        if (completedTests !== testSuite.length || workers.size > 0) {
+          return;
+        }
+        isFinishing = true;
+        await finish();
+      };
       const stopWorkers = () => {
         for (const worker of workers) {
           if (!worker.killed) {
@@ -1875,9 +2873,9 @@ var init_backtest = __esm({
         stopWorkers();
         process.exit(143);
       });
-      console.log(import_chalk.default.yellow(`tests: ${testSuite.length}`));
+      console.log(import_chalk4.default.yellow(`tests: ${testSuite.length}`));
       console.log("");
-      const bar = new import_progress.default(
+      const bar = new import_progress2.default(
         ":current/:total [:bar][:percent] :symbol :amount :eta(s)",
         {
           total: testSuite.length,
@@ -1899,13 +2897,8 @@ var init_backtest = __esm({
         workers.add(tester);
         tester.on("message", async (msg) => {
           if (msg.done) {
-            completedWorkers++;
             workers.delete(tester);
-            if (completedWorkers === chunks.length && !isFinishing) {
-              isFinishing = true;
-              results = (0, import_backtest.sortBestTests)(results, flags.top);
-              await finish();
-            }
+            await maybeFinish();
             return;
           }
           completedTests++;
@@ -1917,49 +2910,55 @@ var init_backtest = __esm({
               payload: msg
             });
             console.error(
-              import_chalk.default.red(`Error in test #${msg.id}: ${JSON.stringify(msg)}`)
+              import_chalk4.default.red(`Error in test #${msg.id}: ${JSON.stringify(msg)}`)
             );
             return;
           } else {
             successTests++;
           }
-          results.push(msg);
-          const goodResults = filterGoodTests(results);
-          goodResults.forEach((res) => {
-            const prevValue = resultsByTickers.get(res.test.symbol);
-            if (!prevValue || prevValue.stat.profit < res.stat.profit) {
-              resultsByTickers.set(res.test.symbol, res);
-            }
-          });
+          const fullResult = msg;
+          const result = stripInlineLogs(fullResult);
+          const inlineArtifacts = getInlineArtifacts(fullResult);
+          const nextTopResults = insertTopResult(results, result, flags3.top);
+          const shouldCacheTopArtifacts = nextTopResults.added;
+          if (nextTopResults.added || results !== nextTopResults.results) {
+            updateTopResults(nextTopResults.results, result, inlineArtifacts);
+          }
+          const updatedBestTickerResult = updateBestTickerResult(
+            result,
+            inlineArtifacts
+          );
+          if ((shouldCacheTopArtifacts || updatedBestTickerResult) && inlineArtifacts) {
+            await cacheArtifactsById(result.orderLogId, inlineArtifacts);
+          }
           if (completedTests % progressStep === 0 || completedTests === testSuite.length) {
-            results = (0, import_backtest.sortBestTests)(results, flags.top);
-            const {
-              test: { symbol, name },
-              stat: { profit }
-            } = results[0];
+            const bestResult = results[0];
+            const symbol = bestResult?.test.symbol || "-";
+            const profit = bestResult?.stat.profit || 0;
             const profitStr = `${(profit || 0).toFixed(2)}$`;
             bar.tick(
               completedTests === testSuite.length ? completedTests % progressStep : progressStep,
               {
-                symbol: import_chalk.default.yellow(symbol),
-                amount: profit > 0 ? import_chalk.default.green(profitStr) : import_chalk.default.red(profitStr)
+                symbol: import_chalk4.default.yellow(symbol),
+                amount: profit > 0 ? import_chalk4.default.green(profitStr) : import_chalk4.default.red(profitStr)
               }
             );
           }
         });
         tester.on("error", (err) => {
           recordError({ error: err?.message ?? err });
-          console.error(import_chalk.default.red(`Worker error: ${err.message}`));
+          console.error(import_chalk4.default.red(`Worker error: ${err.message}`));
         });
         tester.on("exit", (code) => {
           workers.delete(tester);
           if (code !== 0) {
             recordError({ error: `Worker exited with code ${code}` });
-            console.error(import_chalk.default.red(`Worker exited with code ${code}`));
+            console.error(import_chalk4.default.red(`Worker exited with code ${code}`));
           }
+          void maybeFinish();
         });
         await (0, import_redis.setData)(import_redis.redisKeys.cacheChunk(userName, chunkId), chunkWithId, {
-          expire: import_constants.TTL_1D
+          expire: import_constants2.TTL_1D
         });
         tester.send({ chunkId, userName });
       }
@@ -1967,14 +2966,22 @@ var init_backtest = __esm({
     saveAndPrintResults = async () => {
       const colorizedResults = [];
       for await (const result of results) {
-        const { test, orderLogId } = result;
+        const { test } = result;
         const { symbol, name } = test;
-        const { orderLog, positionLog } = await getLogsById(orderLogId);
+        const { orderLog, positionLog } = await resolveResultArtifacts(result);
+        if (!orderLog || !positionLog) {
+          throw new Error(`Logs not found for test ${name}`);
+        }
         const stat = (0, import_backtest.calculateStatsFull)(positionLog);
+        if (!stat && result.stat.orders > 0) {
+          throw new Error(
+            `Position log is empty for test ${name} despite ${result.stat.orders} closed orders`
+          );
+        }
         await setTestData(test, stat, orderLog);
         const statRow = [
-          import_chalk.default.blue(name),
-          import_chalk.default.yellow(symbol),
+          import_chalk4.default.blue(name),
+          import_chalk4.default.yellow(symbol),
           ...(0, import_cli.drawStatInCLI)(stat, [
             "netProfit",
             "orders",
@@ -1987,20 +2994,28 @@ var init_backtest = __esm({
       }
       console.log("");
       console.log("RESULTS:");
-      console.log(createTable(HEADERS_RESULTS, colorizedResults));
+      console.log(createTable2(HEADERS_RESULTS, colorizedResults));
       console.log("");
     };
     saveAndPrintResultsByTickers = async () => {
       const colorizedResultsByTickers = [];
       for await (const result of resultsByTickers.values()) {
-        const { test, orderLogId } = result;
+        const { test } = result;
         const { symbol, name } = test;
-        const { orderLog, positionLog } = await getLogsById(orderLogId);
+        const { orderLog, positionLog } = await resolveResultArtifacts(result);
+        if (!orderLog || !positionLog) {
+          throw new Error(`Logs not found for ticker result ${name}`);
+        }
         const stat = (0, import_backtest.calculateStatsFull)(positionLog);
+        if (!stat && result.stat.orders > 0) {
+          throw new Error(
+            `Position log is empty for ticker result ${name} despite ${result.stat.orders} closed orders`
+          );
+        }
         await setTestData(test, stat, orderLog);
         const statRow = [
-          import_chalk.default.blue(name),
-          import_chalk.default.yellow(symbol),
+          import_chalk4.default.blue(name),
+          import_chalk4.default.yellow(symbol),
           ...(0, import_cli.drawStatInCLI)(stat, [
             "netProfit",
             "orders",
@@ -2014,28 +3029,28 @@ var init_backtest = __esm({
       console.log("");
       console.log("RESULTS BY TICKERS:");
       console.log(
-        createTable(HEADERS_RESULTS_BY_TICKERS, colorizedResultsByTickers)
+        createTable2(HEADERS_RESULTS_BY_TICKERS, colorizedResultsByTickers)
       );
       console.log("");
     };
     finish = async () => {
-      if (flags.tickers) {
+      if (flags3.tickers) {
         await saveAndPrintResults();
       } else {
         await saveAndPrintResultsByTickers();
       }
       const bestConfig = results[0]?.test.strategyConfig;
-      console.log(import_chalk.default.gray("BEST CONFIG:"));
-      console.log(import_chalk.default.green((0, import_data.toJson)(bestConfig, true)));
+      console.log(import_chalk4.default.gray("BEST CONFIG:"));
+      console.log(import_chalk4.default.green((0, import_data.toJson)(bestConfig, true)));
       console.log("");
       const mergedConfig = (0, import_backtest.mergeConfigs)(
         results.map(({ test: { strategyConfig } }) => strategyConfig)
       );
-      console.log(import_chalk.default.gray("MERGED CONFIG:"));
-      console.log(import_chalk.default.blue((0, import_data.toJson)(mergedConfig, true)));
+      console.log(import_chalk4.default.gray("MERGED CONFIG:"));
+      console.log(import_chalk4.default.blue((0, import_data.toJson)(mergedConfig, true)));
       console.log("");
-      console.log(`${import_chalk.default.green("SUCCESS TESTS")}: ${successTests}`);
-      console.log(`${import_chalk.default.red("ERRORS")}: ${errorTests}`);
+      console.log(`${import_chalk4.default.green("SUCCESS TESTS")}: ${successTests}`);
+      console.log(`${import_chalk4.default.red("ERRORS")}: ${errorTests}`);
       console.log("");
       const finishedAt = /* @__PURE__ */ new Date();
       const durationSeconds = Number(
@@ -2043,15 +3058,15 @@ var init_backtest = __esm({
       );
       const timestamp = createTimestamp(finishedAt);
       await (0, import_redis.setData)(
-        import_redis.redisKeys.backtestResults(userName, flags.config, timestamp),
+        import_redis.redisKeys.backtestResults(userName, flags3.config, timestamp),
         {
-          config: flags.config,
+          config: flags3.config,
           user: userName,
           startedAt: new Date(runStartedAt).toISOString(),
           finishedAt: finishedAt.toISOString(),
           durationSeconds,
           results,
-          resultsByTickers: resultsByTickers.values(),
+          resultsByTickers: Array.from(resultsByTickers.values()),
           bestConfig,
           mergedConfig,
           successTests,
@@ -2069,27 +3084,27 @@ var init_backtest = __esm({
 });
 
 // src/lib/runBot.ts
-var import_lodash2, import_connectors3, import_data2, import_strategies, import_async, import_constants2, import_time, import_logger, import_redis2, projectRoot2, runBot;
+var import_lodash2, import_connectors3, import_data2, import_strategies2, import_async2, import_constants3, import_time, import_logger, import_redis2, projectRoot3, runBot;
 var init_runBot = __esm({
   "src/lib/runBot.ts"() {
     "use strict";
     import_lodash2 = __toESM(require("lodash"));
     import_connectors3 = require("@tradejs/node/connectors");
     import_data2 = require("@tradejs/core/data");
-    import_strategies = require("@tradejs/node/strategies");
-    import_async = require("@tradejs/core/async");
-    import_constants2 = require("@tradejs/core/constants");
+    import_strategies2 = require("@tradejs/node/strategies");
+    import_async2 = require("@tradejs/core/async");
+    import_constants3 = require("@tradejs/core/constants");
     import_time = require("@tradejs/core/time");
     import_logger = require("@tradejs/infra/logger");
     import_redis2 = require("@tradejs/infra/redis");
-    projectRoot2 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    projectRoot3 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     runBot = async () => {
       const botResults = [];
-      const preloadStart = (0, import_time.getTimestamp)(import_constants2.BOT_PRELOAD_DAYS);
+      const preloadStart = (0, import_time.getTimestamp)(import_constants3.BOT_PRELOAD_DAYS);
       const end = (0, import_time.getTimestamp)();
       const keys = await (0, import_redis2.getKeys)(import_redis2.redisKeys.botsPrefix());
       const botKeys = keys.filter((key) => key.endsWith(":bots"));
-      await (0, import_async.delay)(5e3);
+      await (0, import_async2.delay)(5e3);
       import_logger.logger.log("info", "files count: %s", botKeys.length);
       for await (const key of botKeys) {
         const userName2 = key.split(":")[1];
@@ -2108,16 +3123,16 @@ var init_runBot = __esm({
             continue;
           }
           try {
-            const strategyCreator = await (0, import_strategies.getStrategyCreator)(
+            const strategyCreator = await (0, import_strategies2.getStrategyCreator)(
               strategyName,
-              projectRoot2
+              projectRoot3
             );
             if (!strategyCreator) {
               throw new Error(`Unknown strategy: ${strategyName}`);
             }
             const connectorCreator = await (0, import_connectors3.getConnectorCreatorByName)(
               connectorName,
-              projectRoot2
+              projectRoot3
             );
             if (!connectorCreator) {
               throw new Error(`Unknown connector: ${connectorName}`);
@@ -2127,11 +3142,11 @@ var init_runBot = __esm({
             });
             const binanceConnectorCreator = await (0, import_connectors3.getConnectorCreatorByName)(
               import_connectors3.BUILTIN_CONNECTOR_NAMES.Binance,
-              projectRoot2
+              projectRoot3
             );
             const coinbaseConnectorCreator = await (0, import_connectors3.getConnectorCreatorByName)(
               import_connectors3.BUILTIN_CONNECTOR_NAMES.Coinbase,
-              projectRoot2
+              projectRoot3
             );
             if (!binanceConnectorCreator || !coinbaseConnectorCreator) {
               throw new Error("Binance/Coinbase connectors are required");
@@ -2221,17 +3236,17 @@ var init_bot = __esm({
 
 // src/scripts/cleanDir.ts
 var cleanDir_exports = {};
-var import_args2, import_cli2, flags2, getDir, run2;
+var import_args4, import_cli2, flags4, getDir, run2;
 var init_cleanDir = __esm({
   "src/scripts/cleanDir.ts"() {
     "use strict";
-    import_args2 = __toESM(require("args"));
+    import_args4 = __toESM(require("args"));
     import_cli2 = require("@tradejs/node/cli");
-    import_args2.default.option("dir", "Directory clean up", "cache");
-    flags2 = import_args2.default.parse(process.argv);
+    import_args4.default.option("dir", "Directory clean up", "cache");
+    flags4 = import_args4.default.parse(process.argv);
     getDir = () => {
-      if (flags2.dir) {
-        return `data/${flags2.dir}`;
+      if (flags4.dir) {
+        return `data/${flags4.dir}`;
       }
       return "data/cache";
     };
@@ -2245,17 +3260,17 @@ var init_cleanDir = __esm({
 
 // src/scripts/cleanRedis.ts
 var cleanRedis_exports = {};
-var import_args3, import_cli3, flags3, getArea, run3;
+var import_args5, import_cli3, flags5, getArea, run3;
 var init_cleanRedis = __esm({
   "src/scripts/cleanRedis.ts"() {
     "use strict";
-    import_args3 = __toESM(require("args"));
+    import_args5 = __toESM(require("args"));
     import_cli3 = require("@tradejs/node/cli");
-    import_args3.default.option("area", "Area clean up", "cache");
-    flags3 = import_args3.default.parse(process.argv);
+    import_args5.default.option("area", "Area clean up", "cache");
+    flags5 = import_args5.default.parse(process.argv);
     getArea = () => {
-      if (flags3.area) {
-        return flags3.area;
+      if (flags5.area) {
+        return flags5.area;
       }
       return "cache";
     };
@@ -2269,17 +3284,17 @@ var init_cleanRedis = __esm({
 
 // src/scripts/cleanTests.ts
 var cleanTests_exports = {};
-var import_args4, import_chalk2, import_cli4, import_redis3, flags4, extractUsers, getUsersToClean, cleanUserTests, run4;
+var import_args6, import_chalk5, import_cli4, import_redis3, flags6, extractUsers, getUsersToClean, cleanUserTests, run4;
 var init_cleanTests = __esm({
   "src/scripts/cleanTests.ts"() {
     "use strict";
-    import_args4 = __toESM(require("args"));
-    import_chalk2 = __toESM(require("chalk"));
+    import_args6 = __toESM(require("args"));
+    import_chalk5 = __toESM(require("chalk"));
     import_cli4 = require("@tradejs/node/cli");
     import_redis3 = require("@tradejs/infra/redis");
-    import_args4.default.option(["U", "user"], "Clean tests for user", "");
-    import_args4.default.option(["C", "cache"], "Clean only cache keys", false);
-    flags4 = import_args4.default.parse(process.argv);
+    import_args6.default.option(["U", "user"], "Clean tests for user", "");
+    import_args6.default.option(["C", "cache"], "Clean only cache keys", false);
+    flags6 = import_args6.default.parse(process.argv);
     extractUsers = (keys) => {
       const users = /* @__PURE__ */ new Set();
       for (const key of keys) {
@@ -2298,7 +3313,7 @@ var init_cleanTests = __esm({
       return Array.from(users).sort();
     };
     getUsersToClean = async () => {
-      const userName2 = String(flags4.user || "").trim();
+      const userName2 = String(flags6.user || "").trim();
       if (userName2) {
         return [userName2];
       }
@@ -2308,19 +3323,19 @@ var init_cleanTests = __esm({
     cleanUserTests = async (userName2) => {
       const testsPrefix = `users:${userName2}:tests:`;
       const testsCachePrefix = `users:${userName2}:cache:tests:`;
-      if (flags4.cache) {
-        console.log(import_chalk2.default.yellow(`clean user cache: ${userName2}`));
+      if (flags6.cache) {
+        console.log(import_chalk5.default.yellow(`clean user cache: ${userName2}`));
         await (0, import_cli4.cleanRedis)(testsCachePrefix);
         return;
       }
-      console.log(import_chalk2.default.yellow(`clean user tests: ${userName2}`));
+      console.log(import_chalk5.default.yellow(`clean user tests: ${userName2}`));
       await (0, import_cli4.cleanRedis)(testsPrefix);
       await (0, import_cli4.cleanRedis)(testsCachePrefix);
     };
     run4 = async () => {
       const users = await getUsersToClean();
       if (users.length === 0) {
-        console.log(import_chalk2.default.yellow("No users found to clean tests."));
+        console.log(import_chalk5.default.yellow("No users found to clean tests."));
         process.exit();
       }
       for await (const userName2 of users) {
@@ -2334,33 +3349,33 @@ var init_cleanTests = __esm({
 
 // src/scripts/continuity.ts
 var continuity_exports = {};
-var import_args5, import_progress2, import_chalk3, import_connectors4, import_cli5, import_constants3, import_time2, import_logger2, import_timescale, flags5, interval2, intervalKey, projectRoot3, parseProviders, findGapInData, continuity;
+var import_args7, import_progress3, import_chalk6, import_connectors4, import_cli5, import_constants4, import_time2, import_logger2, import_timescale, flags7, interval2, intervalKey, projectRoot4, parseProviders, findGapInData, continuity;
 var init_continuity = __esm({
   "src/scripts/continuity.ts"() {
     "use strict";
-    import_args5 = __toESM(require("args"));
-    import_progress2 = __toESM(require("progress"));
-    import_chalk3 = __toESM(require("chalk"));
+    import_args7 = __toESM(require("args"));
+    import_progress3 = __toESM(require("progress"));
+    import_chalk6 = __toESM(require("chalk"));
     import_connectors4 = require("@tradejs/node/connectors");
     import_cli5 = require("@tradejs/node/cli");
-    import_constants3 = require("@tradejs/core/constants");
+    import_constants4 = require("@tradejs/core/constants");
     import_time2 = require("@tradejs/core/time");
     import_logger2 = require("@tradejs/infra/logger");
     import_timescale = require("@tradejs/infra/timescale");
-    import_args5.default.option(["t", "tickers"], "Selected tickers");
-    import_args5.default.option(["f", "timeframe"], "Timeframe", 15);
-    import_args5.default.option(
+    import_args7.default.option(["t", "tickers"], "Selected tickers");
+    import_args7.default.option(["f", "timeframe"], "Timeframe", 15);
+    import_args7.default.option(
       ["p", "provider"],
       "Data provider: all|bybit|binance|coinbase or comma list",
       "all"
     );
-    import_args5.default.option(["U", "user"], "Use user confg", "root");
-    flags5 = import_args5.default.parse(process.argv);
-    interval2 = Number(flags5.timeframe);
-    intervalKey = flags5.timeframe.toString();
-    projectRoot3 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    import_args7.default.option(["U", "user"], "Use user confg", "root");
+    flags7 = import_args7.default.parse(process.argv);
+    interval2 = Number(flags7.timeframe);
+    intervalKey = flags7.timeframe.toString();
+    projectRoot4 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     parseProviders = async (value) => {
-      const allProviders = await (0, import_connectors4.getAvailableConnectorProviders)(projectRoot3);
+      const allProviders = await (0, import_connectors4.getAvailableConnectorProviders)(projectRoot4);
       const raw = String(value || "").trim().toLowerCase();
       if (!raw || raw === "all") {
         return allProviders;
@@ -2395,18 +3410,18 @@ var init_continuity = __esm({
     };
     continuity = async () => {
       if (!Number.isFinite(interval2) || interval2 <= 0) {
-        import_logger2.logger.error("Invalid timeframe: %s", flags5.timeframe);
+        import_logger2.logger.error("Invalid timeframe: %s", flags7.timeframe);
         process.exit(1);
       }
       await (0, import_timescale.waitForDbReady)();
-      const reloadStart = (0, import_time2.getTimestamp)(import_constants3.PRELOAD_DAYS);
+      const reloadStart = (0, import_time2.getTimestamp)(import_constants4.PRELOAD_DAYS);
       const reloadEnd = (0, import_time2.getTimestamp)();
-      const providerIds = await parseProviders(flags5.provider);
+      const providerIds = await parseProviders(flags7.provider);
       const providers = await Promise.all(
         providerIds.map(async (providerId) => {
           const connectorName = await (0, import_connectors4.getConnectorNameByProvider)(
             providerId,
-            projectRoot3
+            projectRoot4
           );
           if (!connectorName) {
             import_logger2.logger.warn(
@@ -2417,7 +3432,7 @@ var init_continuity = __esm({
           }
           const creator = await (0, import_connectors4.getConnectorCreatorByName)(
             connectorName,
-            projectRoot3
+            projectRoot4
           );
           if (!creator) {
             import_logger2.logger.warn(
@@ -2441,10 +3456,10 @@ var init_continuity = __esm({
       }
       for await (const provider of activeProviders) {
         const connector = await provider.create({
-          userName: flags5.user
+          userName: flags7.user
         });
-        const tickers = await (0, import_cli5.getTickers)(connector, flags5.tickers);
-        const bar = new import_progress2.default(
+        const tickers = await (0, import_cli5.getTickers)(connector, flags7.tickers);
+        const bar = new import_progress3.default(
           ":current/:total [:bar][:percent] broken::broken fixed::fixed :eta(s) :symbol",
           {
             total: tickers.length,
@@ -2454,7 +3469,7 @@ var init_continuity = __esm({
         let broken = 0;
         let fixed = 0;
         const expectedMs = interval2 * 60 * 1e3;
-        import_logger2.logger.info(import_chalk3.default.yellow(`continuity ${provider.name}: ${tickers.length}`));
+        import_logger2.logger.info(import_chalk6.default.yellow(`continuity ${provider.name}: ${tickers.length}`));
         for await (const symbol of tickers) {
           const data = await connector.kline({
             symbol,
@@ -2489,13 +3504,13 @@ var init_continuity = __esm({
             }
           }
           bar.tick(1, {
-            broken: import_chalk3.default.yellow(broken),
-            fixed: import_chalk3.default.cyan(fixed),
-            symbol: import_chalk3.default.gray(symbol)
+            broken: import_chalk6.default.yellow(broken),
+            fixed: import_chalk6.default.cyan(fixed),
+            symbol: import_chalk6.default.gray(symbol)
           });
         }
         import_logger2.logger.info(
-          import_chalk3.default.yellow(
+          import_chalk6.default.yellow(
             `[${provider.id}] broken: ${broken}/${tickers.length}, fixed: ${fixed}`
           )
         );
@@ -2508,46 +3523,50 @@ var init_continuity = __esm({
 
 // src/scripts/derivativesIngest.ts
 var derivativesIngest_exports = {};
-var import_config2, import_args6, import_chalk4, import_indicators, import_timescale2, import_connectors5, flags6, asInt, run5;
+var import_config2, import_args8, import_chalk7, import_indicators, import_timescale2, import_userSettings, import_connectors5, flags8, asInt, run5;
 var init_derivativesIngest = __esm({
   "src/scripts/derivativesIngest.ts"() {
     "use strict";
     import_config2 = require("dotenv/config");
-    import_args6 = __toESM(require("args"));
-    import_chalk4 = __toESM(require("chalk"));
+    import_args8 = __toESM(require("args"));
+    import_chalk7 = __toESM(require("chalk"));
     import_indicators = require("@tradejs/core/indicators");
     import_timescale2 = require("@tradejs/infra/timescale");
+    import_userSettings = require("@tradejs/infra/userSettings");
     import_connectors5 = require("@tradejs/connectors");
-    import_args6.default.example(
+    import_args8.default.example(
       "yarn ts-node ./src/scripts/derivativesIngest --provider coinalyze --symbols BTCUSDT,ETHUSDT --intervals 15m,1h --days 120",
       "Ingest market features (derivatives/spread) into Timescale by provider"
     );
-    import_args6.default.option(["s", "symbols"], "Comma-separated symbols", "BTCUSDT,ETHUSDT");
-    import_args6.default.option(["t", "intervals"], "Comma-separated intervals: 15m,1h", "15m,1h");
-    import_args6.default.option(["d", "days"], "Lookback in days", 120);
-    import_args6.default.option(
+    import_args8.default.option(["s", "symbols"], "Comma-separated symbols", "BTCUSDT,ETHUSDT");
+    import_args8.default.option(["t", "intervals"], "Comma-separated intervals: 15m,1h", "15m,1h");
+    import_args8.default.option(["d", "days"], "Lookback in days", 120);
+    import_args8.default.option(
       ["p", "provider"],
       "Provider name: coinalyze | binance_coinbase_spread",
       "coinalyze"
     );
-    import_args6.default.option(["b", "batchDays"], "Request chunk size in days", 7);
-    flags6 = import_args6.default.parse(process.argv);
+    import_args8.default.option(["U", "user"], "User settings profile name from Redis", "root");
+    import_args8.default.option(["b", "batchDays"], "Request chunk size in days", 7);
+    flags8 = import_args8.default.parse(process.argv);
     asInt = (value, fallback) => {
       const parsed = Number.parseInt(String(value ?? ""), 10);
       return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
     };
     run5 = async () => {
-      const providerName = String(flags6.provider || "coinalyze").trim().toLowerCase();
+      const providerName = String(flags8.provider || "coinalyze").trim().toLowerCase();
       const provider = import_connectors5.marketDataProviders[providerName];
       if (!provider) {
         throw new Error(`Unsupported provider: ${providerName}`);
       }
-      const symbols = (0, import_indicators.normalizeCoinalyzeSymbols)(flags6.symbols);
+      const symbols = (0, import_indicators.normalizeCoinalyzeSymbols)(flags8.symbols);
       const intervals = (0, import_indicators.normalizeDerivativesIntervals)(
-        flags6.intervals
+        flags8.intervals
       );
-      const days = asInt(flags6.days, 120);
-      const batchDays = asInt(flags6.batchDays, 7);
+      const days = asInt(flags8.days, 120);
+      const batchDays = asInt(flags8.batchDays, 7);
+      const userName2 = String(flags8.user || "root").trim() || "root";
+      const coinalyzeApiKey = providerName === "coinalyze" ? (await (0, import_userSettings.getUserSettings)(userName2)).COINALYZE_API_KEY : void 0;
       if (!symbols.length) throw new Error("No symbols provided");
       if (!intervals.length) throw new Error("No intervals provided");
       await (0, import_timescale2.waitForDbReady)();
@@ -2561,10 +3580,11 @@ var init_derivativesIngest = __esm({
           while (cursor < now2) {
             const toMs = Math.min(now2, cursor + batchDays * 24 * 60 * 60 * 1e3);
             process.stdout.write(
-              `\r${import_chalk4.default.cyan(providerName)} ${import_chalk4.default.yellow(symbol)} ${interval4} ${new Date(cursor).toISOString()} .. ${new Date(toMs).toISOString()}   `
+              `\r${import_chalk7.default.cyan(providerName)} ${import_chalk7.default.yellow(symbol)} ${interval4} ${new Date(cursor).toISOString()} .. ${new Date(toMs).toISOString()}   `
             );
             const window2 = await provider.fetchWindow({
               symbol,
+              apiKey: coinalyzeApiKey,
               interval: interval4,
               fromMs: cursor,
               toMs
@@ -2585,13 +3605,13 @@ var init_derivativesIngest = __esm({
         }
       }
       console.log(
-        import_chalk4.default.green(
+        import_chalk7.default.green(
           `Done. provider=${providerName} derivatives_rows=${totalDerivativesRows} spread_rows=${totalSpreadRows}`
         )
       );
     };
     run5().catch((error) => {
-      console.error(import_chalk4.default.red(`derivativesIngest failed: ${error}`));
+      console.error(import_chalk7.default.red(`derivativesIngest failed: ${error}`));
       process.exit(1);
     });
   }
@@ -2599,80 +3619,77 @@ var init_derivativesIngest = __esm({
 
 // src/scripts/derivativesIngestCoinalyzeAll.ts
 var derivativesIngestCoinalyzeAll_exports = {};
-var import_config3, import_args7, import_chalk5, import_progress3, import_lodash3, import_connectors6, import_indicators2, import_async2, import_cli6, import_timescale3, coinalyzeIntervalMap, flags7, asInt2, parseList, apiKey, coinalyzeBaseUrl, coinalyzeMaxRetries, lastRequestTs, fetchJsonWithRateLimit, fetchCoinalyzeMarkets, selectBestMarket, buildMatches, normalizeMetricPoint, toSeriesMap, fetchMetricBatch, run6;
+var import_config3, import_args9, import_chalk8, import_progress4, import_lodash3, import_connectors6, import_indicators2, import_async3, import_userSettings2, import_cli6, import_timescale3, coinalyzeIntervalMap, flags9, asInt2, parseList, coinalyzeBaseUrl, coinalyzeMaxRetries, lastRequestTs, fetchJsonWithRateLimit, fetchCoinalyzeMarkets, selectBestMarket, buildMatches, normalizeMetricPoint, toSeriesMap, fetchMetricBatch, run6;
 var init_derivativesIngestCoinalyzeAll = __esm({
   "src/scripts/derivativesIngestCoinalyzeAll.ts"() {
     "use strict";
     import_config3 = require("dotenv/config");
-    import_args7 = __toESM(require("args"));
-    import_chalk5 = __toESM(require("chalk"));
-    import_progress3 = __toESM(require("progress"));
+    import_args9 = __toESM(require("args"));
+    import_chalk8 = __toESM(require("chalk"));
+    import_progress4 = __toESM(require("progress"));
     import_lodash3 = __toESM(require("lodash"));
     import_connectors6 = require("@tradejs/connectors");
     import_indicators2 = require("@tradejs/core/indicators");
-    import_async2 = require("@tradejs/core/async");
+    import_async3 = require("@tradejs/core/async");
+    import_userSettings2 = require("@tradejs/infra/userSettings");
     import_cli6 = require("@tradejs/node/cli");
     import_timescale3 = require("@tradejs/infra/timescale");
     coinalyzeIntervalMap = {
       "15m": "15min",
       "1h": "1hour"
     };
-    import_args7.default.example(
+    import_args9.default.example(
       "yarn ts-node ./src/scripts/derivativesIngestCoinalyzeAll --days 120 --intervals 15m,1h",
       "Fetch derivatives for all getTickers symbols matched to Coinalyze markets"
     );
-    import_args7.default.option(["U", "user"], "Bybit user config name from Redis", "root");
-    import_args7.default.option(["t", "tickers"], "Comma-separated include symbols");
-    import_args7.default.option(["e", "exclude"], "Comma-separated exclude symbols");
-    import_args7.default.option(["l", "tickersLimit"], "Tickers limit");
-    import_args7.default.option(["c", "chunk"], "Chunk selector, e.g. 1/4");
-    import_args7.default.option(["i", "intervals"], "Intervals: 15m,1h", "15m,1h");
-    import_args7.default.option(["d", "days"], "Lookback in days", 120);
-    import_args7.default.option(["b", "batchDays"], "Request chunk size in days", 120);
-    import_args7.default.option(
+    import_args9.default.option(["U", "user"], "User settings profile name from Redis", "root");
+    import_args9.default.option(["t", "tickers"], "Comma-separated include symbols");
+    import_args9.default.option(["e", "exclude"], "Comma-separated exclude symbols");
+    import_args9.default.option(["l", "tickersLimit"], "Tickers limit");
+    import_args9.default.option(["c", "chunk"], "Chunk selector, e.g. 1/4");
+    import_args9.default.option(["i", "intervals"], "Intervals: 15m,1h", "15m,1h");
+    import_args9.default.option(["d", "days"], "Lookback in days", 120);
+    import_args9.default.option(["b", "batchDays"], "Request chunk size in days", 120);
+    import_args9.default.option(
       ["E", "exchangePriority"],
       "Coinalyze exchange priority, comma-separated",
       "A,6,0"
     );
-    import_args7.default.option(
+    import_args9.default.option(
       ["S", "symbolBatchSize"],
       "How many symbols to request in one Coinalyze call",
       8
     );
-    import_args7.default.option(
+    import_args9.default.option(
       ["w", "requestDelayMs"],
       "Delay between API requests to smooth rate limit",
       200
     );
-    import_args7.default.option(
+    import_args9.default.option(
       ["T", "requestTimeoutMs"],
       "HTTP request timeout in milliseconds",
       45e3
     );
-    import_args7.default.option(["L", "showTickersList"], "Print matched symbols only", false);
-    flags7 = import_args7.default.parse(process.argv);
+    import_args9.default.option(["L", "showTickersList"], "Print matched symbols only", false);
+    flags9 = import_args9.default.parse(process.argv);
     asInt2 = (value, fallback) => {
       const parsed = Number.parseInt(String(value ?? ""), 10);
       return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
     };
     parseList = (value) => String(value ?? "").split(",").map((item) => item.trim().toUpperCase()).filter(Boolean);
-    apiKey = process.env.COINALYZE_API_KEY?.trim();
-    if (!apiKey) {
-      throw new Error("Missing COINALYZE_API_KEY");
-    }
     coinalyzeBaseUrl = process.env.COINALYZE_BASE_URL?.trim() || "https://api.coinalyze.net/v1";
     coinalyzeMaxRetries = asInt2(process.env.COINALYZE_MAX_RETRIES, 4);
     lastRequestTs = 0;
-    fetchJsonWithRateLimit = async (url) => {
-      const requestDelayMs = Math.max(100, asInt2(flags7.requestDelayMs, 200));
+    fetchJsonWithRateLimit = async (url, apiKey) => {
+      const requestDelayMs = Math.max(100, asInt2(flags9.requestDelayMs, 200));
       const requestTimeoutMs = Math.max(
         5e3,
-        asInt2(flags7.requestTimeoutMs, 45e3)
+        asInt2(flags9.requestTimeoutMs, 45e3)
       );
       for (let attempt = 0; attempt <= coinalyzeMaxRetries; attempt += 1) {
         const waitMs = Math.max(0, lastRequestTs + requestDelayMs - Date.now());
         if (waitMs > 0) {
-          await (0, import_async2.delay)(waitMs);
+          await (0, import_async3.delay)(waitMs);
         }
         lastRequestTs = Date.now();
         const controller = new AbortController();
@@ -2692,7 +3709,7 @@ var init_derivativesIngestCoinalyzeAll = __esm({
           const abortError = error instanceof Error && (error.name === "AbortError" || String(error.message).toLowerCase().includes("aborted"));
           if (attempt < coinalyzeMaxRetries && abortError) {
             const backoffMs = Math.min(12e3, 800 * 2 ** attempt);
-            await (0, import_async2.delay)(backoffMs);
+            await (0, import_async3.delay)(backoffMs);
             continue;
           }
           throw error;
@@ -2708,16 +3725,17 @@ var init_derivativesIngestCoinalyzeAll = __esm({
         const transient = response.status === 429 || response.status >= 500;
         if (attempt < coinalyzeMaxRetries && transient) {
           const backoffMs = Math.min(12e3, 800 * 2 ** attempt);
-          await (0, import_async2.delay)(retryAfterMs ?? backoffMs);
+          await (0, import_async3.delay)(retryAfterMs ?? backoffMs);
           continue;
         }
         throw new Error(`Coinalyze ${response.status}: ${text}`);
       }
       throw new Error("Coinalyze request failed after retries");
     };
-    fetchCoinalyzeMarkets = async () => {
+    fetchCoinalyzeMarkets = async (apiKey) => {
       const raw = await fetchJsonWithRateLimit(
-        `${coinalyzeBaseUrl}/future-markets`
+        `${coinalyzeBaseUrl}/future-markets`,
+        apiKey
       );
       return Array.isArray(raw) ? raw : [];
     };
@@ -2800,40 +3818,48 @@ var init_derivativesIngestCoinalyzeAll = __esm({
       return out;
     };
     fetchMetricBatch = async (params) => {
-      const { endpoint, metric, marketSymbols, interval: interval4, fromMs, toMs } = params;
+      const { endpoint, metric, marketSymbols, apiKey, interval: interval4, fromMs, toMs } = params;
       const url = new URL(`${coinalyzeBaseUrl}${endpoint}`);
       url.searchParams.set("symbols", marketSymbols.join(","));
       url.searchParams.set("interval", coinalyzeIntervalMap[interval4] || interval4);
       url.searchParams.set("from", String(Math.floor(fromMs / 1e3)));
       url.searchParams.set("to", String(Math.floor(toMs / 1e3)));
-      const raw = await fetchJsonWithRateLimit(url.toString());
+      const raw = await fetchJsonWithRateLimit(url.toString(), apiKey);
       return toSeriesMap(raw, metric);
     };
     run6 = async () => {
+      const userName2 = String(flags9.user || "root").trim() || "root";
       const intervals = (0, import_indicators2.normalizeDerivativesIntervals)(
-        flags7.intervals
+        flags9.intervals
       );
-      const days = asInt2(flags7.days, 120);
-      const batchDays = asInt2(flags7.batchDays, 120);
-      const symbolBatchSize = asInt2(flags7.symbolBatchSize, 25);
-      const tickersLimit = flags7.tickersLimit !== void 0 ? asInt2(flags7.tickersLimit, 0) || void 0 : void 0;
-      const exchangePriority = parseList(flags7.exchangePriority || "A,6,0");
+      const days = asInt2(flags9.days, 120);
+      const batchDays = asInt2(flags9.batchDays, 120);
+      const symbolBatchSize = asInt2(flags9.symbolBatchSize, 25);
+      const tickersLimit = flags9.tickersLimit !== void 0 ? asInt2(flags9.tickersLimit, 0) || void 0 : void 0;
+      const exchangePriority = parseList(flags9.exchangePriority || "A,6,0");
       if (!intervals.length) throw new Error("No intervals provided");
+      const settings = await (0, import_userSettings2.getUserSettings)(userName2);
+      const coinalyzeApiKey = settings.COINALYZE_API_KEY.trim();
+      if (!coinalyzeApiKey) {
+        throw new Error(
+          `Missing COINALYZE_API_KEY in user settings for user ${userName2}`
+        );
+      }
       const connectorFactory = import_connectors6.connectors[import_connectors6.ConnectorNames.ByBit];
       const bybit = await connectorFactory({
-        userName: String(flags7.user || "root")
+        userName: userName2
       });
       const tickers = await (0, import_cli6.getTickers)(
         bybit,
-        String(flags7.tickers || ""),
-        String(flags7.exclude || ""),
+        String(flags9.tickers || ""),
+        String(flags9.exclude || ""),
         tickersLimit,
-        String(flags7.chunk || "")
+        String(flags9.chunk || "")
       );
       if (!tickers.length) {
         throw new Error("No tickers loaded via getTickers");
       }
-      const markets = await fetchCoinalyzeMarkets();
+      const markets = await fetchCoinalyzeMarkets(coinalyzeApiKey);
       if (!markets.length) {
         throw new Error("No markets returned by Coinalyze /future-markets");
       }
@@ -2846,18 +3872,18 @@ var init_derivativesIngestCoinalyzeAll = __esm({
         throw new Error("No matched symbols between getTickers and Coinalyze");
       }
       console.log(
-        import_chalk5.default.cyan(
+        import_chalk8.default.cyan(
           `Tickers=${tickers.length}, matched=${matches.length}, unmatched=${unmatched.length}, intervals=${intervals.join(",")}, symbolBatch=${symbolBatchSize}`
         )
       );
       if (unmatched.length) {
         console.log(
-          import_chalk5.default.yellow(
+          import_chalk8.default.yellow(
             `Unmatched sample (${Math.min(20, unmatched.length)}): ${unmatched.slice(0, 20).join(", ")}`
           )
         );
       }
-      if (flags7.showTickersList) {
+      if (flags9.showTickersList) {
         console.log(
           JSON.stringify(
             matches.map((item) => ({
@@ -2877,7 +3903,7 @@ var init_derivativesIngestCoinalyzeAll = __esm({
       const symbolBatches = import_lodash3.default.chunk(matches, symbolBatchSize);
       const windowsPerPair = Math.ceil(days / batchDays);
       const totalWindows = symbolBatches.length * intervals.length * windowsPerPair;
-      const bar = new import_progress3.default(
+      const bar = new import_progress4.default(
         ":current/:total [:bar][:percent] :eta(s) :batch rows=:rows fail=:fail",
         {
           total: Math.max(1, totalWindows),
@@ -2901,6 +3927,7 @@ var init_derivativesIngestCoinalyzeAll = __esm({
                 endpoint: oiPath,
                 metric: "oi",
                 marketSymbols,
+                apiKey: coinalyzeApiKey,
                 interval: interval4,
                 fromMs: cursor,
                 toMs
@@ -2909,6 +3936,7 @@ var init_derivativesIngestCoinalyzeAll = __esm({
                 endpoint: fundingPath,
                 metric: "funding",
                 marketSymbols,
+                apiKey: coinalyzeApiKey,
                 interval: interval4,
                 fromMs: cursor,
                 toMs
@@ -2917,6 +3945,7 @@ var init_derivativesIngestCoinalyzeAll = __esm({
                 endpoint: liqPath,
                 metric: "liq",
                 marketSymbols,
+                apiKey: coinalyzeApiKey,
                 interval: interval4,
                 fromMs: cursor,
                 toMs
@@ -2938,13 +3967,13 @@ var init_derivativesIngestCoinalyzeAll = __esm({
             } catch (error) {
               failedWindows += 1;
               console.error(
-                import_chalk5.default.red(
+                import_chalk8.default.red(
                   `batch window failed batch=${batchIdx + 1}/${symbolBatches.length} interval=${interval4} ${new Date(cursor).toISOString()}..${new Date(toMs).toISOString()}: ${error}`
                 )
               );
             } finally {
               bar.tick(1, {
-                batch: import_chalk5.default.gray(
+                batch: import_chalk8.default.gray(
                   `${batchIdx + 1}/${symbolBatches.length} ${interval4} (${batch.length} symbols)`
                 ),
                 rows: totalRows,
@@ -2957,7 +3986,7 @@ var init_derivativesIngestCoinalyzeAll = __esm({
       }
       console.log("");
       console.log(
-        import_chalk5.default.green(
+        import_chalk8.default.green(
           `Done. symbols=${matches.length} intervals=${intervals.join(",")} rows=${totalRows} failed_windows=${failedWindows}`
         )
       );
@@ -2966,7 +3995,7 @@ var init_derivativesIngestCoinalyzeAll = __esm({
       }
     };
     run6().catch((error) => {
-      console.error(import_chalk5.default.red(`derivativesIngestCoinalyzeAll failed: ${error}`));
+      console.error(import_chalk8.default.red(`derivativesIngestCoinalyzeAll failed: ${error}`));
       process.exit(1);
     });
   }
@@ -3112,14 +4141,14 @@ var require_postgres_date = __commonJS({
       var ms = matches[7];
       ms = ms ? 1e3 * parseFloat(ms) : 0;
       var date;
-      var offset2 = timeZoneOffset(isoDate);
-      if (offset2 != null) {
+      var offset = timeZoneOffset(isoDate);
+      if (offset != null) {
         date = new Date(Date.UTC(year, month, day, hour, minute, second, ms));
         if (is0To99(year)) {
           date.setUTCFullYear(year);
         }
-        if (offset2 !== 0) {
-          date.setTime(date.getTime() - offset2);
+        if (offset !== 0) {
+          date.setTime(date.getTime() - offset);
         }
       } else {
         date = new Date(year, month, day, hour, minute, second, ms);
@@ -3158,8 +4187,8 @@ var require_postgres_date = __commonJS({
         return 0;
       }
       var sign = type === "-" ? -1 : 1;
-      var offset2 = parseInt(zone[2], 10) * 3600 + parseInt(zone[3] || 0, 10) * 60 + parseInt(zone[4] || 0, 10);
-      return offset2 * sign * 1e3;
+      var offset = parseInt(zone[2], 10) * 3600 + parseInt(zone[3] || 0, 10) * 60 + parseInt(zone[4] || 0, 10);
+      return offset * sign * 1e3;
     }
     function bcYearToNegativeYear(year) {
       return -(year - 1);
@@ -3602,13 +4631,13 @@ var require_binaryParsers = __commonJS({
   "../../node_modules/pg-types/lib/binaryParsers.js"(exports2, module2) {
     "use strict";
     var parseInt64 = require_pg_int8();
-    var parseBits = function(data, bits, offset2, invert, callback) {
-      offset2 = offset2 || 0;
+    var parseBits = function(data, bits, offset, invert, callback) {
+      offset = offset || 0;
       invert = invert || false;
       callback = callback || function(lastValue, newValue, bits2) {
         return lastValue * Math.pow(2, bits2) + newValue;
       };
-      var offsetBytes = offset2 >> 3;
+      var offsetBytes = offset >> 3;
       var inv = function(value) {
         if (invert) {
           return ~value & 255;
@@ -3616,23 +4645,23 @@ var require_binaryParsers = __commonJS({
         return value;
       };
       var mask = 255;
-      var firstBits = 8 - offset2 % 8;
+      var firstBits = 8 - offset % 8;
       if (bits < firstBits) {
         mask = 255 << 8 - bits & 255;
         firstBits = bits;
       }
-      if (offset2) {
-        mask = mask >> offset2 % 8;
+      if (offset) {
+        mask = mask >> offset % 8;
       }
       var result = 0;
-      if (offset2 % 8 + bits >= 8) {
+      if (offset % 8 + bits >= 8) {
         result = callback(0, inv(data[offsetBytes]) & mask, firstBits);
       }
-      var bytes = bits + offset2 >> 3;
+      var bytes = bits + offset >> 3;
       for (var i = offsetBytes + 1; i < bytes; i++) {
         result = callback(result, inv(data[i]), 8);
       }
-      var lastBits = (bits + offset2) % 8;
+      var lastBits = (bits + offset) % 8;
       if (lastBits > 0) {
         result = callback(result, inv(data[bytes]) >> 8 - lastBits, lastBits);
       }
@@ -3722,28 +4751,28 @@ var require_binaryParsers = __commonJS({
     };
     var parseArray = function(value) {
       var dim = parseBits(value, 32);
-      var flags14 = parseBits(value, 32, 32);
+      var flags17 = parseBits(value, 32, 32);
       var elementType = parseBits(value, 32, 64);
-      var offset2 = 96;
+      var offset = 96;
       var dims = [];
       for (var i = 0; i < dim; i++) {
-        dims[i] = parseBits(value, 32, offset2);
-        offset2 += 32;
-        offset2 += 32;
+        dims[i] = parseBits(value, 32, offset);
+        offset += 32;
+        offset += 32;
       }
       var parseElement = function(elementType2) {
-        var length = parseBits(value, 32, offset2);
-        offset2 += 32;
+        var length = parseBits(value, 32, offset);
+        offset += 32;
         if (length == 4294967295) {
           return null;
         }
         var result;
         if (elementType2 == 23 || elementType2 == 20) {
-          result = parseBits(value, length * 8, offset2);
-          offset2 += length * 8;
+          result = parseBits(value, length * 8, offset);
+          offset += length * 8;
           return result;
         } else if (elementType2 == 25) {
-          result = value.toString(this.encoding, offset2 >> 3, (offset2 += length << 3) >> 3);
+          result = value.toString(this.encoding, offset >> 3, (offset += length << 3) >> 3);
           return result;
         } else {
           console.log("ERROR: ElementType not implemented: " + elementType2);
@@ -4051,18 +5080,18 @@ var require_utils = __commonJS({
       return JSON.stringify(val);
     }
     function dateToString(date) {
-      let offset2 = -date.getTimezoneOffset();
+      let offset = -date.getTimezoneOffset();
       let year = date.getFullYear();
       const isBCYear = year < 1;
       if (isBCYear) year = Math.abs(year) + 1;
       let ret = String(year).padStart(4, "0") + "-" + String(date.getMonth() + 1).padStart(2, "0") + "-" + String(date.getDate()).padStart(2, "0") + "T" + String(date.getHours()).padStart(2, "0") + ":" + String(date.getMinutes()).padStart(2, "0") + ":" + String(date.getSeconds()).padStart(2, "0") + "." + String(date.getMilliseconds()).padStart(3, "0");
-      if (offset2 < 0) {
+      if (offset < 0) {
         ret += "-";
-        offset2 *= -1;
+        offset *= -1;
       } else {
         ret += "+";
       }
-      ret += String(Math.floor(offset2 / 60)).padStart(2, "0") + ":" + String(offset2 % 60).padStart(2, "0");
+      ret += String(Math.floor(offset / 60)).padStart(2, "0") + ":" + String(offset % 60).padStart(2, "0");
       if (isBCYear) ret += " BC";
       return ret;
     }
@@ -4604,15 +5633,15 @@ var require_pg_connection_string = __commonJS({
       if (config.sslcert || config.sslkey || config.sslrootcert || config.sslmode) {
         config.ssl = {};
       }
-      const fs4 = config.sslcert || config.sslkey || config.sslrootcert ? require("fs") : null;
+      const fs7 = config.sslcert || config.sslkey || config.sslrootcert ? require("fs") : null;
       if (config.sslcert) {
-        config.ssl.cert = fs4.readFileSync(config.sslcert).toString();
+        config.ssl.cert = fs7.readFileSync(config.sslcert).toString();
       }
       if (config.sslkey) {
-        config.ssl.key = fs4.readFileSync(config.sslkey).toString();
+        config.ssl.key = fs7.readFileSync(config.sslkey).toString();
       }
       if (config.sslrootcert) {
-        config.ssl.ca = fs4.readFileSync(config.sslrootcert).toString();
+        config.ssl.ca = fs7.readFileSync(config.sslrootcert).toString();
       }
       if (options.useLibpqCompat && config.uselibpqcompat) {
         throw new Error("Both useLibpqCompat and uselibpqcompat are set. Please use only one of them.");
@@ -5613,13 +6642,13 @@ var require_buffer_reader = __commonJS({
     exports2.BufferReader = void 0;
     var emptyBuffer = Buffer.allocUnsafe(0);
     var BufferReader = class {
-      constructor(offset2 = 0) {
-        this.offset = offset2;
+      constructor(offset = 0) {
+        this.offset = offset;
         this.buffer = emptyBuffer;
         this.encoding = "utf-8";
       }
-      setBuffer(offset2, buffer) {
-        this.offset = offset2;
+      setBuffer(offset, buffer) {
+        this.offset = offset;
         this.buffer = buffer;
       }
       int16() {
@@ -5691,26 +6720,26 @@ var require_parser = __commonJS({
       parse(buffer, callback) {
         this.mergeBuffer(buffer);
         const bufferFullLength = this.bufferOffset + this.bufferLength;
-        let offset2 = this.bufferOffset;
-        while (offset2 + HEADER_LENGTH <= bufferFullLength) {
-          const code = this.buffer[offset2];
-          const length = this.buffer.readUInt32BE(offset2 + CODE_LENGTH);
+        let offset = this.bufferOffset;
+        while (offset + HEADER_LENGTH <= bufferFullLength) {
+          const code = this.buffer[offset];
+          const length = this.buffer.readUInt32BE(offset + CODE_LENGTH);
           const fullMessageLength = CODE_LENGTH + length;
-          if (fullMessageLength + offset2 <= bufferFullLength) {
-            const message = this.handlePacket(offset2 + HEADER_LENGTH, code, length, this.buffer);
+          if (fullMessageLength + offset <= bufferFullLength) {
+            const message = this.handlePacket(offset + HEADER_LENGTH, code, length, this.buffer);
             callback(message);
-            offset2 += fullMessageLength;
+            offset += fullMessageLength;
           } else {
             break;
           }
         }
-        if (offset2 === bufferFullLength) {
+        if (offset === bufferFullLength) {
           this.buffer = emptyBuffer;
           this.bufferLength = 0;
           this.bufferOffset = 0;
         } else {
-          this.bufferLength = bufferFullLength - offset2;
-          this.bufferOffset = offset2;
+          this.bufferLength = bufferFullLength - offset;
+          this.bufferOffset = offset;
         }
       }
       mergeBuffer(buffer) {
@@ -5740,7 +6769,7 @@ var require_parser = __commonJS({
           this.bufferLength = buffer.byteLength;
         }
       }
-      handlePacket(offset2, code, length, bytes) {
+      handlePacket(offset, code, length, bytes) {
         switch (code) {
           case 50:
             return messages_1.bindComplete;
@@ -5759,59 +6788,59 @@ var require_parser = __commonJS({
           case 73:
             return messages_1.emptyQuery;
           case 68:
-            return this.parseDataRowMessage(offset2, length, bytes);
+            return this.parseDataRowMessage(offset, length, bytes);
           case 67:
-            return this.parseCommandCompleteMessage(offset2, length, bytes);
+            return this.parseCommandCompleteMessage(offset, length, bytes);
           case 90:
-            return this.parseReadyForQueryMessage(offset2, length, bytes);
+            return this.parseReadyForQueryMessage(offset, length, bytes);
           case 65:
-            return this.parseNotificationMessage(offset2, length, bytes);
+            return this.parseNotificationMessage(offset, length, bytes);
           case 82:
-            return this.parseAuthenticationResponse(offset2, length, bytes);
+            return this.parseAuthenticationResponse(offset, length, bytes);
           case 83:
-            return this.parseParameterStatusMessage(offset2, length, bytes);
+            return this.parseParameterStatusMessage(offset, length, bytes);
           case 75:
-            return this.parseBackendKeyData(offset2, length, bytes);
+            return this.parseBackendKeyData(offset, length, bytes);
           case 69:
-            return this.parseErrorMessage(offset2, length, bytes, "error");
+            return this.parseErrorMessage(offset, length, bytes, "error");
           case 78:
-            return this.parseErrorMessage(offset2, length, bytes, "notice");
+            return this.parseErrorMessage(offset, length, bytes, "notice");
           case 84:
-            return this.parseRowDescriptionMessage(offset2, length, bytes);
+            return this.parseRowDescriptionMessage(offset, length, bytes);
           case 116:
-            return this.parseParameterDescriptionMessage(offset2, length, bytes);
+            return this.parseParameterDescriptionMessage(offset, length, bytes);
           case 71:
-            return this.parseCopyInMessage(offset2, length, bytes);
+            return this.parseCopyInMessage(offset, length, bytes);
           case 72:
-            return this.parseCopyOutMessage(offset2, length, bytes);
+            return this.parseCopyOutMessage(offset, length, bytes);
           case 100:
-            return this.parseCopyData(offset2, length, bytes);
+            return this.parseCopyData(offset, length, bytes);
           default:
             return new messages_1.DatabaseError("received invalid response: " + code.toString(16), length, "error");
         }
       }
-      parseReadyForQueryMessage(offset2, length, bytes) {
-        this.reader.setBuffer(offset2, bytes);
+      parseReadyForQueryMessage(offset, length, bytes) {
+        this.reader.setBuffer(offset, bytes);
         const status = this.reader.string(1);
         return new messages_1.ReadyForQueryMessage(length, status);
       }
-      parseCommandCompleteMessage(offset2, length, bytes) {
-        this.reader.setBuffer(offset2, bytes);
+      parseCommandCompleteMessage(offset, length, bytes) {
+        this.reader.setBuffer(offset, bytes);
         const text = this.reader.cstring();
         return new messages_1.CommandCompleteMessage(length, text);
       }
-      parseCopyData(offset2, length, bytes) {
-        const chunk = bytes.slice(offset2, offset2 + (length - 4));
+      parseCopyData(offset, length, bytes) {
+        const chunk = bytes.slice(offset, offset + (length - 4));
         return new messages_1.CopyDataMessage(length, chunk);
       }
-      parseCopyInMessage(offset2, length, bytes) {
-        return this.parseCopyMessage(offset2, length, bytes, "copyInResponse");
+      parseCopyInMessage(offset, length, bytes) {
+        return this.parseCopyMessage(offset, length, bytes, "copyInResponse");
       }
-      parseCopyOutMessage(offset2, length, bytes) {
-        return this.parseCopyMessage(offset2, length, bytes, "copyOutResponse");
+      parseCopyOutMessage(offset, length, bytes) {
+        return this.parseCopyMessage(offset, length, bytes, "copyOutResponse");
       }
-      parseCopyMessage(offset2, length, bytes, messageName) {
-        this.reader.setBuffer(offset2, bytes);
+      parseCopyMessage(offset, length, bytes, messageName) {
+        this.reader.setBuffer(offset, bytes);
         const isBinary = this.reader.byte() !== 0;
         const columnCount = this.reader.int16();
         const message = new messages_1.CopyResponse(length, messageName, isBinary, columnCount);
@@ -5820,15 +6849,15 @@ var require_parser = __commonJS({
         }
         return message;
       }
-      parseNotificationMessage(offset2, length, bytes) {
-        this.reader.setBuffer(offset2, bytes);
+      parseNotificationMessage(offset, length, bytes) {
+        this.reader.setBuffer(offset, bytes);
         const processId = this.reader.int32();
         const channel = this.reader.cstring();
         const payload = this.reader.cstring();
         return new messages_1.NotificationResponseMessage(length, processId, channel, payload);
       }
-      parseRowDescriptionMessage(offset2, length, bytes) {
-        this.reader.setBuffer(offset2, bytes);
+      parseRowDescriptionMessage(offset, length, bytes) {
+        this.reader.setBuffer(offset, bytes);
         const fieldCount = this.reader.int16();
         const message = new messages_1.RowDescriptionMessage(length, fieldCount);
         for (let i = 0; i < fieldCount; i++) {
@@ -5846,8 +6875,8 @@ var require_parser = __commonJS({
         const mode = this.reader.int16() === 0 ? "text" : "binary";
         return new messages_1.Field(name, tableID, columnID, dataTypeID, dataTypeSize, dataTypeModifier, mode);
       }
-      parseParameterDescriptionMessage(offset2, length, bytes) {
-        this.reader.setBuffer(offset2, bytes);
+      parseParameterDescriptionMessage(offset, length, bytes) {
+        this.reader.setBuffer(offset, bytes);
         const parameterCount = this.reader.int16();
         const message = new messages_1.ParameterDescriptionMessage(length, parameterCount);
         for (let i = 0; i < parameterCount; i++) {
@@ -5855,8 +6884,8 @@ var require_parser = __commonJS({
         }
         return message;
       }
-      parseDataRowMessage(offset2, length, bytes) {
-        this.reader.setBuffer(offset2, bytes);
+      parseDataRowMessage(offset, length, bytes) {
+        this.reader.setBuffer(offset, bytes);
         const fieldCount = this.reader.int16();
         const fields = new Array(fieldCount);
         for (let i = 0; i < fieldCount; i++) {
@@ -5865,20 +6894,20 @@ var require_parser = __commonJS({
         }
         return new messages_1.DataRowMessage(length, fields);
       }
-      parseParameterStatusMessage(offset2, length, bytes) {
-        this.reader.setBuffer(offset2, bytes);
+      parseParameterStatusMessage(offset, length, bytes) {
+        this.reader.setBuffer(offset, bytes);
         const name = this.reader.cstring();
         const value = this.reader.cstring();
         return new messages_1.ParameterStatusMessage(length, name, value);
       }
-      parseBackendKeyData(offset2, length, bytes) {
-        this.reader.setBuffer(offset2, bytes);
+      parseBackendKeyData(offset, length, bytes) {
+        this.reader.setBuffer(offset, bytes);
         const processID = this.reader.int32();
         const secretKey = this.reader.int32();
         return new messages_1.BackendKeyDataMessage(length, processID, secretKey);
       }
-      parseAuthenticationResponse(offset2, length, bytes) {
-        this.reader.setBuffer(offset2, bytes);
+      parseAuthenticationResponse(offset, length, bytes) {
+        this.reader.setBuffer(offset, bytes);
         const code = this.reader.int32();
         const message = {
           name: "authenticationOk",
@@ -5925,8 +6954,8 @@ var require_parser = __commonJS({
         }
         return message;
       }
-      parseErrorMessage(offset2, length, bytes, name) {
-        this.reader.setBuffer(offset2, bytes);
+      parseErrorMessage(offset, length, bytes, name) {
+        this.reader.setBuffer(offset, bytes);
         const fields = {};
         let fieldType = this.reader.string(1);
         while (fieldType !== "\0") {
@@ -6347,7 +7376,7 @@ var require_split2 = __commonJS({
 var require_helper = __commonJS({
   "../../node_modules/pgpass/lib/helper.js"(exports2, module2) {
     "use strict";
-    var path5 = require("path");
+    var path8 = require("path");
     var Stream = require("stream").Stream;
     var split = require_split2();
     var util = require("util");
@@ -6367,8 +7396,8 @@ var require_helper = __commonJS({
     function warn() {
       var isWritable = warnStream instanceof Stream && true === warnStream.writable;
       if (isWritable) {
-        var args14 = Array.prototype.slice.call(arguments).concat("\n");
-        warnStream.write(util.format.apply(util, args14));
+        var args17 = Array.prototype.slice.call(arguments).concat("\n");
+        warnStream.write(util.format.apply(util, args17));
       }
     }
     Object.defineProperty(module2.exports, "isWin", {
@@ -6386,7 +7415,7 @@ var require_helper = __commonJS({
     };
     module2.exports.getFileName = function(rawEnv) {
       var env = rawEnv || process.env;
-      var file = env.PGPASSFILE || (isWin ? path5.join(env.APPDATA || "./", "postgresql", "pgpass.conf") : path5.join(env.HOME || "./", ".pgpass"));
+      var file = env.PGPASSFILE || (isWin ? path8.join(env.APPDATA || "./", "postgresql", "pgpass.conf") : path8.join(env.HOME || "./", ".pgpass"));
       return file;
     };
     module2.exports.usePgPass = function(stats, fname) {
@@ -6518,16 +7547,16 @@ var require_helper = __commonJS({
 var require_lib = __commonJS({
   "../../node_modules/pgpass/lib/index.js"(exports2, module2) {
     "use strict";
-    var path5 = require("path");
-    var fs4 = require("fs");
+    var path8 = require("path");
+    var fs7 = require("fs");
     var helper = require_helper();
     module2.exports = function(connInfo, cb) {
       var file = helper.getFileName();
-      fs4.stat(file, function(err, stat) {
+      fs7.stat(file, function(err, stat) {
         if (err || !helper.usePgPass(stat, file)) {
           return cb(void 0);
         }
-        var st = fs4.createReadStream(file);
+        var st = fs7.createReadStream(file);
         helper.getPassword(connInfo, st, cb);
       });
     };
@@ -7925,19 +8954,19 @@ var init_esm = __esm({
 
 // src/scripts/doctor.ts
 var doctor_exports = {};
-var import_config4, import_args8, import_chalk6, import_ioredis, import_node_net, okLabel, failLabel, infoLabel, toPort, parseAddress, checkRedis, checkPostgres, checkMlGrpc, flags8, run7;
+var import_config4, import_args10, import_chalk9, import_ioredis, import_node_net, okLabel, failLabel, infoLabel, toPort, parseAddress, checkRedis, checkPostgres, checkMlGrpc, flags10, run7;
 var init_doctor = __esm({
   "src/scripts/doctor.ts"() {
     "use strict";
     import_config4 = require("dotenv/config");
-    import_args8 = __toESM(require("args"));
-    import_chalk6 = __toESM(require("chalk"));
+    import_args10 = __toESM(require("args"));
+    import_chalk9 = __toESM(require("chalk"));
     import_ioredis = __toESM(require("ioredis"));
     init_esm();
     import_node_net = __toESM(require("net"));
-    okLabel = (text) => `${import_chalk6.default.green("OK")} ${text}`;
-    failLabel = (text) => `${import_chalk6.default.red("FAIL")} ${text}`;
-    infoLabel = (text) => `${import_chalk6.default.yellow("INFO")} ${text}`;
+    okLabel = (text) => `${import_chalk9.default.green("OK")} ${text}`;
+    failLabel = (text) => `${import_chalk9.default.red("FAIL")} ${text}`;
+    infoLabel = (text) => `${import_chalk9.default.yellow("INFO")} ${text}`;
     toPort = (value, fallback) => {
       const parsed = Number.parseInt(String(value ?? ""), 10);
       return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
@@ -8048,20 +9077,20 @@ var init_doctor = __esm({
         );
       });
     };
-    import_args8.default.option("require-ml", "Treat ML gRPC connectivity as required", false).option("skip-ml", "Skip ML gRPC check", false);
-    flags8 = import_args8.default.parse(process.argv);
+    import_args10.default.option("require-ml", "Treat ML gRPC connectivity as required", false).option("skip-ml", "Skip ML gRPC check", false);
+    flags10 = import_args10.default.parse(process.argv);
     run7 = async () => {
       const checks = [];
       checks.push(await checkRedis());
       checks.push(await checkPostgres());
-      if (!flags8.skipMl) {
+      if (!flags10.skipMl) {
         const ml = await checkMlGrpc();
-        if (flags8.requireMl) {
+        if (flags10.requireMl) {
           ml.required = true;
         }
         checks.push(ml);
       }
-      console.log(import_chalk6.default.cyan("TradeJS doctor"));
+      console.log(import_chalk9.default.cyan("TradeJS doctor"));
       for (const item of checks) {
         const label = item.ok ? okLabel(item.name) : failLabel(item.name);
         console.log(`${label} (${item.required ? "required" : "optional"})`);
@@ -8072,7 +9101,7 @@ var init_doctor = __esm({
       if (failedRequired.length) {
         console.log("");
         console.log(
-          import_chalk6.default.red(
+          import_chalk9.default.red(
             `Doctor failed: ${failedRequired.length} required check(s) failed.`
           )
         );
@@ -8092,21 +9121,21 @@ var init_doctor = __esm({
         );
       }
       console.log("");
-      console.log(import_chalk6.default.green("Doctor passed."));
+      console.log(import_chalk9.default.green("Doctor passed."));
     };
     run7().catch((error) => {
-      console.error(import_chalk6.default.red(`doctor failed: ${String(error)}`));
+      console.error(import_chalk9.default.red(`doctor failed: ${String(error)}`));
       process.exit(1);
     });
   }
 });
 
 // src/scripts/infraCommon.ts
-var import_chalk7, import_node_child_process, import_node_fs, import_node_path, DEV_COMPOSE_FILE, resolveProjectRoot, DEV_COMPOSE_TEMPLATE, getDevComposePath, initDevComposeFile, requireDevComposeFile, runDockerCompose;
+var import_chalk10, import_node_child_process, import_node_fs, import_node_path, DEV_COMPOSE_FILE, resolveProjectRoot, DEV_COMPOSE_TEMPLATE, getDevComposePath, initDevComposeFile, requireDevComposeFile, runDockerCompose;
 var init_infraCommon = __esm({
   "src/scripts/infraCommon.ts"() {
     "use strict";
-    import_chalk7 = __toESM(require("chalk"));
+    import_chalk10 = __toESM(require("chalk"));
     import_node_child_process = require("child_process");
     import_node_fs = require("fs");
     import_node_path = __toESM(require("path"));
@@ -8165,28 +9194,28 @@ volumes:
       const composePath = getDevComposePath();
       if ((0, import_node_fs.existsSync)(composePath)) {
         console.log(
-          import_chalk7.default.yellow(
+          import_chalk10.default.yellow(
             `${DEV_COMPOSE_FILE} already exists. Keeping user-defined file as is.`
           )
         );
         return composePath;
       }
       (0, import_node_fs.writeFileSync)(composePath, DEV_COMPOSE_TEMPLATE, "utf8");
-      console.log(import_chalk7.default.green(`Created ${DEV_COMPOSE_FILE} in project root`));
+      console.log(import_chalk10.default.green(`Created ${DEV_COMPOSE_FILE} in project root`));
       return composePath;
     };
     requireDevComposeFile = () => {
       const composePath = import_node_path.default.resolve(resolveProjectRoot(), DEV_COMPOSE_FILE);
       if ((0, import_node_fs.existsSync)(composePath)) {
-        console.log(import_chalk7.default.gray(`Using existing ${DEV_COMPOSE_FILE}`));
+        console.log(import_chalk10.default.gray(`Using existing ${DEV_COMPOSE_FILE}`));
         return composePath;
       }
       throw new Error(
         `${DEV_COMPOSE_FILE} not found in project root. Run "npx @tradejs/cli infra-init" first.`
       );
     };
-    runDockerCompose = (composePath, args14) => {
-      const result = (0, import_node_child_process.spawnSync)("docker", ["compose", "-f", composePath, ...args14], {
+    runDockerCompose = (composePath, args17) => {
+      const result = (0, import_node_child_process.spawnSync)("docker", ["compose", "-f", composePath, ...args17], {
         stdio: "inherit"
       });
       if (result.error) {
@@ -8201,20 +9230,20 @@ volumes:
 
 // src/scripts/infraDown.ts
 var infraDown_exports = {};
-var import_chalk8, run8;
+var import_chalk11, run8;
 var init_infraDown = __esm({
   "src/scripts/infraDown.ts"() {
     "use strict";
-    import_chalk8 = __toESM(require("chalk"));
+    import_chalk11 = __toESM(require("chalk"));
     init_infraCommon();
     run8 = async () => {
       const composePath = requireDevComposeFile();
-      console.log(import_chalk8.default.cyan("Stopping dev infra (timescale, redis)..."));
+      console.log(import_chalk11.default.cyan("Stopping dev infra (timescale, redis)..."));
       runDockerCompose(composePath, ["stop", "timescale", "redis"]);
-      console.log(import_chalk8.default.green("Dev infra is stopped."));
+      console.log(import_chalk11.default.green("Dev infra is stopped."));
     };
     run8().catch((error) => {
-      console.error(import_chalk8.default.red(`infra-down failed: ${String(error)}`));
+      console.error(import_chalk11.default.red(`infra-down failed: ${String(error)}`));
       process.exit(1);
     });
   }
@@ -8222,18 +9251,18 @@ var init_infraDown = __esm({
 
 // src/scripts/infraInit.ts
 var infraInit_exports = {};
-var import_chalk9, run9;
+var import_chalk12, run9;
 var init_infraInit = __esm({
   "src/scripts/infraInit.ts"() {
     "use strict";
-    import_chalk9 = __toESM(require("chalk"));
+    import_chalk12 = __toESM(require("chalk"));
     init_infraCommon();
     run9 = async () => {
       initDevComposeFile();
-      console.log(import_chalk9.default.green("Dev infra files are initialized."));
+      console.log(import_chalk12.default.green("Dev infra files are initialized."));
     };
     run9().catch((error) => {
-      console.error(import_chalk9.default.red(`infra-init failed: ${String(error)}`));
+      console.error(import_chalk12.default.red(`infra-init failed: ${String(error)}`));
       process.exit(1);
     });
   }
@@ -8241,20 +9270,20 @@ var init_infraInit = __esm({
 
 // src/scripts/infraUp.ts
 var infraUp_exports = {};
-var import_chalk10, run10;
+var import_chalk13, run10;
 var init_infraUp = __esm({
   "src/scripts/infraUp.ts"() {
     "use strict";
-    import_chalk10 = __toESM(require("chalk"));
+    import_chalk13 = __toESM(require("chalk"));
     init_infraCommon();
     run10 = async () => {
       const composePath = requireDevComposeFile();
-      console.log(import_chalk10.default.cyan("Starting dev infra (timescale, redis)..."));
+      console.log(import_chalk13.default.cyan("Starting dev infra (timescale, redis)..."));
       runDockerCompose(composePath, ["up", "-d", "timescale", "redis"]);
-      console.log(import_chalk10.default.green("Dev infra is up."));
+      console.log(import_chalk13.default.green("Dev infra is up."));
     };
     run10().catch((error) => {
-      console.error(import_chalk10.default.red(`infra-up failed: ${String(error)}`));
+      console.error(import_chalk13.default.red(`infra-up failed: ${String(error)}`));
       process.exit(1);
     });
   }
@@ -8262,19 +9291,19 @@ var init_infraUp = __esm({
 
 // src/scripts/migration.ts
 var migration_exports = {};
-var import_progress4, import_chalk11, import_logger3, import_files, import_timescale4, DIR, re, BATCH, projectRoot4, migrateFile, migration;
+var import_progress5, import_chalk14, import_logger3, import_files, import_timescale4, DIR, re, BATCH, projectRoot5, migrateFile, migration;
 var init_migration = __esm({
   "src/scripts/migration.ts"() {
     "use strict";
-    import_progress4 = __toESM(require("progress"));
-    import_chalk11 = __toESM(require("chalk"));
+    import_progress5 = __toESM(require("progress"));
+    import_chalk14 = __toESM(require("chalk"));
     import_logger3 = require("@tradejs/infra/logger");
     import_files = require("@tradejs/infra/files");
     import_timescale4 = require("@tradejs/infra/timescale");
     DIR = "data/history";
     re = /^(.+?)_(\d+)\.json$/;
     BATCH = 2e3;
-    projectRoot4 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+    projectRoot5 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
     migrateFile = async (file) => {
       const m = re.exec(file);
       if (!m) return;
@@ -8284,7 +9313,7 @@ var init_migration = __esm({
         DIR,
         `${symbol}_${interval4}`,
         [],
-        projectRoot4
+        projectRoot5
       );
       const rows = (0, import_timescale4.toRows)(symbol, interval4, data);
       for (let i = 0; i < rows.length; i += BATCH) {
@@ -8292,8 +9321,8 @@ var init_migration = __esm({
       }
     };
     migration = async () => {
-      const files = await (0, import_files.getFiles)(DIR, projectRoot4);
-      const bar = new import_progress4.default(
+      const files = await (0, import_files.getFiles)(DIR, projectRoot5);
+      const bar = new import_progress5.default(
         ":current/:total [:bar][:percent] :eta(s) :file",
         {
           total: files.length,
@@ -8307,7 +9336,7 @@ var init_migration = __esm({
           import_logger3.logger.error("Failed: %s %s", file, e);
         } finally {
           bar.tick(1, {
-            file: import_chalk11.default.gray(file)
+            file: import_chalk14.default.gray(file)
           });
         }
       }
@@ -8317,91 +9346,84 @@ var init_migration = __esm({
   }
 });
 
-// src/scripts/selectStrategy.ts
-var import_readline, import_chalk12, import_strategies2, defaultStrategy, projectRoot5, getStrategyChoices, selectStrategy;
-var init_selectStrategy = __esm({
-  "src/scripts/selectStrategy.ts"() {
+// src/scripts/mlExport.ts
+var mlExport_exports = {};
+var import_args11, import_chalk15, import_promises3, import_path4, import_ml, flags11, listChunkFiles, main3;
+var init_mlExport = __esm({
+  "src/scripts/mlExport.ts"() {
     "use strict";
-    import_readline = __toESM(require("readline"));
-    import_chalk12 = __toESM(require("chalk"));
-    import_strategies2 = require("@tradejs/node/strategies");
-    defaultStrategy = "TrendLine";
-    projectRoot5 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
-    getStrategyChoices = async () => {
-      try {
-        const loaded = await (0, import_strategies2.getAvailableStrategyNames)(projectRoot5);
-        if (loaded.length) {
-          return loaded;
-        }
-      } catch (error) {
-        console.warn(`Failed to load strategy list: ${String(error)}`);
-      }
-      return [
-        "Breakout",
-        "MaStrategy",
-        "AdaptiveMomentumRibbon",
-        "TrendLine",
-        "VolumeDivergence"
-      ];
+    import_args11 = __toESM(require("args"));
+    import_chalk15 = __toESM(require("chalk"));
+    import_promises3 = __toESM(require("fs/promises"));
+    import_path4 = __toESM(require("path"));
+    import_ml = require("@tradejs/infra/ml");
+    init_resolveExportStrategy();
+    import_args11.default.example(
+      "yarn ts-node ./src/scripts/mlExport --strategy trendline",
+      "Merge per-worker ML chunks into one dataset JSONL"
+    );
+    import_args11.default.option(["o", "outDir"], "Dataset directory", "data/ml/export");
+    import_args11.default.option(["s", "strategy"], "Strategy name", "");
+    import_args11.default.option(
+      ["k", "keepChunks"],
+      "Keep source chunk files after successful merge",
+      false
+    );
+    flags11 = import_args11.default.parse(process.argv);
+    listChunkFiles = async (outDir, strategyName) => {
+      const prefix = `ml-dataset-${(0, import_ml.toFileToken)(strategyName)}-chunk-`;
+      const entries = await import_promises3.default.readdir(outDir, { withFileTypes: true });
+      return entries.filter((entry) => entry.isFile()).map((entry) => entry.name).filter((name) => name.startsWith(prefix) && name.endsWith(".jsonl")).map((name) => import_path4.default.join(outDir, name)).sort();
     };
-    selectStrategy = async (promptLabel = "Select strategy") => {
-      const strategies = await getStrategyChoices();
-      const fallbackStrategy = strategies.includes(defaultStrategy) ? defaultStrategy : strategies[0];
-      if (!process.stdin.isTTY) {
-        return fallbackStrategy;
-      }
-      console.log(import_chalk12.default.cyan("Available strategies:"));
-      strategies.forEach((name, index) => {
-        const isDefault = name === defaultStrategy;
-        const label = isDefault ? import_chalk12.default.green(name) : name;
-        const suffix = isDefault ? import_chalk12.default.gray(" (default)") : "";
-        console.log(`  ${import_chalk12.default.yellow(String(index + 1))}) ${label}${suffix}`);
-      });
-      const rl = import_readline.default.createInterface({
-        input: process.stdin,
-        output: process.stdout
+    main3 = async () => {
+      const outDir = String(flags11.outDir || "data/ml/export");
+      await import_promises3.default.mkdir(outDir, { recursive: true });
+      const strategyName = await resolveExportStrategy({
+        explicitStrategy: String(flags11.strategy || ""),
+        outDir,
+        datasetLabel: "ML",
+        promptLabel: "Select ML export strategy",
+        listStrategies: import_ml.listMlChunkStrategies
       });
-      const question = (text) => new Promise((resolve) => rl.question(text, resolve));
-      const answer = await question(
-        `${promptLabel} [${import_chalk12.default.green(fallbackStrategy)}]: `
-      );
-      rl.close();
-      const trimmed = answer.trim();
-      if (!trimmed) {
-        return fallbackStrategy;
+      if (!strategyName) {
+        console.log(import_chalk15.default.yellow(`No ML chunk files found in ${outDir}`));
+        process.exit(0);
       }
-      const asNumber = Number(trimmed);
-      if (Number.isFinite(asNumber) && asNumber >= 1 && asNumber <= strategies.length) {
-        return strategies[asNumber - 1];
+      const chunkFiles = await listChunkFiles(outDir, strategyName);
+      if (!chunkFiles.length) {
+        console.log(
+          import_chalk15.default.yellow(
+            `No chunk files found for strategy "${strategyName}" in ${outDir}`
+          )
+        );
+        process.exit(0);
       }
-      const byName = strategies.find(
-        (name) => name.toLowerCase() === trimmed.toLowerCase()
+      const mergedPath = import_path4.default.join(
+        outDir,
+        `ml-dataset-${(0, import_ml.toFileToken)(strategyName)}-merged-${Date.now()}.jsonl`
       );
-      if (byName) {
-        return byName;
+      await (0, import_ml.mergeJsonlFiles)({
+        filePaths: chunkFiles,
+        outPath: mergedPath
+      });
+      const shouldDeleteChunks = !Boolean(flags11.keepChunks);
+      if (shouldDeleteChunks) {
+        for (const filePath of chunkFiles) {
+          await import_promises3.default.rm(filePath, { force: true });
+        }
       }
-      console.warn(`Unknown strategy "${trimmed}", using ${fallbackStrategy}.`);
-      return fallbackStrategy;
-    };
-  }
-});
-
-// src/scripts/mlExportSelect.ts
-var mlExportSelect_exports = {};
-var import_child_process2, run11;
-var init_mlExportSelect = __esm({
-  "src/scripts/mlExportSelect.ts"() {
-    "use strict";
-    import_child_process2 = require("child_process");
-    init_selectStrategy();
-    run11 = async () => {
-      const selected = await selectStrategy();
-      const args14 = ["ts-node", "./src/scripts/mlExport", "--strategy", selected];
-      const result = (0, import_child_process2.spawnSync)("yarn", args14, { stdio: "inherit" });
-      process.exit(result.status ?? 1);
+      console.log(import_chalk15.default.green(`Merged dataset saved: ${mergedPath}`));
+      console.log(
+        import_chalk15.default.gray(
+          `strategy=${strategyName}, source_chunks=${chunkFiles.length}, deleteChunks=${Boolean(
+            shouldDeleteChunks
+          )}`
+        )
+      );
+      process.exit(0);
     };
-    run11().catch((err) => {
-      console.error("Failed to select strategy:", err);
+    main3().catch((error) => {
+      console.error(import_chalk15.default.red(error?.message || String(error)));
       process.exit(1);
     });
   }
@@ -8409,33 +9431,33 @@ var init_mlExportSelect = __esm({
 
 // src/scripts/mlInspect.ts
 var mlInspect_exports = {};
-var import_args9, import_chalk13, import_promises, import_fs2, import_path2, import_readline2, import_child_process3, flags9, toMode, toInspectTool, selectInspectTool, asPositiveInt, readRowsHead, readRowsTail, readRowsSample, quantileSorted, mean, std, findLatestDataset, buildNumericStats, formatNumber, runQuickInspect, runYDataInspect, main;
+var import_args12, import_chalk16, import_promises4, import_fs2, import_path5, import_readline2, import_child_process2, flags12, toMode, toInspectTool, selectInspectTool, asPositiveInt, readRowsHead, readRowsTail, readRowsSample, quantileSorted, mean, std, findLatestDataset, buildNumericStats, formatNumber, runQuickInspect, runYDataInspect, main4;
 var init_mlInspect = __esm({
   "src/scripts/mlInspect.ts"() {
     "use strict";
-    import_args9 = __toESM(require("args"));
-    import_chalk13 = __toESM(require("chalk"));
-    import_promises = __toESM(require("fs/promises"));
+    import_args12 = __toESM(require("args"));
+    import_chalk16 = __toESM(require("chalk"));
+    import_promises4 = __toESM(require("fs/promises"));
     import_fs2 = require("fs");
-    import_path2 = __toESM(require("path"));
+    import_path5 = __toESM(require("path"));
     import_readline2 = __toESM(require("readline"));
-    import_child_process3 = require("child_process");
-    import_args9.default.example(
+    import_child_process2 = require("child_process");
+    import_args12.default.example(
       "yarn ml-inspect --rows 10000 --mode sample",
       "Inspect the latest ML dataset chunk and highlight problematic features"
     );
-    import_args9.default.option(["d", "dir"], "Dataset directory", "data/ml/export");
-    import_args9.default.option(["r", "rows"], "Rows to inspect", 1e4);
-    import_args9.default.option(["m", "mode"], "head | tail | sample", "sample");
-    import_args9.default.option(["S", "strategy"], "Strategy token in dataset filename", "");
-    import_args9.default.option(
+    import_args12.default.option(["d", "dir"], "Dataset directory", "data/ml/export");
+    import_args12.default.option(["r", "rows"], "Rows to inspect", 1e4);
+    import_args12.default.option(["m", "mode"], "head | tail | sample", "sample");
+    import_args12.default.option(["S", "strategy"], "Strategy token in dataset filename", "");
+    import_args12.default.option(
       ["f", "file"],
       "Explicit dataset file path (overrides auto-select)"
     );
-    import_args9.default.option(["L", "limitIssues"], "How many fields to print in report", 25);
-    import_args9.default.option(["M", "minFieldValues"], "Min valid values per numeric field", 50);
-    import_args9.default.option(["T", "tool"], "quick | ydata", "");
-    flags9 = import_args9.default.parse(process.argv);
+    import_args12.default.option(["L", "limitIssues"], "How many fields to print in report", 25);
+    import_args12.default.option(["M", "minFieldValues"], "Min valid values per numeric field", 50);
+    import_args12.default.option(["T", "tool"], "quick | ydata", "");
+    flags12 = import_args12.default.parse(process.argv);
     toMode = (value) => {
       const mode = String(value || "sample").toLowerCase();
       if (mode === "head" || mode === "tail" || mode === "sample") {
@@ -8454,12 +9476,12 @@ var init_mlInspect = __esm({
         return defaultTool;
       }
       const options = ["quick", "ydata"];
-      console.log(import_chalk13.default.cyan("Available inspect tools:"));
+      console.log(import_chalk16.default.cyan("Available inspect tools:"));
       options.forEach((name, index) => {
         const isDefault = name === defaultTool;
-        const label = isDefault ? import_chalk13.default.green(name) : name;
-        const suffix = isDefault ? import_chalk13.default.gray(" (default)") : "";
-        console.log(`  ${import_chalk13.default.yellow(String(index + 1))}) ${label}${suffix}`);
+        const label = isDefault ? import_chalk16.default.green(name) : name;
+        const suffix = isDefault ? import_chalk16.default.gray(" (default)") : "";
+        console.log(`  ${import_chalk16.default.yellow(String(index + 1))}) ${label}${suffix}`);
       });
       const rl = import_readline2.default.createInterface({
         input: process.stdin,
@@ -8467,7 +9489,7 @@ var init_mlInspect = __esm({
       });
       const question = (text) => new Promise((resolve) => rl.question(text, resolve));
       const answer = await question(
-        `Select inspect tool [${import_chalk13.default.green(defaultTool)}]: `
+        `Select inspect tool [${import_chalk16.default.green(defaultTool)}]: `
       );
       rl.close();
       const trimmed = answer.trim().toLowerCase();
@@ -8592,7 +9614,7 @@ var init_mlInspect = __esm({
     };
     findLatestDataset = async (params) => {
       const { dir, strategy } = params;
-      const entries = await import_promises.default.readdir(dir, { withFileTypes: true });
+      const entries = await import_promises4.default.readdir(dir, { withFileTypes: true });
       const strategyToken = strategy.trim().toLowerCase();
       const files = entries.filter((entry) => entry.isFile()).map((entry) => entry.name).filter((name) => name.endsWith(".jsonl")).filter(
         (name) => !name.includes(".train.") && !name.includes(".test.")
@@ -8604,14 +9626,14 @@ var init_mlInspect = __esm({
       }
       const withMtime = await Promise.all(
         files.map(async (name) => {
-          const stat = await import_promises.default.stat(import_path2.default.join(dir, name));
+          const stat = await import_promises4.default.stat(import_path5.default.join(dir, name));
           return { name, mtime: stat.mtimeMs };
         })
       );
       withMtime.sort(
         (a, b) => b.mtime - a.mtime
       );
-      return import_path2.default.join(dir, withMtime[0].name);
+      return import_path5.default.join(dir, withMtime[0].name);
     };
     buildNumericStats = (rows, minFieldValues) => {
       const allFields = /* @__PURE__ */ new Set();
@@ -8773,35 +9795,35 @@ var init_mlInspect = __esm({
         rows = await readRowsSample(datasetPath, rowsToInspect);
       }
       if (!rows.length) {
-        console.error(import_chalk13.default.red("No rows could be read from dataset."));
+        console.error(import_chalk16.default.red("No rows could be read from dataset."));
         process.exit(1);
       }
       const numericStats = buildNumericStats(rows, minFieldValues);
       if (!numericStats.length) {
         console.error(
-          import_chalk13.default.red(
+          import_chalk16.default.red(
             "No numeric fields with enough values were found in sampled rows."
           )
         );
         process.exit(1);
       }
       const problematic = numericStats.filter((item) => item.score > 0);
-      console.log(import_chalk13.default.gray("ML dataset inspection (quick)"));
-      console.log(import_chalk13.default.gray(`file: ${datasetPath}`));
-      console.log(import_chalk13.default.gray(`mode: ${mode}`));
-      console.log(import_chalk13.default.gray(`rows inspected: ${rows.length}`));
-      console.log(import_chalk13.default.gray(`numeric fields analyzed: ${numericStats.length}`));
-      console.log(import_chalk13.default.gray(`fields with recommendations: ${problematic.length}`));
+      console.log(import_chalk16.default.gray("ML dataset inspection (quick)"));
+      console.log(import_chalk16.default.gray(`file: ${datasetPath}`));
+      console.log(import_chalk16.default.gray(`mode: ${mode}`));
+      console.log(import_chalk16.default.gray(`rows inspected: ${rows.length}`));
+      console.log(import_chalk16.default.gray(`numeric fields analyzed: ${numericStats.length}`));
+      console.log(import_chalk16.default.gray(`fields with recommendations: ${problematic.length}`));
       console.log("");
       if (!problematic.length) {
         console.log(
-          import_chalk13.default.green("No problematic fields detected by current rules.")
+          import_chalk16.default.green("No problematic fields detected by current rules.")
         );
         process.exit(0);
       }
       const top = problematic.slice(0, limitIssues);
       for (const item of top) {
-        console.log(import_chalk13.default.yellow(item.field));
+        console.log(import_chalk16.default.yellow(item.field));
         console.log(
           `  score=${item.score} issues=${item.issues.join("; ") || "none"}`
         );
@@ -8815,13 +9837,13 @@ var init_mlInspect = __esm({
       if (problematic.length > limitIssues) {
         console.log("");
         console.log(
-          import_chalk13.default.gray(
+          import_chalk16.default.gray(
             `... ${problematic.length - limitIssues} more fields hidden (raise --limitIssues)`
           )
         );
       }
       console.log("");
-      console.log(import_chalk13.default.cyan("How to fix common issues:"));
+      console.log(import_chalk16.default.cyan("How to fix common issues:"));
       console.log(
         "  - Large scale spread: normalize feature (log1p / relative to price / robust scaling)."
       );
@@ -8836,32 +9858,32 @@ var init_mlInspect = __esm({
     runYDataInspect = async (params) => {
       const { datasetPath, mode, rowsToInspect } = params;
       const cwd = process.cwd();
-      const absDatasetPath = import_path2.default.resolve(datasetPath);
-      const dataRoot = import_path2.default.resolve(cwd, "data");
+      const absDatasetPath = import_path5.default.resolve(datasetPath);
+      const dataRoot = import_path5.default.resolve(cwd, "data");
       if (!absDatasetPath.startsWith(dataRoot)) {
         console.error(
-          import_chalk13.default.red(
+          import_chalk16.default.red(
             `ydata mode supports only files under ${dataRoot}. Use --file inside data/`
           )
         );
         process.exit(1);
       }
-      const relToData = import_path2.default.relative(dataRoot, absDatasetPath);
+      const relToData = import_path5.default.relative(dataRoot, absDatasetPath);
       const inputInContainer = `/app/data/${relToData}`;
-      const reportDir = import_path2.default.dirname(absDatasetPath);
-      await import_promises.default.mkdir(reportDir, { recursive: true });
-      const reportPath = import_path2.default.join(
+      const reportDir = import_path5.default.dirname(absDatasetPath);
+      await import_promises4.default.mkdir(reportDir, { recursive: true });
+      const reportPath = import_path5.default.join(
         reportDir,
-        `${import_path2.default.basename(datasetPath, import_path2.default.extname(datasetPath))}.profile.html`
+        `${import_path5.default.basename(datasetPath, import_path5.default.extname(datasetPath))}.profile.html`
       );
-      const reportRelToData = import_path2.default.relative(dataRoot, reportPath);
+      const reportRelToData = import_path5.default.relative(dataRoot, reportPath);
       const reportInContainer = `/app/data/${reportRelToData}`;
       console.log(
-        import_chalk13.default.gray(
+        import_chalk16.default.gray(
           "Running ydata-profiling report via docker ml-profile service..."
         )
       );
-      const result = (0, import_child_process3.spawnSync)(
+      const result = (0, import_child_process2.spawnSync)(
         "docker",
         [
           "compose",
@@ -8881,7 +9903,7 @@ var init_mlInspect = __esm({
           "--output",
           reportInContainer,
           "--title",
-          `ML Profile: ${import_path2.default.basename(datasetPath)}`
+          `ML Profile: ${import_path5.default.basename(datasetPath)}`
         ],
         {
           stdio: "inherit",
@@ -8893,30 +9915,30 @@ var init_mlInspect = __esm({
       );
       if ((result.status ?? 1) !== 0) {
         console.error(
-          import_chalk13.default.red(
+          import_chalk16.default.red(
             "ydata-profiling failed. Build profile image first: docker compose -f docker-compose.ml.yml build ml-profile"
           )
         );
         process.exit(result.status ?? 1);
       }
-      console.log(import_chalk13.default.green(`Profile report saved: ${reportPath}`));
-    };
-    main = async () => {
-      const dir = String(flags9.dir || "data/ml/export");
-      const rowsToInspect = asPositiveInt(flags9.rows, 1e4);
-      const mode = toMode(flags9.mode);
-      const strategy = String(flags9.strategy || "");
-      const limitIssues = asPositiveInt(flags9.limitIssues, 25);
-      const minFieldValues = asPositiveInt(flags9.minFieldValues, 50);
-      const toolFromFlags = toInspectTool(flags9.tool);
-      const explicitFile = flags9.file ? String(flags9.file) : "";
+      console.log(import_chalk16.default.green(`Profile report saved: ${reportPath}`));
+    };
+    main4 = async () => {
+      const dir = String(flags12.dir || "data/ml/export");
+      const rowsToInspect = asPositiveInt(flags12.rows, 1e4);
+      const mode = toMode(flags12.mode);
+      const strategy = String(flags12.strategy || "");
+      const limitIssues = asPositiveInt(flags12.limitIssues, 25);
+      const minFieldValues = asPositiveInt(flags12.minFieldValues, 50);
+      const toolFromFlags = toInspectTool(flags12.tool);
+      const explicitFile = flags12.file ? String(flags12.file) : "";
       const datasetPath = explicitFile || await findLatestDataset({
         dir,
         strategy
       });
       if (!datasetPath) {
         console.error(
-          import_chalk13.default.red(`No dataset found. Expected ml-dataset-*.jsonl in ${dir}`)
+          import_chalk16.default.red(`No dataset found. Expected ml-dataset-*.jsonl in ${dir}`)
         );
         process.exit(1);
       }
@@ -8937,7 +9959,7 @@ var init_mlInspect = __esm({
         minFieldValues
       });
     };
-    main().catch((err) => {
+    main4().catch((err) => {
       console.error("ml-inspect failed:", err);
       process.exit(1);
     });
@@ -8946,22 +9968,22 @@ var init_mlInspect = __esm({
 
 // src/scripts/mlTrainLatestSelect.ts
 var mlTrainLatestSelect_exports = {};
-var import_path3, import_promises2, import_fs3, import_crypto, import_child_process4, import_events, import_readline3, import_args10, import_chalk14, import_ml, toFileToken, asBool, asInt3, asNonNegativeInt, formatBytes, getMlContainerMemUsage, MODEL_TYPES, STRATEGIES, flags10, parseStrategy, parseModelType, selectModelType, listDatasetFiles, concatFiles, pipeNormalized, DAY_MS, SPLIT_PROGRESS_EVERY, parseTimestampMs, scanMaxLabeledTimestampMs, scanMaxTrainTimestampMs, hashFileNameSha1, prepareTrainWindowFiles, run12;
+var import_path6, import_promises5, import_fs3, import_crypto, import_child_process3, import_events, import_readline3, import_args13, import_chalk17, import_ml2, toFileToken4, asBool, asInt3, asNonNegativeInt, formatBytes, getMlContainerMemUsage, MODEL_TYPES, STRATEGIES, flags13, parseStrategy, parseModelType, selectModelType, listDatasetFiles, concatFiles, pipeNormalized, DAY_MS, SPLIT_PROGRESS_EVERY, parseTimestampMs, scanMaxLabeledTimestampMs, scanMaxTrainTimestampMs, hashFileNameSha1, prepareTrainWindowFiles, run11;
 var init_mlTrainLatestSelect = __esm({
   "src/scripts/mlTrainLatestSelect.ts"() {
     "use strict";
-    import_path3 = __toESM(require("path"));
-    import_promises2 = __toESM(require("fs/promises"));
+    import_path6 = __toESM(require("path"));
+    import_promises5 = __toESM(require("fs/promises"));
     import_fs3 = require("fs");
     import_crypto = require("crypto");
-    import_child_process4 = require("child_process");
+    import_child_process3 = require("child_process");
     import_events = require("events");
     import_readline3 = __toESM(require("readline"));
-    import_args10 = __toESM(require("args"));
-    import_chalk14 = __toESM(require("chalk"));
+    import_args13 = __toESM(require("args"));
+    import_chalk17 = __toESM(require("chalk"));
     init_selectStrategy();
-    import_ml = require("@tradejs/infra/ml");
-    toFileToken = (value) => value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "") || "any";
+    import_ml2 = require("@tradejs/infra/ml");
+    toFileToken4 = (value) => value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "") || "any";
     asBool = (value) => ["1", "true", "yes", "on"].includes((value ?? "").trim().toLowerCase());
     asInt3 = (value, fallback) => {
       const parsed = Number.parseInt((value ?? "").trim(), 10);
@@ -8984,7 +10006,7 @@ var init_mlTrainLatestSelect = __esm({
     };
     getMlContainerMemUsage = () => {
       try {
-        const psRaw = (0, import_child_process4.execSync)(
+        const psRaw = (0, import_child_process3.execSync)(
           'docker ps --filter status=running --filter label=com.docker.compose.service=ml --format "{{.ID}}\\t{{.Names}}\\t{{.Label \\"com.docker.compose.oneoff\\"}}"',
           { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
         ).trim();
@@ -8996,7 +10018,7 @@ var init_mlTrainLatestSelect = __esm({
         if (!rows.length) return "n/a";
         const chosen = rows.find((row) => row.oneoff === "True") ?? rows[0];
         if (!chosen?.id) return "n/a";
-        const memUsage = (0, import_child_process4.execSync)(
+        const memUsage = (0, import_child_process3.execSync)(
           `docker stats --no-stream --format "{{.MemUsage}}" ${chosen.id}`,
           { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
         ).trim();
@@ -9021,17 +10043,17 @@ var init_mlTrainLatestSelect = __esm({
       "VolumeDivergence",
       "any"
     ];
-    import_args10.default.option(["s", "strategy"], "Strategy name (e.g. TrendLine)");
-    import_args10.default.option(
+    import_args13.default.option(["s", "strategy"], "Strategy name (e.g. TrendLine)");
+    import_args13.default.option(
       ["m", "model"],
       "Model type: catboost | random_forest | extra_trees | xgboost | lightgbm"
     );
-    import_args10.default.option(
+    import_args13.default.option(
       ["L", "latestOnly"],
       "Use only latest dataset file (overrides ML_TRAIN_USE_LATEST_ONLY)",
       false
     );
-    flags10 = import_args10.default.parse(process.argv);
+    flags13 = import_args13.default.parse(process.argv);
     parseStrategy = (value) => {
       const raw = String(value ?? "").trim();
       if (!raw) return null;
@@ -9049,12 +10071,12 @@ var init_mlTrainLatestSelect = __esm({
       if (!process.stdin.isTTY) {
         return defaultModel;
       }
-      console.log(import_chalk14.default.cyan("Available models:"));
+      console.log(import_chalk17.default.cyan("Available models:"));
       MODEL_TYPES.forEach((name, index) => {
         const isDefault = name === defaultModel;
-        const label = isDefault ? import_chalk14.default.green(name) : name;
-        const suffix = isDefault ? import_chalk14.default.gray(" (default)") : "";
-        console.log(`  ${import_chalk14.default.yellow(String(index + 1))}) ${label}${suffix}`);
+        const label = isDefault ? import_chalk17.default.green(name) : name;
+        const suffix = isDefault ? import_chalk17.default.gray(" (default)") : "";
+        console.log(`  ${import_chalk17.default.yellow(String(index + 1))}) ${label}${suffix}`);
       });
       const rl = import_readline3.default.createInterface({
         input: process.stdin,
@@ -9062,7 +10084,7 @@ var init_mlTrainLatestSelect = __esm({
       });
       const question = (text) => new Promise((resolve) => rl.question(text, resolve));
       const answer = await question(
-        `Select model [${import_chalk14.default.green(defaultModel)}]: `
+        `Select model [${import_chalk17.default.green(defaultModel)}]: `
       );
       rl.close();
       const trimmed = answer.trim().toLowerCase();
@@ -9080,8 +10102,8 @@ var init_mlTrainLatestSelect = __esm({
       return defaultModel;
     };
     listDatasetFiles = async (dir, strategyName) => {
-      const entries = await import_promises2.default.readdir(dir, { withFileTypes: true });
-      const prefix = `ml-dataset-${toFileToken(strategyName)}-`;
+      const entries = await import_promises5.default.readdir(dir, { withFileTypes: true });
+      const prefix = `ml-dataset-${toFileToken4(strategyName)}-`;
       const legacyPrefix = "ml-dataset-";
       const fileNames = entries.filter((entry) => entry.isFile()).map((entry) => entry.name);
       const hasScopedFiles = fileNames.some((name) => name.startsWith(prefix));
@@ -9091,7 +10113,7 @@ var init_mlTrainLatestSelect = __esm({
       ).filter((name) => !name.includes(".train.") && !name.includes(".test.")).filter((name) => !name.includes(".holdout-train.")).filter((name) => !name.includes(".holdout-test.")).filter((name) => !name.includes(".walk-forward.")).filter((name) => !name.includes(".prod."));
       const withMtime = await Promise.all(
         jsonlFiles.map(async (name) => {
-          const stat = await import_promises2.default.stat(import_path3.default.join(dir, name));
+          const stat = await import_promises5.default.stat(import_path6.default.join(dir, name));
           return { name, mtime: stat.mtimeMs };
         })
       );
@@ -9212,7 +10234,7 @@ var init_mlTrainLatestSelect = __esm({
       }
       return maxTrainTs;
     };
-    hashFileNameSha1 = (filePath) => (0, import_crypto.createHash)("sha1").update(import_path3.default.basename(filePath)).digest("hex");
+    hashFileNameSha1 = (filePath) => (0, import_crypto.createHash)("sha1").update(import_path6.default.basename(filePath)).digest("hex");
     prepareTrainWindowFiles = async ({
       inputPath,
       testDays,
@@ -9220,8 +10242,8 @@ var init_mlTrainLatestSelect = __esm({
       walkForwardFolds,
       enforceCausalityGuard
     }) => {
-      const inputBaseName = import_path3.default.basename(inputPath);
-      if ((0, import_ml.isDerivedDatasetFileName)(inputBaseName)) {
+      const inputBaseName = import_path6.default.basename(inputPath);
+      if ((0, import_ml2.isDerivedDatasetFileName)(inputBaseName)) {
         throw new Error(
           `Refusing to split derived dataset file: ${inputBaseName}. Expected base export file.`
         );
@@ -9235,17 +10257,17 @@ var init_mlTrainLatestSelect = __esm({
         causalityGuardVersion: enforceCausalityGuard ? 1 : 0
       });
       const key = (0, import_crypto.createHash)("sha1").update(keyPayload).digest("hex").slice(0, 12);
-      const dir = import_path3.default.dirname(inputPath);
-      const parsed = import_path3.default.parse(inputPath);
-      const holdoutTrainPath = import_path3.default.join(
+      const dir = import_path6.default.dirname(inputPath);
+      const parsed = import_path6.default.parse(inputPath);
+      const holdoutTrainPath = import_path6.default.join(
         dir,
         `${parsed.name}.holdout-train.${key}.jsonl`
       );
-      const holdoutTestPath = import_path3.default.join(
+      const holdoutTestPath = import_path6.default.join(
         dir,
         `${parsed.name}.holdout-test.${key}.jsonl`
       );
-      const prodPath = import_path3.default.join(dir, `${parsed.name}.prod.${key}.jsonl`);
+      const prodPath = import_path6.default.join(dir, `${parsed.name}.prod.${key}.jsonl`);
       const walkForwardFoldDefs = Array.from(
         { length: Math.max(walkForwardFolds, 0) },
         (_4, idx) => {
@@ -9253,27 +10275,27 @@ var init_mlTrainLatestSelect = __esm({
           const foldToken = `fold-${fold}`;
           return {
             fold,
-            trainPath: import_path3.default.join(
+            trainPath: import_path6.default.join(
               dir,
               `${parsed.name}.walk-forward-${foldToken}.train.${key}.jsonl`
             ),
-            testPath: import_path3.default.join(
+            testPath: import_path6.default.join(
               dir,
               `${parsed.name}.walk-forward-${foldToken}.test.${key}.jsonl`
             )
           };
         }
       );
-      const metaPath = import_path3.default.join(dir, `${parsed.name}.windows.${key}.meta.json`);
+      const metaPath = import_path6.default.join(dir, `${parsed.name}.windows.${key}.meta.json`);
       try {
         const [metaRaw] = await Promise.all([
-          import_promises2.default.readFile(metaPath, "utf8"),
-          import_promises2.default.access(holdoutTrainPath),
-          import_promises2.default.access(holdoutTestPath),
-          import_promises2.default.access(prodPath),
+          import_promises5.default.readFile(metaPath, "utf8"),
+          import_promises5.default.access(holdoutTrainPath),
+          import_promises5.default.access(holdoutTestPath),
+          import_promises5.default.access(prodPath),
           ...walkForwardFoldDefs.flatMap((entry) => [
-            import_promises2.default.access(entry.trainPath),
-            import_promises2.default.access(entry.testPath)
+            import_promises5.default.access(entry.trainPath),
+            import_promises5.default.access(entry.testPath)
           ])
         ]);
         const meta2 = JSON.parse(metaRaw);
@@ -9363,7 +10385,7 @@ var init_mlTrainLatestSelect = __esm({
         wfStartMs,
         prodStartMs,
         folds
-      } = (0, import_ml.computeWindowBoundaries)({
+      } = (0, import_ml2.computeWindowBoundaries)({
         maxLabeledTs,
         maxTrainTs,
         testDays,
@@ -9444,7 +10466,7 @@ var init_mlTrainLatestSelect = __esm({
         const ts = parseTimestampMs(parsedRow.entryTimestamp);
         if (!ts) continue;
         if (enforceCausalityGuard) {
-          const violations = (0, import_ml.findLookaheadViolations)(
+          const violations = (0, import_ml2.findLookaheadViolations)(
             parsedRow
           );
           if (violations.length) {
@@ -9562,7 +10584,7 @@ var init_mlTrainLatestSelect = __esm({
         }
       }
       const meta = {
-        exportFile: import_path3.default.basename(inputPath),
+        exportFile: import_path6.default.basename(inputPath),
         exportHash,
         params: {
           testDays,
@@ -9575,72 +10597,72 @@ var init_mlTrainLatestSelect = __esm({
             holdoutTrainRows,
             holdoutTestRows,
             holdoutCutoffMs,
-            holdoutCutoffDt: (0, import_ml.toIsoUtcOrNull)(holdoutCutoffMs),
+            holdoutCutoffDt: (0, import_ml2.toIsoUtcOrNull)(holdoutCutoffMs),
             holdoutTrainStartMs,
-            holdoutTrainStartDt: (0, import_ml.toIsoUtcOrNull)(holdoutTrainStartMs),
+            holdoutTrainStartDt: (0, import_ml2.toIsoUtcOrNull)(holdoutTrainStartMs),
             holdoutTrainMinTs: holdoutTrainRows > 0 ? holdoutTrainMinTs : null,
-            holdoutTrainMinDt: (0, import_ml.toIsoUtcOrNull)(
+            holdoutTrainMinDt: (0, import_ml2.toIsoUtcOrNull)(
               holdoutTrainRows > 0 ? holdoutTrainMinTs : null
             ),
             holdoutTrainMaxTs: holdoutTrainRows > 0 ? holdoutTrainMaxTs : null,
-            holdoutTrainMaxDt: (0, import_ml.toIsoUtcOrNull)(
+            holdoutTrainMaxDt: (0, import_ml2.toIsoUtcOrNull)(
               holdoutTrainRows > 0 ? holdoutTrainMaxTs : null
             ),
             holdoutTestMinTs: holdoutTestRows > 0 ? holdoutTestMinTs : null,
-            holdoutTestMinDt: (0, import_ml.toIsoUtcOrNull)(
+            holdoutTestMinDt: (0, import_ml2.toIsoUtcOrNull)(
               holdoutTestRows > 0 ? holdoutTestMinTs : null
             ),
             holdoutTestMaxTs: holdoutTestRows > 0 ? holdoutTestMaxTs : null,
-            holdoutTestMaxDt: (0, import_ml.toIsoUtcOrNull)(
+            holdoutTestMaxDt: (0, import_ml2.toIsoUtcOrNull)(
               holdoutTestRows > 0 ? holdoutTestMaxTs : null
             ),
-            holdoutTrain: import_path3.default.basename(holdoutTrainPath),
-            holdoutTest: import_path3.default.basename(holdoutTestPath)
+            holdoutTrain: import_path6.default.basename(holdoutTrainPath),
+            holdoutTest: import_path6.default.basename(holdoutTestPath)
           },
           prod: {
             prodRows,
             prodStartMs: Number.isFinite(prodStartMs) ? prodStartMs : null,
-            prodStartDt: (0, import_ml.toIsoUtcOrNull)(
+            prodStartDt: (0, import_ml2.toIsoUtcOrNull)(
               Number.isFinite(prodStartMs) ? prodStartMs : null
             ),
             prodMinTs: prodRows > 0 ? prodMinTs : null,
-            prodMinDt: (0, import_ml.toIsoUtcOrNull)(prodRows > 0 ? prodMinTs : null),
+            prodMinDt: (0, import_ml2.toIsoUtcOrNull)(prodRows > 0 ? prodMinTs : null),
             prodMaxTs: prodRows > 0 ? prodMaxTs : null,
-            prodMaxDt: (0, import_ml.toIsoUtcOrNull)(prodRows > 0 ? prodMaxTs : null),
-            prod: import_path3.default.basename(prodPath)
+            prodMaxDt: (0, import_ml2.toIsoUtcOrNull)(prodRows > 0 ? prodMaxTs : null),
+            prod: import_path6.default.basename(prodPath)
           },
           walkForwardFolds: walkForwardWriters.map((entry) => ({
             fold: entry.fold,
             walkForwardSourceRows,
             startTs: entry.startTs,
-            startDt: (0, import_ml.toIsoUtcOrNull)(entry.startTs),
+            startDt: (0, import_ml2.toIsoUtcOrNull)(entry.startTs),
             endTs: entry.endTs,
-            endDt: (0, import_ml.toIsoUtcOrNull)(entry.endTs),
+            endDt: (0, import_ml2.toIsoUtcOrNull)(entry.endTs),
             trainStartMs: Number.isFinite(wfStartMs) ? wfStartMs : null,
-            trainStartDt: (0, import_ml.toIsoUtcOrNull)(
+            trainStartDt: (0, import_ml2.toIsoUtcOrNull)(
               Number.isFinite(wfStartMs) ? wfStartMs : null
             ),
             trainMinTs: entry.trainRows > 0 ? entry.trainMinTs : null,
-            trainMinDt: (0, import_ml.toIsoUtcOrNull)(
+            trainMinDt: (0, import_ml2.toIsoUtcOrNull)(
               entry.trainRows > 0 ? entry.trainMinTs : null
             ),
             trainMaxTs: entry.trainRows > 0 ? entry.trainMaxTs : null,
-            trainMaxDt: (0, import_ml.toIsoUtcOrNull)(
+            trainMaxDt: (0, import_ml2.toIsoUtcOrNull)(
               entry.trainRows > 0 ? entry.trainMaxTs : null
             ),
             testMinTs: entry.testRows > 0 ? entry.testMinTs : null,
-            testMinDt: (0, import_ml.toIsoUtcOrNull)(entry.testRows > 0 ? entry.testMinTs : null),
+            testMinDt: (0, import_ml2.toIsoUtcOrNull)(entry.testRows > 0 ? entry.testMinTs : null),
             testMaxTs: entry.testRows > 0 ? entry.testMaxTs : null,
-            testMaxDt: (0, import_ml.toIsoUtcOrNull)(entry.testRows > 0 ? entry.testMaxTs : null),
+            testMaxDt: (0, import_ml2.toIsoUtcOrNull)(entry.testRows > 0 ? entry.testMaxTs : null),
             trainRows: entry.trainRows,
             testRows: entry.testRows,
-            train: import_path3.default.basename(entry.trainPath),
-            test: import_path3.default.basename(entry.testPath)
+            train: import_path6.default.basename(entry.trainPath),
+            test: import_path6.default.basename(entry.testPath)
           }))
         },
         createdAt: (/* @__PURE__ */ new Date()).toISOString()
       };
-      await import_promises2.default.writeFile(metaPath, `${JSON.stringify(meta, null, 2)}
+      await import_promises5.default.writeFile(metaPath, `${JSON.stringify(meta, null, 2)}
 `, "utf8");
       return {
         holdoutTrainPath,
@@ -9667,29 +10689,29 @@ var init_mlTrainLatestSelect = __esm({
         }
       };
     };
-    run12 = async () => {
-      const selectedFromCli = parseStrategy(flags10.strategy);
+    run11 = async () => {
+      const selectedFromCli = parseStrategy(flags13.strategy);
       const selected = selectedFromCli ?? await selectStrategy();
       const envModelType = (process.env.ML_MODEL_TYPE ?? "random_forest").trim().toLowerCase();
       const defaultModelType = MODEL_TYPES.includes(
         envModelType
       ) ? envModelType : "random_forest";
-      const modelFromCli = parseModelType(flags10.model);
+      const modelFromCli = parseModelType(flags13.model);
       const modelType = modelFromCli ?? await selectModelType(defaultModelType);
-      const useLatestOnly = Boolean(flags10.latestOnly) || asBool(process.env.ML_TRAIN_USE_LATEST_ONLY);
-      const exportDir = import_path3.default.join(process.cwd(), "data", "ml", "export");
-      const modelDirRoot = import_path3.default.join(process.cwd(), "data", "ml");
+      const useLatestOnly = Boolean(flags13.latestOnly) || asBool(process.env.ML_TRAIN_USE_LATEST_ONLY);
+      const exportDir = import_path6.default.join(process.cwd(), "data", "ml", "export");
+      const modelDirRoot = import_path6.default.join(process.cwd(), "data", "ml");
       const datasetFiles = await listDatasetFiles(exportDir, selected);
       let inputPath;
       let cleanupFiles = [];
       if (datasetFiles.length && useLatestOnly) {
         const latest = datasetFiles[datasetFiles.length - 1];
-        inputPath = import_path3.default.join(exportDir, latest);
-        console.log(`Using latest JSONL dataset: ${import_path3.default.basename(inputPath)}`);
+        inputPath = import_path6.default.join(exportDir, latest);
+        console.log(`Using latest JSONL dataset: ${import_path6.default.basename(inputPath)}`);
       } else if (datasetFiles.length) {
-        const files = datasetFiles.map((name) => import_path3.default.join(exportDir, name));
+        const files = datasetFiles.map((name) => import_path6.default.join(exportDir, name));
         const mergedPrefix = `ml-dataset-merged-${Date.now()}`;
-        inputPath = import_path3.default.join(exportDir, `${mergedPrefix}.jsonl`);
+        inputPath = import_path6.default.join(exportDir, `${mergedPrefix}.jsonl`);
         await concatFiles(files, inputPath);
         cleanupFiles = [inputPath];
         console.log(`Merged datasets: ${datasetFiles.length} exports`);
@@ -9698,7 +10720,7 @@ var init_mlTrainLatestSelect = __esm({
         process.exit(1);
       }
       try {
-        const inputStat = await import_promises2.default.stat(inputPath);
+        const inputStat = await import_promises5.default.stat(inputPath);
         const totalInputBytes = inputStat.size;
         const autoIncrementalThresholdGb = asInt3(
           process.env.ML_TRAIN_INCREMENTAL_THRESHOLD_GB,
@@ -9754,10 +10776,10 @@ var init_mlTrainLatestSelect = __esm({
           `${splitMode} split key=${splitFiles.key} export_hash=${splitFiles.exportHash.slice(0, 12)}`
         );
         console.log(
-          `${splitMode} holdout files: train=${import_path3.default.basename(splitFiles.holdoutTrainPath)} (${splitFiles.counts.holdoutTrainRows} rows), test=${import_path3.default.basename(splitFiles.holdoutTestPath)} (${splitFiles.counts.holdoutTestRows} rows)`
+          `${splitMode} holdout files: train=${import_path6.default.basename(splitFiles.holdoutTrainPath)} (${splitFiles.counts.holdoutTrainRows} rows), test=${import_path6.default.basename(splitFiles.holdoutTestPath)} (${splitFiles.counts.holdoutTestRows} rows)`
         );
         console.log(
-          `${splitMode} prod file: ${import_path3.default.basename(splitFiles.prodPath)} (${splitFiles.counts.prodRows} rows)`
+          `${splitMode} prod file: ${import_path6.default.basename(splitFiles.prodPath)} (${splitFiles.counts.prodRows} rows)`
         );
         if (splitFiles.walkForwardFolds.length) {
           console.log(
@@ -9765,7 +10787,7 @@ var init_mlTrainLatestSelect = __esm({
           );
           for (const foldEntry of splitFiles.walkForwardFolds) {
             console.log(
-              `${splitMode} walk-forward fold ${foldEntry.fold}: train=${import_path3.default.basename(foldEntry.trainPath)} (${foldEntry.trainRows} rows), test=${import_path3.default.basename(foldEntry.testPath)} (${foldEntry.testRows} rows)`
+              `${splitMode} walk-forward fold ${foldEntry.fold}: train=${import_path6.default.basename(foldEntry.trainPath)} (${foldEntry.trainRows} rows), test=${import_path6.default.basename(foldEntry.testPath)} (${foldEntry.testRows} rows)`
             );
           }
         } else {
@@ -9781,11 +10803,11 @@ var init_mlTrainLatestSelect = __esm({
           "python",
           "/app/ml/train.py",
           "--input",
-          `/app/data/ml/export/${import_path3.default.basename(splitFiles.holdoutTrainPath)}`,
+          `/app/data/ml/export/${import_path6.default.basename(splitFiles.holdoutTrainPath)}`,
           "--test-input",
-          `/app/data/ml/export/${import_path3.default.basename(splitFiles.holdoutTestPath)}`,
+          `/app/data/ml/export/${import_path6.default.basename(splitFiles.holdoutTestPath)}`,
           "--prod-input",
-          `/app/data/ml/export/${import_path3.default.basename(splitFiles.prodPath)}`,
+          `/app/data/ml/export/${import_path6.default.basename(splitFiles.prodPath)}`,
           "--strategy",
           selected,
           "--model-type",
@@ -9803,9 +10825,9 @@ var init_mlTrainLatestSelect = __esm({
           ...useEnsemble ? ["--ensemble"] : [],
           ...splitFiles.walkForwardFolds.flatMap((foldEntry) => [
             "--walk-forward-fold-train-input",
-            `/app/data/ml/export/${import_path3.default.basename(foldEntry.trainPath)}`,
+            `/app/data/ml/export/${import_path6.default.basename(foldEntry.trainPath)}`,
             "--walk-forward-fold-test-input",
-            `/app/data/ml/export/${import_path3.default.basename(foldEntry.testPath)}`
+            `/app/data/ml/export/${import_path6.default.basename(foldEntry.testPath)}`
           ])
         ];
         const startedAt = Date.now();
@@ -9818,7 +10840,7 @@ var init_mlTrainLatestSelect = __esm({
           90
         );
         console.log(`Starting train command: docker ${trainArgs.join(" ")}`);
-        const child = (0, import_child_process4.spawn)("docker", trainArgs, {
+        const child = (0, import_child_process3.spawn)("docker", trainArgs, {
           stdio: ["inherit", "pipe", "pipe"],
           env: {
             ...process.env,
@@ -9884,10 +10906,10 @@ var init_mlTrainLatestSelect = __esm({
           );
         }
         if (code === 0) {
-          const modelDir = import_path3.default.join(modelDirRoot, "models");
+          const modelDir = import_path6.default.join(modelDirRoot, "models");
           let savedModels = [];
           try {
-            const entries = await import_promises2.default.readdir(modelDir, { withFileTypes: true });
+            const entries = await import_promises5.default.readdir(modelDir, { withFileTypes: true });
             savedModels = entries.filter((entry) => entry.isFile()).map((entry) => entry.name).filter(
               (name) => name === `${selected}.joblib` || /^.+\.model\d+\.joblib$/.test(name)
             ).filter((name) => name.startsWith(`${selected}.`)).sort();
@@ -9909,12 +10931,12 @@ var init_mlTrainLatestSelect = __esm({
         process.exitCode = finalCode;
       } finally {
         for (const file of cleanupFiles) {
-          await import_promises2.default.rm(file, { force: true });
+          await import_promises5.default.rm(file, { force: true });
         }
       }
       process.exit(process.exitCode ?? 1);
     };
-    run12().catch((err) => {
+    run11().catch((err) => {
       console.error("Failed to train:", err);
       process.exit(1);
     });
@@ -9926,32 +10948,32 @@ var results_exports = {};
 __export(results_exports, {
   results: () => results2
 });
-var import_args11, import_chalk15, import_connectors7, import_cli7, import_redis4, ListIt2, flags11, MIN_PROFIT, MIN_WIN_RATE, MIN_ORDERS_PER_MONTH, createListIt2, formatPercent, getMonthlyReturn, toStrategyResultEntry, toStrategyResults, getTestConfigs, buildBestResults, getSavedProfitsBySymbol, getCoverageRow, results2;
+var import_args14, import_chalk18, import_connectors7, import_cli7, import_redis4, ListIt3, flags14, MIN_PROFIT, MIN_WIN_RATE, MIN_ORDERS_PER_MONTH, createListIt3, formatPercent, getMonthlyReturn, toStrategyResultEntry, toStrategyResults, getTestConfigs, buildBestResults, getSavedProfitsBySymbol, getCoverageRow, results2;
 var init_results = __esm({
   "src/scripts/results.ts"() {
     "use strict";
-    import_args11 = __toESM(require("args"));
-    import_chalk15 = __toESM(require("chalk"));
+    import_args14 = __toESM(require("args"));
+    import_chalk18 = __toESM(require("chalk"));
     import_connectors7 = require("@tradejs/connectors");
     import_cli7 = require("@tradejs/node/cli");
     import_redis4 = require("@tradejs/infra/redis");
-    ListIt2 = require_list_it();
-    import_args11.default.example(
+    ListIt3 = require_list_it();
+    import_args14.default.example(
       "yarn results --strategy TrendLine --coverage",
       "Show best results per symbol and coverage"
     );
-    import_args11.default.option(["s", "strategy"], "Strategy name");
-    import_args11.default.option(["C", "coverage"], "Show coverage table", false);
-    import_args11.default.option(["u", "update"], "Update results config in redis", false);
-    import_args11.default.option(["m", "merge"], "Merge results config in redis", false);
-    import_args11.default.option(["c", "clear"], "Clear results config in redis", false);
-    import_args11.default.option(["V", "verbose"], "Verbose output", false);
-    import_args11.default.option(["U", "user"], "Use user config", "root");
-    flags11 = import_args11.default.parse(process.argv);
+    import_args14.default.option(["s", "strategy"], "Strategy name");
+    import_args14.default.option(["C", "coverage"], "Show coverage table", false);
+    import_args14.default.option(["u", "update"], "Update results config in redis", false);
+    import_args14.default.option(["m", "merge"], "Merge results config in redis", false);
+    import_args14.default.option(["c", "clear"], "Clear results config in redis", false);
+    import_args14.default.option(["V", "verbose"], "Verbose output", false);
+    import_args14.default.option(["U", "user"], "Use user config", "root");
+    flags14 = import_args14.default.parse(process.argv);
     MIN_PROFIT = 2;
     MIN_WIN_RATE = 40;
     MIN_ORDERS_PER_MONTH = 1;
-    createListIt2 = () => new ListIt2({
+    createListIt3 = () => new ListIt3({
       autoAlign: true,
       headerUnderline: true
     });
@@ -10075,39 +11097,39 @@ var init_results = __esm({
       };
     };
     results2 = async () => {
-      if (!flags11.strategy) {
-        console.error(import_chalk15.default.red("Missing --strategy"));
+      if (!flags14.strategy) {
+        console.error(import_chalk18.default.red("Missing --strategy"));
         process.exit(1);
       }
-      const strategyName = flags11.strategy;
-      const userName2 = flags11.user;
-      if (flags11.clear) {
+      const strategyName = flags14.strategy;
+      const userName2 = flags14.user;
+      if (flags14.clear) {
         const cleared = await (0, import_redis4.delKey)(
           import_redis4.redisKeys.strategyResults(userName2, strategyName)
         );
         console.log(
-          cleared ? import_chalk15.default.green(`Cleared results:${strategyName}`) : import_chalk15.default.yellow(`No results to clear for ${strategyName}`)
+          cleared ? import_chalk18.default.green(`Cleared results:${strategyName}`) : import_chalk18.default.yellow(`No results to clear for ${strategyName}`)
         );
-        if (!flags11.coverage && !flags11.update && !flags11.merge) {
+        if (!flags14.coverage && !flags14.update && !flags14.merge) {
           process.exit();
         }
       }
       const bestBySymbol = await buildBestResults(userName2, strategyName);
-      if (flags11.coverage) {
+      if (flags14.coverage) {
         const rows = [...bestBySymbol.values()].sort((a, b) => b.profit - a.profit).map((row) => [
-          import_chalk15.default.yellow(row.symbol),
-          import_chalk15.default.green(formatPercent(row.profit)),
-          import_chalk15.default.magenta(formatPercent(row.winRate)),
-          import_chalk15.default.blue(row.orders.toString())
+          import_chalk18.default.yellow(row.symbol),
+          import_chalk18.default.green(formatPercent(row.profit)),
+          import_chalk18.default.magenta(formatPercent(row.winRate)),
+          import_chalk18.default.blue(row.orders.toString())
         ]);
         console.log("");
-        console.log(import_chalk15.default.gray("RESULTS:"));
+        console.log(import_chalk18.default.gray("RESULTS:"));
         console.log(
-          createListIt2().setHeaderRow([
-            import_chalk15.default.yellow("SYMBOL"),
-            import_chalk15.default.green("PROFIT"),
-            import_chalk15.default.magenta("WINRATE"),
-            import_chalk15.default.blue("ORDERS")
+          createListIt3().setHeaderRow([
+            import_chalk18.default.yellow("SYMBOL"),
+            import_chalk18.default.green("PROFIT"),
+            import_chalk18.default.magenta("WINRATE"),
+            import_chalk18.default.blue("ORDERS")
           ]).d(rows).toString()
         );
         console.log("");
@@ -10118,17 +11140,17 @@ var init_results = __esm({
           goodSymbols
         );
         console.log(
-          import_chalk15.default.gray(
+          import_chalk18.default.gray(
             `COVERAGE: ${goodMissing} / ${goodExisting} / ${total} (${coverage.toFixed(2)} %)`
           )
         );
         console.log("");
       }
-      if (flags11.update || flags11.merge) {
+      if (flags14.update || flags14.merge) {
         const resultsConfig = toStrategyResults(bestBySymbol.values());
-        if (flags11.merge) {
+        if (flags14.merge) {
           if (Object.keys(resultsConfig).length === 0) {
-            console.log(import_chalk15.default.yellow("No good results to merge."));
+            console.log(import_chalk18.default.yellow("No good results to merge."));
             process.exit(0);
           }
           const current = await (0, import_redis4.getData)(
@@ -10144,7 +11166,7 @@ var init_results = __esm({
           );
           if (updates.length === 0) {
             console.log(
-              import_chalk15.default.yellow(
+              import_chalk18.default.yellow(
                 `No symbols with higher profit than saved results:${strategyName}`
               )
             );
@@ -10157,7 +11179,7 @@ var init_results = __esm({
           await (0, import_redis4.setData)(import_redis4.redisKeys.strategyResults(userName2, strategyName), merged, {
             expire: 0
           });
-          if (flags11.verbose) {
+          if (flags14.verbose) {
             const updateRows = updates.sort((a, b) => {
               const prevA = savedProfitBySymbol.get(a.symbol) ?? -Infinity;
               const prevB = savedProfitBySymbol.get(b.symbol) ?? -Infinity;
@@ -10166,30 +11188,30 @@ var init_results = __esm({
               const prevProfit = savedProfitBySymbol.get(row.symbol);
               const delta = row.profit - (prevProfit ?? 0);
               return [
-                import_chalk15.default.yellow(row.symbol),
-                import_chalk15.default.gray(
+                import_chalk18.default.yellow(row.symbol),
+                import_chalk18.default.gray(
                   prevProfit === void 0 ? "N/A" : formatPercent(prevProfit)
                 ),
-                import_chalk15.default.green(formatPercent(row.profit)),
-                import_chalk15.default.blue(
+                import_chalk18.default.green(formatPercent(row.profit)),
+                import_chalk18.default.blue(
                   `${delta >= 0 ? "+" : ""}${formatPercent(delta).replace("+", "")}`
                 )
               ];
             });
             console.log("");
-            console.log(import_chalk15.default.gray("MERGE UPDATES:"));
+            console.log(import_chalk18.default.gray("MERGE UPDATES:"));
             console.log(
-              createListIt2().setHeaderRow([
-                import_chalk15.default.yellow("SYMBOL"),
-                import_chalk15.default.gray("PREV_PROFIT"),
-                import_chalk15.default.green("NEW_PROFIT"),
-                import_chalk15.default.blue("DELTA")
+              createListIt3().setHeaderRow([
+                import_chalk18.default.yellow("SYMBOL"),
+                import_chalk18.default.gray("PREV_PROFIT"),
+                import_chalk18.default.green("NEW_PROFIT"),
+                import_chalk18.default.blue("DELTA")
               ]).d(updateRows).toString()
             );
             console.log("");
           }
           console.log(
-            import_chalk15.default.green(
+            import_chalk18.default.green(
               `Merged ${updates.length} symbols into results:${strategyName} (only higher profit)`
             )
           );
@@ -10203,7 +11225,7 @@ var init_results = __esm({
           }
         );
         console.log(
-          import_chalk15.default.green(
+          import_chalk18.default.green(
             `Updated results:${strategyName} with ${Object.keys(resultsConfig).length} symbols`
           )
         );
@@ -10218,46 +11240,52 @@ var init_results = __esm({
 
 // src/scripts/signals.ts
 var signals_exports = {};
-var import_config5, import_args12, import_progress5, import_connectors8, import_chalk16, import_connectors9, import_cli8, import_async3, import_constants4, import_strategies3, import_time3, import_logger4, import_redis5, PRELOAD_START, projectRoot6, flags12, minTouches, offset, interval3, formatElapsed, resolveStrategyNameByConfigKey, loadRuntimeStrategies, resolveSignalsConnectorName, findSignals, signals;
+__export(signals_exports, {
+  signals: () => signals
+});
+var import_config5, import_args15, import_progress6, import_connectors8, import_chalk19, import_connectors9, import_cli8, import_async4, import_constants5, import_strategies3, import_time3, import_logger4, import_redis5, PRELOAD_START, projectRoot6, flags15, interval3, formatElapsed, resolveStrategyNameByConfigKey, loadRuntimeStrategies, createStrategySkipStats, recordStrategyReason, logStrategySkipStats, resolveSignalsConnectorName, findSignals, signals;
 var init_signals = __esm({
   "src/scripts/signals.ts"() {
     "use strict";
     import_config5 = require("dotenv/config");
-    import_args12 = __toESM(require("args"));
-    import_progress5 = __toESM(require("progress"));
+    import_args15 = __toESM(require("args"));
+    import_progress6 = __toESM(require("progress"));
     import_connectors8 = require("@tradejs/connectors");
-    import_chalk16 = __toESM(require("chalk"));
+    import_chalk19 = __toESM(require("chalk"));
     import_connectors9 = require("@tradejs/node/connectors");
     import_cli8 = require("@tradejs/node/cli");
-    import_async3 = require("@tradejs/core/async");
-    import_constants4 = require("@tradejs/core/constants");
+    import_async4 = require("@tradejs/core/async");
+    import_constants5 = require("@tradejs/core/constants");
     import_strategies3 = require("@tradejs/node/strategies");
     import_time3 = require("@tradejs/core/time");
     import_logger4 = require("@tradejs/infra/logger");
     import_redis5 = require("@tradejs/infra/redis");
-    import_args12.default.option(["t", "tickers"], "Selected tickers");
-    import_args12.default.option(["e", "exclude"], "Exclude tickers from tests");
-    import_args12.default.option(["l", "tickersLimit"], "Tickers limit");
-    import_args12.default.option(["f", "timeframe"], "Timeframe", 15);
-    import_args12.default.option(["m", "makeOrders"], "Make orders");
-    import_args12.default.option(["N", "notify"], "Send message in Telegram", false);
-    import_args12.default.option(["S", "skipScreenshots"], "Skip screenshot generation", false);
-    import_args12.default.option(["u", "updateOnly"], "Only update tickers history", false);
-    import_args12.default.option(["C", "cacheOnly"], "Do not update tickers history", false);
-    import_args12.default.option(["L", "showTickersList"], "Just show only ticker list", false);
-    import_args12.default.option(["c", "chunk"], "Split by chunks, ex. 1/3");
-    import_args12.default.option(["U", "user"], "Use user confg", "root");
-    import_args12.default.option(
+    import_args15.default.option(["t", "tickers"], "Selected tickers");
+    import_args15.default.option(["e", "exclude"], "Exclude tickers from tests");
+    import_args15.default.option(["l", "tickersLimit"], "Tickers limit");
+    import_args15.default.option(["f", "timeframe"], "Timeframe", 15);
+    import_args15.default.option(["m", "makeOrders"], "Make orders");
+    import_args15.default.option(["N", "notify"], "Send message in Telegram", false);
+    import_args15.default.option(["S", "skipScreenshots"], "Skip screenshot generation", false);
+    import_args15.default.option(["u", "updateOnly"], "Only update tickers history", false);
+    import_args15.default.option(["C", "cacheOnly"], "Do not update tickers history", false);
+    import_args15.default.option(["L", "showTickersList"], "Just show only ticker list", false);
+    import_args15.default.option(
+      ["R", "showSkipStats"],
+      "Show aggregated skip stats by strategy",
+      false
+    );
+    import_args15.default.option(["c", "chunk"], "Split by chunks, ex. 1/3");
+    import_args15.default.option(["U", "user"], "Use user confg", "root");
+    import_args15.default.option(
       "connector",
       "Connector provider or name for signals (e.g. bybit, binance, coinbase, custom)",
       "bybit"
     );
-    PRELOAD_START = (0, import_time3.getTimestamp)(import_constants4.SIGNALS_PRELOAD_DAYS);
+    PRELOAD_START = (0, import_time3.getTimestamp)(import_constants5.SIGNALS_CLI_PRELOAD_DAYS);
     projectRoot6 = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
-    flags12 = import_args12.default.parse(process.argv);
-    minTouches = parseInt(flags12.points);
-    offset = parseInt(flags12.offset);
-    interval3 = flags12.timeframe.toString();
+    flags15 = import_args15.default.parse(process.argv);
+    interval3 = flags15.timeframe.toString();
     formatElapsed = (startedAt) => `${((Date.now() - startedAt) / 1e3).toFixed(1)}s`;
     resolveStrategyNameByConfigKey = (userName2, key) => {
       const parts = key.split(":");
@@ -10297,6 +11325,45 @@ var init_signals = __esm({
       );
       return strategyConfigs.filter(Boolean);
     };
+    createStrategySkipStats = (runtimeStrategies) => new Map(
+      runtimeStrategies.map(({ strategyName }) => [
+        strategyName,
+        {
+          evaluated: 0,
+          signals: 0,
+          reasons: /* @__PURE__ */ new Map()
+        }
+      ])
+    );
+    recordStrategyReason = (strategyStats, strategyName, reason) => {
+      const stats = strategyStats.get(strategyName);
+      if (!stats) {
+        return;
+      }
+      stats.reasons.set(reason, (stats.reasons.get(reason) ?? 0) + 1);
+    };
+    logStrategySkipStats = (runtimeStrategies, strategyStats) => {
+      import_logger4.logger.info(import_chalk19.default.yellow("skip stats:"));
+      for (const { strategyName } of runtimeStrategies) {
+        const stats = strategyStats.get(strategyName);
+        if (!stats) {
+          continue;
+        }
+        import_logger4.logger.info(
+          `${strategyName}: evaluated=${stats.evaluated}, signals=${stats.signals}`
+        );
+        const sortedReasons = [...stats.reasons.entries()].sort(
+          (left, right) => right[1] - left[1] || left[0].localeCompare(right[0])
+        );
+        if (!sortedReasons.length) {
+          import_logger4.logger.info("  none");
+          continue;
+        }
+        for (const [reason, count] of sortedReasons) {
+          import_logger4.logger.info(`  ${reason}: ${count}`);
+        }
+      }
+    };
     resolveSignalsConnectorName = async (value) => {
       const connectorName = await (0, import_connectors9.resolveConnectorName)(value, projectRoot6);
       if (connectorName) {
@@ -10309,13 +11376,9 @@ var init_signals = __esm({
       );
       return import_connectors9.DEFAULT_CONNECTOR_NAME;
     };
-    findSignals = async (symbol, connector, btcBinanceData, btcCoinbaseData, runtimeStrategies) => {
-      const prevSignals = await (0, import_redis5.getKeys)(import_redis5.redisKeys.signalsBySymbol(symbol));
-      if (prevSignals.length) {
-        import_logger4.logger.info("Exit by signal exists %s", symbol);
-        return null;
-      }
+    findSignals = async (symbol, connector, btcBinanceData, btcCoinbaseData, runtimeStrategies, strategyStats) => {
       const currentTimestamp = (0, import_time3.getTimestamp)();
+      const strategySignals = [];
       const [cachedData, btcCachedData] = await Promise.all([
         connector.kline({
           symbol,
@@ -10335,12 +11398,16 @@ var init_signals = __esm({
       const lastCandle = cachedData.pop();
       const btcLastCandle = btcCachedData.pop();
       if (!lastCandle || !btcLastCandle) {
-        return;
+        return strategySignals;
       }
       for (const runtimeStrategy of runtimeStrategies) {
         const { strategyName, strategyCreator, strategyConfig } = runtimeStrategy;
+        const stats = strategyStats.get(strategyName);
+        if (stats) {
+          stats.evaluated += 1;
+        }
         const strategy = await strategyCreator({
-          userName: flags12.user,
+          userName: flags15.user,
           connector,
           symbol,
           data: [...cachedData],
@@ -10351,29 +11418,36 @@ var init_signals = __esm({
             ...strategyConfig,
             ENV: "CRON",
             INTERVAL: interval3,
-            MAKE_ORDERS: flags12.makeOrders
+            MAKE_ORDERS: flags15.makeOrders
           }
         });
         const signal = await strategy(lastCandle, btcLastCandle);
         if (!signal || typeof signal === "string") {
+          if (typeof signal === "string") {
+            recordStrategyReason(strategyStats, strategyName, signal);
+          }
           continue;
         }
+        if (stats) {
+          stats.signals += 1;
+        }
+        strategySignals.push(signal);
         await (0, import_redis5.setData)(import_redis5.redisKeys.signal(symbol, signal.signalId), signal, {
-          expire: import_constants4.TTL_1D
+          expire: import_constants5.TTL_1D
         });
         await (0, import_redis5.setData)(import_redis5.redisKeys.storeSignal(symbol, signal.signalId), signal, {
-          expire: import_constants4.TTL_3M
+          expire: import_constants5.TTL_3M
         });
         import_logger4.logger.info("Signal found %s by strategy %s", symbol, strategyName);
-        return signal;
       }
+      return strategySignals;
     };
     signals = async () => {
       const startedAt = Date.now();
       const signals2 = new Array();
       let status = "completed";
       try {
-        const connectorName = await resolveSignalsConnectorName(flags12.connector);
+        const connectorName = await resolveSignalsConnectorName(flags15.connector);
         const connectorFactory = await (0, import_connectors9.getConnectorCreatorByName)(
           connectorName,
           projectRoot6
@@ -10382,7 +11456,7 @@ var init_signals = __esm({
           throw new Error(`Connector "${connectorName}" is not registered`);
         }
         const marketConnector = await connectorFactory({
-          userName: flags12.user
+          userName: flags15.user
         });
         let btcBinanceConnector = marketConnector;
         let btcCoinbaseConnector = marketConnector;
@@ -10393,7 +11467,7 @@ var init_signals = __esm({
           );
           if (binanceFactory) {
             btcBinanceConnector = await binanceFactory({
-              userName: flags12.user
+              userName: flags15.user
             });
           } else {
             import_logger4.logger.warn(
@@ -10407,7 +11481,7 @@ var init_signals = __esm({
           );
           if (coinbaseFactory) {
             btcCoinbaseConnector = await coinbaseFactory({
-              userName: flags12.user
+              userName: flags15.user
             });
           } else {
             import_logger4.logger.warn(
@@ -10418,22 +11492,37 @@ var init_signals = __esm({
         }
         const tickers = await (0, import_cli8.getTickers)(
           marketConnector,
-          flags12.tickers,
-          flags12.exclude,
-          flags12.tickersLimit,
-          flags12.chunk
+          flags15.tickers,
+          flags15.exclude,
+          flags15.tickersLimit,
+          flags15.chunk
         );
-        if (flags12.showTickersList) {
-          console.log(import_chalk16.default.gray(JSON.stringify(tickers.sort(), null, 2)));
+        if (flags15.showTickersList) {
+          console.log(import_chalk19.default.gray(JSON.stringify(tickers.sort(), null, 2)));
           return;
         }
-        if (!flags12.cacheOnly) {
-          await (0, import_cli8.update)(marketConnector, interval3, tickers);
+        if (!flags15.cacheOnly) {
+          await (0, import_cli8.update)(
+            marketConnector,
+            interval3,
+            tickers,
+            import_constants5.SIGNALS_CLI_PRELOAD_DAYS
+          );
           if (btcBinanceConnector !== marketConnector) {
-            await (0, import_cli8.update)(btcBinanceConnector, interval3, ["BTCUSDT"]);
+            await (0, import_cli8.update)(
+              btcBinanceConnector,
+              interval3,
+              ["BTCUSDT"],
+              import_constants5.SIGNALS_CLI_PRELOAD_DAYS
+            );
           }
           if (btcCoinbaseConnector !== marketConnector) {
-            await (0, import_cli8.update)(btcCoinbaseConnector, interval3, ["BTCUSDT"]);
+            await (0, import_cli8.update)(
+              btcCoinbaseConnector,
+              interval3,
+              ["BTCUSDT"],
+              import_constants5.SIGNALS_CLI_PRELOAD_DAYS
+            );
           }
         }
         const currentTimestamp = (0, import_time3.getTimestamp)();
@@ -10453,52 +11542,53 @@ var init_signals = __esm({
             interval: interval3
           })
         ]);
-        if (flags12.updateOnly) {
+        if (flags15.updateOnly) {
           return;
         }
-        const runtimeStrategies = await loadRuntimeStrategies(flags12.user);
+        const runtimeStrategies = await loadRuntimeStrategies(flags15.user);
         if (!runtimeStrategies.length) {
           import_logger4.logger.warn(
             "No strategy configs found by users:%s:strategies:*:config",
-            flags12.user
+            flags15.user
           );
           return;
         }
         import_logger4.logger.info(
-          import_chalk16.default.yellow(
+          import_chalk19.default.yellow(
             `loaded strategies: ${runtimeStrategies.map((s) => s.strategyName).join(", ")}`
           )
         );
-        const bar = new import_progress5.default(
+        const strategyStats = createStrategySkipStats(runtimeStrategies);
+        const bar = new import_progress6.default(
           ":current/:total [:bar][:percent] :found :eta(s) :symbol",
           {
             total: tickers.length,
             width: 30
           }
         );
-        import_logger4.logger.info(import_chalk16.default.yellow(`tickers: ${tickers.length}`));
-        await (0, import_async3.runWithConcurrency)(tickers, 5, async (symbol) => {
-          const signal = await findSignals(
+        import_logger4.logger.info(import_chalk19.default.yellow(`tickers: ${tickers.length}`));
+        await (0, import_async4.runWithConcurrency)(tickers, 5, async (symbol) => {
+          const strategySignals = await findSignals(
             symbol,
             marketConnector,
             btcBinanceData,
             btcCoinbaseData,
-            runtimeStrategies
+            runtimeStrategies,
+            strategyStats
           );
-          if (signal) {
-            signals2.push(signal);
+          if (strategySignals.length > 0) {
+            signals2.push(...strategySignals);
           }
           bar.tick(1, {
-            found: import_chalk16.default.cyan(signals2.length),
-            symbol: import_chalk16.default.gray(symbol)
+            found: import_chalk19.default.cyan(signals2.length),
+            symbol: import_chalk19.default.gray(symbol)
           });
         });
-        if (!flags12.skipScreenshots) {
-          await (0, import_cli8.makeScreenshots)(signals2, "15");
-          await (0, import_cli8.makeScreenshots)(signals2, "60");
+        if (!flags15.skipScreenshots) {
+          await (0, import_cli8.makeScreenshots)(signals2, "15", flags15.user);
         }
-        if (flags12.notify) {
-          await (0, import_cli8.sendToTG)(signals2, "15");
+        if (flags15.notify) {
+          await (0, import_cli8.sendToTG)(signals2, "15", flags15.user);
         }
         import_logger4.logger.info(
           JSON.stringify(
@@ -10507,6 +11597,9 @@ var init_signals = __esm({
             2
           )
         );
+        if (flags15.showSkipStats) {
+          logStrategySkipStats(runtimeStrategies, strategyStats);
+        }
       } catch (error) {
         status = "failed";
         import_logger4.logger.error(
@@ -10516,33 +11609,35 @@ var init_signals = __esm({
         throw error;
       } finally {
         import_logger4.logger.info(
-          import_chalk16.default.yellow(
+          import_chalk19.default.yellow(
             `signals ${status} in ${formatElapsed(startedAt)} (found=${signals2.length})`
           )
         );
       }
     };
-    signals().then(() => {
-      process.exit(0);
-    }).catch(() => {
-      process.exit(1);
-    });
+    if (process.env.NODE_ENV !== "test") {
+      signals().then(() => {
+        process.exit(0);
+      }).catch(() => {
+        process.exit(1);
+      });
+    }
   }
 });
 
 // src/scripts/test-ml.ts
 var test_ml_exports = {};
-var import_config6, import_constants5, import_ml2, import_strategies4, now, INTERVAL_MIN, CANDLES, makeSeries, makeCandles, buildTrendline, main2;
+var import_config6, import_constants6, import_ml3, import_strategies4, now, INTERVAL_MIN, CANDLES, makeSeries, makeCandles, buildTrendline, main5;
 var init_test_ml = __esm({
   "src/scripts/test-ml.ts"() {
     "use strict";
     import_config6 = require("dotenv/config");
-    import_constants5 = require("@tradejs/core/constants");
-    import_ml2 = require("@tradejs/infra/ml");
+    import_constants6 = require("@tradejs/core/constants");
+    import_ml3 = require("@tradejs/infra/ml");
     import_strategies4 = require("@tradejs/strategies");
     now = Date.now();
     INTERVAL_MIN = 15;
-    CANDLES = import_constants5.ML_BASE_CANDLES_WINDOW;
+    CANDLES = import_constants6.ML_BASE_CANDLES_WINDOW;
     makeSeries = (len, base, step = 0.1) => Array.from({ length: len }, (_4, i) => base + i * step);
     makeCandles = (startPrice, startTs) => {
       const candles = [];
@@ -10582,7 +11677,7 @@ var init_test_ml = __esm({
         { timestamp: entryTs - 2 * INTERVAL_MIN * 6e4, value: price * 0.995 }
       ]
     });
-    main2 = async () => {
+    main5 = async () => {
       const startTs = now - CANDLES * INTERVAL_MIN * 6e4;
       const candles = makeCandles(120, startTs);
       const btcCandles = makeCandles(42e3, startTs);
@@ -10608,8 +11703,8 @@ var init_test_ml = __esm({
           correlation: 0.18,
           touches: 6,
           distance: 0.7,
-          candles15m: candles.slice(-import_constants5.ML_BASE_CANDLES_WINDOW),
-          btcCandles15m: btcCandles.slice(-import_constants5.ML_BASE_CANDLES_WINDOW),
+          candles15m: candles.slice(-import_constants6.ML_BASE_CANDLES_WINDOW),
+          btcCandles15m: btcCandles.slice(-import_constants6.ML_BASE_CANDLES_WINDOW),
           atr: makeSeries(10, 1.2, 0.02),
           atrPct: makeSeries(10, 1.05, 5e-3),
           maFast: makeSeries(10, currentPrice * 0.995, 0.01),
@@ -10634,7 +11729,7 @@ var init_test_ml = __esm({
         }
       };
       const { TRENDLINE, HIGHS, LOWS, ML_THRESHOLD } = import_strategies4.trendLineDefaultConfig;
-      const fullRow = (0, import_ml2.buildMlTrainingRow)(
+      const fullRow = (0, import_ml3.buildMlTrainingRow)(
         {
           signal,
           context: {
@@ -10649,9 +11744,9 @@ var init_test_ml = __esm({
         },
         null
       );
-      const row = (0, import_ml2.trimMlTrainingRowWindows)(fullRow, 5);
-      const features = (0, import_ml2.buildMlFeatures)(row);
-      const mlResult = await (0, import_ml2.fetchMlThreshold)({
+      const row = (0, import_ml3.trimMlTrainingRowWindows)(fullRow, 5);
+      const features = (0, import_ml3.buildMlFeatures)(row);
+      const mlResult = await (0, import_ml3.fetchMlThreshold)({
         strategy: "TrendLine",
         features,
         threshold: ML_THRESHOLD,
@@ -10663,7 +11758,7 @@ var init_test_ml = __esm({
       }
       console.log("ML result:", mlResult);
     };
-    main2().catch((err) => {
+    main5().catch((err) => {
       console.error("test-ml failed:", err);
       process.exit(1);
     });
@@ -10672,7 +11767,7 @@ var init_test_ml = __esm({
 
 // src/scripts/test.ts
 var test_exports = {};
-var import_config7, import_connectors10, getPositions, main3;
+var import_config7, import_connectors10, getPositions, main6;
 var init_test = __esm({
   "src/scripts/test.ts"() {
     "use strict";
@@ -10682,38 +11777,38 @@ var init_test = __esm({
       const res = await connector.getPositions();
       console.log("res", res);
     };
-    main3 = async () => {
+    main6 = async () => {
       const byBitConnector = await import_connectors10.connectors.ByBit({
         userName: "root"
       });
       await getPositions(byBitConnector);
     };
-    main3();
+    main6();
   }
 });
 
 // src/scripts/user-add.ts
 var user_add_exports = {};
-var import_args13, import_chalk17, import_bcryptjs, import_crypto2, import_redis6, flags13, run13;
+var import_args16, import_chalk20, import_bcryptjs, import_crypto2, import_redis6, flags16, run12;
 var init_user_add = __esm({
   "src/scripts/user-add.ts"() {
     "use strict";
-    import_args13 = __toESM(require("args"));
-    import_chalk17 = __toESM(require("chalk"));
+    import_args16 = __toESM(require("args"));
+    import_chalk20 = __toESM(require("chalk"));
     import_bcryptjs = __toESM(require("bcryptjs"));
     import_crypto2 = __toESM(require("crypto"));
     import_redis6 = require("@tradejs/infra/redis");
-    import_args13.default.example("yarn user-add -u myname -p 123456", "Create or update user");
-    import_args13.default.option(["u", "user"], "Username", "");
-    import_args13.default.option(["p", "password"], "Password (plain text)", "");
-    import_args13.default.option(["t", "token"], "Persistent token (optional)", "");
-    flags13 = import_args13.default.parse(process.argv);
-    run13 = async () => {
-      const userName2 = String(flags13.user || "").trim();
-      const password = String(flags13.password || "");
-      const requestedToken = String(flags13.token || "").trim();
+    import_args16.default.example("yarn user-add -u myname -p 123456", "Create or update user");
+    import_args16.default.option(["u", "user"], "Username", "");
+    import_args16.default.option(["p", "password"], "Password (plain text)", "");
+    import_args16.default.option(["t", "token"], "Persistent token (optional)", "");
+    flags16 = import_args16.default.parse(process.argv);
+    run12 = async () => {
+      const userName2 = String(flags16.user || "").trim();
+      const password = String(flags16.password || "");
+      const requestedToken = String(flags16.token || "").trim();
       if (!userName2 || !password) {
-        console.error(import_chalk17.default.red("Missing -U <user> or -P <password>"));
+        console.error(import_chalk20.default.red("Missing -U <user> or -P <password>"));
         process.exit(1);
       }
       const passwordHash = await import_bcryptjs.default.hash(password, 10);
@@ -10730,18 +11825,20 @@ var init_user_add = __esm({
       await (0, import_redis6.setData)(import_redis6.redisKeys.user(userName2), next, {
         expire: 0
       });
-      console.log(import_chalk17.default.green(`User ${userName2} updated`));
+      console.log(import_chalk20.default.green(`User ${userName2} updated`));
       if (token) {
-        console.log(import_chalk17.default.gray(`token: ${token}`));
+        console.log(import_chalk20.default.gray(`token: ${token}`));
       }
       process.exit(0);
     };
-    run13();
+    run12();
   }
 });
 
 // src/cli.ts
 var scriptLoaders = {
+  "ai-export": () => Promise.resolve().then(() => (init_aiExport(), aiExport_exports)),
+  "ai-train": () => Promise.resolve().then(() => (init_aiTrain(), aiTrain_exports)),
   backtest: () => Promise.resolve().then(() => (init_backtest(), backtest_exports)),
   bot: () => Promise.resolve().then(() => (init_bot(), bot_exports)),
   "clean-dir": () => Promise.resolve().then(() => (init_cleanDir(), cleanDir_exports)),
@@ -10755,7 +11852,7 @@ var scriptLoaders = {
   "infra-init": () => Promise.resolve().then(() => (init_infraInit(), infraInit_exports)),
   "infra-up": () => Promise.resolve().then(() => (init_infraUp(), infraUp_exports)),
   migration: () => Promise.resolve().then(() => (init_migration(), migration_exports)),
-  "ml-export": () => Promise.resolve().then(() => (init_mlExportSelect(), mlExportSelect_exports)),
+  "ml-export": () => Promise.resolve().then(() => (init_mlExport(), mlExport_exports)),
   "ml-inspect": () => Promise.resolve().then(() => (init_mlInspect(), mlInspect_exports)),
   "ml-train:latest": () => Promise.resolve().then(() => (init_mlTrainLatestSelect(), mlTrainLatestSelect_exports)),
   results: () => Promise.resolve().then(() => (init_results(), results_exports)),
@@ -10771,21 +11868,21 @@ var printUsage = () => {
     `Usage: tradejs <command> [args]\\n\\nCommands:\\n${commands.join("\\n")}`
   );
 };
-var main4 = async () => {
-  const [, scriptPath, command = "", ...args14] = process.argv;
+var main7 = async () => {
+  const [, scriptPath, command = "", ...args17] = process.argv;
   const loader = scriptLoaders[command];
   if (!loader) {
     printUsage();
     process.exit(command ? 1 : 0);
   }
-  const nextArgs = [...args14];
+  const nextArgs = [...args17];
   if (command === "spread:ingest") {
     nextArgs.push("--provider", "binance_coinbase_spread");
   }
   process.argv = [process.argv[0], scriptPath, ...nextArgs];
   await loader();
 };
-main4().catch((error) => {
+main7().catch((error) => {
   console.error(error);
   process.exit(1);
 });