@tradejs/cli 3.1.29-beta.282 → 3.1.29-beta.284

package/dist/scripts/aiPocketSearch.js

@@ -597,6 +597,7 @@ var DAYS_PER_WEEK = 7;
 var DAYS_PER_MONTH = 30.4375;
 var PRODUCTION_CANDIDATE_MIN_EVENTS = 25;
 var OUTCOME_SEGMENTS = /* @__PURE__ */ new Set([
+  "researchentrydecision",
   "actual",
   "aiapproved",
   "approvalallowednow",
@@ -881,6 +882,8 @@ var classifyAiPocketFeaturePath = (path3) => {
   if (METADATA_LEAVES.has(leaf) || leaf.endsWith("fingerprint") || normalized.some((segment) => segment === "metadata")) {
     return "metadata";
   }
+  if (normalized.some((segment) => OUTCOME_SEGMENTS.has(segment)))
+    return "derived-policy";
   if (DERIVED_POLICY_FRAGMENTS.some(
     (fragment) => !(fragment === "gatefeature" && isStrategySetupEvidence) && normalizedPath.includes(fragment)
   )) {

package/dist/scripts/coreResearch.js

@@ -33,7 +33,7 @@ __export(coreResearch_exports, {
   main: () => main
 });
 module.exports = __toCommonJS(coreResearch_exports);
-var import_promises5 = __toESM(require("fs/promises"));
+var import_promises4 = __toESM(require("fs/promises"));
 var import_node_path7 = __toESM(require("path"));
 var import_chalk = __toESM(require("chalk"));
 
@@ -644,7 +644,7 @@ var writeCoreResearchStageIndex = async (rootDir) => {
 };
 
 // src/lib/coreResearch/orchestrator.ts
-var import_promises4 = __toESM(require("fs/promises"));
+var import_promises3 = __toESM(require("fs/promises"));
 var import_node_path6 = __toESM(require("path"));
 var import_node_child_process = require("child_process");
 var import_node_crypto5 = require("crypto");
@@ -1010,6 +1010,8 @@ var calendarClusterBootstrap = (params) => {
   const alpha = 1 - params.confidenceLevel;
   const positive = samples.filter((value) => value > 0).length;
   const probabilityPositive = positive / samples.length;
+  const observed = deltas.reduce((sum, value) => sum + value, 0) / deltas.length;
+  const oneSidedPValue = (1 + samples.filter((value) => value - observed >= observed - 1e-12).length) / (samples.length + 1);
   return {
     method: "calendar-cluster-bootstrap",
     clusterDays: params.clusterDays,
@@ -1021,7 +1023,7 @@ var calendarClusterBootstrap = (params) => {
       percentile(samples, 1 - alpha / 2)
     ],
     probabilityPositive,
-    oneSidedPValue: 1 - probabilityPositive,
+    oneSidedPValue,
     holmAdjustedPValue: null
   };
 };
@@ -1088,7 +1090,7 @@ var erf = (value) => {
   return sign * y;
 };
 var normalCdf = (value) => 0.5 * (1 + erf(value / Math.SQRT2));
-var deflatedSharpeDiagnostic = (returns, trials) => {
+var deflatedSharpeDiagnostic = (returns, trials, trialSharpes) => {
   const periods = returns.length;
   if (periods < 3) {
     return {
@@ -1113,9 +1115,18 @@ var deflatedSharpeDiagnostic = (returns, trials) => {
   const observedSharpe = mean / standardDeviation;
   const skew = centered.reduce((sum, value) => sum + (value / standardDeviation) ** 3, 0) / periods;
   const kurtosis = centered.reduce((sum, value) => sum + (value / standardDeviation) ** 4, 0) / periods;
-  const expectedMaximumSharpe = inverseNormalCdf(
-    (Math.max(1, trials) - 0.375) / (Math.max(1, trials) + 0.25)
-  );
+  const available = trialSharpes?.filter(Number.isFinite) ?? [];
+  if (trials > 1 && available.length < 2)
+    return {
+      periods,
+      observedSharpe,
+      expectedMaximumSharpe: null,
+      probabilityAboveSelectionBias: null
+    };
+  const trialMean = available.length ? available.reduce((sum, value) => sum + value, 0) / available.length : 0;
+  const trialVariance = available.length > 1 ? available.reduce((sum, value) => sum + (value - trialMean) ** 2, 0) / (available.length - 1) : 0;
+  const gamma = 0.5772156649015329;
+  const expectedMaximumSharpe = trials <= 1 ? 0 : Math.sqrt(trialVariance) * ((1 - gamma) * inverseNormalCdf(1 - 1 / trials) + gamma * inverseNormalCdf(1 - 1 / (trials * Math.E)));
   const standardError = Math.sqrt(
     Math.max(
       1e-12,
@@ -1133,6 +1144,27 @@ var deflatedSharpeDiagnostic = (returns, trials) => {
 };
 var combinations = (items, choose) => {
   const output = [];
+  if (items.length > 10) {
+    const random = createSeededRandom(`cscv-balanced-${items.length}`);
+    const seen = /* @__PURE__ */ new Set();
+    for (let attempt = 0; output.length < 512 && attempt < 1e5; attempt++) {
+      const shuffled = [...items];
+      for (let index = shuffled.length - 1; index > 0; index--) {
+        const swap = Math.floor(random() * (index + 1));
+        [shuffled[index], shuffled[swap]] = [shuffled[swap], shuffled[index]];
+      }
+      const selected = shuffled.slice(0, choose).sort((a, b) => a - b);
+      const complement = items.filter((item) => !selected.includes(item));
+      for (const half of [selected, complement]) {
+        const key = half.join(",");
+        if (!seen.has(key)) {
+          seen.add(key);
+          output.push(half);
+        }
+      }
+    }
+    return output;
+  }
   const visit = (start, selected) => {
     if (output.length >= 512) return;
     if (selected.length === choose) {
@@ -1171,14 +1203,23 @@ var probabilityOfBacktestOverfitting = (performanceByVariant) => {
     const inScores = performanceByVariant.map(
       (performance) => inSample.reduce((sum, index) => sum + performance[index], 0)
     );
-    const selected = inScores.indexOf(Math.max(...inScores));
+    const maximum = Math.max(...inScores);
+    const selected = inScores.flatMap(
+      (score, index) => score === maximum ? [index] : []
+    );
     const outScores = performanceByVariant.map(
       (performance) => outSample.reduce((sum, index) => sum + performance[index], 0)
     );
-    const sorted = [...outScores].sort((left, right) => left - right);
-    const rankAscending = sorted.indexOf(outScores[selected]);
-    const omega = (rankAscending + 1) / (outScores.length + 1);
-    if (Math.log(omega / (1 - omega)) < 0) belowMedian += 1;
+    for (const winner of selected) {
+      const less = outScores.filter(
+        (score) => score < outScores[winner]
+      ).length;
+      const equal = outScores.filter(
+        (score) => score === outScores[winner]
+      ).length;
+      const omega = (less + (equal + 1) / 2) / (outScores.length + 1);
+      if (omega < 0.5) belowMedian += 1 / selected.length;
+    }
   }
   return {
     method: "CSCV",
@@ -2108,34 +2149,55 @@ var applyCoreResearchRobustnessGuardrails = (params) => {
 };
 
 // src/lib/coreResearch/trace.ts
-var import_promises3 = __toESM(require("fs/promises"));
+var import_node_fs4 = require("fs");
+var import_node_readline2 = __toESM(require("readline"));
 var import_node_path4 = __toESM(require("path"));
 var summarizeCoreResearchTrace = async (filePaths = []) => {
   const events = /* @__PURE__ */ Object.create(null);
   const skipCounts = /* @__PURE__ */ Object.create(null);
   const exitCodes = /* @__PURE__ */ Object.create(null);
+  const policyRejections = {};
+  const policyExamples = [];
   for (const inputPath of filePaths) {
     const filePath = import_node_path4.default.resolve(inputPath);
-    const text = await import_promises3.default.readFile(filePath, "utf8");
-    for (const [index, line] of text.split("\n").entries()) {
-      if (!line.trim()) continue;
-      let event;
-      try {
-        event = JSON.parse(line);
-      } catch (error) {
-        throw new Error(
-          `${filePath}:${index + 1} contains invalid trace JSON: ${String(error)}`
-        );
-      }
-      events[event.event] = (events[event.event] ?? 0) + 1;
-      if (event.event === "skip_summary") {
-        for (const [reason, count] of Object.entries(event.skipCounts)) {
-          skipCounts[reason] = (skipCounts[reason] ?? 0) + count;
+    const input = (0, import_node_fs4.createReadStream)(filePath);
+    const lines = import_node_readline2.default.createInterface({ input, crlfDelay: Infinity });
+    let index = -1;
+    try {
+      for await (const line of lines) {
+        index++;
+        if (!line.trim()) continue;
+        let event;
+        try {
+          event = JSON.parse(line);
+        } catch (error) {
+          throw new Error(
+            `${filePath}:${index + 1} contains invalid trace JSON: ${String(error)}`
+          );
+        }
+        events[event.event] = (events[event.event] ?? 0) + 1;
+        if (event.event === "skip_summary") {
+          for (const [reason, count] of Object.entries(event.skipCounts)) {
+            skipCounts[reason] = (skipCounts[reason] ?? 0) + count;
+          }
+        }
+        if (event.event === "position_exited" && event.exitCode) {
+          exitCodes[event.exitCode] = (exitCodes[event.exitCode] ?? 0) + 1;
+        }
+        if ("researchEntryDecision" in event && event.researchEntryDecision && !event.researchEntryDecision.allowed) {
+          const reason = event.researchEntryDecision.reason;
+          policyRejections[reason] = (policyRejections[reason] ?? 0) + 1;
+          if (policyExamples.length < 20)
+            policyExamples.push({
+              timestamp: event.timestamp,
+              symbol: event.symbol,
+              decision: event.researchEntryDecision
+            });
         }
       }
-      if (event.event === "position_exited" && event.exitCode) {
-        exitCodes[event.exitCode] = (exitCodes[event.exitCode] ?? 0) + 1;
-      }
+    } finally {
+      lines.close();
+      input.destroy();
     }
   }
   return {
@@ -2149,7 +2211,13 @@ var summarizeCoreResearchTrace = async (filePaths = []) => {
       Object.entries(exitCodes).sort(
         ([leftKey, leftValue], [rightKey, rightValue]) => rightValue - leftValue || (leftKey < rightKey ? -1 : leftKey > rightKey ? 1 : 0)
       )
-    )
+    ),
+    ...policyExamples.length ? {
+      researchPolicy: {
+        rejections: policyRejections,
+        examples: policyExamples
+      }
+    } : {}
   };
 };
 
@@ -2436,7 +2504,14 @@ var analyzeCoreResearchPrepared = async (spec, options = {}) => {
           analysis.variant.id,
           deflatedSharpeDiagnostic(
             analysis.monthly.map((window) => window.cohorts.ALL.pnl),
-            Math.max(comparisons.length, familyHypotheses)
+            Math.max(comparisons.length, familyHypotheses),
+            analyses.flatMap((entry) => {
+              const diagnostic = deflatedSharpeDiagnostic(
+                entry.monthly.map((window) => window.cohorts.ALL.pnl),
+                1
+              );
+              return diagnostic.observedSharpe == null ? [] : [diagnostic.observedSharpe];
+            })
           )
         ])
       ),
@@ -2461,7 +2536,7 @@ var analyzeCoreResearchPrepared = async (spec, options = {}) => {
   const tradesByVariant = new Map(
     windowed.map((entry) => [entry.variant.id, entry.trades])
   );
-  await import_promises4.default.writeFile(
+  await import_promises3.default.writeFile(
     paths.reportPath,
     buildCoreResearchHtml({ spec, result, tradesByVariant }),
     "utf8"
@@ -2481,7 +2556,7 @@ var analyzeCoreResearchPrepared = async (spec, options = {}) => {
     if (error.code !== "ENOENT") throw error;
   }
   try {
-    for (const name of await import_promises4.default.readdir(paths.runLogDir)) {
+    for (const name of await import_promises3.default.readdir(paths.runLogDir)) {
       if (!name.endsWith(".log")) continue;
       artifactHashes[`runs/${name}`] = await sha256File(
         import_node_path6.default.join(paths.runLogDir, name)
@@ -2681,7 +2756,7 @@ var createCoreResearchSpecTemplate = (params) => {
 };
 var runCommand = async (params) => {
   if (!params.command.length) throw new Error("Cannot run an empty command");
-  await import_promises4.default.mkdir(import_node_path6.default.dirname(params.logPath), { recursive: true });
+  await import_promises3.default.mkdir(import_node_path6.default.dirname(params.logPath), { recursive: true });
   const chunks = [];
   const child = (0, import_node_child_process.spawn)(params.command[0], params.command.slice(1), {
     cwd: params.cwd,
@@ -2701,7 +2776,7 @@ var runCommand = async (params) => {
     child.once("close", (code) => resolve(code ?? 1));
   });
   const output = chunks.join("");
-  await import_promises4.default.writeFile(params.logPath, output, "utf8");
+  await import_promises3.default.writeFile(params.logPath, output, "utf8");
   if (exitCode !== 0) {
     throw new Error(
       `Command failed with exit ${exitCode}: ${params.command.join(" ")}`
@@ -2919,7 +2994,7 @@ var readSymbols = async (argv, projectRoot) => {
   const symbolsFile = valueAfter(argv, "--symbolsFile");
   if (symbolsFile) {
     const parsed = JSON.parse(
-      await import_promises5.default.readFile(import_node_path7.default.resolve(projectRoot, symbolsFile), "utf8")
+      await import_promises4.default.readFile(import_node_path7.default.resolve(projectRoot, symbolsFile), "utf8")
     );
     if (!Array.isArray(parsed) || parsed.some((symbol) => typeof symbol !== "string")) {
       throw new Error("--symbolsFile must contain a JSON string array");

package/dist/scripts/mcpWorker.js

@@ -103,7 +103,7 @@ var buildMcpReplayProcess = async ({
   const heartbeat = JSON.parse(
     await import_promises.default.readFile(import_node_path.default.join(root, "heartbeat.json"), "utf8")
   );
-  if (!Number.isFinite(heartbeat.observedAt) || Date.now() - heartbeat.observedAt < 0 || Date.now() - heartbeat.observedAt > 12e4)
+  if (heartbeat.protocolVersion !== 2 || !Number.isFinite(heartbeat.observedAt) || Date.now() - heartbeat.observedAt < 0 || Date.now() - heartbeat.observedAt > 12e4)
     throw new Error("Host replay runner heartbeat is stale");
   const bytes = await import_promises.default.readFile(evidencePath);
   const request = JSON.stringify({
@@ -136,14 +136,30 @@ var main = async (options = {}) => {
   let leaseLost = false;
   let manifestHash = "";
   let replayReady = false;
+  let replayReadiness = "unknown";
+  let replayResources;
   const updateReplayReady = async () => {
+    replayResources = void 0;
     try {
       const root = process.env.MCP_REPLAY_REQUEST_ROOT || `${process.env.PROJECT_CWD || process.cwd()}/data/mcp-replay-requests`;
       const heartbeat2 = JSON.parse(
         await (0, import_promises2.readFile)(`${root}/heartbeat.json`, "utf8")
       );
-      replayReady = Number.isFinite(heartbeat2.observedAt) && Date.now() - heartbeat2.observedAt >= 0 && Date.now() - heartbeat2.observedAt < 12e4;
+      replayReady = heartbeat2.protocolVersion === 2 && Number.isFinite(heartbeat2.observedAt) && Date.now() - heartbeat2.observedAt >= 0 && Date.now() - heartbeat2.observedAt < 12e4;
+      replayReadiness = replayReady && (heartbeat2.readiness === "ready" || heartbeat2.readiness === "waiting_resources") ? heartbeat2.readiness : "unknown";
+      if (replayReady && Number.isSafeInteger(heartbeat2.memoryAvailableKb) && heartbeat2.memoryAvailableKb >= 0 && Number.isSafeInteger(heartbeat2.minimumAvailableKb) && heartbeat2.minimumAvailableKb > 0) {
+        replayResources = {
+          observedAt: heartbeat2.observedAt,
+          memoryAvailableKb: heartbeat2.memoryAvailableKb,
+          minimumAvailableKb: heartbeat2.minimumAvailableKb,
+          memoryDeficitKb: Math.max(
+            0,
+            heartbeat2.minimumAvailableKb - heartbeat2.memoryAvailableKb
+          )
+        };
+      }
     } catch {
+      replayReadiness = "unknown";
       replayReady = false;
     }
   };
@@ -160,7 +176,9 @@ var main = async (options = {}) => {
   const heartbeatValue = () => ({
     observedAt: Date.now(),
     packageManifestSha256: manifestHash,
-    replayAvailable: replayReady
+    replayAvailable: replayReady,
+    replayReadiness,
+    replayResources
   });
   const stop = () => {
     stopping = true;
@@ -221,7 +239,9 @@ var main = async (options = {}) => {
         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))
+          if (job && ["queued", "waiting_resources", "waiting_executor"].includes(
+            job.status
+          ) && (!queued || job.createdAt < queued.createdAt))
             queued = job;
         }
       } while (cursor !== "0" && !stopping);
@@ -232,13 +252,13 @@ var main = async (options = {}) => {
       const jobKey = (0, import_mcp.mcpJobStorageId)(queued.userName, queued.id);
       const started = {
         ...queued,
-        status: "running",
-        startedAt: Date.now(),
+        status: queued.kind === "runtime-feedback-replay" ? "waiting_executor" : "running",
+        ...queued.kind === "runtime-feedback-replay" ? {} : { 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) {
+      if (started.kind !== "runtime-feedback-replay" && started.packageManifestSha256 !== manifestHash) {
         await import_redis.mcpStorage.compare(
           jobKey,
           started,
@@ -326,7 +346,8 @@ var main = async (options = {}) => {
       });
       const currentChild = child;
       let timedOut = false;
-      const timeout = setTimeout(() => {
+      let replayStartedAt;
+      const timeout = started.kind === "runtime-feedback-replay" ? void 0 : setTimeout(() => {
         timedOut = true;
         signalChild("SIGTERM");
       }, JOB_TIMEOUT_MS);
@@ -346,11 +367,38 @@ var main = async (options = {}) => {
             killAt ??= Date.now();
             signalChild(Date.now() - killAt > 8e3 ? "SIGKILL" : "SIGTERM");
           }
+          let replayStatus;
+          if (latest?.kind === "runtime-feedback-replay") {
+            try {
+              const root = process.env.MCP_REPLAY_REQUEST_ROOT || `${process.env.PROJECT_CWD || process.cwd()}/data/mcp-replay-requests`;
+              const state = JSON.parse(
+                await (0, import_promises2.readFile)(`${root}/${latest.id}.state`, "utf8")
+              );
+              if (state && typeof state === "object" && "status" in state && (state.status === "waiting_resources" || state.status === "waiting_executor" || state.status === "running"))
+                replayStatus = state.status;
+            } catch {
+            }
+          }
+          if (replayStatus === "running") {
+            replayStartedAt ??= latest?.startedAt ?? Date.now();
+            if (Date.now() - replayStartedAt > JOB_TIMEOUT_MS) {
+              timedOut = true;
+              signalChild("SIGTERM");
+            }
+          }
           if (latest && !leaseLost)
             await import_redis.mcpStorage.compare(
               jobKey,
               latest,
-              { ...latest, logs: [...logs], updatedAt: Date.now() },
+              {
+                ...latest,
+                ...replayStatus && !latest.cancelRequested ? {
+                  status: replayStatus,
+                  ...replayStatus === "running" && !latest.startedAt ? { startedAt: Date.now() } : {}
+                } : {},
+                logs: [...logs],
+                updatedAt: Date.now()
+              },
               import_mcp.MCP_JOB_TTL
             );
         } catch {