@tradejs/cli 1.0.5 → 1.0.8

package/dist/scripts/researchAuto.js

@@ -0,0 +1,845 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scripts/researchAuto.ts
+var researchAuto_exports = {};
+__export(researchAuto_exports, {
+  buildTelegramReport: () => buildTelegramReport,
+  createEmptySteps: () => createEmptySteps,
+  escapeHtml: () => escapeHtml,
+  formatMskDateTime: () => formatMskDateTime,
+  getBacktestResultsPrefix: () => getBacktestResultsPrefix,
+  listMergedFiles: () => listMergedFiles,
+  listRuntimeStrategyNames: () => listRuntimeStrategyNames,
+  parseJsonOutput: () => parseJsonOutput,
+  resolveStrategyNameByConfigKey: () => resolveStrategyNameByConfigKey,
+  resolveTarget: () => resolveTarget,
+  runCliCommand: () => runCliCommand,
+  toStrategyConfigGrid: () => toStrategyConfigGrid,
+  trimTextTail: () => trimTextTail
+});
+module.exports = __toCommonJS(researchAuto_exports);
+var import_args = __toESM(require("args"));
+var import_chalk = __toESM(require("chalk"));
+var import_node_child_process = require("child_process");
+var import_promises = __toESM(require("fs/promises"));
+var import_node_path = __toESM(require("path"));
+var import_ai = require("@tradejs/infra/ai");
+var import_logger = require("@tradejs/infra/logger");
+var import_redis = require("@tradejs/infra/redis");
+var import_strategies = require("@tradejs/strategies");
+
+// src/lib/telegramReports.ts
+var import_cli = require("@tradejs/node/cli");
+var TELEGRAM_REPORT_CHUNK_LIMIT = 3900;
+var buildPartHeader = (index, total) => `\u{1F4E9} <b>Part ${index}/${total}</b>`;
+var splitLongLine = (line, limit) => {
+  const chunks = [];
+  for (let index = 0; index < line.length; index += limit) {
+    chunks.push(line.slice(index, index + limit));
+  }
+  return chunks;
+};
+var splitTelegramReport = (message, limit = TELEGRAM_REPORT_CHUNK_LIMIT) => {
+  const normalizedLimit = Math.max(100, Math.floor(limit));
+  if (message.length <= normalizedLimit) {
+    return [message];
+  }
+  const chunks = [];
+  let current = "";
+  const flush = () => {
+    if (!current) {
+      return;
+    }
+    chunks.push(current);
+    current = "";
+  };
+  for (const line of message.split("\n")) {
+    const next = current ? `${current}
+${line}` : line;
+    if (next.length <= normalizedLimit) {
+      current = next;
+      continue;
+    }
+    flush();
+    if (line.length <= normalizedLimit) {
+      current = line;
+      continue;
+    }
+    chunks.push(...splitLongLine(line, normalizedLimit));
+  }
+  flush();
+  return chunks;
+};
+var sendTelegramReport = async (message, options = {}) => {
+  const chunks = splitTelegramReport(message);
+  if (chunks.length === 1) {
+    await (0, import_cli.sendTextToTG)(chunks[0], options);
+    return chunks.length;
+  }
+  for (const [index, chunk] of chunks.entries()) {
+    const header = buildPartHeader(index + 1, chunks.length);
+    await (0, import_cli.sendTextToTG)(`${header}
+
+${chunk}`, {
+      userName: options.userName,
+      markup: index === chunks.length - 1 ? options.markup : void 0
+    });
+  }
+  return chunks.length;
+};
+
+// src/scripts/researchAuto.ts
+import_args.default.example(
+  "yarn cli:node8g research:auto --strategy TrendLine --days 45",
+  "Run the nightly backtest -> ai-export -> ai-train local research pipeline and save structured results to Redis"
+);
+import_args.default.option(["s", "strategy"], "Strategy name");
+import_args.default.option(["c", "config"], "Backtest config name");
+import_args.default.option(["U", "user"], "Use user config", "root");
+import_args.default.option(["o", "connector"], "Backtest connector", "bybit");
+import_args.default.option(["f", "timeframe"], "Backtest timeframe", "15");
+import_args.default.option(["d", "days"], "Backtest days window", 45);
+import_args.default.option(["n", "recent"], "AI train recent rows window", 1e3);
+import_args.default.option("skip", "AI train skip rows from end", 0);
+import_args.default.option("minQuality", "Minimum AI quality required to approve entry", 4);
+import_args.default.option("outDir", "AI export output directory", "data/ai/export");
+import_args.default.option("skipAgent", "Skip direct research agent invocation", false);
+import_args.default.option("json", "Print structured JSON summary", false);
+var flags = import_args.default.parse(process.argv);
+var projectRoot = String(process.env.PROJECT_CWD || process.cwd()).trim() || process.cwd();
+var dotenvPath = String(
+  process.env.DOTENV_CONFIG_PATH || import_node_path.default.join(projectRoot, ".env")
+).trim() || import_node_path.default.join(projectRoot, ".env");
+var trimTextTail = (value, limit = 4e3) => value.length <= limit ? value : value.slice(-limit);
+var escapeHtml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var createEmptySteps = () => ({
+  prepareBacktestConfig: {
+    status: "pending",
+    command: "prepare-backtest-config",
+    args: []
+  },
+  cleanTests: {
+    status: "pending",
+    command: "clean-tests",
+    args: []
+  },
+  cleanAiExport: {
+    status: "pending",
+    command: "clean-dir",
+    args: ["--dir", "ai/export"]
+  },
+  backtest: {
+    status: "pending",
+    command: "backtest",
+    args: []
+  },
+  aiExport: {
+    status: "pending",
+    command: "ai-export",
+    args: []
+  },
+  aiTrainLocal: {
+    status: "pending",
+    command: "ai-train",
+    args: []
+  },
+  agentRun: {
+    status: "pending",
+    command: "agent-run",
+    args: []
+  }
+});
+var saveRun = async (run) => {
+  await (0, import_redis.setData)(import_redis.redisKeys.researchRun(run.userName, run.runId), run, {
+    expire: 0
+  });
+  await (0, import_redis.setData)(import_redis.redisKeys.researchLatestRun(run.userName, run.strategy), run, {
+    expire: 0
+  });
+};
+var listMergedFiles = async (outDir, strategyName) => {
+  try {
+    const entries = await import_promises.default.readdir(outDir);
+    const prefix = `ai-dataset-${(0, import_ai.toFileToken)(strategyName)}-merged-`;
+    return entries.filter((name) => name.startsWith(prefix) && name.endsWith(".jsonl")).sort().map((name) => import_node_path.default.join(outDir, name));
+  } catch {
+    return [];
+  }
+};
+var getBacktestResultsPrefix = (userName, config) => `users:${userName}:backtests:results:${config}:`;
+var resolveStrategyNameByConfigKey = (userName, key) => {
+  const parts = key.split(":");
+  if (parts.length !== 5) {
+    return null;
+  }
+  const [users, keyUserName, strategiesKey, strategyName, configKey] = parts;
+  if (users !== "users" || keyUserName !== userName || strategiesKey !== "strategies" || configKey !== "config" || !strategyName) {
+    return null;
+  }
+  return strategyName;
+};
+var listRuntimeStrategyNames = async (userName) => {
+  const keys = await (0, import_redis.getKeys)(`${import_redis.redisKeys.strategies(userName)}:`);
+  return keys.filter((key) => key.endsWith(":config")).map((key) => resolveStrategyNameByConfigKey(userName, key)).filter((value) => Boolean(value)).sort((left, right) => left.localeCompare(right));
+};
+var toStrategyConfigGrid = (strategyConfig) => {
+  return Object.fromEntries(
+    Object.entries(strategyConfig).map(([key, value]) => [key, [value]])
+  );
+};
+var formatMskDateTime = (value) => {
+  if (!value) {
+    return "n/a";
+  }
+  const timestamp = Date.parse(value);
+  if (!Number.isFinite(timestamp)) {
+    return value;
+  }
+  return new Intl.DateTimeFormat("ru-RU", {
+    timeZone: "Europe/Moscow",
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  }).format(new Date(timestamp));
+};
+var buildTelegramReport = (run) => {
+  const aiTrainLocal = run.artifacts.aiTrainLocal;
+  const agentRun = run.artifacts.agentRun;
+  const lines = [
+    `<b>Research auto: ${escapeHtml(run.strategy)}</b>`,
+    `Status: <b>${run.status}</b>`,
+    `Run: <code>${escapeHtml(run.runId)}</code>`,
+    `Selected by: <code>${escapeHtml(run.selectedBy)}</code>`,
+    `Backtest config: <code>${escapeHtml(run.config)}</code>`,
+    `Window: <code>${run.days}d</code>, timeframe <code>${escapeHtml(run.timeframe)}</code>, connector <code>${escapeHtml(run.connector)}</code>`,
+    `Started: <code>${escapeHtml(formatMskDateTime(run.startedAt))} MSK</code>`,
+    `Finished: <code>${escapeHtml(formatMskDateTime(run.finishedAt))} MSK</code>`
+  ];
+  if (run.artifacts.backtestResultKey) {
+    lines.push(
+      `Backtest result key: <code>${escapeHtml(
+        run.artifacts.backtestResultKey
+      )}</code>`
+    );
+  }
+  if (run.artifacts.aiExportFile) {
+    lines.push(
+      `AI export: <code>${escapeHtml(run.artifacts.aiExportFile)}</code>`
+    );
+  }
+  if (aiTrainLocal?.run || aiTrainLocal?.outcome) {
+    lines.push("");
+    lines.push("<b>AI Train Local</b>");
+    if (typeof aiTrainLocal.run?.totalRows === "number") {
+      lines.push(
+        `Rows: <code>${aiTrainLocal.run.totalRows}</code>, approved: <code>${aiTrainLocal.run.approvedRows ?? 0}</code>, minQuality: <code>${aiTrainLocal.run.minQuality ?? run.minQuality}</code>`
+      );
+    }
+    if (typeof aiTrainLocal.outcome?.approvalRate === "number") {
+      lines.push(
+        `Approval rate: <code>${aiTrainLocal.outcome.approvalRate.toFixed(4)}</code>, precision: <code>${(aiTrainLocal.outcome.precisionApproved ?? 0).toFixed(4)}</code>, recall winners: <code>${(aiTrainLocal.outcome.recallWinners ?? 0).toFixed(4)}</code>`
+      );
+      lines.push(
+        `Avg approved PnL: <code>${(aiTrainLocal.outcome.avgProfitApproved ?? 0).toFixed(4)}</code>, monthly: <code>${(aiTrainLocal.outcome.avgProfitApprovedPerMonth ?? 0).toFixed(4)}</code>, expectancy delta: <code>${(aiTrainLocal.outcome.expectancyDelta ?? 0).toFixed(4)}</code>`
+      );
+    }
+  }
+  if (run.error) {
+    lines.push("");
+    lines.push("<b>Error</b>");
+    lines.push(`<code>${escapeHtml(run.error)}</code>`);
+  }
+  lines.push("");
+  if (agentRun) {
+    lines.push(`Agent layer: <code>${escapeHtml(agentRun.status)}</code>`);
+    if (agentRun.branchName) {
+      lines.push(
+        `Agent branch: <code>${escapeHtml(agentRun.branchName)}</code>`
+      );
+    }
+    if (agentRun.commitHash) {
+      lines.push(
+        `Agent commit: <code>${escapeHtml(agentRun.commitHash)}</code>`
+      );
+    }
+    if (typeof agentRun.pullRequestNumber === "number") {
+      lines.push(`Agent PR: <code>#${agentRun.pullRequestNumber}</code>`);
+    }
+    if (agentRun.pullRequestUrl) {
+      lines.push(
+        `Agent PR URL: <code>${escapeHtml(agentRun.pullRequestUrl)}</code>`
+      );
+    }
+    if (agentRun.summary) {
+      lines.push(`Agent summary: <code>${escapeHtml(agentRun.summary)}</code>`);
+    }
+  } else if (run.steps.agentRun?.status === "pending") {
+    lines.push("Agent layer: <code>pending</code>");
+  } else {
+    lines.push(
+      `Agent layer: <code>${escapeHtml(run.steps.agentRun?.status || "unknown")}</code>`
+    );
+  }
+  return lines.join("\n");
+};
+var runCliCommand = async (params) => {
+  const startedAt = Date.now();
+  const captureMode = params.captureMode || "tail";
+  const tailLimit = Math.max(512, params.tailLimit || 16384);
+  const env = {
+    ...process.env,
+    PROJECT_CWD: projectRoot,
+    DOTENV_CONFIG_PATH: dotenvPath,
+    ...params.node8g ? {
+      NODE_OPTIONS: [
+        "--max-old-space-size=8192",
+        String(process.env.NODE_OPTIONS || "").trim()
+      ].filter(Boolean).join(" ")
+    } : {}
+  };
+  return new Promise((resolve, reject) => {
+    const child = (0, import_node_child_process.spawn)(
+      "bash",
+      ["./bin/run-cli-dist.sh", params.command, ...params.args],
+      {
+        cwd: projectRoot,
+        env,
+        stdio: ["ignore", "pipe", "pipe"]
+      }
+    );
+    let stdout = "";
+    let stderr = "";
+    let heartbeatTimer = null;
+    const appendChunk = (current, incoming) => {
+      if (captureMode === "full") {
+        return current + incoming;
+      }
+      const next = current + incoming;
+      return next.length <= tailLimit ? next : next.slice(-tailLimit);
+    };
+    const emitLines = (source, text) => {
+      const prefix = params.liveLogPrefix ? `[research:auto:${params.liveLogPrefix}:${source}] ` : `[research:auto:${source}] `;
+      for (const line of text.split(/\r?\n/).map((value) => value.trimEnd()).filter(Boolean)) {
+        import_logger.logger.info(import_chalk.default.gray(`${prefix}${line}`));
+      }
+    };
+    if (params.heartbeatMs && params.heartbeatMs > 0) {
+      heartbeatTimer = setInterval(() => {
+        const elapsedMs = Date.now() - startedAt;
+        import_logger.logger.info(
+          import_chalk.default.gray(
+            `[research:auto:${params.liveLogPrefix || params.command}] still running after ${Math.round(elapsedMs / 1e3)}s`
+          )
+        );
+      }, params.heartbeatMs);
+    }
+    child.stdout.on("data", (chunk) => {
+      const text = chunk.toString();
+      stdout = appendChunk(stdout, text);
+      if (params.liveLogPrefix) {
+        emitLines("stdout", text);
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      const text = chunk.toString();
+      stderr = appendChunk(stderr, text);
+      if (params.liveLogPrefix) {
+        emitLines("stderr", text);
+      }
+    });
+    child.on("error", (error) => {
+      if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+      }
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (heartbeatTimer) {
+        clearInterval(heartbeatTimer);
+      }
+      resolve({
+        exitCode: code ?? 1,
+        stdout,
+        stderr,
+        durationMs: Date.now() - startedAt
+      });
+    });
+  });
+};
+var resolveTarget = async () => {
+  const userName = String(flags.user || "root").trim() || "root";
+  const explicitConfig = String(flags.config || "").trim();
+  if (explicitConfig) {
+    return {
+      strategy: explicitConfig.split(":")[0] || explicitConfig,
+      config: explicitConfig,
+      selectedBy: "config"
+    };
+  }
+  const explicitStrategy = String(flags.strategy || "").trim();
+  if (explicitStrategy) {
+    return {
+      strategy: explicitStrategy,
+      config: `${explicitStrategy}:research`,
+      selectedBy: "strategy"
+    };
+  }
+  const availableStrategies = await listRuntimeStrategyNames(userName);
+  const candidates = [];
+  for (const strategy of availableStrategies) {
+    const config = `${strategy}:research`;
+    const latestRun = await (0, import_redis.getData)(
+      import_redis.redisKeys.researchLatestRun(userName, strategy),
+      null
+    );
+    const lastFinishedAt = latestRun?.finishedAt ? Date.parse(latestRun.finishedAt) : 0;
+    candidates.push({
+      strategy,
+      config,
+      lastFinishedAt: Number.isFinite(lastFinishedAt) ? lastFinishedAt : 0
+    });
+  }
+  if (!candidates.length) {
+    throw new Error(
+      `No research candidates found from runtime strategy configs for user ${userName}.`
+    );
+  }
+  candidates.sort(
+    (left, right) => left.lastFinishedAt - right.lastFinishedAt || left.strategy.localeCompare(right.strategy)
+  );
+  logResearch(
+    `auto candidates from runtime configs: ${candidates.map(
+      ({ strategy, lastFinishedAt }) => `${strategy}=${lastFinishedAt ? new Date(lastFinishedAt).toISOString() : "never"}`
+    ).join(", ")}`
+  );
+  return {
+    strategy: candidates[0].strategy,
+    config: candidates[0].config,
+    selectedBy: "auto"
+  };
+};
+var parseJsonOutput = (stdout, label) => {
+  const trimmed = stdout.trim();
+  if (!trimmed) {
+    throw new Error(`${label} returned empty stdout`);
+  }
+  return JSON.parse(trimmed);
+};
+var logResearch = (message) => {
+  import_logger.logger.info(import_chalk.default.cyan(`[research:auto] ${message}`));
+};
+var executeNonBlockingStep = async (run, stepName, command, commandArgs, options = {}) => {
+  logResearch(
+    `starting optional step ${stepName}: ${command} ${commandArgs.join(" ")}`.trim()
+  );
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  run.steps[stepName] = {
+    status: "running",
+    command,
+    args: commandArgs,
+    startedAt
+  };
+  await saveRun(run);
+  const result = await runCliCommand({
+    command,
+    args: commandArgs,
+    node8g: options.node8g,
+    liveLogPrefix: options.liveLog ? stepName : void 0,
+    heartbeatMs: options.liveLog ? options.heartbeatMs || 6e4 : void 0,
+    captureMode: options.captureMode
+  });
+  run.steps[stepName] = {
+    status: result.exitCode === 0 ? "completed" : "failed",
+    command,
+    args: commandArgs,
+    startedAt,
+    finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    durationMs: result.durationMs,
+    exitCode: result.exitCode,
+    stdoutTail: trimTextTail(result.stdout),
+    stderrTail: trimTextTail(result.stderr)
+  };
+  await saveRun(run);
+  logResearch(
+    `finished optional step ${stepName}: exit=${result.exitCode}, duration=${result.durationMs}ms`
+  );
+  return result;
+};
+var main = async () => {
+  const userName = String(flags.user || "root").trim() || "root";
+  const connector = String(flags.connector || "bybit").trim() || "bybit";
+  const timeframe = String(flags.timeframe || "15").trim() || "15";
+  const days = Math.max(1, Number.parseInt(String(flags.days ?? 45), 10) || 45);
+  const recent = Math.max(
+    0,
+    Number.parseInt(String(flags.recent ?? 1e3), 10) || 1e3
+  );
+  const skip = Math.max(0, Number.parseInt(String(flags.skip ?? 0), 10) || 0);
+  const minQuality = Math.max(
+    0,
+    Number.parseInt(String(flags.minQuality ?? 4), 10) || 4
+  );
+  const jsonOutput = Boolean(flags.json);
+  const skipAgent = Boolean(flags.skipAgent);
+  const outDirArg = String(flags.outDir || "data/ai/export").trim() || "data/ai/export";
+  const outDir = import_node_path.default.resolve(projectRoot, outDirArg);
+  const cleanDirArg = import_node_path.default.relative(import_node_path.default.join(projectRoot, "data"), outDir).replace(/\\/g, "/");
+  const target = await resolveTarget();
+  const runId = `${Date.now()}-${(0, import_ai.toFileToken)(target.strategy)}`;
+  const run = {
+    runId,
+    userName,
+    strategy: target.strategy,
+    config: target.config,
+    connector,
+    timeframe,
+    days,
+    recent,
+    skip,
+    minQuality,
+    selectedBy: target.selectedBy,
+    status: "running",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    steps: createEmptySteps(),
+    artifacts: {}
+  };
+  const executeStep = async (stepName, command, commandArgs, options = {}) => {
+    logResearch(
+      `starting step ${stepName}: ${command} ${commandArgs.join(" ")}`.trim()
+    );
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    run.steps[stepName] = {
+      status: "running",
+      command,
+      args: commandArgs,
+      startedAt
+    };
+    await saveRun(run);
+    const result = await runCliCommand({
+      command,
+      args: commandArgs,
+      node8g: options.node8g,
+      liveLogPrefix: options.liveLog ? stepName : void 0,
+      heartbeatMs: options.liveLog ? options.heartbeatMs || 6e4 : void 0,
+      captureMode: options.captureMode
+    });
+    run.steps[stepName] = {
+      status: result.exitCode === 0 ? "completed" : "failed",
+      command,
+      args: commandArgs,
+      startedAt,
+      finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      durationMs: result.durationMs,
+      exitCode: result.exitCode,
+      stdoutTail: trimTextTail(result.stdout),
+      stderrTail: trimTextTail(result.stderr)
+    };
+    await saveRun(run);
+    if (result.exitCode !== 0) {
+      logResearch(
+        `step ${stepName} failed: exit=${result.exitCode}, output=${trimTextTail(
+          result.stderr || result.stdout,
+          400
+        )}`
+      );
+      throw new Error(
+        `${stepName} failed (exitCode=${result.exitCode}): ${trimTextTail(
+          result.stderr || result.stdout,
+          1200
+        )}`
+      );
+    }
+    logResearch(
+      `finished step ${stepName}: exit=${result.exitCode}, duration=${result.durationMs}ms`
+    );
+    return result;
+  };
+  const prepareBacktestConfig = async () => {
+    logResearch(
+      `preparing research backtest config ${target.config} from runtime strategy ${target.strategy}`
+    );
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    run.steps.prepareBacktestConfig = {
+      status: "running",
+      command: "prepare-backtest-config",
+      args: ["--strategy", target.strategy, "--config", target.config],
+      startedAt
+    };
+    await saveRun(run);
+    const strategyConfigKey = import_redis.redisKeys.strategyConfig(
+      userName,
+      target.strategy
+    );
+    const backtestConfigKey = import_redis.redisKeys.backtestConfig(userName, target.config);
+    const defaults = (0, import_strategies.getBuiltInStrategyDefaultConfig)(target.strategy) || {};
+    const userStrategyConfig = await (0, import_redis.getData)(
+      strategyConfigKey,
+      {}
+    );
+    const strategyConfig = {
+      ...defaults,
+      ...userStrategyConfig
+    };
+    if (!Object.keys(strategyConfig).length) {
+      throw new Error(
+        `Strategy config "${target.strategy}" not found in Redis and no built-in defaults available`
+      );
+    }
+    const backtestConfig = toStrategyConfigGrid(strategyConfig);
+    await (0, import_redis.setData)(backtestConfigKey, backtestConfig, { expire: 0 });
+    logResearch(
+      `stored backtest config at ${backtestConfigKey} with ${Object.keys(strategyConfig).length} top-level fields`
+    );
+    run.artifacts.strategyConfigKey = strategyConfigKey;
+    run.artifacts.backtestConfigKey = backtestConfigKey;
+    run.artifacts.strategyConfig = strategyConfig;
+    run.artifacts.backtestConfig = backtestConfig;
+    run.steps.prepareBacktestConfig = {
+      status: "completed",
+      command: "prepare-backtest-config",
+      args: ["--strategy", target.strategy, "--config", target.config],
+      startedAt,
+      finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      durationMs: Date.now() - Date.parse(startedAt)
+    };
+    await saveRun(run);
+  };
+  const sendRunReport = async () => {
+    const message = buildTelegramReport(run);
+    await sendTelegramReport(message, { userName });
+  };
+  await saveRun(run);
+  try {
+    logResearch(
+      `run ${runId} selected target strategy=${target.strategy}, config=${target.config}, selectedBy=${target.selectedBy}`
+    );
+    const backtestKeysBefore = new Set(
+      await (0, import_redis.getKeys)(getBacktestResultsPrefix(userName, target.config))
+    );
+    const aiFilesBefore = new Set(
+      await listMergedFiles(outDir, target.strategy)
+    );
+    logResearch(
+      `baseline artifacts before run: backtests=${backtestKeysBefore.size}, aiMergedFiles=${aiFilesBefore.size}`
+    );
+    await prepareBacktestConfig();
+    await executeStep("cleanTests", "clean-tests", ["--user", userName]);
+    await executeStep("cleanAiExport", "clean-dir", [
+      "--dir",
+      cleanDirArg.startsWith("..") ? "ai/export" : cleanDirArg
+    ]);
+    await executeStep(
+      "backtest",
+      "backtest",
+      [
+        "--user",
+        userName,
+        "--config",
+        target.config,
+        "--connector",
+        connector,
+        "--timeframe",
+        timeframe,
+        "--days",
+        String(days),
+        "--ai"
+      ],
+      { node8g: true, liveLog: true, heartbeatMs: 3e4 }
+    );
+    await executeStep("aiExport", "ai-export", [
+      "--strategy",
+      target.strategy,
+      "--outDir",
+      outDirArg
+    ]);
+    const aiTrainResult = await executeStep(
+      "aiTrainLocal",
+      "ai-train",
+      [
+        "--strategy",
+        target.strategy,
+        "--recent",
+        String(recent),
+        "--skip",
+        String(skip),
+        "--minQuality",
+        String(minQuality),
+        "--localOnly",
+        "--json"
+      ],
+      { node8g: true, captureMode: "full" }
+    );
+    const backtestKeysAfter = await (0, import_redis.getKeys)(
+      getBacktestResultsPrefix(userName, target.config)
+    );
+    const newBacktestKeys = backtestKeysAfter.filter((key) => !backtestKeysBefore.has(key)).sort();
+    const backtestResultKey = newBacktestKeys[newBacktestKeys.length - 1] || backtestKeysAfter.sort().at(-1);
+    if (backtestResultKey) {
+      logResearch(`detected backtest result key ${backtestResultKey}`);
+      const backtestResult = await (0, import_redis.getData)(backtestResultKey, null);
+      run.artifacts.backtestResultKey = backtestResultKey;
+      run.artifacts.backtestResult = backtestResult ? {
+        finishedAt: backtestResult.finishedAt,
+        durationSeconds: backtestResult.durationSeconds,
+        successTests: backtestResult.successTests,
+        errorTests: backtestResult.errorTests,
+        bestConfig: backtestResult.bestConfig,
+        mergedConfig: backtestResult.mergedConfig
+      } : void 0;
+    } else {
+      logResearch("no backtest result key detected after backtest step");
+    }
+    const aiFilesAfter = await listMergedFiles(outDir, target.strategy);
+    const newAiFiles = aiFilesAfter.filter((filePath) => !aiFilesBefore.has(filePath)).sort();
+    run.artifacts.aiExportFile = newAiFiles[newAiFiles.length - 1] || aiFilesAfter.at(-1);
+    if (run.artifacts.aiExportFile) {
+      logResearch(`detected AI export file ${run.artifacts.aiExportFile}`);
+    } else {
+      logResearch("no AI export file detected after ai-export step");
+    }
+    run.artifacts.aiTrainLocal = parseJsonOutput(
+      aiTrainResult.stdout,
+      "ai-train --json"
+    );
+    logResearch("parsed ai-train --json output successfully");
+    run.status = "completed";
+    run.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await saveRun(run);
+    logResearch(`run ${runId} completed successfully`);
+    await sendRunReport();
+    logResearch(`TG report sent for run ${runId}`);
+    if (!skipAgent) {
+      logResearch(`starting direct agent invocation for run ${runId}`);
+      const agentResult = await executeNonBlockingStep(
+        run,
+        "agentRun",
+        "agent-run",
+        [
+          "--user",
+          userName,
+          "--runId",
+          run.runId,
+          "--strategy",
+          run.strategy,
+          "--json"
+        ],
+        {
+          node8g: true,
+          liveLog: true,
+          heartbeatMs: 3e4,
+          captureMode: "full"
+        }
+      );
+      try {
+        run.artifacts.agentRun = parseJsonOutput(
+          agentResult.stdout,
+          "agent-run --json"
+        );
+      } catch (error) {
+        run.artifacts.agentRun = {
+          status: "failed",
+          error: error?.message || String(error),
+          stdout: trimTextTail(agentResult.stdout),
+          stderr: trimTextTail(agentResult.stderr)
+        };
+      }
+      await saveRun(run);
+      logResearch(`agent invocation finished for run ${runId}`);
+      await sendRunReport();
+      logResearch(`updated TG report sent after agent for run ${runId}`);
+    }
+    if (jsonOutput) {
+      console.log(JSON.stringify(run));
+      process.exit(0);
+    }
+    console.log(import_chalk.default.green("Research auto finished"));
+    console.log(
+      import_chalk.default.gray(
+        `strategy=${run.strategy}, config=${run.config}, runId=${run.runId}`
+      )
+    );
+    if (run.artifacts.backtestResultKey) {
+      console.log(
+        import_chalk.default.gray(`backtestResultKey=${run.artifacts.backtestResultKey}`)
+      );
+    }
+    if (run.artifacts.aiExportFile) {
+      console.log(import_chalk.default.gray(`aiExportFile=${run.artifacts.aiExportFile}`));
+    }
+    process.exit(0);
+  } catch (error) {
+    run.status = "failed";
+    run.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    run.error = error?.message || String(error);
+    await saveRun(run);
+    logResearch(`run ${runId} failed: ${run.error}`);
+    try {
+      await sendRunReport();
+      logResearch(`TG report sent for failed run ${runId}`);
+    } catch (reportError) {
+      const suffix = reportError?.message || String(reportError);
+      run.error = `${run.error}
+Telegram report failed: ${suffix}`;
+      await saveRun(run);
+      logResearch(`TG report failed for run ${runId}: ${suffix}`);
+    }
+    if (jsonOutput) {
+      console.log(JSON.stringify(run));
+    } else {
+      console.error(import_chalk.default.red(run.error));
+    }
+    process.exit(1);
+  }
+};
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(import_chalk.default.red(error?.message || String(error)));
+    process.exit(1);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildTelegramReport,
+  createEmptySteps,
+  escapeHtml,
+  formatMskDateTime,
+  getBacktestResultsPrefix,
+  listMergedFiles,
+  listRuntimeStrategyNames,
+  parseJsonOutput,
+  resolveStrategyNameByConfigKey,
+  resolveTarget,
+  runCliCommand,
+  toStrategyConfigGrid,
+  trimTextTail
+});