@tradejs/cli 3.1.29-beta.261 → 3.1.29-beta.263

package/dist/scripts/aiPocketSearch.js

@@ -74,7 +74,7 @@ var resolveAiPocketCadenceProfile = ({
   validationRows = [],
   testRows = [],
   mode = "auto",
-  validationSplit = 0.25,
+  validationSplit = 0,
   minSupport,
   minEvents,
   minValidationSupport,
@@ -124,8 +124,8 @@ var AI_POCKET_SEARCH_CLI_DECIMAL_DEFAULTS = {
   minProfitFactor: "1.2",
   minWinRate: "0",
   minTotalProfit: "0",
-  validationSplit: "0.25",
-  testSplit: "0"
+  validationSplit: "0",
+  testSplit: "0.4"
 };
 var splitAiPocketResearchRowsByTimestamp = (rows, validationSplit, testSplit = 0) => {
   const timestamps = [
@@ -166,11 +166,6 @@ var splitAiPocketResearchRowsByTimestamp = (rows, validationSplit, testSplit = 0
     testRows: rows.filter((row) => isIn(testTimestamps, row.timestamp))
   };
 };
-var splitAiPocketCoverageRowsByTimestamp = (rows, family, validationSplit, testSplit = 0) => splitAiPocketResearchRowsByTimestamp(
-  rows.filter((row) => row.featureCoverage?.[family] === true),
-  validationSplit,
-  testSplit
-);
 var sealAiPocketTestPartition = (split, sealed) => {
   const finiteTimestamps = split.testRows.map((row) => row.timestamp).filter((timestamp) => Number.isFinite(timestamp));
   return {
@@ -436,17 +431,17 @@ var resolveAiPocketSearchCommandOptions = ({
       longName: "validationSplit",
       shortName: "V"
     }) ?? flags2.validationSplit,
-    0.25
-  ) : 0.25;
+    0
+  ) : 0;
   const testSplit = hasCliOption2(argv, "testSplit", "T") ? normalizeRatio(
     readAiPocketSearchCliOption({
       argv,
       longName: "testSplit",
       shortName: "T"
     }) ?? flags2.testSplit,
-    0
-  ) : 0;
-  const sealTest = Boolean(flags2.sealTest);
+    0.4
+  ) : 0.4;
+  const sealTest = flags2.sealTest == null ? true : Boolean(flags2.sealTest);
   if (sealTest && testSplit <= 0) {
     throw new Error("--sealTest requires a positive --testSplit");
   }
@@ -2649,6 +2644,22 @@ var buildAiPocketMarkdownReport = ({
     "",
     markdownTable(pocketTableHeaders, pocketRows(pocketSearch.positivePockets)),
     "",
+    "## Development Stability (inside discovery, not independent validation)",
+    "",
+    markdownTable(
+      ["Condition", "Status", "Block", "Events", "PnL", "PF"],
+      pocketSearch.positivePockets.flatMap(
+        (pocket) => (pocket.stability?.folds ?? []).map((fold, index) => [
+          pocket.condition,
+          pocket.stability?.status,
+          index + 1,
+          fold.summary.events,
+          formatMdNumber(fold.summary.totalProfit),
+          formatMdNumber(fold.summary.profitFactor)
+        ])
+      )
+    ),
+    "",
     "## Top Loss Pockets",
     "",
     markdownTable(pocketTableHeaders, pocketRows(pocketSearch.negativePockets)),
@@ -4099,6 +4110,62 @@ var summarizeAiTrainEvaluationsByQualityThreshold = (evaluations, thresholds = [
   )
 }));
 
+// src/lib/aiPocketSearch/stability.ts
+var assessDevelopmentStability = (result, options) => {
+  const minEvents = options.minEventsPerFold ?? 5;
+  const timestamps = [...new Set(options.timestamps)].sort((a, b) => a - b);
+  const boundaries = [0, 1, 2, 3].map(
+    (index) => index === 3 ? timestamps.at(-1) == null ? Number.POSITIVE_INFINITY : timestamps.at(-1) + 1 : timestamps[Math.floor(timestamps.length * index / 3)] ?? Number.POSITIVE_INFINITY
+  );
+  const blocks = [0, 1, 2].map((index) => ({
+    start: boundaries[index],
+    end: boundaries[index + 1],
+    rows: options.developmentRows.filter(
+      (row) => row.timestamp != null && row.timestamp >= boundaries[index] && row.timestamp < boundaries[index + 1]
+    ),
+    baseline: options.baselineRows.filter(
+      (row) => row.timestamp != null && row.timestamp >= boundaries[index] && row.timestamp < boundaries[index + 1]
+    )
+  }));
+  for (const pocket of result.positivePockets) {
+    const folds = blocks.map((block) => {
+      const mask = buildPredicateListMask(block.rows, pocket.predicates).mask;
+      const selected = block.rows.filter((_, index) => mask[index] === 1);
+      const summary = summarizeAiPocketRows(selected);
+      const baseline = summarizeAiPocketRows(block.baseline);
+      const objectiveSummary = result.objective === "add-to-gate" ? summarizeAiPocketRows([
+        .../* @__PURE__ */ new Set([...block.baseline, ...selected])
+      ]) : summary;
+      return {
+        startTimestamp: Number.isFinite(block.start) ? block.start : null,
+        endTimestamp: Number.isFinite(block.end) ? block.end : null,
+        summary,
+        objectiveSummary,
+        baseline
+      };
+    });
+    const supported = folds.filter((fold) => fold.summary.events >= minEvents);
+    const unstable = supported.some(
+      (fold) => fold.objectiveSummary.totalProfit < (result.objective === "add-to-gate" ? fold.baseline.totalProfit : 0) || (fold.objectiveSummary.profitFactor ?? (fold.objectiveSummary.grossLoss === 0 ? Infinity : 0)) < 1
+    );
+    const status = unstable ? "unstable" : supported.length < 3 ? "insufficient-support" : "stable";
+    pocket.stability = {
+      status,
+      role: "development-only diagnostic",
+      minEventsPerFold: minEvents,
+      folds
+    };
+    if (status !== "stable") {
+      pocket.readiness = "research-only";
+      pocket.readinessReasons.push(`development stability: ${status}`);
+    }
+  }
+  const rank = { stable: 0, "insufficient-support": 1, unstable: 2 };
+  result.positivePockets.sort(
+    (a, b) => rank[a.stability.status] - rank[b.stability.status]
+  );
+};
+
 // src/lib/aiPocketSearch/research.ts
 var resolveScopeRows = (rows, scope) => {
   if (scope === "approved") {
@@ -4194,7 +4261,7 @@ var runAiPocketSearchResearch = ({
       maxEventCountShare,
       explicitMaxEventCountShare
     });
-    return searchAiPockets(train, {
+    const result = searchAiPockets(train, {
       minSupport: cadenceProfile.minSupport,
       minProfitFactor,
       minTotalProfit,
@@ -4224,6 +4291,17 @@ var runAiPocketSearchResearch = ({
       progressInterval: 250,
       onProgress: (progress) => onProgress?.({ label, progress })
     });
+    assessDevelopmentStability(result, {
+      developmentRows: [...train, ...validation],
+      baselineRows: [...trainBaseline, ...validationBaseline],
+      // Every provider/scope uses the same outer development timestamps.
+      timestamps: [
+        ...new Set(
+          fullSplit.trainRows.concat(fullSplit.validationRows).map((row) => row.timestamp)
+        )
+      ].sort((a, b) => a - b)
+    });
+    return result;
   };
   const search = runSearch({
     label: "full",
@@ -4243,12 +4321,12 @@ var runAiPocketSearchResearch = ({
   const coverageSearches = [];
   if (coverageMode === "auto") {
     for (const family of ["cmc", "coinalyze"]) {
-      const cohortSplit = splitAiPocketCoverageRowsByTimestamp(
-        directionRows,
-        family,
-        validationSplit,
-        testSplit
-      );
+      const covered = (row) => row.featureCoverage?.[family] === true;
+      const cohortSplit = {
+        trainRows: fullSplit.trainRows.filter(covered),
+        validationRows: fullSplit.validationRows.filter(covered),
+        testRows: fullSplit.testRows.filter(covered)
+      };
       const sealedCohortSplit = sealAiPocketTestPartition(
         cohortSplit,
         sealTest
@@ -4581,18 +4659,18 @@ import_args.default.option(
 );
 import_args.default.option(
   ["V", "validationSplit"],
-  "Trailing time-ordered scope share reserved for validation (0 disables)",
+  "Optional legacy tuning share; default 0, stability is checked inside development",
   AI_POCKET_SEARCH_CLI_DECIMAL_DEFAULTS.validationSplit
 );
 import_args.default.option(
   ["T", "testSplit"],
-  "Trailing timestamp-grouped scope share withheld as untouched test",
+  "Trailing timestamp-grouped test share; default 0.4 (outer 60/40)",
   AI_POCKET_SEARCH_CLI_DECIMAL_DEFAULTS.testSplit
 );
 import_args.default.option(
   ["w", "sealTest"],
   "Reserve test bounds without exposing its rows or economics to discovery",
-  false
+  true
 );
 import_args.default.option(
   ["N", "minValidationSupport"],

package/dist/scripts/backtest.js

@@ -74,6 +74,10 @@ var import_userSettings = require("@tradejs/infra/userSettings");
 var import_jev3 = require("@tradejs/node/jev");
 var resolveBacktestAiExportEnabled = (flags2) => Boolean(flags2.ai);
 var resolveBacktestJev = async (flags2, userName2, projectRoot2) => {
+  if (flags2.jevQuestionSet != null)
+    throw new Error(
+      "--jevQuestionSet was removed; --jev always uses the current nine-question set"
+    );
   if (!flags2.jev) {
     if (flags2.jevRecorded || flags2.jevModelFile)
       throw new Error("Jev options require --jev");
@@ -4325,6 +4329,11 @@ import_args.default.option(
   "Skip per-test artifact persistence and keep only in-memory summary/AI-ML dataset output",
   false
 );
+import_args.default.option(
+  ["Y", "persistResults"],
+  "Persist lightweight result summaries even in fast mode",
+  false
+);
 import_args.default.option(
   "researchTrace",
   "Write compact setup/entry/exit/skip research trace JSONL",
@@ -5635,7 +5644,7 @@ var finishBacktest = async (testSuite) => {
   }
   console.log(import_chalk10.default.gray(`full report: ${markdownReportPath}`));
   console.log("");
-  if (!isFastMode) {
+  if (!isFastMode || flags.persistResults) {
     await (0, import_redis5.setData)(
       import_redis5.redisKeys.backtestResults(userName, flags.config, timestamp),
       {

package/dist/scripts/jev.js

@@ -172,6 +172,17 @@ var runJevResearch = async (options) => {
         throw new Error(
           "Export exceeds 20000 samples; select a bounded recording directory"
         );
+      await (0, import_jev2.evaluateJevInput)({
+        input: record.input,
+        config: {
+          source: "recorded",
+          mode: "observe",
+          provider: record.provider,
+          recordsDir: options.recordsDir
+        },
+        userName: options.userName,
+        projectRoot: options.projectRoot
+      });
       const outcome = byRecord.get(record.id);
       rows2.push({
         schema: "tradejs-jev-study/v4",

package/dist/scripts/mcpWorker.js

@@ -0,0 +1,273 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/scripts/mcpWorker.ts
+var mcpWorker_exports = {};
+__export(mcpWorker_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(mcpWorker_exports);
+var import_node_child_process = require("child_process");
+var import_node_crypto = require("crypto");
+var import_promises = require("fs/promises");
+var import_redis = require("@tradejs/infra/redis");
+var import_mcp = require("@tradejs/node/mcp");
+var pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var leaseKey = "worker:lease";
+var LEASE_SECONDS = 15;
+var JOB_TIMEOUT_MS = 60 * 60 * 1e3;
+var main = async (options = {}) => {
+  const owner = (0, import_node_crypto.randomUUID)();
+  if (!await import_redis.mcpStorage.put(leaseKey, owner, LEASE_SECONDS, true))
+    throw new Error("Another MCP worker owns this storage");
+  let stopping = false;
+  let child;
+  let renewing = false;
+  let leaseLost = false;
+  let manifestHash = "";
+  const signalChild = (signal) => {
+    if (!child?.pid) return;
+    try {
+      process.kill(
+        process.platform === "win32" ? child.pid : -child.pid,
+        signal
+      );
+    } catch {
+    }
+  };
+  const heartbeatValue = () => ({
+    observedAt: Date.now(),
+    packageManifestSha256: manifestHash,
+    replayAvailable: Boolean(process.env.MCP_REPLAY_REDIS_HOST)
+  });
+  const stop = () => {
+    stopping = true;
+    signalChild("SIGTERM");
+  };
+  options.signal?.addEventListener("abort", stop, { once: true });
+  if (options.signal?.aborted) stop();
+  process.once("SIGINT", stop);
+  process.once("SIGTERM", stop);
+  const heartbeat = setInterval(async () => {
+    if (renewing || leaseLost) return;
+    renewing = true;
+    try {
+      if (!await import_redis.mcpStorage.compare(leaseKey, owner, owner, LEASE_SECONDS))
+        throw new Error("Worker lease lost");
+      await import_redis.mcpStorage.put("worker:heartbeat", heartbeatValue(), LEASE_SECONDS);
+    } catch {
+      leaseLost = true;
+      stop();
+    } finally {
+      renewing = false;
+    }
+  }, 2e3);
+  try {
+    manifestHash = await (0, import_mcp.mcpPackageManifestHash)();
+    await import_redis.mcpStorage.put("worker:heartbeat", heartbeatValue(), LEASE_SECONDS);
+    let cursor = "0";
+    do {
+      const page = await import_redis.mcpStorage.scan("jobs:", cursor);
+      cursor = page.cursor;
+      for (const key of page.ids) {
+        const job = await import_redis.mcpStorage.get(key);
+        if (job?.status === "running")
+          await import_redis.mcpStorage.compare(
+            key,
+            job,
+            {
+              ...job,
+              status: "failed",
+              error: "Worker restarted; this job was not replayed",
+              finishedAt: Date.now(),
+              updatedAt: Date.now()
+            },
+            import_mcp.MCP_JOB_TTL
+          );
+      }
+    } while (cursor !== "0" && !stopping);
+    console.log(
+      "MCP worker ready (one job at a time, cached history, no live order commands)"
+    );
+    while (!stopping) {
+      let queued;
+      cursor = "0";
+      do {
+        const page = await import_redis.mcpStorage.scan("jobs:", cursor);
+        cursor = page.cursor;
+        for (const key of page.ids) {
+          const job = await import_redis.mcpStorage.get(key);
+          if (job?.status === "queued" && (!queued || job.createdAt < queued.createdAt))
+            queued = job;
+        }
+      } while (cursor !== "0" && !stopping);
+      if (!queued) {
+        await pause(1e3);
+        continue;
+      }
+      const jobKey = (0, import_mcp.mcpJobStorageId)(queued.userName, queued.id);
+      const started = {
+        ...queued,
+        status: "running",
+        startedAt: Date.now(),
+        updatedAt: Date.now()
+      };
+      if (!await import_redis.mcpStorage.compare(jobKey, queued, started, import_mcp.MCP_JOB_TTL))
+        continue;
+      if (started.packageManifestSha256 !== manifestHash) {
+        await import_redis.mcpStorage.compare(
+          jobKey,
+          started,
+          {
+            ...started,
+            status: "failed",
+            error: "Package composition changed since submission",
+            finishedAt: Date.now()
+          },
+          import_mcp.MCP_JOB_TTL
+        );
+        continue;
+      }
+      await (0, import_promises.mkdir)((0, import_mcp.mcpJobDirectory)(started), { recursive: true });
+      if (started.kind === "backtest")
+        await (0, import_redis.setDataStrict)(
+          import_redis.redisKeys.backtestConfig(
+            started.userName,
+            String(started.request.frozenConfigId)
+          ),
+          started.request.resolvedConfig,
+          { expire: import_mcp.MCP_JOB_TTL }
+        );
+      const jobEnv = {
+        ...process.env,
+        NODE_OPTIONS: "--max-old-space-size=1024",
+        MCP_WORKER: "true",
+        BACKTEST_WORKER_HEAP_MB: "768",
+        BACKTEST_MAX_PARALLEL: "1",
+        AI_ENABLED: "false",
+        ML_ENABLED: "false",
+        MAKE_ORDERS: "false",
+        TRADEJS_EXTERNAL_ORDER_PLACEMENT: "false"
+      };
+      if (started.kind === "runtime-feedback-replay") {
+        for (const name of Object.keys(jobEnv)) {
+          if (/secret|token|api.?key|private.?key|cookie|credential/i.test(name))
+            delete jobEnv[name];
+        }
+        Object.assign(jobEnv, {
+          DOTENV_CONFIG_PATH: "/dev/null",
+          REDIS_HOST: process.env.MCP_REPLAY_REDIS_HOST,
+          REDIS_PORT: "6379",
+          REDIS_DB: "0",
+          RUNTIME_FEEDBACK_ISOLATED_REDIS: "true",
+          PGOPTIONS: "-c default_transaction_read_only=on",
+          TRADEJS_TIMESCALE_READ_ONLY: "true"
+        });
+      }
+      child = (0, import_node_child_process.spawn)(process.execPath, [process.argv[1], ...started.args], {
+        cwd: process.env.PROJECT_CWD || process.cwd(),
+        env: jobEnv,
+        detached: process.platform !== "win32",
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const currentChild = child;
+      let timedOut = false;
+      const timeout = setTimeout(() => {
+        timedOut = true;
+        signalChild("SIGTERM");
+      }, JOB_TIMEOUT_MS);
+      const logs = [];
+      const log = (chunk) => {
+        const lines = chunk.toString().replace(/\u001b\[[0-9;]*m/g, "").split(/[\r\n]+/).filter(Boolean);
+        logs.push(
+          ...lines.map(
+            (line) => line.slice(0, 1e3).replace(
+              /((?:secret|password|api.?key|token|authorization)\s*[:=]\s*)\S+/gi,
+              "$1[redacted]"
+            )
+          )
+        );
+        if (logs.length > 150) logs.splice(0, logs.length - 150);
+      };
+      currentChild.stdout?.on("data", log);
+      currentChild.stderr?.on("data", log);
+      let killAt;
+      const monitor = setInterval(async () => {
+        try {
+          const latest = await import_redis.mcpStorage.get(jobKey);
+          if (!latest || latest.cancelRequested || stopping || timedOut) {
+            killAt ??= Date.now();
+            signalChild(Date.now() - killAt > 8e3 ? "SIGKILL" : "SIGTERM");
+          }
+          if (latest && !leaseLost)
+            await import_redis.mcpStorage.compare(
+              jobKey,
+              latest,
+              { ...latest, logs: [...logs], updatedAt: Date.now() },
+              import_mcp.MCP_JOB_TTL
+            );
+        } catch {
+          leaseLost = true;
+          stop();
+        }
+      }, 1e3);
+      const outcome = await new Promise((resolve) => {
+        currentChild.once(
+          "error",
+          () => resolve({ code: null, error: "Unable to start research process" })
+        );
+        currentChild.once("exit", (code) => resolve({ code }));
+      });
+      clearTimeout(timeout);
+      clearInterval(monitor);
+      child = void 0;
+      if (!leaseLost) {
+        for (let attempt = 0; attempt < 4; attempt++) {
+          const latest = await import_redis.mcpStorage.get(jobKey);
+          if (!latest) break;
+          const cancelled = latest.cancelRequested;
+          const next = {
+            ...latest,
+            logs,
+            status: cancelled ? "cancelled" : outcome.code === 0 && !timedOut && !stopping ? "completed" : "failed",
+            exitCode: outcome.code,
+            updatedAt: Date.now(),
+            finishedAt: Date.now(),
+            ...cancelled ? {} : timedOut ? { error: "Job exceeded one hour" } : stopping ? { error: "Worker stopped; this job was not replayed" } : outcome.code !== 0 ? { error: outcome.error || "Research process failed" } : {}
+          };
+          if (await import_redis.mcpStorage.compare(jobKey, latest, next, import_mcp.MCP_JOB_TTL))
+            break;
+        }
+      }
+    }
+  } finally {
+    clearInterval(heartbeat);
+    options.signal?.removeEventListener("abort", stop);
+    process.removeListener("SIGINT", stop);
+    process.removeListener("SIGTERM", stop);
+    if (await import_redis.mcpStorage.release(leaseKey, owner))
+      await import_redis.mcpStorage.remove("worker:heartbeat");
+  }
+  if (leaseLost)
+    throw new Error("Worker lease lost; active computation was stopped");
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});