@tradejs/cli 1.0.0

package/dist/scripts/mlTrainLatestSelect.js

@@ -0,0 +1,1056 @@
+"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 __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
+));
+
+// src/scripts/mlTrainLatestSelect.ts
+var import_path = __toESM(require("path"));
+var import_promises = __toESM(require("fs/promises"));
+var import_fs = require("fs");
+var import_crypto = require("crypto");
+var import_child_process = require("child_process");
+var import_events = require("events");
+var import_readline2 = __toESM(require("readline"));
+var import_args = __toESM(require("args"));
+var import_chalk2 = __toESM(require("chalk"));
+
+// src/scripts/selectStrategy.ts
+var import_readline = __toESM(require("readline"));
+var import_chalk = __toESM(require("chalk"));
+var import_strategies = require("@tradejs/node/strategies");
+var defaultStrategy = "TrendLine";
+var getStrategyChoices = async () => {
+  try {
+    const loaded = await (0, import_strategies.getAvailableStrategyNames)();
+    if (loaded.length) {
+      return loaded;
+    }
+  } catch (error) {
+    console.warn(`Failed to load strategy list: ${String(error)}`);
+  }
+  return [
+    "Breakout",
+    "MaStrategy",
+    "AdaptiveMomentumRibbon",
+    "TrendLine",
+    "VolumeDivergence"
+  ];
+};
+var 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_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/mlTrainLatestSelect.ts
+var import_ml = require("@tradejs/infra/ml");
+var toFileToken = (value) => value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "_").replace(/^_+|_+$/g, "") || "any";
+var asBool = (value) => ["1", "true", "yes", "on"].includes((value ?? "").trim().toLowerCase());
+var asInt = (value, fallback) => {
+  const parsed = Number.parseInt((value ?? "").trim(), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
+var asNonNegativeInt = (value, fallback) => {
+  const parsed = Number.parseInt((value ?? "").trim(), 10);
+  return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+};
+var formatBytes = (bytes) => {
+  if (!Number.isFinite(bytes) || bytes <= 0) return "0 B";
+  const units = ["B", "KiB", "MiB", "GiB", "TiB"];
+  let value = bytes;
+  let idx = 0;
+  while (value >= 1024 && idx < units.length - 1) {
+    value /= 1024;
+    idx++;
+  }
+  return `${value.toFixed(idx === 0 ? 0 : 2)} ${units[idx]}`;
+};
+var getMlContainerMemUsage = () => {
+  try {
+    const psRaw = (0, import_child_process.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();
+    if (!psRaw) return "n/a";
+    const rows = psRaw.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => {
+      const [id = "", name = "", oneoff = ""] = line.split("	");
+      return { id, name, oneoff };
+    });
+    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_process.execSync)(
+      `docker stats --no-stream --format "{{.MemUsage}}" ${chosen.id}`,
+      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
+    ).trim();
+    if (!memUsage) return "n/a";
+    return `${chosen.name}: ${memUsage}`;
+  } catch {
+    return "n/a";
+  }
+};
+var MODEL_TYPES = [
+  "catboost",
+  "random_forest",
+  "extra_trees",
+  "xgboost",
+  "lightgbm"
+];
+var STRATEGIES = [
+  "Breakout",
+  "MaStrategy",
+  "AdaptiveMomentumRibbon",
+  "TrendLine",
+  "VolumeDivergence",
+  "any"
+];
+import_args.default.option(["s", "strategy"], "Strategy name (e.g. TrendLine)");
+import_args.default.option(
+  ["m", "model"],
+  "Model type: catboost | random_forest | extra_trees | xgboost | lightgbm"
+);
+import_args.default.option(
+  ["L", "latestOnly"],
+  "Use only latest dataset file (overrides ML_TRAIN_USE_LATEST_ONLY)",
+  false
+);
+var flags = import_args.default.parse(process.argv);
+var parseStrategy = (value) => {
+  const raw = String(value ?? "").trim();
+  if (!raw) return null;
+  const byName = STRATEGIES.find(
+    (name) => name.toLowerCase() === raw.toLowerCase()
+  );
+  return byName ?? null;
+};
+var parseModelType = (value) => {
+  const raw = String(value ?? "").trim().toLowerCase();
+  if (!raw) return null;
+  return MODEL_TYPES.includes(raw) ? raw : null;
+};
+var selectModelType = async (defaultModel) => {
+  if (!process.stdin.isTTY) {
+    return defaultModel;
+  }
+  console.log(import_chalk2.default.cyan("Available models:"));
+  MODEL_TYPES.forEach((name, index) => {
+    const isDefault = name === defaultModel;
+    const label = isDefault ? import_chalk2.default.green(name) : name;
+    const suffix = isDefault ? import_chalk2.default.gray(" (default)") : "";
+    console.log(`  ${import_chalk2.default.yellow(String(index + 1))}) ${label}${suffix}`);
+  });
+  const rl = import_readline2.default.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const question = (text) => new Promise((resolve) => rl.question(text, resolve));
+  const answer = await question(
+    `Select model [${import_chalk2.default.green(defaultModel)}]: `
+  );
+  rl.close();
+  const trimmed = answer.trim().toLowerCase();
+  if (!trimmed) {
+    return defaultModel;
+  }
+  const asNumber = Number(trimmed);
+  if (Number.isFinite(asNumber) && asNumber >= 1 && asNumber <= MODEL_TYPES.length) {
+    return MODEL_TYPES[asNumber - 1];
+  }
+  if (MODEL_TYPES.includes(trimmed)) {
+    return trimmed;
+  }
+  console.warn(`Unknown model "${answer.trim()}", using ${defaultModel}.`);
+  return defaultModel;
+};
+var listDatasetFiles = async (dir, strategyName) => {
+  const entries = await import_promises.default.readdir(dir, { withFileTypes: true });
+  const prefix = `ml-dataset-${toFileToken(strategyName)}-`;
+  const legacyPrefix = "ml-dataset-";
+  const fileNames = entries.filter((entry) => entry.isFile()).map((entry) => entry.name);
+  const hasScopedFiles = fileNames.some((name) => name.startsWith(prefix));
+  const acceptedPrefix = hasScopedFiles ? prefix : legacyPrefix;
+  const jsonlFiles = fileNames.filter(
+    (name) => name.startsWith(acceptedPrefix) && name.endsWith(".jsonl")
+  ).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_promises.default.stat(import_path.default.join(dir, name));
+      return { name, mtime: stat.mtimeMs };
+    })
+  );
+  withMtime.sort((a, b) => a.mtime - b.mtime);
+  return withMtime.map(({ name }) => name);
+};
+var concatFiles = async (files, outPath) => {
+  const out = (0, import_fs.createWriteStream)(outPath, { encoding: "utf8" });
+  const done = (0, import_events.once)(out, "finish");
+  try {
+    for (const file of files) {
+      const reader = (0, import_fs.createReadStream)(file, { encoding: "utf8" });
+      for await (const chunk of reader) {
+        if (!out.write(chunk)) {
+          await (0, import_events.once)(out, "drain");
+        }
+      }
+    }
+  } finally {
+    out.end();
+    await done;
+  }
+};
+var pipeNormalized = (stream, write) => {
+  if (!stream) return () => {
+  };
+  let buffer = "";
+  const onData = (chunk) => {
+    const text = String(chunk).replace(/\r/g, "\n");
+    buffer += text;
+    const parts = buffer.split("\n");
+    buffer = parts.pop() ?? "";
+    for (const part of parts) {
+      write(part);
+    }
+  };
+  stream.on("data", onData);
+  return () => {
+    stream.off("data", onData);
+    if (buffer.length) {
+      write(buffer);
+      buffer = "";
+    }
+  };
+};
+var DAY_MS = 24 * 60 * 60 * 1e3;
+var SPLIT_PROGRESS_EVERY = 2e5;
+var parseTimestampMs = (value) => {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric) || numeric <= 0) return null;
+  return numeric < 1e12 ? Math.trunc(numeric * 1e3) : Math.trunc(numeric);
+};
+var scanMaxLabeledTimestampMs = async (inputPath) => {
+  const rl = import_readline2.default.createInterface({
+    input: (0, import_fs.createReadStream)(inputPath, { encoding: "utf8" }),
+    crlfDelay: Infinity
+  });
+  let maxTs = 0;
+  let scanned = 0;
+  const startedAt = Date.now();
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    scanned++;
+    if (scanned % SPLIT_PROGRESS_EVERY === 0) {
+      const elapsed = Math.floor((Date.now() - startedAt) / 1e3);
+      console.log(
+        `[split] scan max labeled ts: lines=${scanned} elapsed=${elapsed}s`
+      );
+    }
+    try {
+      const row = JSON.parse(trimmed);
+      if (row.label === null || row.label === void 0) continue;
+      const ts = parseTimestampMs(row.entryTimestamp);
+      if (ts && ts > maxTs) maxTs = ts;
+    } catch {
+    }
+  }
+  rl.close();
+  if (!maxTs) {
+    throw new Error("No labeled rows with entryTimestamp found in dataset.");
+  }
+  return maxTs;
+};
+var scanMaxTrainTimestampMs = async (inputPath, holdoutCutoffMs) => {
+  const rl = import_readline2.default.createInterface({
+    input: (0, import_fs.createReadStream)(inputPath, { encoding: "utf8" }),
+    crlfDelay: Infinity
+  });
+  let maxTrainTs = 0;
+  let scanned = 0;
+  const startedAt = Date.now();
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    scanned++;
+    if (scanned % SPLIT_PROGRESS_EVERY === 0) {
+      const elapsed = Math.floor((Date.now() - startedAt) / 1e3);
+      console.log(
+        `[split] scan max train ts: lines=${scanned} elapsed=${elapsed}s`
+      );
+    }
+    try {
+      const row = JSON.parse(trimmed);
+      if (row.label === null || row.label === void 0) continue;
+      const ts = parseTimestampMs(row.entryTimestamp);
+      if (ts && ts <= holdoutCutoffMs && ts > maxTrainTs) {
+        maxTrainTs = ts;
+      }
+    } catch {
+    }
+  }
+  rl.close();
+  if (!maxTrainTs) {
+    throw new Error(
+      "No train rows found after holdout cutoff. Adjust test window."
+    );
+  }
+  return maxTrainTs;
+};
+var hashFileNameSha1 = (filePath) => (0, import_crypto.createHash)("sha1").update(import_path.default.basename(filePath)).digest("hex");
+var prepareTrainWindowFiles = async ({
+  inputPath,
+  testDays,
+  trainRecentDays,
+  walkForwardFolds,
+  enforceCausalityGuard
+}) => {
+  const inputBaseName = import_path.default.basename(inputPath);
+  if ((0, import_ml.isDerivedDatasetFileName)(inputBaseName)) {
+    throw new Error(
+      `Refusing to split derived dataset file: ${inputBaseName}. Expected base export file.`
+    );
+  }
+  const exportHash = hashFileNameSha1(inputPath);
+  const keyPayload = JSON.stringify({
+    exportHash,
+    testDays,
+    trainRecentDays,
+    walkForwardFolds,
+    causalityGuardVersion: enforceCausalityGuard ? 1 : 0
+  });
+  const key = (0, import_crypto.createHash)("sha1").update(keyPayload).digest("hex").slice(0, 12);
+  const dir = import_path.default.dirname(inputPath);
+  const parsed = import_path.default.parse(inputPath);
+  const holdoutTrainPath = import_path.default.join(
+    dir,
+    `${parsed.name}.holdout-train.${key}.jsonl`
+  );
+  const holdoutTestPath = import_path.default.join(
+    dir,
+    `${parsed.name}.holdout-test.${key}.jsonl`
+  );
+  const prodPath = import_path.default.join(dir, `${parsed.name}.prod.${key}.jsonl`);
+  const walkForwardFoldDefs = Array.from(
+    { length: Math.max(walkForwardFolds, 0) },
+    (_, idx) => {
+      const fold = idx + 1;
+      const foldToken = `fold-${fold}`;
+      return {
+        fold,
+        trainPath: import_path.default.join(
+          dir,
+          `${parsed.name}.walk-forward-${foldToken}.train.${key}.jsonl`
+        ),
+        testPath: import_path.default.join(
+          dir,
+          `${parsed.name}.walk-forward-${foldToken}.test.${key}.jsonl`
+        )
+      };
+    }
+  );
+  const metaPath = import_path.default.join(dir, `${parsed.name}.windows.${key}.meta.json`);
+  try {
+    const [metaRaw] = await Promise.all([
+      import_promises.default.readFile(metaPath, "utf8"),
+      import_promises.default.access(holdoutTrainPath),
+      import_promises.default.access(holdoutTestPath),
+      import_promises.default.access(prodPath),
+      ...walkForwardFoldDefs.flatMap((entry) => [
+        import_promises.default.access(entry.trainPath),
+        import_promises.default.access(entry.testPath)
+      ])
+    ]);
+    const meta2 = JSON.parse(metaRaw);
+    if (meta2.exportHash === exportHash) {
+      const foldMetaByFold = /* @__PURE__ */ new Map();
+      const fileFolds = Array.isArray(meta2.files?.walkForwardFolds) ? meta2.files?.walkForwardFolds ?? [] : [];
+      const hasExtendedFoldTiming = fileFolds.length === 0 || "trainMinTs" in fileFolds[0];
+      if (!hasExtendedFoldTiming) {
+        throw new Error("Legacy meta format cache miss");
+      }
+      if (!meta2.files?.prod?.prod) {
+        throw new Error("Legacy meta format cache miss (prod block missing)");
+      }
+      for (const foldFile of fileFolds) {
+        const fold = Number(foldFile.fold);
+        if (!Number.isFinite(fold) || fold <= 0) continue;
+        foldMetaByFold.set(fold, {
+          startTs: Number(foldFile.startTs ?? 0),
+          endTs: Number(foldFile.endTs ?? 0),
+          trainRows: Number(foldFile.trainRows ?? 0),
+          testRows: Number(foldFile.testRows ?? 0)
+        });
+      }
+      if (Array.isArray(meta2.foldCounts)) {
+        for (const row of meta2.foldCounts) {
+          const fold = Number(row.fold);
+          if (!Number.isFinite(fold) || fold <= 0) continue;
+          const prev = foldMetaByFold.get(fold) ?? {
+            startTs: 0,
+            endTs: 0,
+            trainRows: 0,
+            testRows: 0
+          };
+          foldMetaByFold.set(fold, {
+            ...prev,
+            trainRows: Number(row.trainRows ?? 0),
+            testRows: Number(row.testRows ?? 0)
+          });
+        }
+      }
+      return {
+        holdoutTrainPath,
+        holdoutTestPath,
+        prodPath,
+        walkForwardFolds: walkForwardFoldDefs.map((entry) => {
+          const metaRow = foldMetaByFold.get(entry.fold);
+          return {
+            fold: entry.fold,
+            startTs: Number(metaRow?.startTs ?? 0),
+            endTs: Number(metaRow?.endTs ?? 0),
+            trainPath: entry.trainPath,
+            testPath: entry.testPath,
+            trainRows: Number(metaRow?.trainRows ?? 0),
+            testRows: Number(metaRow?.testRows ?? 0)
+          };
+        }),
+        cleanup: [],
+        reused: true,
+        key,
+        exportHash,
+        counts: {
+          holdoutTrainRows: Number(
+            meta2.files?.holdout?.holdoutTrainRows ?? meta2.counts?.holdoutTrainRows ?? 0
+          ),
+          holdoutTestRows: Number(
+            meta2.files?.holdout?.holdoutTestRows ?? meta2.counts?.holdoutTestRows ?? 0
+          ),
+          walkForwardSourceRows: Number(
+            meta2.files?.walkForwardFolds?.[0]?.walkForwardSourceRows ?? meta2.counts?.walkForwardSourceRows ?? 0
+          ),
+          prodRows: Number(
+            meta2.files?.prod?.prodRows ?? meta2.counts?.prodRows ?? 0
+          )
+        }
+      };
+    }
+  } catch {
+  }
+  console.log("[split] phase 1/3: scanning max labeled timestamp...");
+  const maxLabeledTs = await scanMaxLabeledTimestampMs(inputPath);
+  const holdoutCutoffMs = maxLabeledTs - testDays * DAY_MS;
+  console.log("[split] phase 2/3: scanning max train timestamp...");
+  const maxTrainTs = await scanMaxTrainTimestampMs(inputPath, holdoutCutoffMs);
+  const {
+    holdoutCutoffMs: derivedHoldoutCutoffMs,
+    holdoutTrainStartMs,
+    wfStartMs,
+    prodStartMs,
+    folds
+  } = (0, import_ml.computeWindowBoundaries)({
+    maxLabeledTs,
+    maxTrainTs,
+    testDays,
+    trainRecentDays,
+    walkForwardFolds
+  });
+  if (derivedHoldoutCutoffMs !== holdoutCutoffMs) {
+    throw new Error("Internal split boundary mismatch for holdout cutoff.");
+  }
+  const walkForwardFoldsWithWindows = walkForwardFoldDefs.map((entry) => {
+    const foldWindow = folds.find((row) => row.fold === entry.fold);
+    return {
+      ...entry,
+      startTs: Number(foldWindow?.startTs ?? 0),
+      endTs: Number(foldWindow?.endTs ?? 0),
+      trainRows: 0,
+      testRows: 0
+    };
+  });
+  console.log("[split] phase 3/3: writing holdout/walk-forward files...");
+  const holdoutTrainWriter = (0, import_fs.createWriteStream)(holdoutTrainPath, {
+    encoding: "utf8"
+  });
+  const holdoutTestWriter = (0, import_fs.createWriteStream)(holdoutTestPath, {
+    encoding: "utf8"
+  });
+  const prodWriter = (0, import_fs.createWriteStream)(prodPath, {
+    encoding: "utf8"
+  });
+  const walkForwardWriters = walkForwardFoldsWithWindows.map((entry) => ({
+    ...entry,
+    trainWriter: (0, import_fs.createWriteStream)(entry.trainPath, {
+      encoding: "utf8"
+    }),
+    testWriter: (0, import_fs.createWriteStream)(entry.testPath, {
+      encoding: "utf8"
+    }),
+    trainMinTs: Number.POSITIVE_INFINITY,
+    trainMaxTs: 0,
+    testMinTs: Number.POSITIVE_INFINITY,
+    testMaxTs: 0
+  }));
+  let holdoutTrainRows = 0;
+  let holdoutTestRows = 0;
+  let walkForwardSourceRows = 0;
+  let holdoutTrainMinTs = Number.POSITIVE_INFINITY;
+  let holdoutTrainMaxTs = 0;
+  let holdoutTestMinTs = Number.POSITIVE_INFINITY;
+  let holdoutTestMaxTs = 0;
+  let holdoutTrainOutOfRangeRows = 0;
+  let prodRows = 0;
+  let prodMinTs = Number.POSITIVE_INFINITY;
+  let prodMaxTs = 0;
+  let scanned = 0;
+  const writeStartedAt = Date.now();
+  const rl = import_readline2.default.createInterface({
+    input: (0, import_fs.createReadStream)(inputPath, { encoding: "utf8" }),
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    scanned++;
+    if (scanned % SPLIT_PROGRESS_EVERY === 0) {
+      const elapsed = Math.floor((Date.now() - writeStartedAt) / 1e3);
+      console.log(
+        `[split] writing: lines=${scanned} train=${holdoutTrainRows} test=${holdoutTestRows} wf_source=${walkForwardSourceRows} elapsed=${elapsed}s`
+      );
+    }
+    let parsedRow = null;
+    try {
+      parsedRow = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (!parsedRow || parsedRow.label === null || parsedRow.label === void 0)
+      continue;
+    const ts = parseTimestampMs(parsedRow.entryTimestamp);
+    if (!ts) continue;
+    if (enforceCausalityGuard) {
+      const violations = (0, import_ml.findLookaheadViolations)(
+        parsedRow
+      );
+      if (violations.length) {
+        const sample = violations.slice(0, 3).map(
+          (row) => `${row.key}: ${row.featureTimestampMs} > ${row.entryTimestampMs}`
+        ).join(", ");
+        throw new Error(
+          `Lookahead validation failed: feature timestamp is newer than entryTimestamp. ${sample}`
+        );
+      }
+    }
+    if (ts > holdoutCutoffMs) {
+      if (!holdoutTestWriter.write(`${trimmed}
+`)) {
+        await (0, import_events.once)(holdoutTestWriter, "drain");
+      }
+      holdoutTestRows++;
+      if (ts < holdoutTestMinTs) holdoutTestMinTs = ts;
+      if (ts > holdoutTestMaxTs) holdoutTestMaxTs = ts;
+    } else {
+      if (ts >= holdoutTrainStartMs) {
+        if (!holdoutTrainWriter.write(`${trimmed}
+`)) {
+          await (0, import_events.once)(holdoutTrainWriter, "drain");
+        }
+        holdoutTrainRows++;
+        if (ts < holdoutTrainStartMs || ts > holdoutCutoffMs) {
+          holdoutTrainOutOfRangeRows++;
+        }
+        if (ts < holdoutTrainMinTs) holdoutTrainMinTs = ts;
+        if (ts > holdoutTrainMaxTs) holdoutTrainMaxTs = ts;
+      }
+      if (ts >= wfStartMs && ts <= maxTrainTs) {
+        walkForwardSourceRows++;
+        for (const foldWriter of walkForwardWriters) {
+          if (ts > foldWriter.startTs && ts <= foldWriter.endTs) {
+            if (!foldWriter.testWriter.write(`${trimmed}
+`)) {
+              await (0, import_events.once)(foldWriter.testWriter, "drain");
+            }
+            foldWriter.testRows++;
+            if (ts < foldWriter.testMinTs) foldWriter.testMinTs = ts;
+            if (ts > foldWriter.testMaxTs) foldWriter.testMaxTs = ts;
+          } else if (ts <= foldWriter.startTs) {
+            if (!foldWriter.trainWriter.write(`${trimmed}
+`)) {
+              await (0, import_events.once)(foldWriter.trainWriter, "drain");
+            }
+            foldWriter.trainRows++;
+            if (ts < foldWriter.trainMinTs) foldWriter.trainMinTs = ts;
+            if (ts > foldWriter.trainMaxTs) foldWriter.trainMaxTs = ts;
+          }
+        }
+      }
+    }
+    if (ts >= prodStartMs) {
+      if (!prodWriter.write(`${trimmed}
+`)) {
+        await (0, import_events.once)(prodWriter, "drain");
+      }
+      prodRows++;
+      if (ts < prodMinTs) prodMinTs = ts;
+      if (ts > prodMaxTs) prodMaxTs = ts;
+    }
+  }
+  rl.close();
+  holdoutTrainWriter.end();
+  holdoutTestWriter.end();
+  prodWriter.end();
+  for (const foldWriter of walkForwardWriters) {
+    foldWriter.trainWriter.end();
+    foldWriter.testWriter.end();
+  }
+  const finishPromises = [
+    (0, import_events.once)(holdoutTrainWriter, "finish"),
+    (0, import_events.once)(holdoutTestWriter, "finish"),
+    (0, import_events.once)(prodWriter, "finish"),
+    ...walkForwardWriters.flatMap((foldWriter) => [
+      (0, import_events.once)(foldWriter.trainWriter, "finish"),
+      (0, import_events.once)(foldWriter.testWriter, "finish")
+    ])
+  ];
+  await Promise.all(finishPromises);
+  if (!holdoutTrainRows || !holdoutTestRows) {
+    throw new Error(
+      `Window split produced empty holdout set (train=${holdoutTrainRows}, test=${holdoutTestRows}).`
+    );
+  }
+  if (holdoutTrainOutOfRangeRows > 0) {
+    throw new Error(
+      `Holdout split validation failed (train_out_of_range=${holdoutTrainOutOfRangeRows}).`
+    );
+  }
+  if (holdoutTrainMaxTs > holdoutCutoffMs) {
+    throw new Error(
+      `Holdout train contains rows newer than cutoff (${holdoutTrainMaxTs} > ${holdoutCutoffMs}).`
+    );
+  }
+  if (holdoutTestMinTs <= holdoutCutoffMs) {
+    throw new Error(
+      `Holdout test contains rows older/equal cutoff (${holdoutTestMinTs} <= ${holdoutCutoffMs}).`
+    );
+  }
+  if (walkForwardFolds > 0 && !walkForwardSourceRows) {
+    throw new Error("Window split produced empty walk-forward source dataset.");
+  }
+  if (!prodRows) {
+    throw new Error("Window split produced empty prod dataset.");
+  }
+  for (const foldWriter of walkForwardWriters) {
+    if (!foldWriter.trainRows || !foldWriter.testRows) {
+      throw new Error(
+        `Walk-forward fold ${foldWriter.fold} is empty (train=${foldWriter.trainRows}, test=${foldWriter.testRows}).`
+      );
+    }
+  }
+  const meta = {
+    exportFile: import_path.default.basename(inputPath),
+    exportHash,
+    params: {
+      testDays,
+      trainRecentDays,
+      walkForwardFolds,
+      causalityGuard: enforceCausalityGuard
+    },
+    files: {
+      holdout: {
+        holdoutTrainRows,
+        holdoutTestRows,
+        holdoutCutoffMs,
+        holdoutCutoffDt: (0, import_ml.toIsoUtcOrNull)(holdoutCutoffMs),
+        holdoutTrainStartMs,
+        holdoutTrainStartDt: (0, import_ml.toIsoUtcOrNull)(holdoutTrainStartMs),
+        holdoutTrainMinTs: holdoutTrainRows > 0 ? holdoutTrainMinTs : null,
+        holdoutTrainMinDt: (0, import_ml.toIsoUtcOrNull)(
+          holdoutTrainRows > 0 ? holdoutTrainMinTs : null
+        ),
+        holdoutTrainMaxTs: holdoutTrainRows > 0 ? holdoutTrainMaxTs : null,
+        holdoutTrainMaxDt: (0, import_ml.toIsoUtcOrNull)(
+          holdoutTrainRows > 0 ? holdoutTrainMaxTs : null
+        ),
+        holdoutTestMinTs: holdoutTestRows > 0 ? holdoutTestMinTs : null,
+        holdoutTestMinDt: (0, import_ml.toIsoUtcOrNull)(
+          holdoutTestRows > 0 ? holdoutTestMinTs : null
+        ),
+        holdoutTestMaxTs: holdoutTestRows > 0 ? holdoutTestMaxTs : null,
+        holdoutTestMaxDt: (0, import_ml.toIsoUtcOrNull)(
+          holdoutTestRows > 0 ? holdoutTestMaxTs : null
+        ),
+        holdoutTrain: import_path.default.basename(holdoutTrainPath),
+        holdoutTest: import_path.default.basename(holdoutTestPath)
+      },
+      prod: {
+        prodRows,
+        prodStartMs: Number.isFinite(prodStartMs) ? prodStartMs : null,
+        prodStartDt: (0, import_ml.toIsoUtcOrNull)(
+          Number.isFinite(prodStartMs) ? prodStartMs : null
+        ),
+        prodMinTs: prodRows > 0 ? prodMinTs : null,
+        prodMinDt: (0, import_ml.toIsoUtcOrNull)(prodRows > 0 ? prodMinTs : null),
+        prodMaxTs: prodRows > 0 ? prodMaxTs : null,
+        prodMaxDt: (0, import_ml.toIsoUtcOrNull)(prodRows > 0 ? prodMaxTs : null),
+        prod: import_path.default.basename(prodPath)
+      },
+      walkForwardFolds: walkForwardWriters.map((entry) => ({
+        fold: entry.fold,
+        walkForwardSourceRows,
+        startTs: entry.startTs,
+        startDt: (0, import_ml.toIsoUtcOrNull)(entry.startTs),
+        endTs: entry.endTs,
+        endDt: (0, import_ml.toIsoUtcOrNull)(entry.endTs),
+        trainStartMs: Number.isFinite(wfStartMs) ? wfStartMs : null,
+        trainStartDt: (0, import_ml.toIsoUtcOrNull)(
+          Number.isFinite(wfStartMs) ? wfStartMs : null
+        ),
+        trainMinTs: entry.trainRows > 0 ? entry.trainMinTs : null,
+        trainMinDt: (0, import_ml.toIsoUtcOrNull)(
+          entry.trainRows > 0 ? entry.trainMinTs : null
+        ),
+        trainMaxTs: entry.trainRows > 0 ? entry.trainMaxTs : null,
+        trainMaxDt: (0, import_ml.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),
+        testMaxTs: entry.testRows > 0 ? entry.testMaxTs : null,
+        testMaxDt: (0, import_ml.toIsoUtcOrNull)(entry.testRows > 0 ? entry.testMaxTs : null),
+        trainRows: entry.trainRows,
+        testRows: entry.testRows,
+        train: import_path.default.basename(entry.trainPath),
+        test: import_path.default.basename(entry.testPath)
+      }))
+    },
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await import_promises.default.writeFile(metaPath, `${JSON.stringify(meta, null, 2)}
+`, "utf8");
+  return {
+    holdoutTrainPath,
+    holdoutTestPath,
+    prodPath,
+    walkForwardFolds: walkForwardWriters.map((entry) => ({
+      fold: entry.fold,
+      startTs: entry.startTs,
+      endTs: entry.endTs,
+      trainPath: entry.trainPath,
+      testPath: entry.testPath,
+      trainRows: entry.trainRows,
+      testRows: entry.testRows
+    })),
+    cleanup: [],
+    reused: false,
+    key,
+    exportHash,
+    counts: {
+      holdoutTrainRows,
+      holdoutTestRows,
+      walkForwardSourceRows,
+      prodRows
+    }
+  };
+};
+var run = async () => {
+  const selectedFromCli = parseStrategy(flags.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(flags.model);
+  const modelType = modelFromCli ?? await selectModelType(defaultModelType);
+  const useLatestOnly = Boolean(flags.latestOnly) || asBool(process.env.ML_TRAIN_USE_LATEST_ONLY);
+  const exportDir = import_path.default.join(process.cwd(), "data", "ml", "export");
+  const modelDirRoot = import_path.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_path.default.join(exportDir, latest);
+    console.log(`Using latest JSONL dataset: ${import_path.default.basename(inputPath)}`);
+  } else if (datasetFiles.length) {
+    const files = datasetFiles.map((name) => import_path.default.join(exportDir, name));
+    const mergedPrefix = `ml-dataset-merged-${Date.now()}`;
+    inputPath = import_path.default.join(exportDir, `${mergedPrefix}.jsonl`);
+    await concatFiles(files, inputPath);
+    cleanupFiles = [inputPath];
+    console.log(`Merged datasets: ${datasetFiles.length} exports`);
+  } else {
+    console.error("No ml-dataset-*.jsonl found in data/ml/export");
+    process.exit(1);
+  }
+  try {
+    const inputStat = await import_promises.default.stat(inputPath);
+    const totalInputBytes = inputStat.size;
+    const autoIncrementalThresholdGb = asInt(
+      process.env.ML_TRAIN_INCREMENTAL_THRESHOLD_GB,
+      2
+    );
+    const autoIncrementalThresholdBytes = autoIncrementalThresholdGb * 1024 * 1024 * 1024;
+    const forceIncremental = asBool(process.env.ML_TRAIN_INCREMENTAL);
+    const disableIncremental = asBool(process.env.ML_TRAIN_NO_INCREMENTAL);
+    const useIncremental = !disableIncremental && (forceIncremental || totalInputBytes >= autoIncrementalThresholdBytes);
+    const chunkSize = asInt(process.env.ML_TRAIN_CHUNK_SIZE, 1e4);
+    const incrementalIterations = asInt(
+      process.env.ML_TRAIN_INCREMENTAL_ITERATIONS,
+      30
+    );
+    const trainRecentDays = asNonNegativeInt(
+      process.env.ML_TRAIN_RECENT_DAYS,
+      60
+    );
+    const enableEnsemble = asBool(process.env.ML_TRAIN_ENSEMBLE);
+    const forceEnsemble = asBool(process.env.ML_TRAIN_FORCE_ENSEMBLE);
+    const disableEnsemble = asBool(process.env.ML_TRAIN_NO_ENSEMBLE);
+    const useEnsemble = (forceEnsemble || enableEnsemble) && !disableEnsemble;
+    const walkForwardFolds = asNonNegativeInt(
+      process.env.ML_TRAIN_WALK_FORWARD_FOLDS,
+      2
+    );
+    const featureProfile = (process.env.ML_TRAIN_FEATURE_PROFILE ?? "all").trim().toLowerCase();
+    const reportDir = (process.env.ML_TRAIN_REPORT_DIR ?? "data/ml/models").trim();
+    const testDays = asInt(process.env.ML_TRAIN_TEST_DAYS, 30);
+    if (useIncremental && modelType === "catboost") {
+      console.log(
+        `Using incremental mode (total input ${(totalInputBytes / 1024 / 1024 / 1024).toFixed(2)} GiB, chunk size ${chunkSize}, iters/chunk ${incrementalIterations})`
+      );
+    }
+    if (!useEnsemble) {
+      console.log("Using single-model mode (outer ensemble disabled).");
+    }
+    console.log(`Train recent days: ${trainRecentDays}`);
+    console.log(`Walk-forward folds: ${walkForwardFolds}`);
+    console.log(`Feature profile: ${featureProfile}`);
+    const splitFiles = await prepareTrainWindowFiles({
+      inputPath,
+      testDays,
+      trainRecentDays,
+      walkForwardFolds,
+      enforceCausalityGuard: !asBool(
+        process.env.ML_TRAIN_DISABLE_CAUSALITY_GUARD
+      )
+    });
+    cleanupFiles.push(...splitFiles.cleanup);
+    const splitMode = splitFiles.reused ? "Reusing" : "Prepared";
+    console.log(
+      `${splitMode} split key=${splitFiles.key} export_hash=${splitFiles.exportHash.slice(0, 12)}`
+    );
+    console.log(
+      `${splitMode} holdout files: train=${import_path.default.basename(splitFiles.holdoutTrainPath)} (${splitFiles.counts.holdoutTrainRows} rows), test=${import_path.default.basename(splitFiles.holdoutTestPath)} (${splitFiles.counts.holdoutTestRows} rows)`
+    );
+    console.log(
+      `${splitMode} prod file: ${import_path.default.basename(splitFiles.prodPath)} (${splitFiles.counts.prodRows} rows)`
+    );
+    if (splitFiles.walkForwardFolds.length) {
+      console.log(
+        `${splitMode} walk-forward source rows: ${splitFiles.counts.walkForwardSourceRows}`
+      );
+      for (const foldEntry of splitFiles.walkForwardFolds) {
+        console.log(
+          `${splitMode} walk-forward fold ${foldEntry.fold}: train=${import_path.default.basename(foldEntry.trainPath)} (${foldEntry.trainRows} rows), test=${import_path.default.basename(foldEntry.testPath)} (${foldEntry.testRows} rows)`
+        );
+      }
+    } else {
+      console.log(`${splitMode} walk-forward folds disabled.`);
+    }
+    const trainArgs = [
+      "compose",
+      "-f",
+      "docker-compose.ml.yml",
+      "run",
+      "--rm",
+      "ml",
+      "python",
+      "/app/ml/train.py",
+      "--input",
+      `/app/data/ml/export/${import_path.default.basename(splitFiles.holdoutTrainPath)}`,
+      "--test-input",
+      `/app/data/ml/export/${import_path.default.basename(splitFiles.holdoutTestPath)}`,
+      "--prod-input",
+      `/app/data/ml/export/${import_path.default.basename(splitFiles.prodPath)}`,
+      "--strategy",
+      selected,
+      "--model-type",
+      modelType,
+      "--feature-profile",
+      featureProfile,
+      "--train-recent-days",
+      String(trainRecentDays),
+      "--walk-forward-folds",
+      String(walkForwardFolds),
+      "--test-days",
+      String(testDays),
+      "--report-dir",
+      reportDir,
+      ...useEnsemble ? ["--ensemble"] : [],
+      ...splitFiles.walkForwardFolds.flatMap((foldEntry) => [
+        "--walk-forward-fold-train-input",
+        `/app/data/ml/export/${import_path.default.basename(foldEntry.trainPath)}`,
+        "--walk-forward-fold-test-input",
+        `/app/data/ml/export/${import_path.default.basename(foldEntry.testPath)}`
+      ])
+    ];
+    const startedAt = Date.now();
+    let lastOutputAt = startedAt;
+    let sawDockerOutput = false;
+    const heartbeatSec = asInt(process.env.ML_TRAIN_HEARTBEAT_SEC, 10);
+    const trainDebug = asBool(process.env.ML_TRAIN_DEBUG);
+    const noOutputTimeoutSec = asInt(
+      process.env.ML_TRAIN_DOCKER_NO_OUTPUT_TIMEOUT_SEC,
+      90
+    );
+    console.log(`Starting train command: docker ${trainArgs.join(" ")}`);
+    const child = (0, import_child_process.spawn)("docker", trainArgs, {
+      stdio: ["inherit", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        PYTHONUNBUFFERED: "1",
+        COMPOSE_IGNORE_ORPHANS: "1"
+      }
+    });
+    const stopStdoutPipe = pipeNormalized(child.stdout, (line) => {
+      sawDockerOutput = true;
+      lastOutputAt = Date.now();
+      process.stdout.write(`${line}
+`);
+    });
+    const stopStderrPipe = pipeNormalized(child.stderr, (line) => {
+      sawDockerOutput = true;
+      lastOutputAt = Date.now();
+      process.stderr.write(`${line}
+`);
+    });
+    const heartbeat = setInterval(
+      () => {
+        const elapsedSec = Math.floor((Date.now() - startedAt) / 1e3);
+        const silenceSec = Math.floor((Date.now() - lastOutputAt) / 1e3);
+        if (trainDebug) {
+          const nodeMem = formatBytes(process.memoryUsage().rss);
+          const mlMem = getMlContainerMemUsage();
+          process.stdout.write(
+            `
+[train] still running... elapsed ${elapsedSec}s, silence=${silenceSec}s (model=${modelType}, strategy=${selected}, node_rss=${nodeMem}, ml_mem=${mlMem})
+`
+          );
+        }
+        if (noOutputTimeoutSec > 0 && !sawDockerOutput && silenceSec >= noOutputTimeoutSec) {
+          process.stderr.write(
+            `[train] docker produced no output for ${silenceSec}s; terminating process. Check Docker Desktop/daemon health.
+`
+          );
+          child.kill("SIGTERM");
+          setTimeout(() => {
+            if (child.exitCode === null && child.signalCode === null) {
+              child.kill("SIGKILL");
+            }
+          }, 5e3).unref();
+        }
+      },
+      Math.max(heartbeatSec, 1) * 1e3
+    );
+    const result = await new Promise((resolve) => {
+      child.on("error", (error) => resolve({ code: 1, signal: null, error }));
+      child.on("exit", (code2, signal) => resolve({ code: code2, signal }));
+    });
+    clearInterval(heartbeat);
+    stopStdoutPipe();
+    stopStderrPipe();
+    const code = result.code ?? 1;
+    let finalCode = code;
+    if (result.error) {
+      console.error(`Failed to start docker process: ${result.error.message}`);
+    }
+    if (result.signal === "SIGKILL" || code === 137) {
+      console.error(
+        "Training was killed (exit 137). Most likely out-of-memory. Try ML_TRAIN_USE_LATEST_ONLY=1, random_forest/extra_trees, or a smaller export."
+      );
+    }
+    if (code === 0) {
+      const modelDir = import_path.default.join(modelDirRoot, "models");
+      let savedModels = [];
+      try {
+        const entries = await import_promises.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();
+      } catch {
+        savedModels = [];
+      }
+      if (!savedModels.length) {
+        console.error(
+          `Training finished but no model artifacts found in ${modelDir} for strategy "${selected}".`
+        );
+        finalCode = 1;
+      } else {
+        console.log(`Saved model artifacts (${savedModels.length}):`);
+        for (const name of savedModels) {
+          console.log(`  - data/ml/models/${name}`);
+        }
+      }
+    }
+    process.exitCode = finalCode;
+  } finally {
+    for (const file of cleanupFiles) {
+      await import_promises.default.rm(file, { force: true });
+    }
+  }
+  process.exit(process.exitCode ?? 1);
+};
+run().catch((err) => {
+  console.error("Failed to train:", err);
+  process.exit(1);
+});